Rename cc::CompositorFrameSink to cc::LayerTreeFrameSink
Along with all associated names such as clients and subclasses.
CompositorFrameSink is the name of the mojo APIs. Now that IPC is thru
mojo, these APIs are actual C++ type names. Having other C++ types with
the same name is eternally confusing.
In the future one day LayerTreeFrameSink will submit ContentFrames or
so instead of CompositorFrames, luckily its name won't need to change
at that time.
This CL is not opinionated on what things *should* be using. There are
some places that are using LayerTreeFrameSinks that clearly should not
be since they are not involved with LayerTreeHost. However this CL
makes these more obvious instead of being hidden.
Once this is done, we may rename the MojoCompositorFrameSink API to
CompositorFrameSink and be free of the mojom::Mojo conundrum.
R=enne@chromium.org, fsamuel@chromium.org
TBR=sky@chromium.org, jam@chromium.org
Bug: 722935
Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_layout_tests_slimming_paint_v2
Change-Id: I26377c13f46fc7aff9bb4f43590ee7e42c00df40
Reviewed-on: https://chromium-review.googlesource.com/538096
Commit-Queue: danakj <danakj@chromium.org>
Reviewed-by: danakj <danakj@chromium.org>
Reviewed-by: Bo Liu <boliu@chromium.org>
Reviewed-by: kylechar <kylechar@chromium.org>
Reviewed-by: Fady Samuel <fsamuel@chromium.org>
Cr-Commit-Position: refs/heads/master@{#481086}diff --git a/android_webview/browser/browser_view_renderer.cc b/android_webview/browser/browser_view_renderer.cc
index c1e6c61..c4191417 100644
--- a/android_webview/browser/browser_view_renderer.cc
+++ b/android_webview/browser/browser_view_renderer.cc
@@ -253,7 +253,7 @@
allow_async_draw_ = true;
std::unique_ptr<ChildFrame> child_frame = base::MakeUnique<ChildFrame>(
- std::move(future), frame.compositor_frame_sink_id, std::move(frame.frame),
+ std::move(future), frame.layer_tree_frame_sink_id, std::move(frame.frame),
compositor_id_, viewport_rect_for_tile_priority.IsEmpty(),
transform_for_tile_priority, offscreen_pre_raster_,
external_draw_constraints_.is_layer);
@@ -321,7 +321,7 @@
content::SynchronousCompositor* compositor =
FindCompositor(child_frame->compositor_id);
if (compositor && !resources.empty())
- compositor->ReturnResources(child_frame->compositor_frame_sink_id,
+ compositor->ReturnResources(child_frame->layer_tree_frame_sink_id,
resources);
}
@@ -336,7 +336,7 @@
resources.swap(pair.second.resources);
if (compositor && !resources.empty()) {
- compositor->ReturnResources(pair.second.compositor_frame_sink_id,
+ compositor->ReturnResources(pair.second.layer_tree_frame_sink_id,
resources);
}
}
diff --git a/android_webview/browser/browser_view_renderer_unittest.cc b/android_webview/browser/browser_view_renderer_unittest.cc
index 4db9e91..8a34ef0 100644
--- a/android_webview/browser/browser_view_renderer_unittest.cc
+++ b/android_webview/browser/browser_view_renderer_unittest.cc
@@ -342,7 +342,7 @@
class ResourceRenderingTest : public RenderingTest {
public:
using ResourceCountMap = std::map<cc::ResourceId, int>;
- using CompositorFrameSinkResourceCountMap =
+ using LayerTreeFrameSinkResourceCountMap =
std::map<uint32_t, ResourceCountMap>;
virtual std::unique_ptr<content::SynchronousCompositor::Frame> GetFrame(
@@ -355,7 +355,7 @@
void WillOnDraw() override {
if (next_frame_) {
- compositor_->SetHardwareFrame(next_frame_->compositor_frame_sink_id,
+ compositor_->SetHardwareFrame(next_frame_->layer_tree_frame_sink_id,
std::move(next_frame_->frame));
}
}
@@ -369,13 +369,13 @@
}
}
- CompositorFrameSinkResourceCountMap GetReturnedResourceCounts() {
- CompositorFrameSinkResourceCountMap counts;
+ LayerTreeFrameSinkResourceCountMap GetReturnedResourceCounts() {
+ LayerTreeFrameSinkResourceCountMap counts;
content::TestSynchronousCompositor::FrameAckArray returned_resources_array;
compositor_->SwapReturnedResources(&returned_resources_array);
for (const auto& resources : returned_resources_array) {
for (const auto& returned_resource : resources.resources) {
- counts[resources.compositor_frame_sink_id][returned_resource.id] +=
+ counts[resources.layer_tree_frame_sink_id][returned_resource.id] +=
returned_resource.count;
}
}
@@ -398,9 +398,9 @@
int frame_number_;
};
-class SwitchCompositorFrameSinkIdTest : public ResourceRenderingTest {
+class SwitchLayerTreeFrameSinkIdTest : public ResourceRenderingTest {
struct FrameInfo {
- uint32_t compositor_frame_sink_id;
+ uint32_t layer_tree_frame_sink_id;
cc::ResourceId resource_id; // Each frame contains a single resource.
};
@@ -418,22 +418,22 @@
std::unique_ptr<content::SynchronousCompositor::Frame> frame(
new content::SynchronousCompositor::Frame);
- frame->compositor_frame_sink_id =
- infos[frame_number].compositor_frame_sink_id;
+ frame->layer_tree_frame_sink_id =
+ infos[frame_number].layer_tree_frame_sink_id;
frame->frame = ConstructFrame(infos[frame_number].resource_id);
- if (last_compositor_frame_sink_id_ !=
- infos[frame_number].compositor_frame_sink_id) {
+ if (last_layer_tree_frame_sink_id_ !=
+ infos[frame_number].layer_tree_frame_sink_id) {
expected_return_count_.clear();
- last_compositor_frame_sink_id_ =
- infos[frame_number].compositor_frame_sink_id;
+ last_layer_tree_frame_sink_id_ =
+ infos[frame_number].layer_tree_frame_sink_id;
}
++expected_return_count_[infos[frame_number].resource_id];
return frame;
}
void StartTest() override {
- last_compositor_frame_sink_id_ = -1U;
+ last_layer_tree_frame_sink_id_ = -1U;
ResourceRenderingTest::StartTest();
}
@@ -444,16 +444,16 @@
// Make sure resources for the last output surface are returned.
EXPECT_EQ(expected_return_count_,
- GetReturnedResourceCounts()[last_compositor_frame_sink_id_]);
+ GetReturnedResourceCounts()[last_layer_tree_frame_sink_id_]);
EndTest();
}
private:
- uint32_t last_compositor_frame_sink_id_;
+ uint32_t last_layer_tree_frame_sink_id_;
ResourceCountMap expected_return_count_;
};
-RENDERING_TEST_F(SwitchCompositorFrameSinkIdTest);
+RENDERING_TEST_F(SwitchLayerTreeFrameSinkIdTest);
class RenderThreadManagerDeletionTest : public ResourceRenderingTest {
std::unique_ptr<content::SynchronousCompositor::Frame> GetFrame(
@@ -462,20 +462,20 @@
return nullptr;
}
- const uint32_t compositor_frame_sink_id = 0u;
+ const uint32_t layer_tree_frame_sink_id = 0u;
const cc::ResourceId resource_id =
static_cast<cc::ResourceId>(frame_number);
std::unique_ptr<content::SynchronousCompositor::Frame> frame(
new content::SynchronousCompositor::Frame);
- frame->compositor_frame_sink_id = compositor_frame_sink_id;
+ frame->layer_tree_frame_sink_id = layer_tree_frame_sink_id;
frame->frame = ConstructFrame(resource_id);
- ++expected_return_count_[compositor_frame_sink_id][resource_id];
+ ++expected_return_count_[layer_tree_frame_sink_id][resource_id];
return frame;
}
void CheckResults() override {
- CompositorFrameSinkResourceCountMap resource_counts;
+ LayerTreeFrameSinkResourceCountMap resource_counts;
functor_.reset();
// Make sure resources for the last frame are returned.
EXPECT_EQ(expected_return_count_, GetReturnedResourceCounts());
@@ -483,7 +483,7 @@
}
private:
- CompositorFrameSinkResourceCountMap expected_return_count_;
+ LayerTreeFrameSinkResourceCountMap expected_return_count_;
};
RENDERING_TEST_F(RenderThreadManagerDeletionTest);
@@ -524,20 +524,20 @@
return nullptr;
}
- const uint32_t compositor_frame_sink_id = 0u;
+ const uint32_t layer_tree_frame_sink_id = 0u;
const cc::ResourceId resource_id =
static_cast<cc::ResourceId>(frame_number);
std::unique_ptr<content::SynchronousCompositor::Frame> frame(
new content::SynchronousCompositor::Frame);
- frame->compositor_frame_sink_id = compositor_frame_sink_id;
+ frame->layer_tree_frame_sink_id = layer_tree_frame_sink_id;
frame->frame = ConstructFrame(resource_id);
- ++expected_return_count_[compositor_frame_sink_id][resource_id];
+ ++expected_return_count_[layer_tree_frame_sink_id][resource_id];
return frame;
}
void CheckResults() override {
- CompositorFrameSinkResourceCountMap resource_counts;
+ LayerTreeFrameSinkResourceCountMap resource_counts;
functor_.reset();
// Make sure resources for all frames are returned.
EXPECT_EQ(expected_return_count_, GetReturnedResourceCounts());
@@ -546,7 +546,7 @@
private:
std::unique_ptr<FakeFunctor> saved_functor_;
- CompositorFrameSinkResourceCountMap expected_return_count_;
+ LayerTreeFrameSinkResourceCountMap expected_return_count_;
};
RENDERING_TEST_F(RenderThreadManagerSwitchTest);
diff --git a/android_webview/browser/child_frame.cc b/android_webview/browser/child_frame.cc
index f0d639b..ce87860 100644
--- a/android_webview/browser/child_frame.cc
+++ b/android_webview/browser/child_frame.cc
@@ -13,7 +13,7 @@
ChildFrame::ChildFrame(
scoped_refptr<content::SynchronousCompositor::FrameFuture> frame_future,
- uint32_t compositor_frame_sink_id,
+ uint32_t layer_tree_frame_sink_id,
std::unique_ptr<cc::CompositorFrame> frame,
const CompositorID& compositor_id,
bool viewport_rect_for_tile_priority_empty,
@@ -21,7 +21,7 @@
bool offscreen_pre_raster,
bool is_layer)
: frame_future(std::move(frame_future)),
- compositor_frame_sink_id(compositor_frame_sink_id),
+ layer_tree_frame_sink_id(layer_tree_frame_sink_id),
frame(std::move(frame)),
compositor_id(compositor_id),
viewport_rect_for_tile_priority_empty(
@@ -41,7 +41,7 @@
DCHECK(!frame);
auto frame_ptr = frame_future->GetFrame();
if (frame_ptr) {
- compositor_frame_sink_id = frame_ptr->compositor_frame_sink_id;
+ layer_tree_frame_sink_id = frame_ptr->layer_tree_frame_sink_id;
frame = std::move(frame_ptr->frame);
}
frame_future = nullptr;
diff --git a/android_webview/browser/child_frame.h b/android_webview/browser/child_frame.h
index 5e88f21..e976bfc 100644
--- a/android_webview/browser/child_frame.h
+++ b/android_webview/browser/child_frame.h
@@ -25,7 +25,7 @@
public:
ChildFrame(
scoped_refptr<content::SynchronousCompositor::FrameFuture> frame_future,
- uint32_t compositor_frame_sink_id,
+ uint32_t layer_tree_frame_sink_id,
std::unique_ptr<cc::CompositorFrame> frame,
const CompositorID& compositor_id,
bool viewport_rect_for_tile_priority_empty,
@@ -41,7 +41,7 @@
// or |frame|. It's illegal if both are non-null.
scoped_refptr<content::SynchronousCompositor::FrameFuture> frame_future;
// These two fields are not const to make async path easier.
- uint32_t compositor_frame_sink_id;
+ uint32_t layer_tree_frame_sink_id;
std::unique_ptr<cc::CompositorFrame> frame;
// The id of the compositor this |frame| comes from.
const CompositorID compositor_id;
diff --git a/android_webview/browser/compositor_frame_consumer.h b/android_webview/browser/compositor_frame_consumer.h
index 600ae42..d1cb24b3 100644
--- a/android_webview/browser/compositor_frame_consumer.h
+++ b/android_webview/browser/compositor_frame_consumer.h
@@ -25,7 +25,7 @@
ReturnedResources();
~ReturnedResources();
- uint32_t compositor_frame_sink_id;
+ uint32_t layer_tree_frame_sink_id;
cc::ReturnedResourceArray resources;
};
using ReturnedResourcesMap =
diff --git a/android_webview/browser/hardware_renderer.cc b/android_webview/browser/hardware_renderer.cc
index 95ca24a..f88749b 100644
--- a/android_webview/browser/hardware_renderer.cc
+++ b/android_webview/browser/hardware_renderer.cc
@@ -30,8 +30,8 @@
frame_sink_id_(surfaces_->AllocateFrameSinkId()),
local_surface_id_allocator_(
base::MakeUnique<cc::LocalSurfaceIdAllocator>()),
- last_committed_compositor_frame_sink_id_(0u),
- last_submitted_compositor_frame_sink_id_(0u) {
+ last_committed_layer_tree_frame_sink_id_(0u),
+ last_submitted_layer_tree_frame_sink_id_(0u) {
DCHECK(last_egl_context_);
surfaces_->GetSurfaceManager()->RegisterFrameSinkId(frame_sink_id_);
CreateNewCompositorFrameSinkSupport();
@@ -85,8 +85,8 @@
child_frame_queue_.clear();
}
if (child_frame_) {
- last_committed_compositor_frame_sink_id_ =
- child_frame_->compositor_frame_sink_id;
+ last_committed_layer_tree_frame_sink_id_ =
+ child_frame_->layer_tree_frame_sink_id;
}
// We need to watch if the current Android context has changed and enforce
@@ -104,15 +104,15 @@
// unnecessary kModeProcess.
if (child_frame_.get() && child_frame_->frame.get()) {
if (!compositor_id_.Equals(child_frame_->compositor_id) ||
- last_submitted_compositor_frame_sink_id_ !=
- child_frame_->compositor_frame_sink_id) {
+ last_submitted_layer_tree_frame_sink_id_ !=
+ child_frame_->layer_tree_frame_sink_id) {
if (child_id_.is_valid())
DestroySurface();
CreateNewCompositorFrameSinkSupport();
compositor_id_ = child_frame_->compositor_id;
- last_submitted_compositor_frame_sink_id_ =
- child_frame_->compositor_frame_sink_id;
+ last_submitted_layer_tree_frame_sink_id_ =
+ child_frame_->layer_tree_frame_sink_id;
}
std::unique_ptr<cc::CompositorFrame> child_compositor_frame =
@@ -178,7 +178,7 @@
void HardwareRenderer::DidReceiveCompositorFrameAck(
const cc::ReturnedResourceArray& resources) {
ReturnResourcesToCompositor(resources, compositor_id_,
- last_submitted_compositor_frame_sink_id_);
+ last_submitted_layer_tree_frame_sink_id_);
}
void HardwareRenderer::OnBeginFrame(const cc::BeginFrameArgs& args) {
@@ -188,7 +188,7 @@
void HardwareRenderer::ReclaimResources(
const cc::ReturnedResourceArray& resources) {
ReturnResourcesToCompositor(resources, compositor_id_,
- last_submitted_compositor_frame_sink_id_);
+ last_submitted_layer_tree_frame_sink_id_);
}
void HardwareRenderer::WillDrawSurface(
@@ -244,17 +244,17 @@
// The child frame's compositor id is not necessarily same as
// compositor_id_.
ReturnResourcesToCompositor(resources_to_return, child_frame->compositor_id,
- child_frame->compositor_frame_sink_id);
+ child_frame->layer_tree_frame_sink_id);
}
void HardwareRenderer::ReturnResourcesToCompositor(
const cc::ReturnedResourceArray& resources,
const CompositorID& compositor_id,
- uint32_t compositor_frame_sink_id) {
- if (compositor_frame_sink_id != last_committed_compositor_frame_sink_id_)
+ uint32_t layer_tree_frame_sink_id) {
+ if (layer_tree_frame_sink_id != last_committed_layer_tree_frame_sink_id_)
return;
render_thread_manager_->InsertReturnedResourcesOnRT(resources, compositor_id,
- compositor_frame_sink_id);
+ layer_tree_frame_sink_id);
}
void HardwareRenderer::CreateNewCompositorFrameSinkSupport() {
diff --git a/android_webview/browser/hardware_renderer.h b/android_webview/browser/hardware_renderer.h
index a99fb73..a6836bf 100644
--- a/android_webview/browser/hardware_renderer.h
+++ b/android_webview/browser/hardware_renderer.h
@@ -60,7 +60,7 @@
void ReturnChildFrame(std::unique_ptr<ChildFrame> child_frame);
void ReturnResourcesToCompositor(const cc::ReturnedResourceArray& resources,
const CompositorID& compositor_id,
- uint32_t compositor_frame_sink_id);
+ uint32_t layer_tree_frame_sink_id);
void AllocateSurface();
void DestroySurface();
@@ -94,10 +94,10 @@
cc::LocalSurfaceId child_id_;
CompositorID compositor_id_;
// HardwareRenderer guarantees resources are returned in the order of
- // compositor_frame_sink_id, and resources for old output surfaces are
+ // layer_tree_frame_sink_id, and resources for old output surfaces are
// dropped.
- uint32_t last_committed_compositor_frame_sink_id_;
- uint32_t last_submitted_compositor_frame_sink_id_;
+ uint32_t last_committed_layer_tree_frame_sink_id_;
+ uint32_t last_submitted_layer_tree_frame_sink_id_;
DISALLOW_COPY_AND_ASSIGN(HardwareRenderer);
};
diff --git a/android_webview/browser/render_thread_manager.cc b/android_webview/browser/render_thread_manager.cc
index 9070cc9..8faa8eb 100644
--- a/android_webview/browser/render_thread_manager.cc
+++ b/android_webview/browser/render_thread_manager.cc
@@ -260,23 +260,23 @@
}
RenderThreadManager::ReturnedResources::ReturnedResources()
- : compositor_frame_sink_id(0u) {}
+ : layer_tree_frame_sink_id(0u) {}
RenderThreadManager::ReturnedResources::~ReturnedResources() {}
void RenderThreadManager::InsertReturnedResourcesOnRT(
const cc::ReturnedResourceArray& resources,
const CompositorID& compositor_id,
- uint32_t compositor_frame_sink_id) {
+ uint32_t layer_tree_frame_sink_id) {
base::AutoLock lock(lock_);
ReturnedResources& returned_resources =
returned_resources_map_[compositor_id];
- if (returned_resources.compositor_frame_sink_id != compositor_frame_sink_id) {
+ if (returned_resources.layer_tree_frame_sink_id != layer_tree_frame_sink_id) {
returned_resources.resources.clear();
}
returned_resources.resources.insert(returned_resources.resources.end(),
resources.begin(), resources.end());
- returned_resources.compositor_frame_sink_id = compositor_frame_sink_id;
+ returned_resources.layer_tree_frame_sink_id = layer_tree_frame_sink_id;
}
void RenderThreadManager::SwapReturnedResourcesOnUI(
diff --git a/android_webview/browser/render_thread_manager.h b/android_webview/browser/render_thread_manager.h
index e93c4b8..fe335d36 100644
--- a/android_webview/browser/render_thread_manager.h
+++ b/android_webview/browser/render_thread_manager.h
@@ -66,7 +66,7 @@
const ParentCompositorDrawConstraints& parent_draw_constraints);
void InsertReturnedResourcesOnRT(const cc::ReturnedResourceArray& resources,
const CompositorID& compositor_id,
- uint32_t compositor_frame_sink_id);
+ uint32_t layer_tree_frame_sink_id);
private:
friend class internal::RequestInvokeGLTracker;
diff --git a/ash/laser/laser_pointer_view.cc b/ash/laser/laser_pointer_view.cc
index 56cecc0..23e9ae87 100644
--- a/ash/laser/laser_pointer_view.cc
+++ b/ash/laser/laser_pointer_view.cc
@@ -22,9 +22,9 @@
#include "base/threading/thread_task_runner_handle.h"
#include "base/trace_event/trace_event.h"
#include "cc/output/compositor_frame.h"
-#include "cc/output/compositor_frame_sink.h"
-#include "cc/output/compositor_frame_sink_client.h"
#include "cc/output/context_provider.h"
+#include "cc/output/layer_tree_frame_sink.h"
+#include "cc/output/layer_tree_frame_sink_client.h"
#include "cc/quads/texture_draw_quad.h"
#include "cc/resources/texture_mailbox.h"
#include "cc/resources/transferable_resource.h"
@@ -184,24 +184,22 @@
DISALLOW_COPY_AND_ASSIGN(LaserSegment);
};
-class LaserCompositorFrameSinkHolder : public cc::CompositorFrameSinkClient {
+class LaserLayerTreeFrameSinkHolder : public cc::LayerTreeFrameSinkClient {
public:
- LaserCompositorFrameSinkHolder(
+ LaserLayerTreeFrameSinkHolder(
LaserPointerView* view,
- std::unique_ptr<cc::CompositorFrameSink> frame_sink)
+ std::unique_ptr<cc::LayerTreeFrameSink> frame_sink)
: view_(view), frame_sink_(std::move(frame_sink)) {
frame_sink_->BindToClient(this);
}
- ~LaserCompositorFrameSinkHolder() override {
- frame_sink_->DetachFromClient();
- }
+ ~LaserLayerTreeFrameSinkHolder() override { frame_sink_->DetachFromClient(); }
- cc::CompositorFrameSink* frame_sink() { return frame_sink_.get(); }
+ cc::LayerTreeFrameSink* frame_sink() { return frame_sink_.get(); }
// Called before laser pointer view is destroyed.
void OnLaserPointerViewDestroying() { view_ = nullptr; }
- // Overridden from cc::CompositorFrameSinkClient:
+ // Overridden from cc::LayerTreeFrameSinkClient:
void SetBeginFrameSource(cc::BeginFrameSource* source) override {}
void ReclaimResources(const cc::ReturnedResourceArray& resources) override {
if (view_)
@@ -212,7 +210,7 @@
if (view_)
view_->DidReceiveCompositorFrameAck();
}
- void DidLoseCompositorFrameSink() override {}
+ void DidLoseLayerTreeFrameSink() override {}
void OnDraw(const gfx::Transform& transform,
const gfx::Rect& viewport,
bool resourceless_software_draw) override {}
@@ -223,9 +221,9 @@
private:
LaserPointerView* view_;
- std::unique_ptr<cc::CompositorFrameSink> frame_sink_;
+ std::unique_ptr<cc::LayerTreeFrameSink> frame_sink_;
- DISALLOW_COPY_AND_ASSIGN(LaserCompositorFrameSinkHolder);
+ DISALLOW_COPY_AND_ASSIGN(LaserLayerTreeFrameSinkHolder);
};
// This struct contains the resources associated with a laser pointer frame.
@@ -274,8 +272,8 @@
scale_factor_ = ui::GetScaleFactorForNativeView(widget_->GetNativeView());
- frame_sink_holder_ = base::MakeUnique<LaserCompositorFrameSinkHolder>(
- this, widget_->GetNativeView()->CreateCompositorFrameSink());
+ frame_sink_holder_ = base::MakeUnique<LaserLayerTreeFrameSinkHolder>(
+ this, widget_->GetNativeView()->CreateLayerTreeFrameSink());
}
LaserPointerView::~LaserPointerView() {
diff --git a/ash/laser/laser_pointer_view.h b/ash/laser/laser_pointer_view.h
index 7096431..fd8df67 100644
--- a/ash/laser/laser_pointer_view.h
+++ b/ash/laser/laser_pointer_view.h
@@ -29,7 +29,7 @@
}
namespace ash {
-class LaserCompositorFrameSinkHolder;
+class LaserLayerTreeFrameSinkHolder;
struct LaserResource;
// LaserPointerView displays the palette tool laser pointer. It draws the laser,
@@ -74,7 +74,7 @@
gfx::Rect surface_damage_rect_;
bool needs_update_surface_ = false;
bool pending_draw_surface_ = false;
- std::unique_ptr<LaserCompositorFrameSinkHolder> frame_sink_holder_;
+ std::unique_ptr<LaserLayerTreeFrameSinkHolder> frame_sink_holder_;
int next_resource_id_ = 1;
base::flat_map<int, std::unique_ptr<LaserResource>> resources_;
std::vector<std::unique_ptr<LaserResource>> returned_resources_;
diff --git a/cc/BUILD.gn b/cc/BUILD.gn
index f8a6ceb..0ffd466 100644
--- a/cc/BUILD.gn
+++ b/cc/BUILD.gn
@@ -150,9 +150,6 @@
"output/compositor_frame.h",
"output/compositor_frame_metadata.cc",
"output/compositor_frame_metadata.h",
- "output/compositor_frame_sink.cc",
- "output/compositor_frame_sink.h",
- "output/compositor_frame_sink_client.h",
"output/context_cache_controller.cc",
"output/context_cache_controller.h",
"output/context_provider.cc",
@@ -179,6 +176,9 @@
"output/latency_info_swap_promise.h",
"output/layer_quad.cc",
"output/layer_quad.h",
+ "output/layer_tree_frame_sink.cc",
+ "output/layer_tree_frame_sink.h",
+ "output/layer_tree_frame_sink_client.h",
"output/managed_memory_policy.cc",
"output/managed_memory_policy.h",
"output/output_surface.cc",
@@ -526,10 +526,6 @@
"test/begin_frame_source_test.h",
"test/compositor_frame_helpers.cc",
"test/compositor_frame_helpers.h",
- "test/fake_compositor_frame_sink.cc",
- "test/fake_compositor_frame_sink.h",
- "test/fake_compositor_frame_sink_client.cc",
- "test/fake_compositor_frame_sink_client.h",
"test/fake_compositor_frame_sink_support_client.cc",
"test/fake_compositor_frame_sink_support_client.h",
"test/fake_content_layer_client.cc",
@@ -537,6 +533,10 @@
"test/fake_external_begin_frame_source.cc",
"test/fake_external_begin_frame_source.h",
"test/fake_impl_task_runner_provider.h",
+ "test/fake_layer_tree_frame_sink.cc",
+ "test/fake_layer_tree_frame_sink.h",
+ "test/fake_layer_tree_frame_sink_client.cc",
+ "test/fake_layer_tree_frame_sink_client.h",
"test/fake_layer_tree_host.cc",
"test/fake_layer_tree_host.h",
"test/fake_layer_tree_host_client.cc",
@@ -639,8 +639,6 @@
"test/surface_hittest_test_helpers.h",
"test/task_graph_runner_test_template.cc",
"test/task_graph_runner_test_template.h",
- "test/test_compositor_frame_sink.cc",
- "test/test_compositor_frame_sink.h",
"test/test_context_provider.cc",
"test/test_context_provider.h",
"test/test_context_support.cc",
@@ -655,6 +653,8 @@
"test/test_image_factory.h",
"test/test_in_process_context_provider.cc",
"test/test_in_process_context_provider.h",
+ "test/test_layer_tree_frame_sink.cc",
+ "test/test_layer_tree_frame_sink.h",
"test/test_layer_tree_host_base.cc",
"test/test_layer_tree_host_base.h",
"test/test_occlusion_tracker.h",
@@ -766,10 +766,10 @@
"output/begin_frame_args_unittest.cc",
"output/bsp_tree_unittest.cc",
"output/buffer_to_texture_target_map_unittest.cc",
- "output/compositor_frame_sink_unittest.cc",
"output/context_cache_controller_unittest.cc",
"output/gl_renderer_unittest.cc",
"output/layer_quad_unittest.cc",
+ "output/layer_tree_frame_sink_unittest.cc",
"output/overlay_unittest.cc",
"output/renderer_pixeltest.cc",
"output/shader_unittest.cc",
@@ -858,7 +858,7 @@
# Surfaces test files.
"surfaces/compositor_frame_sink_support_unittest.cc",
- "surfaces/direct_compositor_frame_sink_unittest.cc",
+ "surfaces/direct_layer_tree_frame_sink_unittest.cc",
"surfaces/display_scheduler_unittest.cc",
"surfaces/display_unittest.cc",
"surfaces/referenced_surface_tracker_unittest.cc",
diff --git a/cc/layers/heads_up_display_layer_impl_unittest.cc b/cc/layers/heads_up_display_layer_impl_unittest.cc
index ddfb058..94d3f13 100644
--- a/cc/layers/heads_up_display_layer_impl_unittest.cc
+++ b/cc/layers/heads_up_display_layer_impl_unittest.cc
@@ -6,8 +6,8 @@
#include "cc/layers/append_quads_data.h"
#include "cc/layers/heads_up_display_layer_impl.h"
-#include "cc/test/fake_compositor_frame_sink.h"
#include "cc/test/fake_impl_task_runner_provider.h"
+#include "cc/test/fake_layer_tree_frame_sink.h"
#include "cc/test/fake_layer_tree_host_impl.h"
#include "cc/test/test_task_graph_runner.h"
#include "cc/trees/layer_tree_impl.h"
@@ -38,12 +38,12 @@
TEST(HeadsUpDisplayLayerImplTest, ResourcelessSoftwareDrawAfterResourceLoss) {
FakeImplTaskRunnerProvider task_runner_provider;
TestTaskGraphRunner task_graph_runner;
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink =
- FakeCompositorFrameSink::Create3d();
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink =
+ FakeLayerTreeFrameSink::Create3d();
FakeLayerTreeHostImpl host_impl(&task_runner_provider, &task_graph_runner);
host_impl.CreatePendingTree();
host_impl.SetVisible(true);
- host_impl.InitializeRenderer(compositor_frame_sink.get());
+ host_impl.InitializeRenderer(layer_tree_frame_sink.get());
std::unique_ptr<HeadsUpDisplayLayerImpl> layer_ptr =
HeadsUpDisplayLayerImpl::Create(host_impl.pending_tree(), 1);
layer_ptr->SetBounds(gfx::Size(100, 100));
@@ -55,26 +55,26 @@
// Check regular hardware draw is ok.
CheckDrawLayer(layer, host_impl.resource_provider(),
- compositor_frame_sink->context_provider(), DRAW_MODE_HARDWARE);
+ layer_tree_frame_sink->context_provider(), DRAW_MODE_HARDWARE);
// Simulate a resource loss on transitioning to resourceless software mode.
layer->ReleaseResources();
// Should skip resourceless software draw and not crash in UpdateHudTexture.
CheckDrawLayer(layer, host_impl.resource_provider(),
- compositor_frame_sink->context_provider(),
+ layer_tree_frame_sink->context_provider(),
DRAW_MODE_RESOURCELESS_SOFTWARE);
}
TEST(HeadsUpDisplayLayerImplTest, CPUAndGPURasterCanvas) {
FakeImplTaskRunnerProvider task_runner_provider;
TestTaskGraphRunner task_graph_runner;
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink =
- FakeCompositorFrameSink::Create3d();
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink =
+ FakeLayerTreeFrameSink::Create3d();
FakeLayerTreeHostImpl host_impl(&task_runner_provider, &task_graph_runner);
host_impl.CreatePendingTree();
host_impl.SetVisible(true);
- host_impl.InitializeRenderer(compositor_frame_sink.get());
+ host_impl.InitializeRenderer(layer_tree_frame_sink.get());
std::unique_ptr<HeadsUpDisplayLayerImpl> layer_ptr =
HeadsUpDisplayLayerImpl::Create(host_impl.pending_tree(), 1);
layer_ptr->SetBounds(gfx::Size(100, 100));
@@ -86,7 +86,7 @@
// Check Ganesh canvas drawing is ok.
CheckDrawLayer(layer, host_impl.resource_provider(),
- compositor_frame_sink->context_provider(), DRAW_MODE_HARDWARE);
+ layer_tree_frame_sink->context_provider(), DRAW_MODE_HARDWARE);
// Check SW canvas drawing is ok.
CheckDrawLayer(layer, host_impl.resource_provider(), NULL,
diff --git a/cc/layers/layer_impl_unittest.cc b/cc/layers/layer_impl_unittest.cc
index 721d4ca..326ef45 100644
--- a/cc/layers/layer_impl_unittest.cc
+++ b/cc/layers/layer_impl_unittest.cc
@@ -9,8 +9,8 @@
#include "cc/layers/painted_scrollbar_layer_impl.h"
#include "cc/layers/solid_color_scrollbar_layer_impl.h"
#include "cc/test/animation_test_common.h"
-#include "cc/test/fake_compositor_frame_sink.h"
#include "cc/test/fake_impl_task_runner_provider.h"
+#include "cc/test/fake_layer_tree_frame_sink.h"
#include "cc/test/fake_layer_tree_host_impl.h"
#include "cc/test/geometry_test_utils.h"
#include "cc/test/test_task_graph_runner.h"
@@ -124,11 +124,11 @@
// Create a simple LayerImpl tree:
FakeImplTaskRunnerProvider task_runner_provider;
TestTaskGraphRunner task_graph_runner;
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink =
- FakeCompositorFrameSink::Create3d();
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink =
+ FakeLayerTreeFrameSink::Create3d();
FakeLayerTreeHostImpl host_impl(&task_runner_provider, &task_graph_runner);
host_impl.SetVisible(true);
- EXPECT_TRUE(host_impl.InitializeRenderer(compositor_frame_sink.get()));
+ EXPECT_TRUE(host_impl.InitializeRenderer(layer_tree_frame_sink.get()));
host_impl.CreatePendingTree();
std::unique_ptr<LayerImpl> root_clip_ptr =
LayerImpl::Create(host_impl.pending_tree(), 1);
@@ -219,11 +219,11 @@
TEST(LayerImplTest, VerifyActiveLayerChangesAreTrackedProperly) {
FakeImplTaskRunnerProvider task_runner_provider;
TestTaskGraphRunner task_graph_runner;
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink =
- FakeCompositorFrameSink::Create3d();
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink =
+ FakeLayerTreeFrameSink::Create3d();
FakeLayerTreeHostImpl host_impl(&task_runner_provider, &task_graph_runner);
host_impl.SetVisible(true);
- EXPECT_TRUE(host_impl.InitializeRenderer(compositor_frame_sink.get()));
+ EXPECT_TRUE(host_impl.InitializeRenderer(layer_tree_frame_sink.get()));
std::unique_ptr<LayerImpl> root_clip_ptr =
LayerImpl::Create(host_impl.active_tree(), 1);
LayerImpl* root_clip = root_clip_ptr.get();
@@ -294,11 +294,11 @@
TEST(LayerImplTest, VerifyNeedsUpdateDrawProperties) {
FakeImplTaskRunnerProvider task_runner_provider;
TestTaskGraphRunner task_graph_runner;
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink =
- FakeCompositorFrameSink::Create3d();
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink =
+ FakeLayerTreeFrameSink::Create3d();
FakeLayerTreeHostImpl host_impl(&task_runner_provider, &task_graph_runner);
host_impl.SetVisible(true);
- EXPECT_TRUE(host_impl.InitializeRenderer(compositor_frame_sink.get()));
+ EXPECT_TRUE(host_impl.InitializeRenderer(layer_tree_frame_sink.get()));
host_impl.active_tree()->SetRootLayerForTesting(
LayerImpl::Create(host_impl.active_tree(), 1));
LayerImpl* root = host_impl.active_tree()->root_layer_for_testing();
@@ -408,11 +408,11 @@
TEST(LayerImplTest, SafeOpaqueBackgroundColor) {
FakeImplTaskRunnerProvider task_runner_provider;
TestTaskGraphRunner task_graph_runner;
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink =
- FakeCompositorFrameSink::Create3d();
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink =
+ FakeLayerTreeFrameSink::Create3d();
FakeLayerTreeHostImpl host_impl(&task_runner_provider, &task_graph_runner);
host_impl.SetVisible(true);
- EXPECT_TRUE(host_impl.InitializeRenderer(compositor_frame_sink.get()));
+ EXPECT_TRUE(host_impl.InitializeRenderer(layer_tree_frame_sink.get()));
host_impl.active_tree()->SetRootLayerForTesting(
LayerImpl::Create(host_impl.active_tree(), 1));
LayerImpl* layer = host_impl.active_tree()->root_layer_for_testing();
@@ -446,8 +446,8 @@
TEST(LayerImplTest, PerspectiveTransformHasReasonableScale) {
FakeImplTaskRunnerProvider task_runner_provider;
TestTaskGraphRunner task_graph_runner;
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink =
- FakeCompositorFrameSink::Create3d();
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink =
+ FakeLayerTreeFrameSink::Create3d();
LayerTreeSettings settings;
settings.layer_transforms_should_scale_layer_contents = true;
FakeLayerTreeHostImpl host_impl(settings, &task_runner_provider,
diff --git a/cc/layers/layer_list_iterator_unittest.cc b/cc/layers/layer_list_iterator_unittest.cc
index 54e1006e..0c984bf 100644
--- a/cc/layers/layer_list_iterator_unittest.cc
+++ b/cc/layers/layer_list_iterator_unittest.cc
@@ -8,8 +8,8 @@
#include "base/containers/adapters.h"
#include "cc/animation/animation_host.h"
-#include "cc/test/fake_compositor_frame_sink.h"
#include "cc/test/fake_impl_task_runner_provider.h"
+#include "cc/test/fake_layer_tree_frame_sink.h"
#include "cc/test/fake_layer_tree_host.h"
#include "cc/test/fake_layer_tree_host_impl.h"
#include "cc/test/test_task_graph_runner.h"
@@ -203,11 +203,11 @@
// Unfortunate preamble.
FakeImplTaskRunnerProvider task_runner_provider;
TestTaskGraphRunner task_graph_runner;
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink =
- FakeCompositorFrameSink::Create3d();
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink =
+ FakeLayerTreeFrameSink::Create3d();
FakeLayerTreeHostImpl host_impl(&task_runner_provider, &task_graph_runner);
host_impl.SetVisible(true);
- EXPECT_TRUE(host_impl.InitializeRenderer(compositor_frame_sink.get()));
+ EXPECT_TRUE(host_impl.InitializeRenderer(layer_tree_frame_sink.get()));
// This test constructs the following tree.
// 1
@@ -256,11 +256,11 @@
// Unfortunate preamble.
FakeImplTaskRunnerProvider task_runner_provider;
TestTaskGraphRunner task_graph_runner;
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink =
- FakeCompositorFrameSink::Create3d();
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink =
+ FakeLayerTreeFrameSink::Create3d();
FakeLayerTreeHostImpl host_impl(&task_runner_provider, &task_graph_runner);
host_impl.SetVisible(true);
- EXPECT_TRUE(host_impl.InitializeRenderer(compositor_frame_sink.get()));
+ EXPECT_TRUE(host_impl.InitializeRenderer(layer_tree_frame_sink.get()));
// This test constructs a tree consisting of a single layer.
std::unique_ptr<LayerImpl> layer1 =
@@ -291,11 +291,11 @@
// Unfortunate preamble.
FakeImplTaskRunnerProvider task_runner_provider;
TestTaskGraphRunner task_graph_runner;
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink =
- FakeCompositorFrameSink::Create3d();
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink =
+ FakeLayerTreeFrameSink::Create3d();
FakeLayerTreeHostImpl host_impl(&task_runner_provider, &task_graph_runner);
host_impl.SetVisible(true);
- EXPECT_TRUE(host_impl.InitializeRenderer(compositor_frame_sink.get()));
+ EXPECT_TRUE(host_impl.InitializeRenderer(layer_tree_frame_sink.get()));
// This test constructs the following tree.
// 1
@@ -346,11 +346,11 @@
// Unfortunate preamble.
FakeImplTaskRunnerProvider task_runner_provider;
TestTaskGraphRunner task_graph_runner;
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink =
- FakeCompositorFrameSink::Create3d();
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink =
+ FakeLayerTreeFrameSink::Create3d();
FakeLayerTreeHostImpl host_impl(&task_runner_provider, &task_graph_runner);
host_impl.SetVisible(true);
- EXPECT_TRUE(host_impl.InitializeRenderer(compositor_frame_sink.get()));
+ EXPECT_TRUE(host_impl.InitializeRenderer(layer_tree_frame_sink.get()));
// This test constructs a tree consisting of a single layer.
std::unique_ptr<LayerImpl> layer1 =
diff --git a/cc/layers/nine_patch_layer_impl_unittest.cc b/cc/layers/nine_patch_layer_impl_unittest.cc
index d704a83..7d6636bd 100644
--- a/cc/layers/nine_patch_layer_impl_unittest.cc
+++ b/cc/layers/nine_patch_layer_impl_unittest.cc
@@ -9,8 +9,8 @@
#include "cc/quads/texture_draw_quad.h"
#include "cc/resources/ui_resource_bitmap.h"
#include "cc/resources/ui_resource_client.h"
-#include "cc/test/fake_compositor_frame_sink.h"
#include "cc/test/fake_impl_task_runner_provider.h"
+#include "cc/test/fake_layer_tree_frame_sink.h"
#include "cc/test/fake_ui_resource_layer_tree_host_impl.h"
#include "cc/test/geometry_test_utils.h"
#include "cc/test/layer_test_common.h"
@@ -45,12 +45,12 @@
FakeImplTaskRunnerProvider task_runner_provider;
TestTaskGraphRunner task_graph_runner;
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink =
- FakeCompositorFrameSink::Create3d();
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink =
+ FakeLayerTreeFrameSink::Create3d();
FakeUIResourceLayerTreeHostImpl host_impl(&task_runner_provider,
&task_graph_runner);
host_impl.SetVisible(true);
- host_impl.InitializeRenderer(compositor_frame_sink.get());
+ host_impl.InitializeRenderer(layer_tree_frame_sink.get());
std::unique_ptr<NinePatchLayerImpl> layer =
NinePatchLayerImpl::Create(host_impl.active_tree(), 1);
@@ -153,12 +153,12 @@
FakeImplTaskRunnerProvider task_runner_provider;
TestTaskGraphRunner task_graph_runner;
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink =
- FakeCompositorFrameSink::Create3d();
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink =
+ FakeLayerTreeFrameSink::Create3d();
FakeUIResourceLayerTreeHostImpl host_impl(&task_runner_provider,
&task_graph_runner);
host_impl.SetVisible(true);
- host_impl.InitializeRenderer(compositor_frame_sink.get());
+ host_impl.InitializeRenderer(layer_tree_frame_sink.get());
std::unique_ptr<NinePatchLayerImpl> layer =
NinePatchLayerImpl::Create(host_impl.active_tree(), 1);
diff --git a/cc/layers/picture_layer_impl_perftest.cc b/cc/layers/picture_layer_impl_perftest.cc
index 3f5033a..98382d4 100644
--- a/cc/layers/picture_layer_impl_perftest.cc
+++ b/cc/layers/picture_layer_impl_perftest.cc
@@ -7,8 +7,8 @@
#include "base/macros.h"
#include "base/threading/thread_task_runner_handle.h"
#include "cc/base/lap_timer.h"
-#include "cc/test/fake_compositor_frame_sink.h"
#include "cc/test/fake_impl_task_runner_provider.h"
+#include "cc/test/fake_layer_tree_frame_sink.h"
#include "cc/test/fake_layer_tree_host_impl.h"
#include "cc/test/fake_picture_layer_impl.h"
#include "cc/test/fake_raster_source.h"
@@ -42,7 +42,7 @@
public:
PictureLayerImplPerfTest()
: task_runner_provider_(base::ThreadTaskRunnerHandle::Get()),
- compositor_frame_sink_(FakeCompositorFrameSink::Create3d()),
+ layer_tree_frame_sink_(FakeLayerTreeFrameSink::Create3d()),
host_impl_(LayerTreeSettings(),
&task_runner_provider_,
&task_graph_runner_),
@@ -52,7 +52,7 @@
void SetUp() override {
host_impl_.SetVisible(true);
- host_impl_.InitializeRenderer(compositor_frame_sink_.get());
+ host_impl_.InitializeRenderer(layer_tree_frame_sink_.get());
}
void SetupPendingTree(const gfx::Size& layer_bounds) {
@@ -175,7 +175,7 @@
protected:
TestTaskGraphRunner task_graph_runner_;
FakeImplTaskRunnerProvider task_runner_provider_;
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink_;
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink_;
FakeLayerTreeHostImpl host_impl_;
FakePictureLayerImpl* pending_layer_;
LapTimer timer_;
diff --git a/cc/layers/picture_layer_impl_unittest.cc b/cc/layers/picture_layer_impl_unittest.cc
index 6b326b8..0d7ac4d0 100644
--- a/cc/layers/picture_layer_impl_unittest.cc
+++ b/cc/layers/picture_layer_impl_unittest.cc
@@ -22,9 +22,9 @@
#include "cc/quads/draw_quad.h"
#include "cc/quads/tile_draw_quad.h"
#include "cc/test/begin_frame_args_test.h"
-#include "cc/test/fake_compositor_frame_sink.h"
#include "cc/test/fake_content_layer_client.h"
#include "cc/test/fake_impl_task_runner_provider.h"
+#include "cc/test/fake_layer_tree_frame_sink.h"
#include "cc/test/fake_layer_tree_host.h"
#include "cc/test/fake_layer_tree_host_client.h"
#include "cc/test/fake_layer_tree_host_impl.h"
@@ -86,8 +86,8 @@
return settings;
}
- std::unique_ptr<CompositorFrameSink> CreateCompositorFrameSink() override {
- return FakeCompositorFrameSink::Create3dForGpuRasterization();
+ std::unique_ptr<LayerTreeFrameSink> CreateLayerTreeFrameSink() override {
+ return FakeLayerTreeFrameSink::Create3dForGpuRasterization();
}
void SetupDefaultTreesWithFixedTileSize(const gfx::Size& layer_bounds,
@@ -1445,8 +1445,7 @@
std::unique_ptr<TestWebGraphicsContext3D> context =
TestWebGraphicsContext3D::Create();
context->set_max_texture_size(140);
- ResetCompositorFrameSink(
- FakeCompositorFrameSink::Create3d(std::move(context)));
+ ResetLayerTreeFrameSink(FakeLayerTreeFrameSink::Create3d(std::move(context)));
SetupDrawPropertiesAndUpdateTiles(pending_layer(), 1.f, 1.f, 1.f, 1.f, 0.f,
false);
@@ -1481,8 +1480,7 @@
std::unique_ptr<TestWebGraphicsContext3D> context =
TestWebGraphicsContext3D::Create();
context->set_max_texture_size(140);
- ResetCompositorFrameSink(
- FakeCompositorFrameSink::Create3d(std::move(context)));
+ ResetLayerTreeFrameSink(FakeLayerTreeFrameSink::Create3d(std::move(context)));
SetupDrawPropertiesAndUpdateTiles(active_layer(), 1.f, 1.f, 1.f, 1.f, 0.f,
false);
@@ -3593,8 +3591,8 @@
class PictureLayerImplTestWithDelegatingRenderer : public PictureLayerImplTest {
public:
- std::unique_ptr<CompositorFrameSink> CreateCompositorFrameSink() override {
- return FakeCompositorFrameSink::Create3d();
+ std::unique_ptr<LayerTreeFrameSink> CreateLayerTreeFrameSink() override {
+ return FakeLayerTreeFrameSink::Create3d();
}
};
diff --git a/cc/layers/picture_layer_unittest.cc b/cc/layers/picture_layer_unittest.cc
index f976ab9f..82cd0be 100644
--- a/cc/layers/picture_layer_unittest.cc
+++ b/cc/layers/picture_layer_unittest.cc
@@ -13,8 +13,8 @@
#include "cc/layers/content_layer_client.h"
#include "cc/layers/picture_layer_impl.h"
#include "cc/paint/paint_flags.h"
-#include "cc/test/fake_compositor_frame_sink.h"
#include "cc/test/fake_content_layer_client.h"
+#include "cc/test/fake_layer_tree_frame_sink.h"
#include "cc/test/fake_layer_tree_host.h"
#include "cc/test/fake_picture_layer.h"
#include "cc/test/fake_picture_layer_impl.h"
@@ -57,11 +57,11 @@
FakeImplTaskRunnerProvider impl_task_runner_provider;
- std::unique_ptr<FakeCompositorFrameSink> compositor_frame_sink =
- FakeCompositorFrameSink::CreateSoftware();
+ std::unique_ptr<FakeLayerTreeFrameSink> layer_tree_frame_sink =
+ FakeLayerTreeFrameSink::CreateSoftware();
FakeLayerTreeHostImpl host_impl(
LayerTreeSettings(), &impl_task_runner_provider, &task_graph_runner);
- host_impl.InitializeRenderer(compositor_frame_sink.get());
+ host_impl.InitializeRenderer(layer_tree_frame_sink.get());
host_impl.CreatePendingTree();
std::unique_ptr<FakePictureLayerImpl> layer_impl =
FakePictureLayerImpl::Create(host_impl.pending_tree(), 1);
@@ -96,13 +96,13 @@
host->CommitComplete();
FakeImplTaskRunnerProvider impl_task_runner_provider;
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink(
- FakeCompositorFrameSink::Create3d());
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink(
+ FakeLayerTreeFrameSink::Create3d());
LayerTreeSettings layer_tree_settings = LayerTreeSettings();
FakeLayerTreeHostImpl host_impl(
layer_tree_settings, &impl_task_runner_provider, &task_graph_runner);
host_impl.SetVisible(true);
- host_impl.InitializeRenderer(compositor_frame_sink.get());
+ host_impl.InitializeRenderer(layer_tree_frame_sink.get());
host_impl.CreatePendingTree();
host_impl.pending_tree()->SetRootLayerForTesting(
FakePictureLayerImpl::Create(host_impl.pending_tree(), 1));
@@ -137,13 +137,13 @@
host->CommitComplete();
FakeImplTaskRunnerProvider impl_task_runner_provider;
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink(
- FakeCompositorFrameSink::Create3d());
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink(
+ FakeLayerTreeFrameSink::Create3d());
LayerTreeSettings layer_tree_settings = LayerTreeSettings();
FakeLayerTreeHostImpl host_impl(
layer_tree_settings, &impl_task_runner_provider, &task_graph_runner);
host_impl.SetVisible(true);
- host_impl.InitializeRenderer(compositor_frame_sink.get());
+ host_impl.InitializeRenderer(layer_tree_frame_sink.get());
host_impl.CreatePendingTree();
host_impl.pending_tree()->SetRootLayerForTesting(
FakePictureLayerImpl::Create(host_impl.pending_tree(), 1));
@@ -182,13 +182,13 @@
FakeImplTaskRunnerProvider impl_task_runner_provider;
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink(
- FakeCompositorFrameSink::Create3d());
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink(
+ FakeLayerTreeFrameSink::Create3d());
LayerTreeSettings layer_tree_settings = LayerTreeSettings();
FakeLayerTreeHostImpl host_impl(
layer_tree_settings, &impl_task_runner_provider, &task_graph_runner);
host_impl.SetVisible(true);
- EXPECT_TRUE(host_impl.InitializeRenderer(compositor_frame_sink.get()));
+ EXPECT_TRUE(host_impl.InitializeRenderer(layer_tree_frame_sink.get()));
host_impl.CreatePendingTree();
host_impl.pending_tree()->SetRootLayerForTesting(
diff --git a/cc/layers/render_surface_unittest.cc b/cc/layers/render_surface_unittest.cc
index db9fed9..d05b5b1b 100644
--- a/cc/layers/render_surface_unittest.cc
+++ b/cc/layers/render_surface_unittest.cc
@@ -6,8 +6,8 @@
#include "cc/layers/layer_impl.h"
#include "cc/layers/render_surface_impl.h"
#include "cc/quads/shared_quad_state.h"
-#include "cc/test/fake_compositor_frame_sink.h"
#include "cc/test/fake_impl_task_runner_provider.h"
+#include "cc/test/fake_layer_tree_frame_sink.h"
#include "cc/test/fake_layer_tree_host_impl.h"
#include "cc/test/geometry_test_utils.h"
#include "cc/test/layer_test_common.h"
@@ -39,8 +39,8 @@
FakeImplTaskRunnerProvider task_runner_provider;
TestTaskGraphRunner task_graph_runner;
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink =
- FakeCompositorFrameSink::Create3d();
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink =
+ FakeLayerTreeFrameSink::Create3d();
FakeLayerTreeHostImpl host_impl(&task_runner_provider, &task_graph_runner);
std::unique_ptr<LayerImpl> owning_layer =
LayerImpl::Create(host_impl.active_tree(), 1);
@@ -49,7 +49,7 @@
host_impl.active_tree()->ResetAllChangeTracking();
host_impl.active_tree()->SetRootLayerForTesting(std::move(owning_layer));
host_impl.SetVisible(true);
- host_impl.InitializeRenderer(compositor_frame_sink.get());
+ host_impl.InitializeRenderer(layer_tree_frame_sink.get());
host_impl.active_tree()->BuildLayerListAndPropertyTreesForTesting();
host_impl.active_tree()->UpdateDrawProperties(false /* update_lcd_text */);
@@ -92,8 +92,8 @@
TEST(RenderSurfaceTest, SanityCheckSurfaceCreatesCorrectSharedQuadState) {
FakeImplTaskRunnerProvider task_runner_provider;
TestTaskGraphRunner task_graph_runner;
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink =
- FakeCompositorFrameSink::Create3d();
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink =
+ FakeLayerTreeFrameSink::Create3d();
FakeLayerTreeHostImpl host_impl(&task_runner_provider, &task_graph_runner);
std::unique_ptr<LayerImpl> root_layer =
LayerImpl::Create(host_impl.active_tree(), 1);
@@ -109,7 +109,7 @@
root_layer->test_properties()->AddChild(std::move(owning_layer));
host_impl.active_tree()->SetRootLayerForTesting(std::move(root_layer));
host_impl.SetVisible(true);
- host_impl.InitializeRenderer(compositor_frame_sink.get());
+ host_impl.InitializeRenderer(layer_tree_frame_sink.get());
host_impl.active_tree()->BuildLayerListAndPropertyTreesForTesting();
host_impl.active_tree()->UpdateDrawProperties(false /* update_lcd_text */);
@@ -154,8 +154,8 @@
TEST(RenderSurfaceTest, SanityCheckSurfaceCreatesCorrectRenderPass) {
FakeImplTaskRunnerProvider task_runner_provider;
TestTaskGraphRunner task_graph_runner;
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink =
- FakeCompositorFrameSink::Create3d();
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink =
+ FakeLayerTreeFrameSink::Create3d();
FakeLayerTreeHostImpl host_impl(&task_runner_provider, &task_graph_runner);
std::unique_ptr<LayerImpl> root_layer =
LayerImpl::Create(host_impl.active_tree(), 1);
@@ -168,7 +168,7 @@
root_layer->test_properties()->AddChild(std::move(owning_layer));
host_impl.active_tree()->SetRootLayerForTesting(std::move(root_layer));
host_impl.SetVisible(true);
- host_impl.InitializeRenderer(compositor_frame_sink.get());
+ host_impl.InitializeRenderer(layer_tree_frame_sink.get());
host_impl.active_tree()->BuildLayerListAndPropertyTreesForTesting();
host_impl.active_tree()->UpdateDrawProperties(false /* update_lcd_text */);
diff --git a/cc/layers/texture_layer_impl_unittest.cc b/cc/layers/texture_layer_impl_unittest.cc
index babb446..aa44f93 100644
--- a/cc/layers/texture_layer_impl_unittest.cc
+++ b/cc/layers/texture_layer_impl_unittest.cc
@@ -6,11 +6,11 @@
#include <stddef.h>
-#include "cc/output/compositor_frame_sink.h"
#include "cc/output/context_provider.h"
+#include "cc/output/layer_tree_frame_sink.h"
#include "cc/quads/draw_quad.h"
#include "cc/quads/texture_draw_quad.h"
-#include "cc/test/fake_compositor_frame_sink.h"
+#include "cc/test/fake_layer_tree_frame_sink.h"
#include "cc/test/layer_test_common.h"
#include "gpu/command_buffer/client/gles2_interface.h"
#include "testing/gtest/include/gtest/gtest.h"
@@ -55,7 +55,7 @@
LayerTestCommon::LayerImplTest impl;
gpu::Mailbox mailbox;
- impl.compositor_frame_sink()
+ impl.layer_tree_frame_sink()
->context_provider()
->ContextGL()
->GenMailboxCHROMIUM(mailbox.name);
@@ -115,7 +115,7 @@
LayerTestCommon::LayerImplTest impl;
gpu::Mailbox mailbox;
- impl.compositor_frame_sink()
+ impl.layer_tree_frame_sink()
->context_provider()
->ContextGL()
->GenMailboxCHROMIUM(mailbox.name);
@@ -151,14 +151,14 @@
TEST(TextureLayerImplTest, ResourceNotFreedOnGpuRasterToggle) {
bool released = false;
LayerTestCommon::LayerImplTest impl(
- FakeCompositorFrameSink::Create3dForGpuRasterization());
+ FakeLayerTreeFrameSink::Create3dForGpuRasterization());
impl.host_impl()->AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
gfx::Size layer_size(1000, 1000);
gfx::Size viewport_size(1000, 1000);
gpu::Mailbox mailbox;
- impl.compositor_frame_sink()
+ impl.layer_tree_frame_sink()
->context_provider()
->ContextGL()
->GenMailboxCHROMIUM(mailbox.name);
diff --git a/cc/layers/texture_layer_unittest.cc b/cc/layers/texture_layer_unittest.cc
index c886a26..7e224a8 100644
--- a/cc/layers/texture_layer_unittest.cc
+++ b/cc/layers/texture_layer_unittest.cc
@@ -27,14 +27,14 @@
#include "cc/layers/texture_layer_impl.h"
#include "cc/output/context_provider.h"
#include "cc/resources/returned_resource.h"
-#include "cc/test/fake_compositor_frame_sink.h"
#include "cc/test/fake_impl_task_runner_provider.h"
+#include "cc/test/fake_layer_tree_frame_sink.h"
#include "cc/test/fake_layer_tree_host_client.h"
#include "cc/test/fake_layer_tree_host_impl.h"
#include "cc/test/layer_test_common.h"
#include "cc/test/layer_tree_test.h"
#include "cc/test/stub_layer_tree_host_single_thread_client.h"
-#include "cc/test/test_compositor_frame_sink.h"
+#include "cc/test/test_layer_tree_frame_sink.h"
#include "cc/test/test_task_graph_runner.h"
#include "cc/test/test_web_graphics_context_3d.h"
#include "cc/trees/blocking_task_runner.h"
@@ -207,9 +207,8 @@
class TextureLayerTest : public testing::Test {
public:
TextureLayerTest()
- : compositor_frame_sink_(FakeCompositorFrameSink::Create3d()),
- host_impl_(&task_runner_provider_,
- &task_graph_runner_),
+ : layer_tree_frame_sink_(FakeLayerTreeFrameSink::Create3d()),
+ host_impl_(&task_runner_provider_, &task_graph_runner_),
test_data_(&shared_bitmap_manager_) {}
protected:
@@ -238,7 +237,7 @@
FakeLayerTreeHostClient fake_client_;
TestSharedBitmapManager shared_bitmap_manager_;
TestTaskGraphRunner task_graph_runner_;
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink_;
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink_;
FakeLayerTreeHostImpl host_impl_;
CommonMailboxObjects test_data_;
};
@@ -635,7 +634,7 @@
public:
TextureLayerImplWithMailboxThreadedCallback() = default;
- std::unique_ptr<TestCompositorFrameSink> CreateCompositorFrameSink(
+ std::unique_ptr<TestLayerTreeFrameSink> CreateLayerTreeFrameSink(
const RendererSettings& renderer_settings,
double refresh_rate,
scoped_refptr<ContextProvider> compositor_context_provider,
@@ -644,7 +643,7 @@
bool synchronous_composite =
!HasImplThread() &&
!layer_tree_host()->GetSettings().single_thread_proxy_scheduler;
- return base::MakeUnique<TestCompositorFrameSink>(
+ return base::MakeUnique<TestLayerTreeFrameSink>(
compositor_context_provider, std::move(worker_context_provider),
shared_bitmap_manager(), gpu_memory_buffer_manager(), renderer_settings,
ImplThreadTaskRunner(), synchronous_composite, disable_display_vsync,
@@ -891,7 +890,7 @@
layer_tree_host_ = MockLayerTreeHost::Create(
&fake_client_, &task_graph_runner_, animation_host_.get());
host_impl_.SetVisible(true);
- EXPECT_TRUE(host_impl_.InitializeRenderer(compositor_frame_sink_.get()));
+ EXPECT_TRUE(host_impl_.InitializeRenderer(layer_tree_frame_sink_.get()));
}
bool WillDraw(TextureLayerImpl* layer, DrawMode mode) {
diff --git a/cc/layers/ui_resource_layer_impl_unittest.cc b/cc/layers/ui_resource_layer_impl_unittest.cc
index 37e3927..9e4d4a81 100644
--- a/cc/layers/ui_resource_layer_impl_unittest.cc
+++ b/cc/layers/ui_resource_layer_impl_unittest.cc
@@ -9,8 +9,8 @@
#include "cc/quads/draw_quad.h"
#include "cc/resources/ui_resource_bitmap.h"
#include "cc/resources/ui_resource_client.h"
-#include "cc/test/fake_compositor_frame_sink.h"
#include "cc/test/fake_impl_task_runner_provider.h"
+#include "cc/test/fake_layer_tree_frame_sink.h"
#include "cc/test/fake_layer_tree_host_impl.h"
#include "cc/test/fake_ui_resource_layer_tree_host_impl.h"
#include "cc/test/layer_test_common.h"
@@ -66,12 +66,12 @@
TEST(UIResourceLayerImplTest, VerifyDrawQuads) {
FakeImplTaskRunnerProvider task_runner_provider;
TestTaskGraphRunner task_graph_runner;
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink =
- FakeCompositorFrameSink::Create3d();
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink =
+ FakeLayerTreeFrameSink::Create3d();
FakeUIResourceLayerTreeHostImpl host_impl(&task_runner_provider,
&task_graph_runner);
host_impl.SetVisible(true);
- host_impl.InitializeRenderer(compositor_frame_sink.get());
+ host_impl.InitializeRenderer(layer_tree_frame_sink.get());
// Make sure we're appending quads when there are valid values.
gfx::Size bitmap_size(100, 100);
@@ -118,12 +118,12 @@
TEST(UIResourceLayerImplTest, VerifySetOpaqueOnSkBitmap) {
FakeImplTaskRunnerProvider task_runner_provider;
TestTaskGraphRunner task_graph_runner;
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink =
- FakeCompositorFrameSink::Create3d();
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink =
+ FakeLayerTreeFrameSink::Create3d();
FakeUIResourceLayerTreeHostImpl host_impl(&task_runner_provider,
&task_graph_runner);
host_impl.SetVisible(true);
- host_impl.InitializeRenderer(compositor_frame_sink.get());
+ host_impl.InitializeRenderer(layer_tree_frame_sink.get());
gfx::Size bitmap_size(100, 100);
gfx::Size layer_size(100, 100);
@@ -147,12 +147,12 @@
TEST(UIResourceLayerImplTest, VerifySetOpaqueOnLayer) {
FakeImplTaskRunnerProvider task_runner_provider;
TestTaskGraphRunner task_graph_runner;
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink =
- FakeCompositorFrameSink::Create3d();
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink =
+ FakeLayerTreeFrameSink::Create3d();
FakeUIResourceLayerTreeHostImpl host_impl(&task_runner_provider,
&task_graph_runner);
host_impl.SetVisible(true);
- host_impl.InitializeRenderer(compositor_frame_sink.get());
+ host_impl.InitializeRenderer(layer_tree_frame_sink.get());
gfx::Size bitmap_size(100, 100);
gfx::Size layer_size(100, 100);
diff --git a/cc/output/compositor_frame_sink_unittest.cc b/cc/output/compositor_frame_sink_unittest.cc
deleted file mode 100644
index 127eb43..0000000
--- a/cc/output/compositor_frame_sink_unittest.cc
+++ /dev/null
@@ -1,74 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "cc/output/compositor_frame_sink.h"
-
-#include "base/memory/ptr_util.h"
-#include "cc/output/compositor_frame.h"
-#include "cc/test/fake_compositor_frame_sink_client.h"
-#include "cc/test/test_context_provider.h"
-#include "cc/test/test_web_graphics_context_3d.h"
-#include "gpu/GLES2/gl2extchromium.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace cc {
-namespace {
-
-class TestCompositorFrameSink : public CompositorFrameSink {
- public:
- explicit TestCompositorFrameSink(
- scoped_refptr<TestContextProvider> context_provider,
- scoped_refptr<TestContextProvider> worker_context_provider)
- : CompositorFrameSink(std::move(context_provider),
- std::move(worker_context_provider),
- nullptr,
- nullptr) {}
-
- void SubmitCompositorFrame(CompositorFrame frame) override {
- client_->DidReceiveCompositorFrameAck();
- }
- void DidNotProduceFrame(const BeginFrameAck& ack) override {}
-};
-
-TEST(CompositorFrameSinkTest, ContextLossInformsClient) {
- scoped_refptr<TestContextProvider> provider = TestContextProvider::Create();
- scoped_refptr<TestContextProvider> worker_provider =
- TestContextProvider::CreateWorker();
- TestCompositorFrameSink compositor_frame_sink(provider, worker_provider);
- EXPECT_FALSE(compositor_frame_sink.HasClient());
-
- FakeCompositorFrameSinkClient client;
- EXPECT_TRUE(compositor_frame_sink.BindToClient(&client));
- EXPECT_TRUE(compositor_frame_sink.HasClient());
-
- // Verify DidLoseCompositorFrameSink callback is hooked up correctly.
- EXPECT_FALSE(client.did_lose_compositor_frame_sink_called());
- compositor_frame_sink.context_provider()->ContextGL()->LoseContextCHROMIUM(
- GL_GUILTY_CONTEXT_RESET_ARB, GL_INNOCENT_CONTEXT_RESET_ARB);
- compositor_frame_sink.context_provider()->ContextGL()->Flush();
- EXPECT_TRUE(client.did_lose_compositor_frame_sink_called());
-}
-
-// TODO(danakj): Add a test for worker context failure as well when
-// CompositorFrameSink creates/binds it.
-TEST(CompositorFrameSinkTest, ContextLossFailsBind) {
- scoped_refptr<TestContextProvider> context_provider =
- TestContextProvider::Create();
- scoped_refptr<TestContextProvider> worker_provider =
- TestContextProvider::CreateWorker();
-
- // Lose the context so BindToClient fails.
- context_provider->UnboundTestContext3d()->set_context_lost(true);
-
- TestCompositorFrameSink compositor_frame_sink(context_provider,
- worker_provider);
- EXPECT_FALSE(compositor_frame_sink.HasClient());
-
- FakeCompositorFrameSinkClient client;
- EXPECT_FALSE(compositor_frame_sink.BindToClient(&client));
- EXPECT_FALSE(compositor_frame_sink.HasClient());
-}
-
-} // namespace
-} // namespace cc
diff --git a/cc/output/compositor_frame_sink.cc b/cc/output/layer_tree_frame_sink.cc
similarity index 73%
rename from cc/output/compositor_frame_sink.cc
rename to cc/output/layer_tree_frame_sink.cc
index 607ddf1..fedee969 100644
--- a/cc/output/compositor_frame_sink.cc
+++ b/cc/output/layer_tree_frame_sink.cc
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "cc/output/compositor_frame_sink.h"
+#include "cc/output/layer_tree_frame_sink.h"
#include <stdint.h>
@@ -11,14 +11,14 @@
#include "base/macros.h"
#include "base/threading/thread_task_runner_handle.h"
#include "base/trace_event/trace_event.h"
-#include "cc/output/compositor_frame_sink_client.h"
+#include "cc/output/layer_tree_frame_sink_client.h"
#include "gpu/GLES2/gl2extchromium.h"
#include "gpu/command_buffer/client/context_support.h"
#include "gpu/command_buffer/client/gles2_interface.h"
namespace cc {
-CompositorFrameSink::CompositorFrameSink(
+LayerTreeFrameSink::LayerTreeFrameSink(
scoped_refptr<ContextProvider> context_provider,
scoped_refptr<ContextProvider> worker_context_provider,
gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
@@ -26,22 +26,20 @@
: context_provider_(std::move(context_provider)),
worker_context_provider_(std::move(worker_context_provider)),
gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
- shared_bitmap_manager_(shared_bitmap_manager) {
-}
+ shared_bitmap_manager_(shared_bitmap_manager) {}
-CompositorFrameSink::CompositorFrameSink(
+LayerTreeFrameSink::LayerTreeFrameSink(
scoped_refptr<VulkanContextProvider> vulkan_context_provider)
: vulkan_context_provider_(vulkan_context_provider),
gpu_memory_buffer_manager_(nullptr),
- shared_bitmap_manager_(nullptr) {
-}
+ shared_bitmap_manager_(nullptr) {}
-CompositorFrameSink::~CompositorFrameSink() {
+LayerTreeFrameSink::~LayerTreeFrameSink() {
if (client_)
DetachFromClient();
}
-bool CompositorFrameSink::BindToClient(CompositorFrameSinkClient* client) {
+bool LayerTreeFrameSink::BindToClient(LayerTreeFrameSinkClient* client) {
DCHECK(client);
DCHECK(!client_);
client_ = client;
@@ -51,7 +49,7 @@
success = context_provider_->BindToCurrentThread();
if (success) {
context_provider_->SetLostContextCallback(
- base::Bind(&CompositorFrameSink::DidLoseCompositorFrameSink,
+ base::Bind(&LayerTreeFrameSink::DidLoseLayerTreeFrameSink,
base::Unretained(this)));
}
}
@@ -65,7 +63,7 @@
return success;
}
-void CompositorFrameSink::DetachFromClient() {
+void LayerTreeFrameSink::DetachFromClient() {
DCHECK(client_);
if (context_provider_.get()) {
@@ -77,9 +75,9 @@
client_ = nullptr;
}
-void CompositorFrameSink::DidLoseCompositorFrameSink() {
- TRACE_EVENT0("cc", "CompositorFrameSink::DidLoseCompositorFrameSink");
- client_->DidLoseCompositorFrameSink();
+void LayerTreeFrameSink::DidLoseLayerTreeFrameSink() {
+ TRACE_EVENT0("cc", "LayerTreeFrameSink::DidLoseLayerTreeFrameSink");
+ client_->DidLoseLayerTreeFrameSink();
}
} // namespace cc
diff --git a/cc/output/compositor_frame_sink.h b/cc/output/layer_tree_frame_sink.h
similarity index 75%
rename from cc/output/compositor_frame_sink.h
rename to cc/output/layer_tree_frame_sink.h
index 28b7258..94d8231 100644
--- a/cc/output/compositor_frame_sink.h
+++ b/cc/output/layer_tree_frame_sink.h
@@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef CC_OUTPUT_COMPOSITOR_FRAME_SINK_H_
-#define CC_OUTPUT_COMPOSITOR_FRAME_SINK_H_
+#ifndef CC_OUTPUT_LAYER_TREE_FRAME_SINK_H_
+#define CC_OUTPUT_LAYER_TREE_FRAME_SINK_H_
#include <deque>
#include <memory>
@@ -27,17 +27,17 @@
struct BeginFrameAck;
class CompositorFrame;
-class CompositorFrameSinkClient;
+class LayerTreeFrameSinkClient;
class LocalSurfaceId;
class SharedBitmapManager;
// An interface for submitting CompositorFrames to a display compositor
-// which will compose frames from multiple CompositorFrameSinks to show
-// on screen to the user.
+// which will compose frames from multiple clients to show on screen to the
+// user.
// If a context_provider() is present, frames should be submitted with
// OpenGL resources (created with the context_provider()). If not, then
// SharedBitmap resources should be used.
-class CC_EXPORT CompositorFrameSink {
+class CC_EXPORT LayerTreeFrameSink {
public:
struct Capabilities {
Capabilities() = default;
@@ -56,33 +56,33 @@
// Constructor for GL-based and/or software resources.
// gpu_memory_buffer_manager and shared_bitmap_manager must outlive the
- // CompositorFrameSink.
+ // LayerTreeFrameSink.
// shared_bitmap_manager is optional (won't be used) if context_provider is
// present.
// gpu_memory_buffer_manager is optional (won't be used) if context_provider
// is not present.
- CompositorFrameSink(scoped_refptr<ContextProvider> context_provider,
- scoped_refptr<ContextProvider> worker_context_provider,
- gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
- SharedBitmapManager* shared_bitmap_manager);
+ LayerTreeFrameSink(scoped_refptr<ContextProvider> context_provider,
+ scoped_refptr<ContextProvider> worker_context_provider,
+ gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
+ SharedBitmapManager* shared_bitmap_manager);
// Constructor for Vulkan-based resources.
- explicit CompositorFrameSink(
+ explicit LayerTreeFrameSink(
scoped_refptr<VulkanContextProvider> vulkan_context_provider);
- virtual ~CompositorFrameSink();
+ virtual ~LayerTreeFrameSink();
// Called by the compositor on the compositor thread. This is a place where
// thread-specific data for the output surface can be initialized, since from
// this point to when DetachFromClient() is called the output surface will
// only be used on the compositor thread.
// The caller should call DetachFromClient() on the same thread before
- // destroying the CompositorFrameSink, even if this fails. And BindToClient
- // should not be called twice for a given CompositorFrameSink.
- virtual bool BindToClient(CompositorFrameSinkClient* client);
+ // destroying the LayerTreeFrameSink, even if this fails. And BindToClient
+ // should not be called twice for a given LayerTreeFrameSink.
+ virtual bool BindToClient(LayerTreeFrameSinkClient* client);
// Must be called from the thread where BindToClient was called if
- // BindToClient succeeded, after which the CompositorFrameSink may be
+ // BindToClient succeeded, after which the LayerTreeFrameSink may be
// destroyed from any thread. This is a place where thread-specific data for
// the object can be uninitialized.
virtual void DetachFromClient();
@@ -107,14 +107,13 @@
return shared_bitmap_manager_;
}
- // If supported, this sets the LocalSurfaceId the CompositorFrameSink will use
+ // If supported, this sets the LocalSurfaceId the LayerTreeFrameSink will use
// to submit a CompositorFrame.
virtual void SetLocalSurfaceId(const LocalSurfaceId& local_surface_id) {}
- // Support for a pull-model where draws are requested by the output surface.
- //
- // CompositorFrameSink::Invalidate is called by the compositor to notify that
- // there's new content.
+ // Support for a pull-model where draws are requested by the implementation of
+ // LayerTreeFrameSink. This is called by the compositor to notify that there's
+ // new content.
virtual void Invalidate() {}
// For successful swaps, the implementation must call
@@ -129,11 +128,11 @@
protected:
// Bound to the ContextProvider to hear about when it is lost and inform the
// |client_|.
- void DidLoseCompositorFrameSink();
+ void DidLoseLayerTreeFrameSink();
- CompositorFrameSinkClient* client_ = nullptr;
+ LayerTreeFrameSinkClient* client_ = nullptr;
- struct CompositorFrameSink::Capabilities capabilities_;
+ struct LayerTreeFrameSink::Capabilities capabilities_;
scoped_refptr<ContextProvider> context_provider_;
scoped_refptr<ContextProvider> worker_context_provider_;
scoped_refptr<VulkanContextProvider> vulkan_context_provider_;
@@ -141,9 +140,9 @@
SharedBitmapManager* shared_bitmap_manager_;
private:
- DISALLOW_COPY_AND_ASSIGN(CompositorFrameSink);
+ DISALLOW_COPY_AND_ASSIGN(LayerTreeFrameSink);
};
} // namespace cc
-#endif // CC_OUTPUT_COMPOSITOR_FRAME_SINK_H_
+#endif // CC_OUTPUT_LAYER_TREE_FRAME_SINK_H_
diff --git a/cc/output/compositor_frame_sink_client.h b/cc/output/layer_tree_frame_sink_client.h
similarity index 80%
rename from cc/output/compositor_frame_sink_client.h
rename to cc/output/layer_tree_frame_sink_client.h
index afc9b3a..9cf8728 100644
--- a/cc/output/compositor_frame_sink_client.h
+++ b/cc/output/layer_tree_frame_sink_client.h
@@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef CC_OUTPUT_COMPOSITOR_FRAME_SINK_CLIENT_H_
-#define CC_OUTPUT_COMPOSITOR_FRAME_SINK_CLIENT_H_
+#ifndef CC_OUTPUT_LAYER_TREE_FRAME_SINK_CLIENT_H_
+#define CC_OUTPUT_LAYER_TREE_FRAME_SINK_CLIENT_H_
#include "base/callback.h"
#include "base/memory/ref_counted.h"
@@ -23,10 +23,10 @@
class BeginFrameSource;
struct ManagedMemoryPolicy;
-class CC_EXPORT CompositorFrameSinkClient {
+class CC_EXPORT LayerTreeFrameSinkClient {
public:
// Pass the begin frame source for the client to observe. Client does not own
- // the BeginFrameSource. CompositorFrameSink should call this once after
+ // the BeginFrameSource. LayerTreeFrameSink should call this once after
// binding to the client and then call again with a null while detaching.
virtual void SetBeginFrameSource(BeginFrameSource* source) = 0;
@@ -35,7 +35,7 @@
// If set, |callback| will be called subsequent to each new tree activation,
// regardless of the compositor visibility or damage. |callback| must remain
- // valid for the lifetime of the CompositorFrameSinkClient or until
+ // valid for the lifetime of the LayerTreeFrameSinkClient or until
// unregistered by giving a null base::Closure.
virtual void SetTreeActivationCallback(const base::Closure& callback) = 0;
@@ -45,10 +45,10 @@
// so that frames are submitted only at the rate it can handle them.
virtual void DidReceiveCompositorFrameAck() = 0;
- // The CompositorFrameSink is lost when the ContextProviders held by it
- // encounter an error. In this case the CompositorFrameSink (and the
+ // The LayerTreeFrameSink is lost when the ContextProviders held by it
+ // encounter an error. In this case the LayerTreeFrameSink (and the
// ContextProviders) must be recreated.
- virtual void DidLoseCompositorFrameSink() = 0;
+ virtual void DidLoseLayerTreeFrameSink() = 0;
// For SynchronousCompositor (WebView) to ask the layer compositor to submit
// a new CompositorFrame synchronously.
@@ -68,9 +68,9 @@
const gfx::Transform& transform) = 0;
protected:
- virtual ~CompositorFrameSinkClient() {}
+ virtual ~LayerTreeFrameSinkClient() {}
};
} // namespace cc
-#endif // CC_OUTPUT_COMPOSITOR_FRAME_SINK_CLIENT_H_
+#endif // CC_OUTPUT_LAYER_TREE_FRAME_SINK_CLIENT_H_
diff --git a/cc/output/layer_tree_frame_sink_unittest.cc b/cc/output/layer_tree_frame_sink_unittest.cc
new file mode 100644
index 0000000..9fc98f7
--- /dev/null
+++ b/cc/output/layer_tree_frame_sink_unittest.cc
@@ -0,0 +1,74 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "cc/output/layer_tree_frame_sink.h"
+
+#include "base/memory/ptr_util.h"
+#include "cc/output/compositor_frame.h"
+#include "cc/test/fake_layer_tree_frame_sink_client.h"
+#include "cc/test/test_context_provider.h"
+#include "cc/test/test_web_graphics_context_3d.h"
+#include "gpu/GLES2/gl2extchromium.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace cc {
+namespace {
+
+class TestLayerTreeFrameSink : public LayerTreeFrameSink {
+ public:
+ explicit TestLayerTreeFrameSink(
+ scoped_refptr<TestContextProvider> context_provider,
+ scoped_refptr<TestContextProvider> worker_context_provider)
+ : LayerTreeFrameSink(std::move(context_provider),
+ std::move(worker_context_provider),
+ nullptr,
+ nullptr) {}
+
+ void SubmitCompositorFrame(CompositorFrame frame) override {
+ client_->DidReceiveCompositorFrameAck();
+ }
+ void DidNotProduceFrame(const BeginFrameAck& ack) override {}
+};
+
+TEST(LayerTreeFrameSinkTest, ContextLossInformsClient) {
+ scoped_refptr<TestContextProvider> provider = TestContextProvider::Create();
+ scoped_refptr<TestContextProvider> worker_provider =
+ TestContextProvider::CreateWorker();
+ TestLayerTreeFrameSink layer_tree_frame_sink(provider, worker_provider);
+ EXPECT_FALSE(layer_tree_frame_sink.HasClient());
+
+ FakeLayerTreeFrameSinkClient client;
+ EXPECT_TRUE(layer_tree_frame_sink.BindToClient(&client));
+ EXPECT_TRUE(layer_tree_frame_sink.HasClient());
+
+ // Verify DidLoseLayerTreeFrameSink callback is hooked up correctly.
+ EXPECT_FALSE(client.did_lose_layer_tree_frame_sink_called());
+ layer_tree_frame_sink.context_provider()->ContextGL()->LoseContextCHROMIUM(
+ GL_GUILTY_CONTEXT_RESET_ARB, GL_INNOCENT_CONTEXT_RESET_ARB);
+ layer_tree_frame_sink.context_provider()->ContextGL()->Flush();
+ EXPECT_TRUE(client.did_lose_layer_tree_frame_sink_called());
+}
+
+// TODO(danakj): Add a test for worker context failure as well when
+// LayerTreeFrameSink creates/binds it.
+TEST(LayerTreeFrameSinkTest, ContextLossFailsBind) {
+ scoped_refptr<TestContextProvider> context_provider =
+ TestContextProvider::Create();
+ scoped_refptr<TestContextProvider> worker_provider =
+ TestContextProvider::CreateWorker();
+
+ // Lose the context so BindToClient fails.
+ context_provider->UnboundTestContext3d()->set_context_lost(true);
+
+ TestLayerTreeFrameSink layer_tree_frame_sink(context_provider,
+ worker_provider);
+ EXPECT_FALSE(layer_tree_frame_sink.HasClient());
+
+ FakeLayerTreeFrameSinkClient client;
+ EXPECT_FALSE(layer_tree_frame_sink.BindToClient(&client));
+ EXPECT_FALSE(layer_tree_frame_sink.HasClient());
+}
+
+} // namespace
+} // namespace cc
diff --git a/cc/scheduler/commit_earlyout_reason.h b/cc/scheduler/commit_earlyout_reason.h
index cd79c5c..b272b34 100644
--- a/cc/scheduler/commit_earlyout_reason.h
+++ b/cc/scheduler/commit_earlyout_reason.h
@@ -11,7 +11,7 @@
namespace cc {
enum class CommitEarlyOutReason {
- ABORTED_COMPOSITOR_FRAME_SINK_LOST,
+ ABORTED_LAYER_TREE_FRAME_SINK_LOST,
ABORTED_NOT_VISIBLE,
ABORTED_DEFERRED_COMMIT,
FINISHED_NO_UPDATES,
@@ -19,8 +19,8 @@
inline const char* CommitEarlyOutReasonToString(CommitEarlyOutReason reason) {
switch (reason) {
- case CommitEarlyOutReason::ABORTED_COMPOSITOR_FRAME_SINK_LOST:
- return "CommitEarlyOutReason::ABORTED_COMPOSITOR_FRAME_SINK_LOST";
+ case CommitEarlyOutReason::ABORTED_LAYER_TREE_FRAME_SINK_LOST:
+ return "CommitEarlyOutReason::ABORTED_LAYER_TREE_FRAME_SINK_LOST";
case CommitEarlyOutReason::ABORTED_NOT_VISIBLE:
return "CommitEarlyOutReason::ABORTED_NOT_VISIBLE";
case CommitEarlyOutReason::ABORTED_DEFERRED_COMMIT:
diff --git a/cc/scheduler/compositor_timing_history.cc b/cc/scheduler/compositor_timing_history.cc
index d53023a..9b25f361 100644
--- a/cc/scheduler/compositor_timing_history.cc
+++ b/cc/scheduler/compositor_timing_history.cc
@@ -459,7 +459,7 @@
return draw_duration_history_.Percentile(kDrawEstimationPercentile);
}
-void CompositorTimingHistory::DidCreateAndInitializeCompositorFrameSink() {
+void CompositorTimingHistory::DidCreateAndInitializeLayerTreeFrameSink() {
// After we get a new output surface, we won't get a spurious
// CompositorFrameAck from the old output surface.
submit_start_time_ = base::TimeTicks();
diff --git a/cc/scheduler/compositor_timing_history.h b/cc/scheduler/compositor_timing_history.h
index 58f5a20..21a6eae 100644
--- a/cc/scheduler/compositor_timing_history.h
+++ b/cc/scheduler/compositor_timing_history.h
@@ -52,7 +52,7 @@
// State that affects when events should be expected/recorded/reported.
void SetRecordingEnabled(bool enabled);
- void DidCreateAndInitializeCompositorFrameSink();
+ void DidCreateAndInitializeLayerTreeFrameSink();
// Events to be timed.
void WillBeginImplFrame(bool new_active_tree_is_likely,
diff --git a/cc/scheduler/scheduler.cc b/cc/scheduler/scheduler.cc
index ac507a3d..ee5c3b7 100644
--- a/cc/scheduler/scheduler.cc
+++ b/cc/scheduler/scheduler.cc
@@ -180,19 +180,19 @@
state_machine_.DidPrepareTiles();
}
-void Scheduler::DidLoseCompositorFrameSink() {
- TRACE_EVENT0("cc", "Scheduler::DidLoseCompositorFrameSink");
- state_machine_.DidLoseCompositorFrameSink();
+void Scheduler::DidLoseLayerTreeFrameSink() {
+ TRACE_EVENT0("cc", "Scheduler::DidLoseLayerTreeFrameSink");
+ state_machine_.DidLoseLayerTreeFrameSink();
UpdateCompositorTimingHistoryRecordingEnabled();
ProcessScheduledActions();
}
-void Scheduler::DidCreateAndInitializeCompositorFrameSink() {
- TRACE_EVENT0("cc", "Scheduler::DidCreateAndInitializeCompositorFrameSink");
+void Scheduler::DidCreateAndInitializeLayerTreeFrameSink() {
+ TRACE_EVENT0("cc", "Scheduler::DidCreateAndInitializeLayerTreeFrameSink");
DCHECK(!observing_begin_frame_source_);
DCHECK(begin_impl_frame_deadline_task_.IsCancelled());
- state_machine_.DidCreateAndInitializeCompositorFrameSink();
- compositor_timing_history_->DidCreateAndInitializeCompositorFrameSink();
+ state_machine_.DidCreateAndInitializeLayerTreeFrameSink();
+ compositor_timing_history_->DidCreateAndInitializeLayerTreeFrameSink();
UpdateCompositorTimingHistoryRecordingEnabled();
ProcessScheduledActions();
}
@@ -304,7 +304,7 @@
ProcessScheduledActions();
}
-void Scheduler::OnDrawForCompositorFrameSink(bool resourceless_software_draw) {
+void Scheduler::OnDrawForLayerTreeFrameSink(bool resourceless_software_draw) {
DCHECK(settings_.using_synchronous_renderer_compositor);
DCHECK_EQ(state_machine_.begin_impl_frame_state(),
SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
@@ -475,7 +475,7 @@
DCHECK_EQ(state_machine_.begin_impl_frame_state(),
SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
DCHECK(begin_impl_frame_deadline_task_.IsCancelled());
- DCHECK(state_machine_.HasInitializedCompositorFrameSink());
+ DCHECK(state_machine_.HasInitializedLayerTreeFrameSink());
begin_impl_frame_tracker_.Start(args);
state_machine_.OnBeginImplFrame(args.source_id, args.sequence_number);
@@ -684,17 +684,17 @@
compositor_timing_history_->DrawAborted();
break;
}
- case SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION:
- state_machine_.WillBeginCompositorFrameSinkCreation();
- client_->ScheduledActionBeginCompositorFrameSinkCreation();
+ case SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION:
+ state_machine_.WillBeginLayerTreeFrameSinkCreation();
+ client_->ScheduledActionBeginLayerTreeFrameSinkCreation();
break;
case SchedulerStateMachine::ACTION_PREPARE_TILES:
state_machine_.WillPrepareTiles();
client_->ScheduledActionPrepareTiles();
break;
- case SchedulerStateMachine::ACTION_INVALIDATE_COMPOSITOR_FRAME_SINK: {
- state_machine_.WillInvalidateCompositorFrameSink();
- client_->ScheduledActionInvalidateCompositorFrameSink();
+ case SchedulerStateMachine::ACTION_INVALIDATE_LAYER_TREE_FRAME_SINK: {
+ state_machine_.WillInvalidateLayerTreeFrameSink();
+ client_->ScheduledActionInvalidateLayerTreeFrameSink();
break;
}
}
@@ -766,7 +766,7 @@
void Scheduler::UpdateCompositorTimingHistoryRecordingEnabled() {
compositor_timing_history_->SetRecordingEnabled(
- state_machine_.HasInitializedCompositorFrameSink() &&
+ state_machine_.HasInitializedLayerTreeFrameSink() &&
state_machine_.visible());
}
diff --git a/cc/scheduler/scheduler.h b/cc/scheduler/scheduler.h
index 72241c5..aa1aad6a 100644
--- a/cc/scheduler/scheduler.h
+++ b/cc/scheduler/scheduler.h
@@ -42,9 +42,9 @@
virtual DrawResult ScheduledActionDrawForced() = 0;
virtual void ScheduledActionCommit() = 0;
virtual void ScheduledActionActivateSyncTree() = 0;
- virtual void ScheduledActionBeginCompositorFrameSinkCreation() = 0;
+ virtual void ScheduledActionBeginLayerTreeFrameSinkCreation() = 0;
virtual void ScheduledActionPrepareTiles() = 0;
- virtual void ScheduledActionInvalidateCompositorFrameSink() = 0;
+ virtual void ScheduledActionInvalidateLayerTreeFrameSink() = 0;
virtual void ScheduledActionPerformImplSideInvalidation() = 0;
virtual void DidFinishImplFrame() = 0;
virtual void DidNotProduceFrame(const BeginFrameAck& ack) = 0;
@@ -73,7 +73,7 @@
void OnBeginFrameSourcePausedChanged(bool paused) override;
bool OnBeginFrameDerivedImpl(const BeginFrameArgs& args) override;
- void OnDrawForCompositorFrameSink(bool resourceless_software_draw);
+ void OnDrawForLayerTreeFrameSink(bool resourceless_software_draw);
const SchedulerSettings& settings() const { return settings_; }
@@ -103,9 +103,9 @@
void SetNeedsImplSideInvalidation();
// Drawing should result in submitting a CompositorFrame to the
- // CompositorFrameSink and then calling this.
+ // LayerTreeFrameSink and then calling this.
void DidSubmitCompositorFrame();
- // The CompositorFrameSink acks when it is ready for a new frame which
+ // The LayerTreeFrameSink acks when it is ready for a new frame which
// should result in this getting called to unblock the next draw.
void DidReceiveCompositorFrameAck();
@@ -118,8 +118,8 @@
void WillPrepareTiles();
void DidPrepareTiles();
- void DidLoseCompositorFrameSink();
- void DidCreateAndInitializeCompositorFrameSink();
+ void DidLoseLayerTreeFrameSink();
+ void DidCreateAndInitializeLayerTreeFrameSink();
// Tests do not want to shut down until all possible BeginMainFrames have
// occured to prevent flakiness.
diff --git a/cc/scheduler/scheduler_state_machine.cc b/cc/scheduler/scheduler_state_machine.cc
index cbfe4f63..0f5df578 100644
--- a/cc/scheduler/scheduler_state_machine.cc
+++ b/cc/scheduler/scheduler_state_machine.cc
@@ -23,19 +23,19 @@
SchedulerStateMachine::~SchedulerStateMachine() = default;
-const char* SchedulerStateMachine::CompositorFrameSinkStateToString(
- CompositorFrameSinkState state) {
+const char* SchedulerStateMachine::LayerTreeFrameSinkStateToString(
+ LayerTreeFrameSinkState state) {
switch (state) {
- case COMPOSITOR_FRAME_SINK_NONE:
- return "COMPOSITOR_FRAME_SINK_NONE";
- case COMPOSITOR_FRAME_SINK_ACTIVE:
- return "COMPOSITOR_FRAME_SINK_ACTIVE";
- case COMPOSITOR_FRAME_SINK_CREATING:
- return "COMPOSITOR_FRAME_SINK_CREATING";
- case COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_COMMIT:
- return "COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_COMMIT";
- case COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_ACTIVATION:
- return "COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_ACTIVATION";
+ case LAYER_TREE_FRAME_SINK_NONE:
+ return "LAYER_TREE_FRAME_SINK_NONE";
+ case LAYER_TREE_FRAME_SINK_ACTIVE:
+ return "LAYER_TREE_FRAME_SINK_ACTIVE";
+ case LAYER_TREE_FRAME_SINK_CREATING:
+ return "LAYER_TREE_FRAME_SINK_CREATING";
+ case LAYER_TREE_FRAME_SINK_WAITING_FOR_FIRST_COMMIT:
+ return "LAYER_TREE_FRAME_SINK_WAITING_FOR_FIRST_COMMIT";
+ case LAYER_TREE_FRAME_SINK_WAITING_FOR_FIRST_ACTIVATION:
+ return "LAYER_TREE_FRAME_SINK_WAITING_FOR_FIRST_ACTIVATION";
}
NOTREACHED();
return "???";
@@ -132,12 +132,12 @@
return "ACTION_DRAW_FORCED";
case ACTION_DRAW_ABORT:
return "ACTION_DRAW_ABORT";
- case ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION:
- return "ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION";
+ case ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION:
+ return "ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION";
case ACTION_PREPARE_TILES:
return "ACTION_PREPARE_TILES";
- case ACTION_INVALIDATE_COMPOSITOR_FRAME_SINK:
- return "ACTION_INVALIDATE_COMPOSITOR_FRAME_SINK";
+ case ACTION_INVALIDATE_LAYER_TREE_FRAME_SINK:
+ return "ACTION_INVALIDATE_LAYER_TREE_FRAME_SINK";
case ACTION_PERFORM_IMPL_SIDE_INVALIDATION:
return "ACTION_PERFORM_IMPL_SIDE_INVALIDATION";
case ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_SENT:
@@ -164,8 +164,8 @@
state->SetString("begin_main_frame_state",
BeginMainFrameStateToString(begin_main_frame_state_));
state->SetString(
- "compositor_frame_sink_state",
- CompositorFrameSinkStateToString(compositor_frame_sink_state_));
+ "layer_tree_frame_sink_state",
+ LayerTreeFrameSinkStateToString(layer_tree_frame_sink_state_));
state->SetString("forced_redraw_state",
ForcedRedrawOnTimeoutStateToString(forced_redraw_state_));
state->EndDictionary();
@@ -199,16 +199,16 @@
state->SetBoolean("wants_begin_main_frame_not_expected",
wants_begin_main_frame_not_expected_);
state->SetBoolean("did_commit_during_frame", did_commit_during_frame_);
- state->SetBoolean("did_invalidate_compositor_frame_sink",
- did_invalidate_compositor_frame_sink_);
+ state->SetBoolean("did_invalidate_layer_tree_frame_sink",
+ did_invalidate_layer_tree_frame_sink_);
state->SetBoolean("did_perform_impl_side_invalidaion",
did_perform_impl_side_invalidation_);
state->SetBoolean("did_prepare_tiles", did_prepare_tiles_);
state->SetInteger("consecutive_checkerboard_animations",
consecutive_checkerboard_animations_);
state->SetInteger("pending_submit_frames", pending_submit_frames_);
- state->SetInteger("submit_frames_with_current_compositor_frame_sink",
- submit_frames_with_current_compositor_frame_sink_);
+ state->SetInteger("submit_frames_with_current_layer_tree_frame_sink",
+ submit_frames_with_current_layer_tree_frame_sink_);
state->SetBoolean("needs_redraw", needs_redraw_);
state->SetBoolean("needs_prepare_tiles", needs_prepare_tiles_);
state->SetBoolean("needs_begin_main_frame", needs_begin_main_frame_);
@@ -223,8 +223,8 @@
state->SetBoolean("active_tree_needs_first_draw",
active_tree_needs_first_draw_);
state->SetBoolean("wait_for_ready_to_draw", wait_for_ready_to_draw_);
- state->SetBoolean("did_create_and_initialize_first_compositor_frame_sink",
- did_create_and_initialize_first_compositor_frame_sink_);
+ state->SetBoolean("did_create_and_initialize_first_layer_tree_frame_sink",
+ did_create_and_initialize_first_layer_tree_frame_sink_);
state->SetString("tree_priority", TreePriorityToString(tree_priority_));
state->SetString("scroll_handler_state",
ScrollHandlerStateToString(scroll_handler_state_));
@@ -253,10 +253,10 @@
// pending activations will be forced and draws will be aborted. However,
// when the embedder is Android WebView, software draws could be scheduled by
// the Android OS at any time and draws should not be aborted in this case.
- bool is_compositor_frame_sink_lost =
- (compositor_frame_sink_state_ == COMPOSITOR_FRAME_SINK_NONE);
+ bool is_layer_tree_frame_sink_lost =
+ (layer_tree_frame_sink_state_ == LAYER_TREE_FRAME_SINK_NONE);
if (resourceless_draw_)
- return is_compositor_frame_sink_lost || !can_draw_;
+ return is_layer_tree_frame_sink_lost || !can_draw_;
// These are all the cases where we normally cannot or do not want to draw
// but, if needs_redraw_ is true and we do not draw to make forward progress,
@@ -264,7 +264,7 @@
// This should be a superset of PendingActivationsShouldBeForced() since
// activation of the pending tree is blocked by drawing of the active tree and
// the main thread might be blocked on activation of the most recent commit.
- return is_compositor_frame_sink_lost || !can_draw_ || !visible_ ||
+ return is_layer_tree_frame_sink_lost || !can_draw_ || !visible_ ||
begin_frame_source_paused_;
}
@@ -272,7 +272,7 @@
// There is no output surface to trigger our activations.
// If we do not force activations to make forward progress, we might deadlock
// with the main thread.
- if (compositor_frame_sink_state_ == COMPOSITOR_FRAME_SINK_NONE)
+ if (layer_tree_frame_sink_state_ == LAYER_TREE_FRAME_SINK_NONE)
return true;
// If we're not visible, we should force activation.
@@ -293,7 +293,7 @@
return false;
}
-bool SchedulerStateMachine::ShouldBeginCompositorFrameSinkCreation() const {
+bool SchedulerStateMachine::ShouldBeginLayerTreeFrameSinkCreation() const {
if (!visible_)
return false;
@@ -303,8 +303,8 @@
return false;
}
- // Make sure the BeginImplFrame from any previous CompositorFrameSinks
- // are complete before creating the new CompositorFrameSink.
+ // Make sure the BeginImplFrame from any previous LayerTreeFrameSinks
+ // are complete before creating the new LayerTreeFrameSink.
if (begin_impl_frame_state_ != BEGIN_IMPL_FRAME_STATE_IDLE)
return false;
@@ -317,7 +317,7 @@
// We need to create the output surface if we don't have one and we haven't
// started creating one yet.
- return compositor_frame_sink_state_ == COMPOSITOR_FRAME_SINK_NONE;
+ return layer_tree_frame_sink_state_ == LAYER_TREE_FRAME_SINK_NONE;
}
bool SchedulerStateMachine::ShouldDraw() const {
@@ -335,7 +335,7 @@
return false;
// Don't draw if we are waiting on the first commit after a surface.
- if (compositor_frame_sink_state_ != COMPOSITOR_FRAME_SINK_ACTIVE)
+ if (layer_tree_frame_sink_state_ != LAYER_TREE_FRAME_SINK_ACTIVE)
return false;
// Do not queue too many draws.
@@ -491,8 +491,8 @@
if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_COMMIT)
return true;
- // We shouldn't normally accept commits if there isn't an CompositorFrameSink.
- if (!HasInitializedCompositorFrameSink())
+ // We shouldn't normally accept commits if there isn't a LayerTreeFrameSink.
+ if (!HasInitializedLayerTreeFrameSink())
return false;
if (!settings_.main_frame_while_submit_frame_throttled_enabled) {
@@ -549,9 +549,9 @@
return needs_prepare_tiles_;
}
-bool SchedulerStateMachine::ShouldInvalidateCompositorFrameSink() const {
+bool SchedulerStateMachine::ShouldInvalidateLayerTreeFrameSink() const {
// Do not invalidate more than once per begin frame.
- if (did_invalidate_compositor_frame_sink_)
+ if (did_invalidate_layer_tree_frame_sink_)
return false;
// Only the synchronous compositor requires invalidations.
@@ -587,10 +587,10 @@
return ACTION_PREPARE_TILES;
if (ShouldSendBeginMainFrame())
return ACTION_SEND_BEGIN_MAIN_FRAME;
- if (ShouldInvalidateCompositorFrameSink())
- return ACTION_INVALIDATE_COMPOSITOR_FRAME_SINK;
- if (ShouldBeginCompositorFrameSinkCreation())
- return ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION;
+ if (ShouldInvalidateLayerTreeFrameSink())
+ return ACTION_INVALIDATE_LAYER_TREE_FRAME_SINK;
+ if (ShouldBeginLayerTreeFrameSinkCreation())
+ return ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION;
if (ShouldNotifyBeginMainFrameNotSent())
return ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_SENT;
return ACTION_NONE;
@@ -659,7 +659,7 @@
return false;
// Don't create a pending tree till a frame sink is initialized.
- if (!HasInitializedCompositorFrameSink())
+ if (!HasInitializedLayerTreeFrameSink())
return false;
return true;
@@ -739,18 +739,18 @@
}
// Update the output surface state.
- if (compositor_frame_sink_state_ ==
- COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_COMMIT) {
- compositor_frame_sink_state_ =
- has_pending_tree_ ? COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_ACTIVATION
- : COMPOSITOR_FRAME_SINK_ACTIVE;
+ if (layer_tree_frame_sink_state_ ==
+ LAYER_TREE_FRAME_SINK_WAITING_FOR_FIRST_COMMIT) {
+ layer_tree_frame_sink_state_ =
+ has_pending_tree_ ? LAYER_TREE_FRAME_SINK_WAITING_FOR_FIRST_ACTIVATION
+ : LAYER_TREE_FRAME_SINK_ACTIVE;
}
}
void SchedulerStateMachine::WillActivate() {
- if (compositor_frame_sink_state_ ==
- COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_ACTIVATION)
- compositor_frame_sink_state_ = COMPOSITOR_FRAME_SINK_ACTIVE;
+ if (layer_tree_frame_sink_state_ ==
+ LAYER_TREE_FRAME_SINK_WAITING_FOR_FIRST_ACTIVATION)
+ layer_tree_frame_sink_state_ = LAYER_TREE_FRAME_SINK_ACTIVE;
if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_ACTIVATION)
forced_redraw_state_ = FORCED_REDRAW_STATE_WAITING_FOR_DRAW;
@@ -863,9 +863,9 @@
needs_prepare_tiles_ = false;
}
-void SchedulerStateMachine::WillBeginCompositorFrameSinkCreation() {
- DCHECK_EQ(compositor_frame_sink_state_, COMPOSITOR_FRAME_SINK_NONE);
- compositor_frame_sink_state_ = COMPOSITOR_FRAME_SINK_CREATING;
+void SchedulerStateMachine::WillBeginLayerTreeFrameSinkCreation() {
+ DCHECK_EQ(layer_tree_frame_sink_state_, LAYER_TREE_FRAME_SINK_NONE);
+ layer_tree_frame_sink_state_ = LAYER_TREE_FRAME_SINK_CREATING;
// The following DCHECKs make sure we are in the proper quiescent state.
// The pipeline should be flushed entirely before we start output
@@ -875,10 +875,10 @@
DCHECK(!active_tree_needs_first_draw_);
}
-void SchedulerStateMachine::WillInvalidateCompositorFrameSink() {
- DCHECK(!did_invalidate_compositor_frame_sink_);
- did_invalidate_compositor_frame_sink_ = true;
- last_frame_number_invalidate_compositor_frame_sink_performed_ =
+void SchedulerStateMachine::WillInvalidateLayerTreeFrameSink() {
+ DCHECK(!did_invalidate_layer_tree_frame_sink_);
+ did_invalidate_layer_tree_frame_sink_ = true;
+ last_frame_number_invalidate_layer_tree_frame_sink_performed_ =
current_frame_number_;
// The synchronous compositor makes no guarantees about a draw coming in after
@@ -900,7 +900,7 @@
bool SchedulerStateMachine::BeginFrameNeeded() const {
// We can't handle BeginFrames when output surface isn't initialized.
// TODO(brianderson): Support output surface creation inside a BeginFrame.
- if (!HasInitializedCompositorFrameSink())
+ if (!HasInitializedLayerTreeFrameSink())
return false;
// If we are not visible, we don't need BeginFrame messages.
@@ -1048,7 +1048,7 @@
did_notify_begin_main_frame_not_sent_ = false;
did_send_begin_main_frame_for_current_frame_ = false;
did_commit_during_frame_ = false;
- did_invalidate_compositor_frame_sink_ = false;
+ did_invalidate_layer_tree_frame_sink_ = false;
did_perform_impl_side_invalidation_ = false;
}
@@ -1199,7 +1199,7 @@
DCHECK_LT(pending_submit_frames_, kMaxPendingSubmitFrames);
pending_submit_frames_++;
- submit_frames_with_current_compositor_frame_sink_++;
+ submit_frames_with_current_layer_tree_frame_sink_++;
did_submit_in_last_frame_ = true;
last_frame_number_submit_performed_ = current_frame_number_;
@@ -1264,7 +1264,7 @@
main_thread_missed_last_deadline_ = false;
switch (reason) {
- case CommitEarlyOutReason::ABORTED_COMPOSITOR_FRAME_SINK_LOST:
+ case CommitEarlyOutReason::ABORTED_LAYER_TREE_FRAME_SINK_LOST:
case CommitEarlyOutReason::ABORTED_NOT_VISIBLE:
case CommitEarlyOutReason::ABORTED_DEFERRED_COMMIT:
begin_main_frame_state_ = BEGIN_MAIN_FRAME_STATE_IDLE;
@@ -1282,11 +1282,11 @@
did_prepare_tiles_ = true;
}
-void SchedulerStateMachine::DidLoseCompositorFrameSink() {
- if (compositor_frame_sink_state_ == COMPOSITOR_FRAME_SINK_NONE ||
- compositor_frame_sink_state_ == COMPOSITOR_FRAME_SINK_CREATING)
+void SchedulerStateMachine::DidLoseLayerTreeFrameSink() {
+ if (layer_tree_frame_sink_state_ == LAYER_TREE_FRAME_SINK_NONE ||
+ layer_tree_frame_sink_state_ == LAYER_TREE_FRAME_SINK_CREATING)
return;
- compositor_frame_sink_state_ = COMPOSITOR_FRAME_SINK_NONE;
+ layer_tree_frame_sink_state_ = LAYER_TREE_FRAME_SINK_NONE;
needs_redraw_ = false;
wait_for_ready_to_draw_ = false;
}
@@ -1300,18 +1300,18 @@
wait_for_ready_to_draw_ = false;
}
-void SchedulerStateMachine::DidCreateAndInitializeCompositorFrameSink() {
- DCHECK_EQ(compositor_frame_sink_state_, COMPOSITOR_FRAME_SINK_CREATING);
- compositor_frame_sink_state_ = COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_COMMIT;
+void SchedulerStateMachine::DidCreateAndInitializeLayerTreeFrameSink() {
+ DCHECK_EQ(layer_tree_frame_sink_state_, LAYER_TREE_FRAME_SINK_CREATING);
+ layer_tree_frame_sink_state_ = LAYER_TREE_FRAME_SINK_WAITING_FOR_FIRST_COMMIT;
- if (did_create_and_initialize_first_compositor_frame_sink_) {
+ if (did_create_and_initialize_first_layer_tree_frame_sink_) {
// TODO(boliu): See if we can remove this when impl-side painting is always
// on. Does anything on the main thread need to update after recreate?
needs_begin_main_frame_ = true;
}
- did_create_and_initialize_first_compositor_frame_sink_ = true;
+ did_create_and_initialize_first_layer_tree_frame_sink_ = true;
pending_submit_frames_ = 0;
- submit_frames_with_current_compositor_frame_sink_ = 0;
+ submit_frames_with_current_layer_tree_frame_sink_ = 0;
main_thread_missed_last_deadline_ = false;
}
@@ -1320,15 +1320,15 @@
begin_main_frame_state_ = BEGIN_MAIN_FRAME_STATE_STARTED;
}
-bool SchedulerStateMachine::HasInitializedCompositorFrameSink() const {
- switch (compositor_frame_sink_state_) {
- case COMPOSITOR_FRAME_SINK_NONE:
- case COMPOSITOR_FRAME_SINK_CREATING:
+bool SchedulerStateMachine::HasInitializedLayerTreeFrameSink() const {
+ switch (layer_tree_frame_sink_state_) {
+ case LAYER_TREE_FRAME_SINK_NONE:
+ case LAYER_TREE_FRAME_SINK_CREATING:
return false;
- case COMPOSITOR_FRAME_SINK_ACTIVE:
- case COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_COMMIT:
- case COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_ACTIVATION:
+ case LAYER_TREE_FRAME_SINK_ACTIVE:
+ case LAYER_TREE_FRAME_SINK_WAITING_FOR_FIRST_COMMIT:
+ case LAYER_TREE_FRAME_SINK_WAITING_FOR_FIRST_ACTIVATION:
return true;
}
NOTREACHED();
diff --git a/cc/scheduler/scheduler_state_machine.h b/cc/scheduler/scheduler_state_machine.h
index 8ed42c8..bbd7323 100644
--- a/cc/scheduler/scheduler_state_machine.h
+++ b/cc/scheduler/scheduler_state_machine.h
@@ -50,15 +50,15 @@
explicit SchedulerStateMachine(const SchedulerSettings& settings);
~SchedulerStateMachine();
- enum CompositorFrameSinkState {
- COMPOSITOR_FRAME_SINK_NONE,
- COMPOSITOR_FRAME_SINK_ACTIVE,
- COMPOSITOR_FRAME_SINK_CREATING,
- COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_COMMIT,
- COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_ACTIVATION,
+ enum LayerTreeFrameSinkState {
+ LAYER_TREE_FRAME_SINK_NONE,
+ LAYER_TREE_FRAME_SINK_ACTIVE,
+ LAYER_TREE_FRAME_SINK_CREATING,
+ LAYER_TREE_FRAME_SINK_WAITING_FOR_FIRST_COMMIT,
+ LAYER_TREE_FRAME_SINK_WAITING_FOR_FIRST_ACTIVATION,
};
- static const char* CompositorFrameSinkStateToString(
- CompositorFrameSinkState state);
+ static const char* LayerTreeFrameSinkStateToString(
+ LayerTreeFrameSinkState state);
// Note: BeginImplFrameState does not cycle through these states in a fixed
// order on all platforms. It's up to the scheduler to set these correctly.
@@ -122,9 +122,9 @@
ACTION_DRAW_IF_POSSIBLE,
ACTION_DRAW_FORCED,
ACTION_DRAW_ABORT,
- ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION,
+ ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION,
ACTION_PREPARE_TILES,
- ACTION_INVALIDATE_COMPOSITOR_FRAME_SINK,
+ ACTION_INVALIDATE_LAYER_TREE_FRAME_SINK,
ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_SENT,
};
static const char* ActionToString(Action action);
@@ -138,9 +138,9 @@
void WillCommit(bool commit_had_no_updates);
void WillActivate();
void WillDraw();
- void WillBeginCompositorFrameSinkCreation();
+ void WillBeginLayerTreeFrameSinkCreation();
void WillPrepareTiles();
- void WillInvalidateCompositorFrameSink();
+ void WillInvalidateLayerTreeFrameSink();
void WillPerformImplSideInvalidation();
void DidDraw(DrawResult draw_result);
@@ -205,7 +205,7 @@
// submitting anything when there is not damage, for example.
void DidSubmitCompositorFrame();
- // Notification from the CompositorFrameSink that a submitted frame has been
+ // Notification from the LayerTreeFrameSink that a submitted frame has been
// consumed and it is ready for the next one.
void DidReceiveCompositorFrameAck();
@@ -275,9 +275,9 @@
}
void DidPrepareTiles();
- void DidLoseCompositorFrameSink();
- void DidCreateAndInitializeCompositorFrameSink();
- bool HasInitializedCompositorFrameSink() const;
+ void DidLoseLayerTreeFrameSink();
+ void DidCreateAndInitializeLayerTreeFrameSink();
+ bool HasInitializedLayerTreeFrameSink() const;
// True if we need to abort draws to make forward progress.
bool PendingDrawsShouldBeAborted() const;
@@ -320,13 +320,13 @@
// TODO(sunnyps): Rename this to ShouldAbortCurrentFrame or similar.
bool PendingActivationsShouldBeForced() const;
- bool ShouldBeginCompositorFrameSinkCreation() const;
+ bool ShouldBeginLayerTreeFrameSinkCreation() const;
bool ShouldDraw() const;
bool ShouldActivatePendingTree() const;
bool ShouldSendBeginMainFrame() const;
bool ShouldCommit() const;
bool ShouldPrepareTiles() const;
- bool ShouldInvalidateCompositorFrameSink() const;
+ bool ShouldInvalidateLayerTreeFrameSink() const;
bool ShouldNotifyBeginMainFrameNotSent() const;
void WillDrawInternal();
@@ -339,8 +339,8 @@
const SchedulerSettings settings_;
- CompositorFrameSinkState compositor_frame_sink_state_ =
- COMPOSITOR_FRAME_SINK_NONE;
+ LayerTreeFrameSinkState layer_tree_frame_sink_state_ =
+ LAYER_TREE_FRAME_SINK_NONE;
BeginImplFrameState begin_impl_frame_state_ = BEGIN_IMPL_FRAME_STATE_IDLE;
BeginMainFrameState begin_main_frame_state_ = BEGIN_MAIN_FRAME_STATE_IDLE;
ForcedRedrawOnTimeoutState forced_redraw_state_ = FORCED_REDRAW_STATE_IDLE;
@@ -366,7 +366,7 @@
int last_frame_number_submit_performed_ = -1;
int last_frame_number_draw_performed_ = -1;
int last_frame_number_begin_main_frame_sent_ = -1;
- int last_frame_number_invalidate_compositor_frame_sink_performed_ = -1;
+ int last_frame_number_invalidate_layer_tree_frame_sink_performed_ = -1;
// These are used to ensure that an action only happens once per frame,
// deadline, etc.
@@ -376,13 +376,13 @@
// started. Reset to true when we stop asking for begin frames.
bool did_notify_begin_main_frame_not_sent_ = true;
bool did_commit_during_frame_ = false;
- bool did_invalidate_compositor_frame_sink_ = false;
+ bool did_invalidate_layer_tree_frame_sink_ = false;
bool did_perform_impl_side_invalidation_ = false;
bool did_prepare_tiles_ = false;
int consecutive_checkerboard_animations_ = 0;
int pending_submit_frames_ = 0;
- int submit_frames_with_current_compositor_frame_sink_ = 0;
+ int submit_frames_with_current_layer_tree_frame_sink_ = 0;
bool needs_redraw_ = false;
bool needs_prepare_tiles_ = false;
bool needs_begin_main_frame_ = false;
@@ -394,7 +394,7 @@
bool has_pending_tree_ = false;
bool pending_tree_is_ready_for_activation_ = false;
bool active_tree_needs_first_draw_ = false;
- bool did_create_and_initialize_first_compositor_frame_sink_ = false;
+ bool did_create_and_initialize_first_layer_tree_frame_sink_ = false;
TreePriority tree_priority_ = NEW_CONTENT_TAKES_PRIORITY;
ScrollHandlerState scroll_handler_state_ =
ScrollHandlerState::SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER;
diff --git a/cc/scheduler/scheduler_state_machine_unittest.cc b/cc/scheduler/scheduler_state_machine_unittest.cc
index c5c5dcc..77b1648f5 100644
--- a/cc/scheduler/scheduler_state_machine_unittest.cc
+++ b/cc/scheduler/scheduler_state_machine_unittest.cc
@@ -66,9 +66,9 @@
#define SET_UP_STATE(state) \
state.SetVisible(true); \
EXPECT_ACTION_UPDATE_STATE( \
- SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); \
+ SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION); \
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); \
- state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit(); \
+ state.CreateAndInitializeLayerTreeFrameSinkWithActivatedCommit(); \
state.SetCanDraw(true);
namespace cc {
@@ -95,9 +95,9 @@
: SchedulerStateMachine(scheduler_settings),
draw_result_for_test_(DRAW_SUCCESS) {}
- void CreateAndInitializeCompositorFrameSinkWithActivatedCommit() {
- DidCreateAndInitializeCompositorFrameSink();
- compositor_frame_sink_state_ = COMPOSITOR_FRAME_SINK_ACTIVE;
+ void CreateAndInitializeLayerTreeFrameSinkWithActivatedCommit() {
+ DidCreateAndInitializeLayerTreeFrameSink();
+ layer_tree_frame_sink_state_ = LAYER_TREE_FRAME_SINK_ACTIVE;
}
void IssueNextBeginImplFrame() {
@@ -123,8 +123,8 @@
return begin_impl_frame_state_;
}
- CompositorFrameSinkState compositor_frame_sink_state() const {
- return compositor_frame_sink_state_;
+ LayerTreeFrameSinkState layer_tree_frame_sink_state() const {
+ return layer_tree_frame_sink_state_;
}
void SetNeedsBeginMainFrameForTest(bool needs_begin_main_frame) {
@@ -226,16 +226,16 @@
return;
}
- case SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION:
- sm->WillBeginCompositorFrameSinkCreation();
+ case SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION:
+ sm->WillBeginLayerTreeFrameSinkCreation();
return;
case SchedulerStateMachine::ACTION_PREPARE_TILES:
sm->WillPrepareTiles();
return;
- case SchedulerStateMachine::ACTION_INVALIDATE_COMPOSITOR_FRAME_SINK:
- sm->WillInvalidateCompositorFrameSink();
+ case SchedulerStateMachine::ACTION_INVALIDATE_LAYER_TREE_FRAME_SINK:
+ sm->WillInvalidateLayerTreeFrameSink();
return;
case SchedulerStateMachine::ACTION_PERFORM_IMPL_SIDE_INVALIDATION:
@@ -249,9 +249,9 @@
StateMachine state(default_scheduler_settings);
state.SetVisible(true);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION);
+ SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit();
+ state.CreateAndInitializeLayerTreeFrameSinkWithActivatedCommit();
state.SetBeginMainFrameState(
SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE);
@@ -300,9 +300,9 @@
state.SetMainThreadWantsBeginMainFrameNotExpectedMessages(true);
state.SetVisible(true);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION);
+ SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION);
state.IssueNextBeginImplFrame();
- state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit();
+ state.CreateAndInitializeLayerTreeFrameSinkWithActivatedCommit();
EXPECT_ACTION_UPDATE_STATE(
SchedulerStateMachine::ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_SENT);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
@@ -322,9 +322,9 @@
StateMachine state(default_scheduler_settings);
state.SetVisible(true);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION);
+ SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit();
+ state.CreateAndInitializeLayerTreeFrameSinkWithActivatedCommit();
state.SetBeginMainFrameState(
SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE);
state.SetNeedsRedraw(false);
@@ -366,9 +366,9 @@
SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE);
state.SetVisible(true);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION);
+ SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit();
+ state.CreateAndInitializeLayerTreeFrameSinkWithActivatedCommit();
state.SetNeedsRedraw(false);
state.SetNeedsBeginMainFrame();
@@ -393,9 +393,9 @@
SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE);
state.SetVisible(true);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION);
+ SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit();
+ state.CreateAndInitializeLayerTreeFrameSinkWithActivatedCommit();
state.SetNeedsRedraw(false);
state.SetNeedsBeginMainFrame();
state.SetCanDraw(false);
@@ -767,9 +767,9 @@
StateMachine state(default_scheduler_settings);
state.SetVisible(true);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION);
+ SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit();
+ state.CreateAndInitializeLayerTreeFrameSinkWithActivatedCommit();
state.SetBeginMainFrameState(begin_main_frame_states[i]);
state.SetBeginImplFrameState(all_begin_impl_frame_states[j]);
bool visible =
@@ -795,9 +795,9 @@
StateMachine state(default_scheduler_settings);
state.SetVisible(true);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION);
+ SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit();
+ state.CreateAndInitializeLayerTreeFrameSinkWithActivatedCommit();
state.SetCanDraw(true);
state.SetBeginMainFrameState(begin_main_frame_states[i]);
state.SetBeginImplFrameState(
@@ -834,9 +834,9 @@
StateMachine state(default_scheduler_settings);
state.SetVisible(true);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION);
+ SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit();
+ state.CreateAndInitializeLayerTreeFrameSinkWithActivatedCommit();
state.SetBeginMainFrameState(begin_main_frame_states[i]);
state.SetVisible(false);
state.SetNeedsRedraw(true);
@@ -870,9 +870,9 @@
StateMachine state(default_scheduler_settings);
state.SetVisible(true);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION);
+ SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit();
+ state.CreateAndInitializeLayerTreeFrameSinkWithActivatedCommit();
state.SetBeginMainFrameState(begin_main_frame_states[i]);
state.SetVisible(false);
state.SetNeedsRedraw(true);
@@ -892,9 +892,9 @@
StateMachine state(default_scheduler_settings);
state.SetVisible(true);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION);
+ SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit();
+ state.CreateAndInitializeLayerTreeFrameSinkWithActivatedCommit();
state.SetActiveTreeNeedsFirstDraw(true);
state.SetNeedsBeginMainFrame();
@@ -1290,9 +1290,9 @@
StateMachine state(default_scheduler_settings);
state.SetVisible(true);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION);
+ SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit();
+ state.CreateAndInitializeLayerTreeFrameSinkWithActivatedCommit();
state.SetVisible(false);
state.SetNeedsBeginMainFrame();
EXPECT_FALSE(state.CouldSendBeginMainFrame());
@@ -1304,36 +1304,36 @@
StateMachine state(default_scheduler_settings);
state.SetVisible(true);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION);
+ SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit();
+ state.CreateAndInitializeLayerTreeFrameSinkWithActivatedCommit();
state.SetBeginFrameSourcePaused(true);
state.SetNeedsBeginMainFrame();
EXPECT_FALSE(state.CouldSendBeginMainFrame());
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
}
-TEST(SchedulerStateMachineTest, TestNoRequestCompositorFrameSinkWhenInvisible) {
+TEST(SchedulerStateMachineTest, TestNoRequestLayerTreeFrameSinkWhenInvisible) {
SchedulerSettings default_scheduler_settings;
StateMachine state(default_scheduler_settings);
- // We should not request an CompositorFrameSink when we are still invisible.
+ // We should not request a LayerTreeFrameSink when we are still invisible.
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
state.SetVisible(true);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION);
+ SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit();
+ state.CreateAndInitializeLayerTreeFrameSinkWithActivatedCommit();
state.SetVisible(false);
- state.DidLoseCompositorFrameSink();
+ state.DidLoseLayerTreeFrameSink();
state.SetNeedsBeginMainFrame();
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
state.SetVisible(true);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION);
+ SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION);
}
// See ProxyMain::BeginMainFrame "EarlyOut_NotVisible" /
-// "EarlyOut_CompositorFrameSinkLost" cases.
+// "EarlyOut_LayerTreeFrameSinkLost" cases.
TEST(SchedulerStateMachineTest, TestAbortBeginMainFrameBecauseInvisible) {
SchedulerSettings default_scheduler_settings;
StateMachine state(default_scheduler_settings);
@@ -1392,9 +1392,9 @@
StateMachine state(default_scheduler_settings);
state.SetVisible(true);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION);
+ SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- state.DidCreateAndInitializeCompositorFrameSink();
+ state.DidCreateAndInitializeLayerTreeFrameSink();
state.SetCanDraw(true);
// Get into a begin frame / commit state.
@@ -1442,8 +1442,8 @@
state.SetCanDraw(true);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION);
- state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit();
+ SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION);
+ state.CreateAndInitializeLayerTreeFrameSinkWithActivatedCommit();
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
// Check that the first init does not SetNeedsBeginMainFrame.
@@ -1464,19 +1464,19 @@
StateMachine state(default_scheduler_settings);
SET_UP_STATE(state)
- EXPECT_NE(SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION,
+ EXPECT_NE(SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION,
state.NextAction());
- state.DidLoseCompositorFrameSink();
+ state.DidLoseLayerTreeFrameSink();
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION);
+ SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
// Once context recreation begins, nothing should happen.
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
// Recreate the context.
- state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit();
+ state.CreateAndInitializeLayerTreeFrameSinkWithActivatedCommit();
// When the context is recreated, we should begin a commit.
state.IssueNextBeginImplFrame();
@@ -1490,14 +1490,14 @@
StateMachine state(default_scheduler_settings);
SET_UP_STATE(state)
- EXPECT_NE(SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION,
+ EXPECT_NE(SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION,
state.NextAction());
- state.DidLoseCompositorFrameSink();
- EXPECT_EQ(state.compositor_frame_sink_state(),
- SchedulerStateMachine::COMPOSITOR_FRAME_SINK_NONE);
+ state.DidLoseLayerTreeFrameSink();
+ EXPECT_EQ(state.layer_tree_frame_sink_state(),
+ SchedulerStateMachine::LAYER_TREE_FRAME_SINK_NONE);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION);
+ SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
// Once context recreation begins, nothing should happen.
@@ -1514,10 +1514,10 @@
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
// Recreate the context
- state.DidCreateAndInitializeCompositorFrameSink();
+ state.DidCreateAndInitializeLayerTreeFrameSink();
EXPECT_EQ(
- state.compositor_frame_sink_state(),
- SchedulerStateMachine::COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_COMMIT);
+ state.layer_tree_frame_sink_state(),
+ SchedulerStateMachine::LAYER_TREE_FRAME_SINK_WAITING_FOR_FIRST_COMMIT);
EXPECT_FALSE(state.RedrawPending());
// When the context is recreated, we wait until the next BeginImplFrame
@@ -1539,16 +1539,16 @@
state.NotifyBeginMainFrameStarted();
state.NotifyReadyToCommit();
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT);
- EXPECT_EQ(state.compositor_frame_sink_state(),
+ EXPECT_EQ(state.layer_tree_frame_sink_state(),
SchedulerStateMachine::
- COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_ACTIVATION);
+ LAYER_TREE_FRAME_SINK_WAITING_FOR_FIRST_ACTIVATION);
state.NotifyReadyToActivate();
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- EXPECT_EQ(state.compositor_frame_sink_state(),
- SchedulerStateMachine::COMPOSITOR_FRAME_SINK_ACTIVE);
+ EXPECT_EQ(state.layer_tree_frame_sink_state(),
+ SchedulerStateMachine::LAYER_TREE_FRAME_SINK_ACTIVE);
- // Finishing the first commit after initializing an CompositorFrameSink should
+ // Finishing the first commit after initializing a LayerTreeFrameSink should
// automatically cause a redraw.
EXPECT_TRUE(state.RedrawPending());
state.IssueNextBeginImplFrame();
@@ -1627,7 +1627,7 @@
BeginFrameArgs::kInvalidFrameNumber);
// Cause a lost context while the BeginMainFrame is in flight.
- state.DidLoseCompositorFrameSink();
+ state.DidLoseLayerTreeFrameSink();
EXPECT_FALSE(state.BeginFrameNeeded());
// Ask for another draw. Expect nothing happens.
@@ -1645,7 +1645,7 @@
EXPECT_SEQUENCE_NUMBERS(10u, 10u, 10u, 10u,
BeginFrameArgs::kInvalidFrameNumber);
- // We will abort the draw when the CompositorFrameSink is lost if we are
+ // We will abort the draw when the LayerTreeFrameSink is lost if we are
// waiting for the first draw to unblock the main thread.
EXPECT_TRUE(state.active_tree_needs_first_draw());
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_ABORT);
@@ -1655,7 +1655,7 @@
// Expect to begin context recreation only in BEGIN_IMPL_FRAME_STATE_IDLE
EXPECT_IMPL_FRAME_STATE(SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
EXPECT_ACTION(
- SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION);
+ SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION);
state.OnBeginImplFrame(0, 11);
EXPECT_IMPL_FRAME_STATE(
@@ -1694,7 +1694,7 @@
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
// Cause a lost context while the BeginMainFrame is in flight.
- state.DidLoseCompositorFrameSink();
+ state.DidLoseLayerTreeFrameSink();
// Ask for another draw and also set needs commit. Expect nothing happens.
state.SetNeedsRedraw(true);
@@ -1709,13 +1709,13 @@
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE);
EXPECT_TRUE(state.active_tree_needs_first_draw());
- // Because the CompositorFrameSink is missing, we expect the draw to abort.
+ // Because the LayerTreeFrameSink is missing, we expect the draw to abort.
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_ABORT);
// Expect to begin context recreation only in BEGIN_IMPL_FRAME_STATE_IDLE
EXPECT_IMPL_FRAME_STATE(SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
EXPECT_ACTION(
- SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION);
+ SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION);
state.IssueNextBeginImplFrame();
EXPECT_IMPL_FRAME_STATE(
@@ -1729,10 +1729,10 @@
state.OnBeginImplFrameIdle();
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION);
+ SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION);
- // After we get a new CompositorFrameSink, the commit flow should start.
- state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit();
+ // After we get a new LayerTreeFrameSink, the commit flow should start.
+ state.CreateAndInitializeLayerTreeFrameSinkWithActivatedCommit();
state.IssueNextBeginImplFrame();
EXPECT_ACTION_UPDATE_STATE(
SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
@@ -1752,19 +1752,19 @@
}
TEST(SchedulerStateMachineTest,
- DontDrawBeforeCommitAfterLostCompositorFrameSink) {
+ DontDrawBeforeCommitAfterLostLayerTreeFrameSink) {
SchedulerSettings default_scheduler_settings;
StateMachine state(default_scheduler_settings);
SET_UP_STATE(state)
state.SetNeedsRedraw(true);
- // Cause a lost CompositorFrameSink, and restore it.
- state.DidLoseCompositorFrameSink();
+ // Cause a lost LayerTreeFrameSink, and restore it.
+ state.DidLoseLayerTreeFrameSink();
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION);
+ SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- state.DidCreateAndInitializeCompositorFrameSink();
+ state.DidCreateAndInitializeLayerTreeFrameSink();
EXPECT_FALSE(state.RedrawPending());
state.IssueNextBeginImplFrame();
@@ -1772,7 +1772,7 @@
}
TEST(SchedulerStateMachineTest,
- TestPendingActivationsShouldBeForcedAfterLostCompositorFrameSink) {
+ TestPendingActivationsShouldBeForcedAfterLostLayerTreeFrameSink) {
SchedulerSettings default_scheduler_settings;
StateMachine state(default_scheduler_settings);
SET_UP_STATE(state)
@@ -1781,7 +1781,7 @@
SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT);
// Cause a lost context.
- state.DidLoseCompositorFrameSink();
+ state.DidLoseLayerTreeFrameSink();
state.NotifyBeginMainFrameStarted();
state.NotifyReadyToCommit();
@@ -1799,9 +1799,9 @@
StateMachine state(default_scheduler_settings);
state.SetVisible(true);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION);
+ SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit();
+ state.CreateAndInitializeLayerTreeFrameSinkWithActivatedCommit();
EXPECT_FALSE(state.BeginFrameNeeded());
state.SetNeedsRedraw(true);
@@ -1819,9 +1819,9 @@
StateMachine state(default_scheduler_settings);
state.SetVisible(true);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION);
+ SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit();
+ state.CreateAndInitializeLayerTreeFrameSinkWithActivatedCommit();
state.SetVisible(false);
state.SetNeedsBeginMainFrame();
EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE);
@@ -1840,9 +1840,9 @@
StateMachine state(default_scheduler_settings);
state.SetVisible(true);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION);
+ SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit();
+ state.CreateAndInitializeLayerTreeFrameSinkWithActivatedCommit();
state.SetVisible(false);
state.SetBeginMainFrameState(
SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT);
@@ -1865,9 +1865,9 @@
StateMachine state(default_scheduler_settings);
state.SetVisible(true);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION);
+ SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit();
+ state.CreateAndInitializeLayerTreeFrameSinkWithActivatedCommit();
state.SetBeginFrameSourcePaused(true);
state.SetBeginMainFrameState(
SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT);
@@ -1890,20 +1890,20 @@
StateMachine state(default_scheduler_settings);
SET_UP_STATE(state)
state.SetNeedsBeginMainFrame();
- state.DidLoseCompositorFrameSink();
+ state.DidLoseLayerTreeFrameSink();
- // When we are visible, we normally want to begin CompositorFrameSink creation
+ // When we are visible, we normally want to begin LayerTreeFrameSink creation
// as soon as possible.
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION);
+ SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION);
- state.DidCreateAndInitializeCompositorFrameSink();
+ state.DidCreateAndInitializeLayerTreeFrameSink();
EXPECT_EQ(
- state.compositor_frame_sink_state(),
- SchedulerStateMachine::COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_COMMIT);
+ state.layer_tree_frame_sink_state(),
+ SchedulerStateMachine::LAYER_TREE_FRAME_SINK_WAITING_FOR_FIRST_COMMIT);
// We should not send a BeginMainFrame when we are invisible, even if we've
- // lost the CompositorFrameSink and are trying to get the first commit, since
+ // lost the LayerTreeFrameSink and are trying to get the first commit, since
// the
// main thread will just abort anyway.
state.SetVisible(false);
@@ -1965,24 +1965,24 @@
state.SetBeginFrameSourcePaused(false);
state.SetVisible(false);
- state.DidLoseCompositorFrameSink();
+ state.DidLoseLayerTreeFrameSink();
state.SetCanDraw(false);
- state.WillBeginCompositorFrameSinkCreation();
- state.DidCreateAndInitializeCompositorFrameSink();
+ state.WillBeginLayerTreeFrameSinkCreation();
+ state.DidCreateAndInitializeLayerTreeFrameSink();
EXPECT_TRUE(state.PendingDrawsShouldBeAborted());
state.SetCanDraw(true);
- state.DidLoseCompositorFrameSink();
+ state.DidLoseLayerTreeFrameSink();
EXPECT_TRUE(state.PendingDrawsShouldBeAborted());
state.SetCanDraw(true);
- state.WillBeginCompositorFrameSinkCreation();
- state.DidCreateAndInitializeCompositorFrameSink();
+ state.WillBeginLayerTreeFrameSinkCreation();
+ state.DidCreateAndInitializeLayerTreeFrameSink();
EXPECT_FALSE(state.PendingDrawsShouldBeAborted());
state.SetCanDraw(false);
- state.DidLoseCompositorFrameSink();
+ state.DidLoseLayerTreeFrameSink();
EXPECT_TRUE(state.PendingDrawsShouldBeAborted());
}
@@ -2092,7 +2092,7 @@
}
TEST(SchedulerStateMachineTest,
- TestTriggerDeadlineImmediatelyOnLostCompositorFrameSink) {
+ TestTriggerDeadlineImmediatelyOnLostLayerTreeFrameSink) {
SchedulerSettings default_scheduler_settings;
StateMachine state(default_scheduler_settings);
SET_UP_STATE(state)
@@ -2105,9 +2105,9 @@
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
EXPECT_FALSE(state.ShouldTriggerBeginImplFrameDeadlineImmediately());
- state.DidLoseCompositorFrameSink();
+ state.DidLoseLayerTreeFrameSink();
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- // The deadline should be triggered immediately when CompositorFrameSink is
+ // The deadline should be triggered immediately when LayerTreeFrameSink is
// lost.
EXPECT_TRUE(state.ShouldTriggerBeginImplFrameDeadlineImmediately());
}
@@ -2188,7 +2188,7 @@
}
TEST(SchedulerStateMachineTest,
- NoCompositorFrameSinkCreationWhileCommitPending) {
+ NoLayerTreeFrameSinkCreationWhileCommitPending) {
SchedulerSettings settings;
StateMachine state(settings);
SET_UP_STATE(state);
@@ -2198,10 +2198,10 @@
state.IssueNextBeginImplFrame();
PerformAction(&state, SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
- // Lose the CompositorFrameSink.
- state.DidLoseCompositorFrameSink();
+ // Lose the LayerTreeFrameSink.
+ state.DidLoseLayerTreeFrameSink();
- // The scheduler shouldn't trigger the CompositorFrameSink creation till the
+ // The scheduler shouldn't trigger the LayerTreeFrameSink creation till the
// previous commit has been cleared.
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
@@ -2212,15 +2212,15 @@
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
// Abort the commit, since that is what we expect the main thread to do if the
- // CompositorFrameSink was lost due to a synchronous call from the main thread
- // to release the CompositorFrameSink.
+ // LayerTreeFrameSink was lost due to a synchronous call from the main thread
+ // to release the LayerTreeFrameSink.
state.NotifyBeginMainFrameStarted();
state.BeginMainFrameAborted(
- CommitEarlyOutReason::ABORTED_COMPOSITOR_FRAME_SINK_LOST);
+ CommitEarlyOutReason::ABORTED_LAYER_TREE_FRAME_SINK_LOST);
- // The scheduler should begin the CompositorFrameSink creation now.
+ // The scheduler should begin the LayerTreeFrameSink creation now.
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION);
+ SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION);
}
TEST(SchedulerStateMachineTest, NoImplSideInvalidationsWhileInvisible) {
@@ -2265,16 +2265,16 @@
}
TEST(SchedulerStateMachineTest,
- NoImplSideInvalidationWithoutCompositorFrameSink) {
+ NoImplSideInvalidationWithoutLayerTreeFrameSink) {
SchedulerSettings settings;
StateMachine state(settings);
SET_UP_STATE(state);
// Impl-side invalidations should not be triggered till the frame sink is
// initialized.
- state.DidLoseCompositorFrameSink();
+ state.DidLoseLayerTreeFrameSink();
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION);
+ SchedulerStateMachine::ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
// No impl-side invalidations should be performed during frame sink creation.
@@ -2283,9 +2283,9 @@
state.OnBeginImplFrameDeadline();
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- // Initializing the CompositorFrameSink puts us in a state waiting for the
+ // Initializing the LayerTreeFrameSink puts us in a state waiting for the
// first commit.
- state.DidCreateAndInitializeCompositorFrameSink();
+ state.DidCreateAndInitializeLayerTreeFrameSink();
state.IssueNextBeginImplFrame();
EXPECT_ACTION_UPDATE_STATE(
SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
diff --git a/cc/scheduler/scheduler_unittest.cc b/cc/scheduler/scheduler_unittest.cc
index b8622cc..6327c22 100644
--- a/cc/scheduler/scheduler_unittest.cc
+++ b/cc/scheduler/scheduler_unittest.cc
@@ -156,16 +156,16 @@
void ScheduledActionActivateSyncTree() override {
PushAction("ScheduledActionActivateSyncTree");
}
- void ScheduledActionBeginCompositorFrameSinkCreation() override {
- PushAction("ScheduledActionBeginCompositorFrameSinkCreation");
+ void ScheduledActionBeginLayerTreeFrameSinkCreation() override {
+ PushAction("ScheduledActionBeginLayerTreeFrameSinkCreation");
}
void ScheduledActionPrepareTiles() override {
PushAction("ScheduledActionPrepareTiles");
scheduler_->WillPrepareTiles();
scheduler_->DidPrepareTiles();
}
- void ScheduledActionInvalidateCompositorFrameSink() override {
- actions_.push_back("ScheduledActionInvalidateCompositorFrameSink");
+ void ScheduledActionInvalidateLayerTreeFrameSink() override {
+ actions_.push_back("ScheduledActionInvalidateLayerTreeFrameSink");
states_.push_back(scheduler_->AsValue());
}
void ScheduledActionPerformImplSideInvalidation() override {
@@ -301,14 +301,14 @@
std::unique_ptr<FakeSchedulerClient> client) {
client_ = std::move(client);
CreateScheduler(bfs_type);
- EXPECT_SCOPED(InitializeCompositorFrameSinkAndFirstCommit());
+ EXPECT_SCOPED(InitializeLayerTreeFrameSinkAndFirstCommit());
}
void SetUpScheduler(BeginFrameSourceType bfs_type) {
SetUpScheduler(bfs_type, base::MakeUnique<FakeSchedulerClient>());
}
- void SetUpSchedulerWithNoCompositorFrameSink(BeginFrameSourceType bfs_type) {
+ void SetUpSchedulerWithNoLayerTreeFrameSink(BeginFrameSourceType bfs_type) {
client_ = base::MakeUnique<FakeSchedulerClient>();
CreateScheduler(bfs_type);
}
@@ -319,10 +319,10 @@
// As this function contains EXPECT macros, to allow debugging it should be
// called inside EXPECT_SCOPED like so;
// EXPECT_SCOPED(
- // client.InitializeCompositorFrameSinkAndFirstCommit(scheduler));
- void InitializeCompositorFrameSinkAndFirstCommit() {
+ // client.InitializeLayerTreeFrameSinkAndFirstCommit(scheduler));
+ void InitializeLayerTreeFrameSinkAndFirstCommit() {
TRACE_EVENT0(
- "cc", "SchedulerUnitTest::InitializeCompositorFrameSinkAndFirstCommit");
+ "cc", "SchedulerUnitTest::InitializeLayerTreeFrameSinkAndFirstCommit");
DCHECK(scheduler_);
// Check the client doesn't have any actions queued when calling this
@@ -330,15 +330,15 @@
EXPECT_NO_ACTION();
EXPECT_FALSE(scheduler_->begin_frames_expected());
- // Start the initial CompositorFrameSink creation.
+ // Start the initial LayerTreeFrameSink creation.
scheduler_->SetVisible(true);
scheduler_->SetCanDraw(true);
- EXPECT_ACTIONS("ScheduledActionBeginCompositorFrameSinkCreation");
+ EXPECT_ACTIONS("ScheduledActionBeginLayerTreeFrameSinkCreation");
client_->Reset();
// We don't see anything happening until the first impl frame.
- scheduler_->DidCreateAndInitializeCompositorFrameSink();
+ scheduler_->DidCreateAndInitializeLayerTreeFrameSink();
scheduler_->SetNeedsBeginMainFrame();
EXPECT_TRUE(scheduler_->begin_frames_expected());
EXPECT_FALSE(client_->IsInsideBeginImplFrame());
@@ -358,7 +358,7 @@
if (scheduler_settings_.using_synchronous_renderer_compositor) {
scheduler_->SetNeedsRedraw();
bool resourceless_software_draw = false;
- scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
+ scheduler_->OnDrawForLayerTreeFrameSink(resourceless_software_draw);
} else {
// Run the posted deadline task.
EXPECT_TRUE(client_->IsInsideBeginImplFrame());
@@ -459,14 +459,14 @@
FakeCompositorTimingHistory* fake_compositor_timing_history_;
};
-TEST_F(SchedulerTest, InitializeCompositorFrameSinkDoesNotBeginImplFrame) {
- SetUpSchedulerWithNoCompositorFrameSink(EXTERNAL_BFS);
+TEST_F(SchedulerTest, InitializeLayerTreeFrameSinkDoesNotBeginImplFrame) {
+ SetUpSchedulerWithNoLayerTreeFrameSink(EXTERNAL_BFS);
scheduler_->SetVisible(true);
scheduler_->SetCanDraw(true);
- EXPECT_ACTIONS("ScheduledActionBeginCompositorFrameSinkCreation");
+ EXPECT_ACTIONS("ScheduledActionBeginLayerTreeFrameSinkCreation");
client_->Reset();
- scheduler_->DidCreateAndInitializeCompositorFrameSink();
+ scheduler_->DidCreateAndInitializeLayerTreeFrameSink();
EXPECT_NO_ACTION();
}
@@ -668,7 +668,7 @@
EXPECT_FALSE(client_->IsInsideBeginImplFrame());
// Because we just swapped, the Scheduler should also request the next
- // BeginImplFrame from the CompositorFrameSink.
+ // BeginImplFrame from the LayerTreeFrameSink.
EXPECT_TRUE(scheduler_->begin_frames_expected());
client_->Reset();
// Since another commit is needed, the next BeginImplFrame should initiate
@@ -1275,7 +1275,7 @@
EXPECT_TRUE(client_->HasAction("ScheduledActionDrawIfPossible"));
}
-TEST_F(SchedulerTest, WaitForReadyToDrawCancelledWhenLostCompositorFrameSink) {
+TEST_F(SchedulerTest, WaitForReadyToDrawCancelledWhenLostLayerTreeFrameSink) {
SchedulerClientNeedsPrepareTilesInDraw* client =
new SchedulerClientNeedsPrepareTilesInDraw;
scheduler_settings_.commit_to_active_tree = true;
@@ -1305,13 +1305,13 @@
// There is no posted deadline.
EXPECT_NO_ACTION();
- // Scheduler loses CompositorFrameSink, and stops waiting for ready to draw
+ // Scheduler loses LayerTreeFrameSink, and stops waiting for ready to draw
// signal.
client_->Reset();
- scheduler_->DidLoseCompositorFrameSink();
+ scheduler_->DidLoseLayerTreeFrameSink();
EXPECT_TRUE(client_->IsInsideBeginImplFrame());
task_runner().RunPendingTasks(); // Run posted deadline.
- EXPECT_ACTIONS("ScheduledActionBeginCompositorFrameSinkCreation",
+ EXPECT_ACTIONS("ScheduledActionBeginLayerTreeFrameSinkCreation",
"RemoveObserver(this)");
}
@@ -2204,22 +2204,22 @@
}
TEST_F(SchedulerTest,
- DidLoseCompositorFrameSinkAfterCompositorFrameSinkIsInitialized) {
- SetUpSchedulerWithNoCompositorFrameSink(EXTERNAL_BFS);
+ DidLoseLayerTreeFrameSinkAfterLayerTreeFrameSinkIsInitialized) {
+ SetUpSchedulerWithNoLayerTreeFrameSink(EXTERNAL_BFS);
scheduler_->SetVisible(true);
scheduler_->SetCanDraw(true);
- EXPECT_ACTIONS("ScheduledActionBeginCompositorFrameSinkCreation");
+ EXPECT_ACTIONS("ScheduledActionBeginLayerTreeFrameSinkCreation");
client_->Reset();
- scheduler_->DidCreateAndInitializeCompositorFrameSink();
+ scheduler_->DidCreateAndInitializeLayerTreeFrameSink();
EXPECT_NO_ACTION();
- scheduler_->DidLoseCompositorFrameSink();
- EXPECT_ACTIONS("ScheduledActionBeginCompositorFrameSinkCreation");
+ scheduler_->DidLoseLayerTreeFrameSink();
+ EXPECT_ACTIONS("ScheduledActionBeginLayerTreeFrameSinkCreation");
}
-TEST_F(SchedulerTest, DidLoseCompositorFrameSinkAfterBeginFrameStarted) {
+TEST_F(SchedulerTest, DidLoseLayerTreeFrameSinkAfterBeginFrameStarted) {
SetUpScheduler(EXTERNAL_BFS);
// SetNeedsBeginMainFrame should begin the frame.
@@ -2232,7 +2232,7 @@
EXPECT_TRUE(client_->IsInsideBeginImplFrame());
client_->Reset();
- scheduler_->DidLoseCompositorFrameSink();
+ scheduler_->DidLoseLayerTreeFrameSink();
// RemoveObserver(this) is not called until the end of the frame.
EXPECT_NO_ACTION();
@@ -2243,12 +2243,12 @@
client_->Reset();
task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
- EXPECT_ACTIONS("ScheduledActionBeginCompositorFrameSinkCreation",
+ EXPECT_ACTIONS("ScheduledActionBeginLayerTreeFrameSinkCreation",
"RemoveObserver(this)");
}
TEST_F(SchedulerTest,
- DidLoseCompositorFrameSinkAfterBeginFrameStartedWithHighLatency) {
+ DidLoseLayerTreeFrameSinkAfterBeginFrameStartedWithHighLatency) {
SetUpScheduler(EXTERNAL_BFS);
// SetNeedsBeginMainFrame should begin the frame.
@@ -2261,7 +2261,7 @@
EXPECT_TRUE(client_->IsInsideBeginImplFrame());
client_->Reset();
- scheduler_->DidLoseCompositorFrameSink();
+ scheduler_->DidLoseLayerTreeFrameSink();
// Do nothing when impl frame is in deadine pending state.
EXPECT_NO_ACTION();
@@ -2269,7 +2269,7 @@
// Run posted deadline.
EXPECT_TRUE(client_->IsInsideBeginImplFrame());
task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
- // OnBeginImplFrameDeadline didn't schedule CompositorFrameSink creation
+ // OnBeginImplFrameDeadline didn't schedule LayerTreeFrameSink creation
// because
// main frame is not yet completed.
EXPECT_ACTIONS("RemoveObserver(this)");
@@ -2286,10 +2286,10 @@
scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
scheduler_->NotifyReadyToCommit();
EXPECT_ACTIONS("ScheduledActionCommit", "ScheduledActionActivateSyncTree",
- "ScheduledActionBeginCompositorFrameSinkCreation");
+ "ScheduledActionBeginLayerTreeFrameSinkCreation");
}
-TEST_F(SchedulerTest, DidLoseCompositorFrameSinkAfterReadyToCommit) {
+TEST_F(SchedulerTest, DidLoseLayerTreeFrameSinkAfterReadyToCommit) {
SetUpScheduler(EXTERNAL_BFS);
// SetNeedsBeginMainFrame should begin the frame.
@@ -2307,18 +2307,18 @@
EXPECT_ACTIONS("ScheduledActionCommit");
client_->Reset();
- scheduler_->DidLoseCompositorFrameSink();
+ scheduler_->DidLoseLayerTreeFrameSink();
// Sync tree should be forced to activate.
EXPECT_ACTIONS("ScheduledActionActivateSyncTree");
// RemoveObserver(this) is not called until the end of the frame.
client_->Reset();
task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
- EXPECT_ACTIONS("ScheduledActionBeginCompositorFrameSinkCreation",
+ EXPECT_ACTIONS("ScheduledActionBeginLayerTreeFrameSinkCreation",
"RemoveObserver(this)");
}
-TEST_F(SchedulerTest, DidLoseCompositorFrameSinkAfterSetNeedsPrepareTiles) {
+TEST_F(SchedulerTest, DidLoseLayerTreeFrameSinkAfterSetNeedsPrepareTiles) {
SetUpScheduler(EXTERNAL_BFS);
scheduler_->SetNeedsPrepareTiles();
@@ -2331,19 +2331,18 @@
EXPECT_TRUE(client_->IsInsideBeginImplFrame());
client_->Reset();
- scheduler_->DidLoseCompositorFrameSink();
+ scheduler_->DidLoseLayerTreeFrameSink();
// RemoveObserver(this) is not called until the end of the frame.
EXPECT_NO_ACTION();
client_->Reset();
task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
EXPECT_ACTIONS("ScheduledActionPrepareTiles",
- "ScheduledActionBeginCompositorFrameSinkCreation",
+ "ScheduledActionBeginLayerTreeFrameSinkCreation",
"RemoveObserver(this)");
}
-TEST_F(SchedulerTest,
- DidLoseCompositorFrameSinkWithDelayBasedBeginFrameSource) {
+TEST_F(SchedulerTest, DidLoseLayerTreeFrameSinkWithDelayBasedBeginFrameSource) {
SetUpScheduler(THROTTLED_BFS);
// SetNeedsBeginMainFrame should begin the frame on the next BeginImplFrame.
@@ -2371,18 +2370,18 @@
EXPECT_TRUE(scheduler_->begin_frames_expected());
client_->Reset();
- scheduler_->DidLoseCompositorFrameSink();
+ scheduler_->DidLoseLayerTreeFrameSink();
// RemoveObserver(this) is not called until the end of the frame.
EXPECT_NO_ACTION();
EXPECT_TRUE(scheduler_->begin_frames_expected());
client_->Reset();
task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
- EXPECT_ACTIONS("ScheduledActionBeginCompositorFrameSinkCreation");
+ EXPECT_ACTIONS("ScheduledActionBeginLayerTreeFrameSinkCreation");
EXPECT_FALSE(scheduler_->begin_frames_expected());
}
-TEST_F(SchedulerTest, DidLoseCompositorFrameSinkWhenIdle) {
+TEST_F(SchedulerTest, DidLoseLayerTreeFrameSinkWhenIdle) {
SetUpScheduler(EXTERNAL_BFS);
// SetNeedsBeginMainFrame should begin the frame.
@@ -2409,8 +2408,8 @@
// Idle time between BeginFrames.
client_->Reset();
- scheduler_->DidLoseCompositorFrameSink();
- EXPECT_ACTIONS("ScheduledActionBeginCompositorFrameSinkCreation",
+ scheduler_->DidLoseLayerTreeFrameSink();
+ EXPECT_ACTIONS("ScheduledActionBeginLayerTreeFrameSinkCreation",
"RemoveObserver(this)");
}
@@ -2645,13 +2644,13 @@
scheduler_->NotifyReadyToActivate();
EXPECT_ACTIONS("ScheduledActionActivateSyncTree");
- // Scheduler loses CompositorFrameSink, and stops waiting for ready to draw
+ // Scheduler loses LayerTreeFrameSink, and stops waiting for ready to draw
// signal.
client_->Reset();
- scheduler_->DidLoseCompositorFrameSink();
+ scheduler_->DidLoseLayerTreeFrameSink();
EXPECT_TRUE(client_->IsInsideBeginImplFrame());
task_runner().RunPendingTasks();
- EXPECT_ACTIONS("ScheduledActionBeginCompositorFrameSinkCreation",
+ EXPECT_ACTIONS("ScheduledActionBeginLayerTreeFrameSinkCreation",
"RemoveObserver(this)");
// Changing begin frame source doesn't do anything.
@@ -2661,7 +2660,7 @@
EXPECT_NO_ACTION();
client_->Reset();
- scheduler_->DidCreateAndInitializeCompositorFrameSink();
+ scheduler_->DidCreateAndInitializeLayerTreeFrameSink();
EXPECT_NO_ACTION();
client_->Reset();
@@ -2779,14 +2778,14 @@
// Next vsync.
AdvanceFrame();
EXPECT_ACTIONS("WillBeginImplFrame",
- "ScheduledActionInvalidateCompositorFrameSink");
+ "ScheduledActionInvalidateLayerTreeFrameSink");
EXPECT_FALSE(client_->IsInsideBeginImplFrame());
client_->Reset();
// Android onDraw. This doesn't consume the single begin frame request.
scheduler_->SetNeedsRedraw();
bool resourceless_software_draw = false;
- scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
+ scheduler_->OnDrawForLayerTreeFrameSink(resourceless_software_draw);
EXPECT_ACTIONS("ScheduledActionDrawIfPossible");
EXPECT_FALSE(client_->IsInsideBeginImplFrame());
client_->Reset();
@@ -2798,13 +2797,13 @@
// Next vsync.
AdvanceFrame();
EXPECT_ACTIONS("WillBeginImplFrame",
- "ScheduledActionInvalidateCompositorFrameSink");
+ "ScheduledActionInvalidateLayerTreeFrameSink");
EXPECT_FALSE(client_->IsInsideBeginImplFrame());
client_->Reset();
// Android onDraw.
scheduler_->SetNeedsRedraw();
- scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
+ scheduler_->OnDrawForLayerTreeFrameSink(resourceless_software_draw);
EXPECT_ACTIONS("ScheduledActionDrawIfPossible");
EXPECT_FALSE(client_->IsInsideBeginImplFrame());
client_->Reset();
@@ -2822,7 +2821,7 @@
scheduler_->SetNeedsRedraw();
bool resourceless_software_draw = false;
- scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
+ scheduler_->OnDrawForLayerTreeFrameSink(resourceless_software_draw);
EXPECT_ACTIONS("AddObserver(this)", "ScheduledActionDrawIfPossible");
EXPECT_FALSE(client_->IsInsideBeginImplFrame());
client_->Reset();
@@ -2918,7 +2917,7 @@
// Next vsync.
args = SendNextBeginFrame();
EXPECT_ACTIONS("WillBeginImplFrame",
- "ScheduledActionInvalidateCompositorFrameSink");
+ "ScheduledActionInvalidateLayerTreeFrameSink");
EXPECT_FALSE(client_->IsInsideBeginImplFrame());
// Not confirmed yet and no damage, since not drawn yet.
@@ -2934,7 +2933,7 @@
// Android onDraw.
scheduler_->SetNeedsRedraw();
bool resourceless_software_draw = false;
- scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
+ scheduler_->OnDrawForLayerTreeFrameSink(resourceless_software_draw);
EXPECT_ACTIONS("ScheduledActionDrawIfPossible");
EXPECT_FALSE(client_->IsInsideBeginImplFrame());
client_->Reset();
@@ -2982,7 +2981,7 @@
AdvanceFrame();
EXPECT_ACTIONS("WillBeginImplFrame", "ScheduledActionSendBeginMainFrame",
- "ScheduledActionInvalidateCompositorFrameSink");
+ "ScheduledActionInvalidateLayerTreeFrameSink");
EXPECT_FALSE(client_->IsInsideBeginImplFrame());
client_->Reset();
@@ -3020,13 +3019,13 @@
// Next vsync.
EXPECT_SCOPED(AdvanceFrame());
EXPECT_ACTIONS("WillBeginImplFrame",
- "ScheduledActionInvalidateCompositorFrameSink");
+ "ScheduledActionInvalidateLayerTreeFrameSink");
client_->Reset();
// Android onDraw.
scheduler_->SetNeedsRedraw();
bool resourceless_software_draw = false;
- scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
+ scheduler_->OnDrawForLayerTreeFrameSink(resourceless_software_draw);
EXPECT_ACTIONS("ScheduledActionDrawIfPossible",
"ScheduledActionPrepareTiles");
EXPECT_FALSE(client_->IsInsideBeginImplFrame());
@@ -3035,7 +3034,7 @@
// Android onDraw.
scheduler_->SetNeedsRedraw();
- scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
+ scheduler_->OnDrawForLayerTreeFrameSink(resourceless_software_draw);
EXPECT_ACTIONS("ScheduledActionDrawIfPossible",
"ScheduledActionPrepareTiles");
EXPECT_FALSE(client_->IsInsideBeginImplFrame());
@@ -3061,13 +3060,13 @@
// Next vsync.
EXPECT_SCOPED(AdvanceFrame());
EXPECT_ACTIONS("WillBeginImplFrame",
- "ScheduledActionInvalidateCompositorFrameSink");
+ "ScheduledActionInvalidateLayerTreeFrameSink");
client_->Reset();
// Android onDraw.
scheduler_->SetNeedsRedraw();
bool resourceless_software_draw = false;
- scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
+ scheduler_->OnDrawForLayerTreeFrameSink(resourceless_software_draw);
EXPECT_ACTIONS("ScheduledActionDrawIfPossible");
EXPECT_FALSE(client_->IsInsideBeginImplFrame());
EXPECT_FALSE(scheduler_->PrepareTilesPending());
@@ -3090,12 +3089,12 @@
// Next vsync.
EXPECT_SCOPED(AdvanceFrame());
EXPECT_ACTIONS("WillBeginImplFrame",
- "ScheduledActionInvalidateCompositorFrameSink");
+ "ScheduledActionInvalidateLayerTreeFrameSink");
client_->Reset();
// Android onDraw.
scheduler_->SetNeedsRedraw();
- scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
+ scheduler_->OnDrawForLayerTreeFrameSink(resourceless_software_draw);
EXPECT_ACTIONS("ScheduledActionDrawIfPossible");
EXPECT_FALSE(client_->IsInsideBeginImplFrame());
EXPECT_FALSE(scheduler_->PrepareTilesPending());
@@ -3115,7 +3114,7 @@
scheduler_->SetNeedsRedraw();
bool resourceless_software_draw = true;
- scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
+ scheduler_->OnDrawForLayerTreeFrameSink(resourceless_software_draw);
// SynchronousCompositor has to draw regardless of visibility.
EXPECT_ACTIONS("ScheduledActionDrawIfPossible");
EXPECT_FALSE(client_->IsInsideBeginImplFrame());
@@ -3186,7 +3185,7 @@
EXPECT_FALSE(scheduler_->ImplLatencyTakesPriority());
}
-TEST_F(SchedulerTest, NoCompositorFrameSinkCreationWhileCommitPending) {
+TEST_F(SchedulerTest, NoLayerTreeFrameSinkCreationWhileCommitPending) {
SetUpScheduler(THROTTLED_BFS);
// SetNeedsBeginMainFrame should begin the frame.
@@ -3195,13 +3194,13 @@
EXPECT_SCOPED(AdvanceFrame());
EXPECT_ACTIONS("WillBeginImplFrame", "ScheduledActionSendBeginMainFrame");
- // Lose the CompositorFrameSink and trigger the deadline.
+ // Lose the LayerTreeFrameSink and trigger the deadline.
client_->Reset();
- scheduler_->DidLoseCompositorFrameSink();
+ scheduler_->DidLoseLayerTreeFrameSink();
EXPECT_TRUE(client_->IsInsideBeginImplFrame());
EXPECT_NO_ACTION();
- // The scheduler should not trigger the CompositorFrameSink creation till the
+ // The scheduler should not trigger the LayerTreeFrameSink creation till the
// commit is aborted.
task_runner_->RunTasksWhile(client_->InsideBeginImplFrame(true));
EXPECT_FALSE(client_->IsInsideBeginImplFrame());
@@ -3211,8 +3210,8 @@
client_->Reset();
scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks::Now());
scheduler_->BeginMainFrameAborted(
- CommitEarlyOutReason::ABORTED_COMPOSITOR_FRAME_SINK_LOST);
- EXPECT_ACTIONS("ScheduledActionBeginCompositorFrameSinkCreation");
+ CommitEarlyOutReason::ABORTED_LAYER_TREE_FRAME_SINK_LOST);
+ EXPECT_ACTIONS("ScheduledActionBeginLayerTreeFrameSinkCreation");
}
TEST_F(SchedulerTest, ImplSideInvalidationsInDeadline) {
diff --git a/cc/surfaces/BUILD.gn b/cc/surfaces/BUILD.gn
index b2ca53b..de46eef 100644
--- a/cc/surfaces/BUILD.gn
+++ b/cc/surfaces/BUILD.gn
@@ -36,8 +36,8 @@
"compositor_frame_sink_support.cc",
"compositor_frame_sink_support.h",
"compositor_frame_sink_support_client.h",
- "direct_compositor_frame_sink.cc",
- "direct_compositor_frame_sink.h",
+ "direct_layer_tree_frame_sink.cc",
+ "direct_layer_tree_frame_sink.h",
"direct_surface_reference_factory.cc",
"direct_surface_reference_factory.h",
"display.cc",
diff --git a/cc/surfaces/direct_compositor_frame_sink.cc b/cc/surfaces/direct_layer_tree_frame_sink.cc
similarity index 73%
rename from cc/surfaces/direct_compositor_frame_sink.cc
rename to cc/surfaces/direct_layer_tree_frame_sink.cc
index da704c51..2bae572 100644
--- a/cc/surfaces/direct_compositor_frame_sink.cc
+++ b/cc/surfaces/direct_layer_tree_frame_sink.cc
@@ -2,11 +2,11 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "cc/surfaces/direct_compositor_frame_sink.h"
+#include "cc/surfaces/direct_layer_tree_frame_sink.h"
#include "base/bind.h"
#include "cc/output/compositor_frame.h"
-#include "cc/output/compositor_frame_sink_client.h"
+#include "cc/output/layer_tree_frame_sink_client.h"
#include "cc/surfaces/display.h"
#include "cc/surfaces/frame_sink_id.h"
#include "cc/surfaces/local_surface_id_allocator.h"
@@ -15,7 +15,7 @@
namespace cc {
-DirectCompositorFrameSink::DirectCompositorFrameSink(
+DirectLayerTreeFrameSink::DirectLayerTreeFrameSink(
const FrameSinkId& frame_sink_id,
SurfaceManager* surface_manager,
Display* display,
@@ -23,26 +23,26 @@
scoped_refptr<ContextProvider> worker_context_provider,
gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
SharedBitmapManager* shared_bitmap_manager)
- : CompositorFrameSink(std::move(context_provider),
- std::move(worker_context_provider),
- gpu_memory_buffer_manager,
- shared_bitmap_manager),
+ : LayerTreeFrameSink(std::move(context_provider),
+ std::move(worker_context_provider),
+ gpu_memory_buffer_manager,
+ shared_bitmap_manager),
frame_sink_id_(frame_sink_id),
surface_manager_(surface_manager),
display_(display) {
DCHECK(thread_checker_.CalledOnValidThread());
capabilities_.must_always_swap = true;
- // Display and DirectCompositorFrameSink share a GL context, so sync
+ // Display and DirectLayerTreeFrameSink share a GL context, so sync
// points aren't needed when passing resources between them.
capabilities_.delegated_sync_points_required = false;
}
-DirectCompositorFrameSink::DirectCompositorFrameSink(
+DirectLayerTreeFrameSink::DirectLayerTreeFrameSink(
const FrameSinkId& frame_sink_id,
SurfaceManager* surface_manager,
Display* display,
scoped_refptr<VulkanContextProvider> vulkan_context_provider)
- : CompositorFrameSink(std::move(vulkan_context_provider)),
+ : LayerTreeFrameSink(std::move(vulkan_context_provider)),
frame_sink_id_(frame_sink_id),
surface_manager_(surface_manager),
display_(display) {
@@ -50,15 +50,14 @@
capabilities_.must_always_swap = true;
}
-DirectCompositorFrameSink::~DirectCompositorFrameSink() {
+DirectLayerTreeFrameSink::~DirectLayerTreeFrameSink() {
DCHECK(thread_checker_.CalledOnValidThread());
}
-bool DirectCompositorFrameSink::BindToClient(
- CompositorFrameSinkClient* client) {
+bool DirectLayerTreeFrameSink::BindToClient(LayerTreeFrameSinkClient* client) {
DCHECK(thread_checker_.CalledOnValidThread());
- if (!CompositorFrameSink::BindToClient(client))
+ if (!LayerTreeFrameSink::BindToClient(client))
return false;
// We want the Display's output surface to hear about lost context, and since
@@ -82,7 +81,7 @@
return true;
}
-void DirectCompositorFrameSink::DetachFromClient() {
+void DirectLayerTreeFrameSink::DetachFromClient() {
client_->SetBeginFrameSource(nullptr);
begin_frame_source_.reset();
@@ -90,10 +89,10 @@
// one client is alive for this namespace at any given time.
support_.reset();
- CompositorFrameSink::DetachFromClient();
+ LayerTreeFrameSink::DetachFromClient();
}
-void DirectCompositorFrameSink::SubmitCompositorFrame(CompositorFrame frame) {
+void DirectLayerTreeFrameSink::SubmitCompositorFrame(CompositorFrame frame) {
DCHECK(frame.metadata.begin_frame_ack.has_damage);
DCHECK_LE(BeginFrameArgs::kStartingFrameNumber,
frame.metadata.begin_frame_ack.sequence_number);
@@ -112,51 +111,51 @@
DCHECK(result);
}
-void DirectCompositorFrameSink::DidNotProduceFrame(const BeginFrameAck& ack) {
+void DirectLayerTreeFrameSink::DidNotProduceFrame(const BeginFrameAck& ack) {
DCHECK(!ack.has_damage);
DCHECK_LE(BeginFrameArgs::kStartingFrameNumber, ack.sequence_number);
support_->DidNotProduceFrame(ack);
}
-void DirectCompositorFrameSink::DisplayOutputSurfaceLost() {
+void DirectLayerTreeFrameSink::DisplayOutputSurfaceLost() {
is_lost_ = true;
- client_->DidLoseCompositorFrameSink();
+ client_->DidLoseLayerTreeFrameSink();
}
-void DirectCompositorFrameSink::DisplayWillDrawAndSwap(
+void DirectLayerTreeFrameSink::DisplayWillDrawAndSwap(
bool will_draw_and_swap,
const RenderPassList& render_passes) {
// This notification is not relevant to our client outside of tests.
}
-void DirectCompositorFrameSink::DisplayDidDrawAndSwap() {
+void DirectLayerTreeFrameSink::DisplayDidDrawAndSwap() {
// This notification is not relevant to our client outside of tests. We
// unblock the client from DidDrawCallback() when the surface is going to
// be drawn.
}
-void DirectCompositorFrameSink::DidReceiveCompositorFrameAck(
+void DirectLayerTreeFrameSink::DidReceiveCompositorFrameAck(
const ReturnedResourceArray& resources) {
client_->ReclaimResources(resources);
client_->DidReceiveCompositorFrameAck();
}
-void DirectCompositorFrameSink::OnBeginFrame(const BeginFrameArgs& args) {
+void DirectLayerTreeFrameSink::OnBeginFrame(const BeginFrameArgs& args) {
begin_frame_source_->OnBeginFrame(args);
}
-void DirectCompositorFrameSink::ReclaimResources(
+void DirectLayerTreeFrameSink::ReclaimResources(
const ReturnedResourceArray& resources) {
client_->ReclaimResources(resources);
}
-void DirectCompositorFrameSink::WillDrawSurface(
+void DirectLayerTreeFrameSink::WillDrawSurface(
const LocalSurfaceId& local_surface_id,
const gfx::Rect& damage_rect) {
// TODO(staraz): Implement this.
}
-void DirectCompositorFrameSink::OnNeedsBeginFrames(bool needs_begin_frame) {
+void DirectLayerTreeFrameSink::OnNeedsBeginFrames(bool needs_begin_frame) {
support_->SetNeedsBeginFrame(needs_begin_frame);
}
diff --git a/cc/surfaces/direct_compositor_frame_sink.h b/cc/surfaces/direct_layer_tree_frame_sink.h
similarity index 84%
rename from cc/surfaces/direct_compositor_frame_sink.h
rename to cc/surfaces/direct_layer_tree_frame_sink.h
index 24480cb..f1c9c4b 100644
--- a/cc/surfaces/direct_compositor_frame_sink.h
+++ b/cc/surfaces/direct_layer_tree_frame_sink.h
@@ -2,12 +2,12 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef CC_SURFACES_DIRECT_COMPOSITOR_FRAME_SINK_H_
-#define CC_SURFACES_DIRECT_COMPOSITOR_FRAME_SINK_H_
+#ifndef CC_SURFACES_DIRECT_LAYER_TREE_FRAME_SINK_H_
+#define CC_SURFACES_DIRECT_LAYER_TREE_FRAME_SINK_H_
#include "base/macros.h"
#include "base/threading/thread_checker.h"
-#include "cc/output/compositor_frame_sink.h"
+#include "cc/output/layer_tree_frame_sink.h"
#include "cc/scheduler/begin_frame_source.h"
#include "cc/surfaces/compositor_frame_sink_support.h"
#include "cc/surfaces/compositor_frame_sink_support_client.h"
@@ -22,15 +22,15 @@
// This class submits compositor frames to an in-process Display, with the
// client's frame being the root surface of the Display.
-class CC_SURFACES_EXPORT DirectCompositorFrameSink
- : public CompositorFrameSink,
+class CC_SURFACES_EXPORT DirectLayerTreeFrameSink
+ : public LayerTreeFrameSink,
public NON_EXPORTED_BASE(CompositorFrameSinkSupportClient),
public ExternalBeginFrameSourceClient,
public NON_EXPORTED_BASE(DisplayClient) {
public:
// The underlying Display, SurfaceManager, and LocalSurfaceIdAllocator must
// outlive this class.
- DirectCompositorFrameSink(
+ DirectLayerTreeFrameSink(
const FrameSinkId& frame_sink_id,
SurfaceManager* surface_manager,
Display* display,
@@ -38,15 +38,15 @@
scoped_refptr<ContextProvider> worker_context_provider,
gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
SharedBitmapManager* shared_bitmap_manager);
- DirectCompositorFrameSink(
+ DirectLayerTreeFrameSink(
const FrameSinkId& frame_sink_id,
SurfaceManager* surface_manager,
Display* display,
scoped_refptr<VulkanContextProvider> vulkan_context_provider);
- ~DirectCompositorFrameSink() override;
+ ~DirectLayerTreeFrameSink() override;
- // CompositorFrameSink implementation.
- bool BindToClient(CompositorFrameSinkClient* client) override;
+ // LayerTreeFrameSink implementation.
+ bool BindToClient(LayerTreeFrameSinkClient* client) override;
void DetachFromClient() override;
void SubmitCompositorFrame(CompositorFrame frame) override;
void DidNotProduceFrame(const BeginFrameAck& ack) override;
@@ -85,9 +85,9 @@
bool is_lost_ = false;
std::unique_ptr<ExternalBeginFrameSource> begin_frame_source_;
- DISALLOW_COPY_AND_ASSIGN(DirectCompositorFrameSink);
+ DISALLOW_COPY_AND_ASSIGN(DirectLayerTreeFrameSink);
};
} // namespace cc
-#endif // CC_SURFACES_DIRECT_COMPOSITOR_FRAME_SINK_H_
+#endif // CC_SURFACES_DIRECT_LAYER_TREE_FRAME_SINK_H_
diff --git a/cc/surfaces/direct_compositor_frame_sink_unittest.cc b/cc/surfaces/direct_layer_tree_frame_sink_unittest.cc
similarity index 82%
rename from cc/surfaces/direct_compositor_frame_sink_unittest.cc
rename to cc/surfaces/direct_layer_tree_frame_sink_unittest.cc
index a56be81..3558826 100644
--- a/cc/surfaces/direct_compositor_frame_sink_unittest.cc
+++ b/cc/surfaces/direct_layer_tree_frame_sink_unittest.cc
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "cc/surfaces/direct_compositor_frame_sink.h"
+#include "cc/surfaces/direct_layer_tree_frame_sink.h"
#include <memory>
@@ -18,7 +18,7 @@
#include "cc/surfaces/surface_manager.h"
#include "cc/test/begin_frame_args_test.h"
#include "cc/test/compositor_frame_helpers.h"
-#include "cc/test/fake_compositor_frame_sink_client.h"
+#include "cc/test/fake_layer_tree_frame_sink_client.h"
#include "cc/test/fake_output_surface.h"
#include "cc/test/ordered_simple_task_runner.h"
#include "cc/test/test_context_provider.h"
@@ -31,16 +31,16 @@
static constexpr FrameSinkId kArbitraryFrameSinkId(1, 1);
-class TestDirectCompositorFrameSink : public DirectCompositorFrameSink {
+class TestDirectLayerTreeFrameSink : public DirectLayerTreeFrameSink {
public:
- using DirectCompositorFrameSink::DirectCompositorFrameSink;
+ using DirectLayerTreeFrameSink::DirectLayerTreeFrameSink;
CompositorFrameSinkSupport* support() const { return support_.get(); }
};
-class DirectCompositorFrameSinkTest : public testing::Test {
+class DirectLayerTreeFrameSinkTest : public testing::Test {
public:
- DirectCompositorFrameSinkTest()
+ DirectLayerTreeFrameSinkTest()
: now_src_(new base::SimpleTestTickClock()),
task_runner_(new OrderedSimpleTaskRunner(now_src_.get(), true)),
display_size_(1920, 1080),
@@ -64,21 +64,21 @@
kArbitraryFrameSinkId, std::move(display_output_surface),
std::move(scheduler),
base::MakeUnique<TextureMailboxDeleter>(task_runner_.get())));
- compositor_frame_sink_.reset(new TestDirectCompositorFrameSink(
+ layer_tree_frame_sink_.reset(new TestDirectLayerTreeFrameSink(
kArbitraryFrameSinkId, &surface_manager_, display_.get(),
context_provider_, nullptr, &gpu_memory_buffer_manager_,
&bitmap_manager_));
- compositor_frame_sink_->BindToClient(&compositor_frame_sink_client_);
+ layer_tree_frame_sink_->BindToClient(&layer_tree_frame_sink_client_);
display_->Resize(display_size_);
display_->SetVisible(true);
EXPECT_FALSE(
- compositor_frame_sink_client_.did_lose_compositor_frame_sink_called());
+ layer_tree_frame_sink_client_.did_lose_layer_tree_frame_sink_called());
}
- ~DirectCompositorFrameSinkTest() override {
- compositor_frame_sink_->DetachFromClient();
+ ~DirectLayerTreeFrameSinkTest() override {
+ layer_tree_frame_sink_->DetachFromClient();
}
void SwapBuffersWithDamage(const gfx::Rect& damage_rect) {
@@ -89,7 +89,7 @@
frame.metadata.begin_frame_ack = BeginFrameAck(0, 1, 1, true);
frame.render_pass_list.push_back(std::move(render_pass));
- compositor_frame_sink_->SubmitCompositorFrame(std::move(frame));
+ layer_tree_frame_sink_->SubmitCompositorFrame(std::move(frame));
}
void SetUp() override {
@@ -115,25 +115,25 @@
FakeOutputSurface* display_output_surface_ = nullptr;
std::unique_ptr<BackToBackBeginFrameSource> begin_frame_source_;
std::unique_ptr<Display> display_;
- FakeCompositorFrameSinkClient compositor_frame_sink_client_;
- std::unique_ptr<TestDirectCompositorFrameSink> compositor_frame_sink_;
+ FakeLayerTreeFrameSinkClient layer_tree_frame_sink_client_;
+ std::unique_ptr<TestDirectLayerTreeFrameSink> layer_tree_frame_sink_;
};
-TEST_F(DirectCompositorFrameSinkTest, DamageTriggersSwapBuffers) {
+TEST_F(DirectLayerTreeFrameSinkTest, DamageTriggersSwapBuffers) {
SwapBuffersWithDamage(display_rect_);
EXPECT_EQ(1u, display_output_surface_->num_sent_frames());
task_runner_->RunUntilIdle();
EXPECT_EQ(2u, display_output_surface_->num_sent_frames());
}
-TEST_F(DirectCompositorFrameSinkTest, NoDamageDoesNotTriggerSwapBuffers) {
+TEST_F(DirectLayerTreeFrameSinkTest, NoDamageDoesNotTriggerSwapBuffers) {
SwapBuffersWithDamage(gfx::Rect());
EXPECT_EQ(1u, display_output_surface_->num_sent_frames());
task_runner_->RunUntilIdle();
EXPECT_EQ(1u, display_output_surface_->num_sent_frames());
}
-TEST_F(DirectCompositorFrameSinkTest, SuspendedDoesNotTriggerSwapBuffers) {
+TEST_F(DirectLayerTreeFrameSinkTest, SuspendedDoesNotTriggerSwapBuffers) {
SwapBuffersWithDamage(display_rect_);
EXPECT_EQ(1u, display_output_surface_->num_sent_frames());
display_output_surface_->set_suspended_for_recycle(true);
diff --git a/cc/surfaces/frame_sink_manager.cc b/cc/surfaces/frame_sink_manager.cc
index 22f1d17..2d6078a 100644
--- a/cc/surfaces/frame_sink_manager.cc
+++ b/cc/surfaces/frame_sink_manager.cc
@@ -27,8 +27,7 @@
FrameSinkManager::FrameSinkManager() = default;
FrameSinkManager::~FrameSinkManager() {
- // All CompositorFrameSinks should be unregistered prior to
- // SurfaceManager destruction.
+ // All FrameSinks should be unregistered prior to SurfaceManager destruction.
DCHECK_EQ(clients_.size(), 0u);
DCHECK_EQ(registered_sources_.size(), 0u);
}
diff --git a/cc/surfaces/surface_hittest_unittest.cc b/cc/surfaces/surface_hittest_unittest.cc
index 4e406e3..9b2b236 100644
--- a/cc/surfaces/surface_hittest_unittest.cc
+++ b/cc/surfaces/surface_hittest_unittest.cc
@@ -29,7 +29,7 @@
struct TestCase {
SurfaceId input_surface_id;
gfx::Point input_point;
- SurfaceId expected_compositor_frame_sink_id;
+ SurfaceId expected_layer_tree_frame_sink_id;
gfx::Point expected_output_point;
};
@@ -42,7 +42,7 @@
const TestCase& test = tests[i];
gfx::Point point(test.input_point);
gfx::Transform transform;
- EXPECT_EQ(test.expected_compositor_frame_sink_id,
+ EXPECT_EQ(test.expected_layer_tree_frame_sink_id,
hittest.GetTargetSurfaceAtPoint(test.input_surface_id, point,
&transform));
transform.TransformPoint(&point);
@@ -52,7 +52,7 @@
// transform as returned by GetTargetSurfaceAtPoint.
gfx::Transform target_transform;
EXPECT_TRUE(hittest.GetTransformToTargetSurface(
- test.input_surface_id, test.expected_compositor_frame_sink_id,
+ test.input_surface_id, test.expected_layer_tree_frame_sink_id,
&target_transform));
EXPECT_EQ(transform, target_transform);
}
diff --git a/cc/surfaces/surface_manager.cc b/cc/surfaces/surface_manager.cc
index f51b71f9..2b35c74 100644
--- a/cc/surfaces/surface_manager.cc
+++ b/cc/surfaces/surface_manager.cc
@@ -485,11 +485,11 @@
if (lifetime_type_ == LifetimeType::REFERENCES) {
// We can get into a situation where multiple CompositorFrames arrive for
- // a CompositorFrameSink before the client can add any references for the
- // frame. When the second frame with a new size arrives, the first will be
- // destroyed in SurfaceFactory and then if there are no references it will
- // be deleted during surface GC. A temporary reference, removed when a
- // real reference is received, is added to prevent this from happening.
+ // a FrameSink before the client can add any references for the frame. When
+ // the second frame with a new size arrives, the first will be destroyed in
+ // SurfaceFactory and then if there are no references it will be deleted
+ // during surface GC. A temporary reference, removed when a real reference
+ // is received, is added to prevent this from happening.
AddTemporaryReference(surface_info.id());
}
diff --git a/cc/surfaces/surface_manager_ref_unittest.cc b/cc/surfaces/surface_manager_ref_unittest.cc
index 82dbd1cf..c3518e7 100644
--- a/cc/surfaces/surface_manager_ref_unittest.cc
+++ b/cc/surfaces/surface_manager_ref_unittest.cc
@@ -501,9 +501,9 @@
manager().AssignTemporaryReference(id1a, kFrameSink1);
ASSERT_THAT(GetAllTempReferences(), UnorderedElementsAre(id1a, id1b));
- // If the parent client crashes then the CompositorFrameSink connection will
- // be closed and the FrameSinkId invalidated. The temporary reference
- // |kFrameSink1| owns to |id2a| will be removed.
+ // If the parent client crashes then the FrameSink connection will be closed
+ // and the FrameSinkId invalidated. The temporary reference |kFrameSink1| owns
+ // to |id2a| will be removed.
DestroyCompositorFrameSinkSupport(kFrameSink1);
ASSERT_THAT(GetAllTempReferences(), UnorderedElementsAre(id1b));
diff --git a/cc/test/fake_compositor_frame_sink_client.cc b/cc/test/fake_compositor_frame_sink_client.cc
deleted file mode 100644
index 59963ab5..0000000
--- a/cc/test/fake_compositor_frame_sink_client.cc
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "cc/output/compositor_frame_sink.h"
-#include "cc/test/fake_compositor_frame_sink_client.h"
-
-namespace cc {
-
-void FakeCompositorFrameSinkClient::SetBeginFrameSource(
- BeginFrameSource* source) {
- begin_frame_source_ = source;
-}
-
-void FakeCompositorFrameSinkClient::DidReceiveCompositorFrameAck() {
- ack_count_++;
-}
-
-void FakeCompositorFrameSinkClient::DidLoseCompositorFrameSink() {
- did_lose_compositor_frame_sink_called_ = true;
-}
-
-void FakeCompositorFrameSinkClient::SetMemoryPolicy(
- const ManagedMemoryPolicy& policy) {
- memory_policy_ = policy;
-}
-
-} // namespace cc
diff --git a/cc/test/fake_compositor_frame_sink.cc b/cc/test/fake_layer_tree_frame_sink.cc
similarity index 67%
rename from cc/test/fake_compositor_frame_sink.cc
rename to cc/test/fake_layer_tree_frame_sink.cc
index ebc6842..88b3793 100644
--- a/cc/test/fake_compositor_frame_sink.cc
+++ b/cc/test/fake_layer_tree_frame_sink.cc
@@ -2,11 +2,11 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "cc/test/fake_compositor_frame_sink.h"
+#include "cc/test/fake_layer_tree_frame_sink.h"
#include "base/bind.h"
#include "base/threading/thread_task_runner_handle.h"
-#include "cc/output/compositor_frame_sink_client.h"
+#include "cc/output/layer_tree_frame_sink_client.h"
#include "cc/resources/returned_resource.h"
#include "cc/scheduler/begin_frame_source.h"
#include "cc/scheduler/delay_based_time_source.h"
@@ -15,13 +15,13 @@
namespace cc {
-FakeCompositorFrameSink::FakeCompositorFrameSink(
+FakeLayerTreeFrameSink::FakeLayerTreeFrameSink(
scoped_refptr<ContextProvider> context_provider,
scoped_refptr<ContextProvider> worker_context_provider)
- : CompositorFrameSink(std::move(context_provider),
- std::move(worker_context_provider),
- nullptr,
- nullptr),
+ : LayerTreeFrameSink(std::move(context_provider),
+ std::move(worker_context_provider),
+ nullptr,
+ nullptr),
weak_ptr_factory_(this) {
gpu_memory_buffer_manager_ =
context_provider_ ? &test_gpu_memory_buffer_manager_ : nullptr;
@@ -29,10 +29,10 @@
context_provider_ ? nullptr : &test_shared_bitmap_manager_;
}
-FakeCompositorFrameSink::~FakeCompositorFrameSink() = default;
+FakeLayerTreeFrameSink::~FakeLayerTreeFrameSink() = default;
-bool FakeCompositorFrameSink::BindToClient(CompositorFrameSinkClient* client) {
- if (!CompositorFrameSink::BindToClient(client))
+bool FakeLayerTreeFrameSink::BindToClient(LayerTreeFrameSinkClient* client) {
+ if (!LayerTreeFrameSink::BindToClient(client))
return false;
begin_frame_source_ = base::MakeUnique<BackToBackBeginFrameSource>(
base::MakeUnique<DelayBasedTimeSource>(
@@ -41,12 +41,12 @@
return true;
}
-void FakeCompositorFrameSink::DetachFromClient() {
+void FakeLayerTreeFrameSink::DetachFromClient() {
ReturnResourcesHeldByParent();
- CompositorFrameSink::DetachFromClient();
+ LayerTreeFrameSink::DetachFromClient();
}
-void FakeCompositorFrameSink::SubmitCompositorFrame(CompositorFrame frame) {
+void FakeLayerTreeFrameSink::SubmitCompositorFrame(CompositorFrame frame) {
ReturnResourcesHeldByParent();
last_sent_frame_.reset(new CompositorFrame(std::move(frame)));
@@ -60,17 +60,17 @@
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::BindOnce(&FakeCompositorFrameSink::DidReceiveCompositorFrameAck,
+ base::BindOnce(&FakeLayerTreeFrameSink::DidReceiveCompositorFrameAck,
weak_ptr_factory_.GetWeakPtr()));
}
-void FakeCompositorFrameSink::DidNotProduceFrame(const BeginFrameAck& ack) {}
+void FakeLayerTreeFrameSink::DidNotProduceFrame(const BeginFrameAck& ack) {}
-void FakeCompositorFrameSink::DidReceiveCompositorFrameAck() {
+void FakeLayerTreeFrameSink::DidReceiveCompositorFrameAck() {
client_->DidReceiveCompositorFrameAck();
}
-void FakeCompositorFrameSink::ReturnResourcesHeldByParent() {
+void FakeLayerTreeFrameSink::ReturnResourcesHeldByParent() {
if (last_sent_frame_) {
// Return the last frame's resources immediately.
ReturnedResourceArray resources;
diff --git a/cc/test/fake_compositor_frame_sink.h b/cc/test/fake_layer_tree_frame_sink.h
similarity index 65%
rename from cc/test/fake_compositor_frame_sink.h
rename to cc/test/fake_layer_tree_frame_sink.h
index 49b4abe..d6d63c4 100644
--- a/cc/test/fake_compositor_frame_sink.h
+++ b/cc/test/fake_layer_tree_frame_sink.h
@@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef CC_TEST_FAKE_COMPOSITOR_FRAME_SINK_H_
-#define CC_TEST_FAKE_COMPOSITOR_FRAME_SINK_H_
+#ifndef CC_TEST_FAKE_LAYER_TREE_FRAME_SINK_H_
+#define CC_TEST_FAKE_LAYER_TREE_FRAME_SINK_H_
#include <stddef.h>
@@ -14,7 +14,7 @@
#include "base/time/time.h"
#include "cc/output/begin_frame_args.h"
#include "cc/output/compositor_frame.h"
-#include "cc/output/compositor_frame_sink.h"
+#include "cc/output/layer_tree_frame_sink.h"
#include "cc/output/software_output_device.h"
#include "cc/test/test_context_provider.h"
#include "cc/test/test_gles2_interface.h"
@@ -26,64 +26,61 @@
class BeginFrameSource;
-class FakeCompositorFrameSink : public CompositorFrameSink {
+class FakeLayerTreeFrameSink : public LayerTreeFrameSink {
public:
- ~FakeCompositorFrameSink() override;
+ ~FakeLayerTreeFrameSink() override;
- static std::unique_ptr<FakeCompositorFrameSink> Create3d() {
- return base::WrapUnique(new FakeCompositorFrameSink(
+ static std::unique_ptr<FakeLayerTreeFrameSink> Create3d() {
+ return base::WrapUnique(new FakeLayerTreeFrameSink(
TestContextProvider::Create(), TestContextProvider::CreateWorker()));
}
- static std::unique_ptr<FakeCompositorFrameSink> Create3d(
+ static std::unique_ptr<FakeLayerTreeFrameSink> Create3d(
scoped_refptr<TestContextProvider> context_provider) {
- return base::WrapUnique(new FakeCompositorFrameSink(
+ return base::WrapUnique(new FakeLayerTreeFrameSink(
context_provider, TestContextProvider::CreateWorker()));
}
- static std::unique_ptr<FakeCompositorFrameSink> Create3d(
+ static std::unique_ptr<FakeLayerTreeFrameSink> Create3d(
std::unique_ptr<TestWebGraphicsContext3D> context) {
- return base::WrapUnique(new FakeCompositorFrameSink(
+ return base::WrapUnique(new FakeLayerTreeFrameSink(
TestContextProvider::Create(std::move(context)),
TestContextProvider::CreateWorker()));
}
- static std::unique_ptr<FakeCompositorFrameSink>
- Create3dForGpuRasterization() {
+ static std::unique_ptr<FakeLayerTreeFrameSink> Create3dForGpuRasterization() {
auto context = TestWebGraphicsContext3D::Create();
context->set_gpu_rasterization(true);
auto context_provider = TestContextProvider::Create(std::move(context));
- return base::WrapUnique(new FakeCompositorFrameSink(
+ return base::WrapUnique(new FakeLayerTreeFrameSink(
std::move(context_provider), TestContextProvider::CreateWorker()));
}
- static std::unique_ptr<FakeCompositorFrameSink> CreateSoftware() {
- return base::WrapUnique(new FakeCompositorFrameSink(nullptr, nullptr));
+ static std::unique_ptr<FakeLayerTreeFrameSink> CreateSoftware() {
+ return base::WrapUnique(new FakeLayerTreeFrameSink(nullptr, nullptr));
}
- // CompositorFrameSink implementation.
+ // LayerTreeFrameSink implementation.
void SubmitCompositorFrame(CompositorFrame frame) override;
void DidNotProduceFrame(const BeginFrameAck& ack) override;
- bool BindToClient(CompositorFrameSinkClient* client) override;
+ bool BindToClient(LayerTreeFrameSinkClient* client) override;
void DetachFromClient() override;
CompositorFrame* last_sent_frame() { return last_sent_frame_.get(); }
size_t num_sent_frames() { return num_sent_frames_; }
- CompositorFrameSinkClient* client() { return client_; }
+ LayerTreeFrameSinkClient* client() { return client_; }
const TransferableResourceArray& resources_held_by_parent() {
return resources_held_by_parent_;
}
- gfx::Rect last_swap_rect() const {
- return last_swap_rect_;
- }
+ gfx::Rect last_swap_rect() const { return last_swap_rect_; }
void ReturnResourcesHeldByParent();
protected:
- FakeCompositorFrameSink(
+ FakeLayerTreeFrameSink(
scoped_refptr<ContextProvider> context_provider,
scoped_refptr<ContextProvider> worker_context_provider);
@@ -99,9 +96,9 @@
void DidReceiveCompositorFrameAck();
std::unique_ptr<BeginFrameSource> begin_frame_source_;
- base::WeakPtrFactory<FakeCompositorFrameSink> weak_ptr_factory_;
+ base::WeakPtrFactory<FakeLayerTreeFrameSink> weak_ptr_factory_;
};
} // namespace cc
-#endif // CC_TEST_FAKE_COMPOSITOR_FRAME_SINK_H_
+#endif // CC_TEST_FAKE_LAYER_TREE_FRAME_SINK_H_
diff --git a/cc/test/fake_layer_tree_frame_sink_client.cc b/cc/test/fake_layer_tree_frame_sink_client.cc
new file mode 100644
index 0000000..ed1f8ea
--- /dev/null
+++ b/cc/test/fake_layer_tree_frame_sink_client.cc
@@ -0,0 +1,28 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "cc/test/fake_layer_tree_frame_sink_client.h"
+#include "cc/output/layer_tree_frame_sink.h"
+
+namespace cc {
+
+void FakeLayerTreeFrameSinkClient::SetBeginFrameSource(
+ BeginFrameSource* source) {
+ begin_frame_source_ = source;
+}
+
+void FakeLayerTreeFrameSinkClient::DidReceiveCompositorFrameAck() {
+ ack_count_++;
+}
+
+void FakeLayerTreeFrameSinkClient::DidLoseLayerTreeFrameSink() {
+ did_lose_layer_tree_frame_sink_called_ = true;
+}
+
+void FakeLayerTreeFrameSinkClient::SetMemoryPolicy(
+ const ManagedMemoryPolicy& policy) {
+ memory_policy_ = policy;
+}
+
+} // namespace cc
diff --git a/cc/test/fake_compositor_frame_sink_client.h b/cc/test/fake_layer_tree_frame_sink_client.h
similarity index 69%
rename from cc/test/fake_compositor_frame_sink_client.h
rename to cc/test/fake_layer_tree_frame_sink_client.h
index a004912..fff25f14 100644
--- a/cc/test/fake_compositor_frame_sink_client.h
+++ b/cc/test/fake_layer_tree_frame_sink_client.h
@@ -2,22 +2,23 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef CC_TEST_FAKE_COMPOSITOR_FRAME_SINK_CLIENT_H_
-#define CC_TEST_FAKE_COMPOSITOR_FRAME_SINK_CLIENT_H_
+#ifndef CC_TEST_FAKE_LAYER_TREE_FRAME_SINK_CLIENT_H_
+#define CC_TEST_FAKE_LAYER_TREE_FRAME_SINK_CLIENT_H_
-#include "cc/output/compositor_frame_sink_client.h"
+#include "cc/output/layer_tree_frame_sink_client.h"
+
#include "cc/output/managed_memory_policy.h"
namespace cc {
-class FakeCompositorFrameSinkClient : public CompositorFrameSinkClient {
+class FakeLayerTreeFrameSinkClient : public LayerTreeFrameSinkClient {
public:
- FakeCompositorFrameSinkClient() : memory_policy_(0) {}
+ FakeLayerTreeFrameSinkClient() : memory_policy_(0) {}
void SetBeginFrameSource(BeginFrameSource* source) override;
void DidReceiveCompositorFrameAck() override;
void ReclaimResources(const ReturnedResourceArray& resources) override {}
- void DidLoseCompositorFrameSink() override;
+ void DidLoseLayerTreeFrameSink() override;
void SetExternalTilePriorityConstraints(
const gfx::Rect& viewport_rect_for_tile_priority,
const gfx::Transform& transform_for_tile_priority) override {}
@@ -29,8 +30,8 @@
int ack_count() { return ack_count_; }
- bool did_lose_compositor_frame_sink_called() {
- return did_lose_compositor_frame_sink_called_;
+ bool did_lose_layer_tree_frame_sink_called() {
+ return did_lose_layer_tree_frame_sink_called_;
}
const ManagedMemoryPolicy& memory_policy() const { return memory_policy_; }
@@ -39,11 +40,11 @@
private:
int ack_count_ = 0;
- bool did_lose_compositor_frame_sink_called_ = false;
+ bool did_lose_layer_tree_frame_sink_called_ = false;
ManagedMemoryPolicy memory_policy_;
BeginFrameSource* begin_frame_source_;
};
} // namespace cc
-#endif // CC_TEST_FAKE_COMPOSITOR_FRAME_SINK_CLIENT_H_
+#endif // CC_TEST_FAKE_LAYER_TREE_FRAME_SINK_CLIENT_H_
diff --git a/cc/test/fake_layer_tree_host_client.cc b/cc/test/fake_layer_tree_host_client.cc
index 1f5f912..f40ebb5 100644
--- a/cc/test/fake_layer_tree_host_client.cc
+++ b/cc/test/fake_layer_tree_host_client.cc
@@ -4,7 +4,7 @@
#include "cc/test/fake_layer_tree_host_client.h"
-#include "cc/test/fake_compositor_frame_sink.h"
+#include "cc/test/fake_layer_tree_frame_sink.h"
#include "cc/trees/layer_tree_host.h"
namespace cc {
@@ -12,13 +12,13 @@
FakeLayerTreeHostClient::FakeLayerTreeHostClient() = default;
FakeLayerTreeHostClient::~FakeLayerTreeHostClient() = default;
-void FakeLayerTreeHostClient::RequestNewCompositorFrameSink() {
+void FakeLayerTreeHostClient::RequestNewLayerTreeFrameSink() {
DCHECK(host_);
- host_->SetCompositorFrameSink(FakeCompositorFrameSink::Create3d());
+ host_->SetLayerTreeFrameSink(FakeLayerTreeFrameSink::Create3d());
}
-void FakeLayerTreeHostClient::DidFailToInitializeCompositorFrameSink() {
- RequestNewCompositorFrameSink();
+void FakeLayerTreeHostClient::DidFailToInitializeLayerTreeFrameSink() {
+ RequestNewLayerTreeFrameSink();
}
} // namespace cc
diff --git a/cc/test/fake_layer_tree_host_client.h b/cc/test/fake_layer_tree_host_client.h
index 0eb80269..2fe38fa 100644
--- a/cc/test/fake_layer_tree_host_client.h
+++ b/cc/test/fake_layer_tree_host_client.h
@@ -19,8 +19,8 @@
void SetLayerTreeHost(LayerTreeHost* host) { host_ = host; }
// StubLayerTreeHostClient overrides.
- void RequestNewCompositorFrameSink() override;
- void DidFailToInitializeCompositorFrameSink() override;
+ void RequestNewLayerTreeFrameSink() override;
+ void DidFailToInitializeLayerTreeFrameSink() override;
private:
LayerTreeHost* host_ = nullptr;
diff --git a/cc/test/fake_layer_tree_host_impl.cc b/cc/test/fake_layer_tree_host_impl.cc
index a98ebd3..cc8b84c9 100644
--- a/cc/test/fake_layer_tree_host_impl.cc
+++ b/cc/test/fake_layer_tree_host_impl.cc
@@ -54,7 +54,7 @@
}
FakeLayerTreeHostImpl::~FakeLayerTreeHostImpl() {
- ReleaseCompositorFrameSink();
+ ReleaseLayerTreeFrameSink();
}
void FakeLayerTreeHostImpl::CreatePendingTree() {
diff --git a/cc/test/fake_layer_tree_host_impl_client.h b/cc/test/fake_layer_tree_host_impl_client.h
index 8d7471a..78b2ed8 100644
--- a/cc/test/fake_layer_tree_host_impl_client.h
+++ b/cc/test/fake_layer_tree_host_impl_client.h
@@ -13,7 +13,7 @@
class FakeLayerTreeHostImplClient : public LayerTreeHostImplClient {
public:
// LayerTreeHostImplClient implementation.
- void DidLoseCompositorFrameSinkOnImplThread() override {}
+ void DidLoseLayerTreeFrameSinkOnImplThread() override {}
void SetBeginFrameSource(BeginFrameSource* source) override {}
void DidReceiveCompositorFrameAckOnImplThread() override {}
void OnCanDrawStateChanged(bool can_draw) override {}
@@ -34,7 +34,7 @@
void WillPrepareTiles() override {}
void DidPrepareTiles() override {}
void DidCompletePageScaleAnimationOnImplThread() override {}
- void OnDrawForCompositorFrameSink(bool resourceless_software_draw) override {}
+ void OnDrawForLayerTreeFrameSink(bool resourceless_software_draw) override {}
void NeedsImplSideInvalidation() override;
void RequestBeginMainFrameNotExpected(bool new_state) override {}
void NotifyImageDecodeRequestFinished() override {}
diff --git a/cc/test/fake_proxy.cc b/cc/test/fake_proxy.cc
index a5a3a25..fed9365 100644
--- a/cc/test/fake_proxy.cc
+++ b/cc/test/fake_proxy.cc
@@ -18,8 +18,6 @@
return false;
}
-void FakeProxy::ReleaseCompositorFrameSink() {}
-
bool FakeProxy::CommitRequested() const { return false; }
void FakeProxy::SetMutator(std::unique_ptr<LayerTreeMutator> mutator) {}
diff --git a/cc/test/fake_proxy.h b/cc/test/fake_proxy.h
index 8688d857..daf017f 100644
--- a/cc/test/fake_proxy.h
+++ b/cc/test/fake_proxy.h
@@ -19,9 +19,9 @@
bool IsStarted() const override;
bool CommitToActiveTree() const override;
- void SetCompositorFrameSink(
- CompositorFrameSink* compositor_frame_sink) override {}
- void ReleaseCompositorFrameSink() override;
+ void SetLayerTreeFrameSink(
+ LayerTreeFrameSink* layer_tree_frame_sink) override {}
+ void ReleaseLayerTreeFrameSink() override {}
void SetVisible(bool visible) override {}
void SetNeedsAnimate() override {}
void SetNeedsUpdateLayers() override {}
diff --git a/cc/test/layer_test_common.cc b/cc/test/layer_test_common.cc
index cb19026..0f61bac 100644
--- a/cc/test/layer_test_common.cc
+++ b/cc/test/layer_test_common.cc
@@ -17,7 +17,7 @@
#include "cc/quads/draw_quad.h"
#include "cc/quads/render_pass.h"
#include "cc/test/animation_test_common.h"
-#include "cc/test/fake_compositor_frame_sink.h"
+#include "cc/test/fake_layer_tree_frame_sink.h"
#include "cc/test/mock_occlusion_tracker.h"
#include "cc/trees/layer_tree_host_common.h"
#include "testing/gtest/include/gtest/gtest.h"
@@ -132,16 +132,16 @@
: LayerImplTest(LayerTreeSettings()) {}
LayerTestCommon::LayerImplTest::LayerImplTest(
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink)
- : LayerImplTest(LayerTreeSettings(), std::move(compositor_frame_sink)) {}
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink)
+ : LayerImplTest(LayerTreeSettings(), std::move(layer_tree_frame_sink)) {}
LayerTestCommon::LayerImplTest::LayerImplTest(const LayerTreeSettings& settings)
- : LayerImplTest(settings, FakeCompositorFrameSink::Create3d()) {}
+ : LayerImplTest(settings, FakeLayerTreeFrameSink::Create3d()) {}
LayerTestCommon::LayerImplTest::LayerImplTest(
const LayerTreeSettings& settings,
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink)
- : compositor_frame_sink_(std::move(compositor_frame_sink)),
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink)
+ : layer_tree_frame_sink_(std::move(layer_tree_frame_sink)),
animation_host_(AnimationHost::CreateForTesting(ThreadInstance::MAIN)),
host_(FakeLayerTreeHost::Create(&client_,
&task_graph_runner_,
@@ -154,7 +154,7 @@
host_->host_impl()->active_tree()->SetRootLayerForTesting(std::move(root));
host_->host_impl()->SetVisible(true);
EXPECT_TRUE(
- host_->host_impl()->InitializeRenderer(compositor_frame_sink_.get()));
+ host_->host_impl()->InitializeRenderer(layer_tree_frame_sink_.get()));
const int timeline_id = AnimationIdProvider::NextTimelineId();
timeline_ = AnimationTimeline::Create(timeline_id);
@@ -168,7 +168,7 @@
LayerTestCommon::LayerImplTest::~LayerImplTest() {
animation_host_->RemoveAnimationTimeline(timeline_);
timeline_ = nullptr;
- host_->host_impl()->ReleaseCompositorFrameSink();
+ host_->host_impl()->ReleaseLayerTreeFrameSink();
}
void LayerTestCommon::LayerImplTest::CalcDrawProps(
diff --git a/cc/test/layer_test_common.h b/cc/test/layer_test_common.h
index 3d3bd104..87466a0 100644
--- a/cc/test/layer_test_common.h
+++ b/cc/test/layer_test_common.h
@@ -36,7 +36,7 @@
namespace cc {
class LayerImpl;
-class CompositorFrameSink;
+class LayerTreeFrameSink;
class QuadList;
class RenderSurfaceImpl;
class ResourceProvider;
@@ -59,10 +59,10 @@
public:
LayerImplTest();
explicit LayerImplTest(
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink);
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink);
explicit LayerImplTest(const LayerTreeSettings& settings);
LayerImplTest(const LayerTreeSettings& settings,
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink);
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink);
~LayerImplTest();
template <typename T>
@@ -176,8 +176,8 @@
void RequestCopyOfOutput();
- CompositorFrameSink* compositor_frame_sink() const {
- return host_->host_impl()->compositor_frame_sink();
+ LayerTreeFrameSink* layer_tree_frame_sink() const {
+ return host_->host_impl()->layer_tree_frame_sink();
}
ResourceProvider* resource_provider() const {
return host_->host_impl()->resource_provider();
@@ -201,7 +201,7 @@
private:
FakeLayerTreeHostClient client_;
TestTaskGraphRunner task_graph_runner_;
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink_;
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink_;
std::unique_ptr<AnimationHost> animation_host_;
std::unique_ptr<FakeLayerTreeHost> host_;
std::unique_ptr<RenderPass> render_pass_;
diff --git a/cc/test/layer_tree_pixel_resource_test.cc b/cc/test/layer_tree_pixel_resource_test.cc
index 261c833..1dd5db0e 100644
--- a/cc/test/layer_tree_pixel_resource_test.cc
+++ b/cc/test/layer_tree_pixel_resource_test.cc
@@ -6,7 +6,7 @@
#include "base/memory/ptr_util.h"
#include "cc/layers/layer.h"
-#include "cc/output/compositor_frame_sink.h"
+#include "cc/output/layer_tree_frame_sink.h"
#include "cc/raster/bitmap_raster_buffer_provider.h"
#include "cc/raster/gpu_raster_buffer_provider.h"
#include "cc/raster/one_copy_raster_buffer_provider.h"
@@ -129,9 +129,9 @@
DCHECK(initialized_);
ContextProvider* compositor_context_provider =
- host_impl->compositor_frame_sink()->context_provider();
+ host_impl->layer_tree_frame_sink()->context_provider();
ContextProvider* worker_context_provider =
- host_impl->compositor_frame_sink()->worker_context_provider();
+ host_impl->layer_tree_frame_sink()->worker_context_provider();
ResourceProvider* resource_provider = host_impl->resource_provider();
int max_bytes_per_copy_operation = 1024 * 1024;
int max_staging_buffer_usage_in_bytes = 32 * 1024 * 1024;
diff --git a/cc/test/layer_tree_pixel_test.cc b/cc/test/layer_tree_pixel_test.cc
index ce61a691..915a95d 100644
--- a/cc/test/layer_tree_pixel_test.cc
+++ b/cc/test/layer_tree_pixel_test.cc
@@ -21,8 +21,8 @@
#include "cc/test/pixel_comparator.h"
#include "cc/test/pixel_test_output_surface.h"
#include "cc/test/pixel_test_utils.h"
-#include "cc/test/test_compositor_frame_sink.h"
#include "cc/test/test_in_process_context_provider.h"
+#include "cc/test/test_layer_tree_frame_sink.h"
#include "cc/trees/layer_tree_impl.h"
#include "gpu/command_buffer/client/gles2_implementation.h"
#include "gpu/ipc/gl_in_process_context.h"
@@ -38,8 +38,8 @@
LayerTreePixelTest::~LayerTreePixelTest() {}
-std::unique_ptr<TestCompositorFrameSink>
-LayerTreePixelTest::CreateCompositorFrameSink(
+std::unique_ptr<TestLayerTreeFrameSink>
+LayerTreePixelTest::CreateLayerTreeFrameSink(
const RendererSettings& renderer_settings,
double refresh_rate,
scoped_refptr<ContextProvider>,
@@ -55,7 +55,7 @@
bool synchronous_composite =
!HasImplThread() &&
!layer_tree_host()->GetSettings().single_thread_proxy_scheduler;
- auto delegating_output_surface = base::MakeUnique<TestCompositorFrameSink>(
+ auto delegating_output_surface = base::MakeUnique<TestLayerTreeFrameSink>(
compositor_context_provider, std::move(worker_context_provider),
shared_bitmap_manager(), gpu_memory_buffer_manager(), RendererSettings(),
ImplThreadTaskRunner(), synchronous_composite, disable_display_vsync,
diff --git a/cc/test/layer_tree_pixel_test.h b/cc/test/layer_tree_pixel_test.h
index 26f9da68f..5b2c7bb 100644
--- a/cc/test/layer_tree_pixel_test.h
+++ b/cc/test/layer_tree_pixel_test.h
@@ -36,7 +36,7 @@
~LayerTreePixelTest() override;
// LayerTreeTest overrides.
- std::unique_ptr<TestCompositorFrameSink> CreateCompositorFrameSink(
+ std::unique_ptr<TestLayerTreeFrameSink> CreateLayerTreeFrameSink(
const RendererSettings& renderer_settings,
double refresh_rate,
scoped_refptr<ContextProvider> compositor_context_provider,
diff --git a/cc/test/layer_tree_test.cc b/cc/test/layer_tree_test.cc
index 67b7028..2bd8d5b 100644
--- a/cc/test/layer_tree_test.cc
+++ b/cc/test/layer_tree_test.cc
@@ -24,8 +24,8 @@
#include "cc/test/begin_frame_args_test.h"
#include "cc/test/fake_layer_tree_host_client.h"
#include "cc/test/fake_output_surface.h"
-#include "cc/test/test_compositor_frame_sink.h"
#include "cc/test/test_context_provider.h"
+#include "cc/test/test_layer_tree_frame_sink.h"
#include "cc/test/test_shared_bitmap_manager.h"
#include "cc/trees/layer_tree_host_client.h"
#include "cc/trees/layer_tree_host_impl.h"
@@ -240,8 +240,8 @@
test_hooks_->DidActivateTreeOnThread(this);
}
- bool InitializeRenderer(CompositorFrameSink* compositor_frame_sink) override {
- bool success = LayerTreeHostImpl::InitializeRenderer(compositor_frame_sink);
+ bool InitializeRenderer(LayerTreeFrameSink* layer_tree_frame_sink) override {
+ bool success = LayerTreeHostImpl::InitializeRenderer(layer_tree_frame_sink);
test_hooks_->InitializedRendererOnThread(this, success);
return success;
}
@@ -343,17 +343,17 @@
void RecordWheelAndTouchScrollingCount(bool has_scrolled_by_wheel,
bool has_scrolled_by_touch) override {}
- void RequestNewCompositorFrameSink() override {
- test_hooks_->RequestNewCompositorFrameSink();
+ void RequestNewLayerTreeFrameSink() override {
+ test_hooks_->RequestNewLayerTreeFrameSink();
}
- void DidInitializeCompositorFrameSink() override {
- test_hooks_->DidInitializeCompositorFrameSink();
+ void DidInitializeLayerTreeFrameSink() override {
+ test_hooks_->DidInitializeLayerTreeFrameSink();
}
- void DidFailToInitializeCompositorFrameSink() override {
- test_hooks_->DidFailToInitializeCompositorFrameSink();
- RequestNewCompositorFrameSink();
+ void DidFailToInitializeLayerTreeFrameSink() override {
+ test_hooks_->DidFailToInitializeLayerTreeFrameSink();
+ RequestNewLayerTreeFrameSink();
}
void WillCommit() override { test_hooks_->WillCommit(); }
@@ -369,7 +369,7 @@
}
void DidSubmitCompositorFrame() override {}
- void DidLoseCompositorFrameSink() override {}
+ void DidLoseLayerTreeFrameSink() override {}
void RequestScheduleComposite() override { test_hooks_->ScheduleComposite(); }
void DidCompletePageScaleAnimation() override {}
void BeginMainFrameNotExpectedSoon() override {
@@ -466,13 +466,13 @@
bool test_started_;
};
-class LayerTreeTestCompositorFrameSinkClient
- : public TestCompositorFrameSinkClient {
+class LayerTreeTestLayerTreeFrameSinkClient
+ : public TestLayerTreeFrameSinkClient {
public:
- explicit LayerTreeTestCompositorFrameSinkClient(TestHooks* hooks)
+ explicit LayerTreeTestLayerTreeFrameSinkClient(TestHooks* hooks)
: hooks_(hooks) {}
- // TestCompositorFrameSinkClient implementation.
+ // TestLayerTreeFrameSinkClient implementation.
std::unique_ptr<OutputSurface> CreateDisplayOutputSurface(
scoped_refptr<ContextProvider> compositor_context_provider) override {
return hooks_->CreateDisplayOutputSurfaceOnThread(
@@ -498,8 +498,8 @@
};
LayerTreeTest::LayerTreeTest()
- : compositor_frame_sink_client_(
- new LayerTreeTestCompositorFrameSinkClient(this)),
+ : layer_tree_frame_sink_client_(
+ new LayerTreeTestLayerTreeFrameSinkClient(this)),
weak_factory_(this) {
main_thread_weak_ptr_ = weak_factory_.GetWeakPtr();
@@ -638,9 +638,9 @@
main_thread_weak_ptr_));
}
-std::unique_ptr<CompositorFrameSink>
-LayerTreeTest::ReleaseCompositorFrameSinkOnLayerTreeHost() {
- return layer_tree_host_->ReleaseCompositorFrameSink();
+std::unique_ptr<LayerTreeFrameSink>
+LayerTreeTest::ReleaseLayerTreeFrameSinkOnLayerTreeHost() {
+ return layer_tree_host_->ReleaseLayerTreeFrameSink();
}
void LayerTreeTest::SetVisibleOnLayerTreeHost(bool visible) {
@@ -855,7 +855,7 @@
AfterTest();
}
-void LayerTreeTest::RequestNewCompositorFrameSink() {
+void LayerTreeTest::RequestNewLayerTreeFrameSink() {
scoped_refptr<TestContextProvider> shared_context_provider =
TestContextProvider::Create();
scoped_refptr<TestContextProvider> worker_context_provider =
@@ -867,15 +867,14 @@
constexpr double refresh_rate = 200.0;
renderer_settings.resource_settings.buffer_to_texture_target_map =
DefaultBufferToTextureTargetMapForTesting();
- auto compositor_frame_sink = CreateCompositorFrameSink(
+ auto layer_tree_frame_sink = CreateLayerTreeFrameSink(
renderer_settings, refresh_rate, std::move(shared_context_provider),
std::move(worker_context_provider));
- compositor_frame_sink->SetClient(compositor_frame_sink_client_.get());
- layer_tree_host_->SetCompositorFrameSink(std::move(compositor_frame_sink));
+ layer_tree_frame_sink->SetClient(layer_tree_frame_sink_client_.get());
+ layer_tree_host_->SetLayerTreeFrameSink(std::move(layer_tree_frame_sink));
}
-std::unique_ptr<TestCompositorFrameSink>
-LayerTreeTest::CreateCompositorFrameSink(
+std::unique_ptr<TestLayerTreeFrameSink> LayerTreeTest::CreateLayerTreeFrameSink(
const RendererSettings& renderer_settings,
double refresh_rate,
scoped_refptr<ContextProvider> compositor_context_provider,
@@ -884,7 +883,7 @@
bool synchronous_composite =
!HasImplThread() &&
!layer_tree_host()->GetSettings().single_thread_proxy_scheduler;
- return base::MakeUnique<TestCompositorFrameSink>(
+ return base::MakeUnique<TestLayerTreeFrameSink>(
compositor_context_provider, std::move(worker_context_provider),
shared_bitmap_manager(), gpu_memory_buffer_manager(), renderer_settings,
impl_task_runner_, synchronous_composite, disable_display_vsync,
diff --git a/cc/test/layer_tree_test.h b/cc/test/layer_tree_test.h
index 67f927e..e7c4644 100644
--- a/cc/test/layer_tree_test.h
+++ b/cc/test/layer_tree_test.h
@@ -23,10 +23,10 @@
class LayerImpl;
class LayerTreeHost;
class LayerTreeHostForTesting;
-class LayerTreeTestCompositorFrameSinkClient;
+class LayerTreeTestLayerTreeFrameSinkClient;
class Proxy;
class TestContextProvider;
-class TestCompositorFrameSink;
+class TestLayerTreeFrameSink;
class TestTaskGraphRunner;
// Creates the virtual viewport layer hierarchy under the given root_layer.
@@ -98,8 +98,8 @@
void RealEndTest();
- std::unique_ptr<CompositorFrameSink>
- ReleaseCompositorFrameSinkOnLayerTreeHost();
+ std::unique_ptr<LayerTreeFrameSink>
+ ReleaseLayerTreeFrameSinkOnLayerTreeHost();
void SetVisibleOnLayerTreeHost(bool visible);
virtual void AfterTest() = 0;
@@ -134,18 +134,18 @@
void DestroyLayerTreeHost();
// By default, output surface recreation is synchronous.
- void RequestNewCompositorFrameSink() override;
+ void RequestNewLayerTreeFrameSink() override;
// Override this and call the base class to change what ContextProviders will
// be used (such as for pixel tests). Or override it and create your own
- // TestCompositorFrameSink to control how it is created.
- virtual std::unique_ptr<TestCompositorFrameSink> CreateCompositorFrameSink(
+ // TestLayerTreeFrameSink to control how it is created.
+ virtual std::unique_ptr<TestLayerTreeFrameSink> CreateLayerTreeFrameSink(
const RendererSettings& renderer_settings,
double refresh_rate,
scoped_refptr<ContextProvider> compositor_context_provider,
scoped_refptr<ContextProvider> worker_context_provider);
// Override this and call the base class to change what ContextProvider will
// be used, such as to prevent sharing the context with the
- // CompositorFrameSink. Or override it and create your own OutputSurface to
+ // LayerTreeFrameSink. Or override it and create your own OutputSurface to
// change what type of OutputSurface is used, such as a real OutputSurface for
// pixel tests or a software-compositing OutputSurface.
std::unique_ptr<OutputSurface> CreateDisplayOutputSurfaceOnThread(
@@ -190,8 +190,8 @@
int timeout_seconds_ = false;
- std::unique_ptr<LayerTreeTestCompositorFrameSinkClient>
- compositor_frame_sink_client_;
+ std::unique_ptr<LayerTreeTestLayerTreeFrameSinkClient>
+ layer_tree_frame_sink_client_;
scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner_;
std::unique_ptr<base::Thread> impl_thread_;
diff --git a/cc/test/stub_layer_tree_host_client.h b/cc/test/stub_layer_tree_host_client.h
index 948e5b2..0e23fc43 100644
--- a/cc/test/stub_layer_tree_host_client.h
+++ b/cc/test/stub_layer_tree_host_client.h
@@ -27,9 +27,9 @@
float top_controls_delta) override {}
void RecordWheelAndTouchScrollingCount(bool has_scrolled_by_wheel,
bool has_scrolled_by_touch) override {}
- void RequestNewCompositorFrameSink() override {}
- void DidInitializeCompositorFrameSink() override {}
- void DidFailToInitializeCompositorFrameSink() override {}
+ void RequestNewLayerTreeFrameSink() override {}
+ void DidInitializeLayerTreeFrameSink() override {}
+ void DidFailToInitializeLayerTreeFrameSink() override {}
void WillCommit() override {}
void DidCommit() override {}
void DidCommitAndDrawFrame() override {}
diff --git a/cc/test/stub_layer_tree_host_single_thread_client.h b/cc/test/stub_layer_tree_host_single_thread_client.h
index 1112675..762b6ce 100644
--- a/cc/test/stub_layer_tree_host_single_thread_client.h
+++ b/cc/test/stub_layer_tree_host_single_thread_client.h
@@ -18,7 +18,7 @@
void RequestScheduleComposite() override {}
void RequestScheduleAnimation() override {}
void DidSubmitCompositorFrame() override {}
- void DidLoseCompositorFrameSink() override {}
+ void DidLoseLayerTreeFrameSink() override {}
};
} // namespace cc
diff --git a/cc/test/test_hooks.h b/cc/test/test_hooks.h
index bff5cd5..a59f6aa 100644
--- a/cc/test/test_hooks.h
+++ b/cc/test/test_hooks.h
@@ -94,8 +94,8 @@
virtual void WillBeginMainFrame() {}
virtual void DidBeginMainFrame() {}
virtual void UpdateLayerTreeHost() {}
- virtual void DidInitializeCompositorFrameSink() {}
- virtual void DidFailToInitializeCompositorFrameSink() {}
+ virtual void DidInitializeLayerTreeFrameSink() {}
+ virtual void DidFailToInitializeLayerTreeFrameSink() {}
virtual void DidAddAnimation() {}
virtual void WillCommit() {}
virtual void DidCommit() {}
@@ -122,7 +122,7 @@
// OutputSurface indirections to the LayerTreeTest, that can be further
// overridden.
- virtual void RequestNewCompositorFrameSink() = 0;
+ virtual void RequestNewLayerTreeFrameSink() = 0;
virtual std::unique_ptr<OutputSurface> CreateDisplayOutputSurfaceOnThread(
scoped_refptr<ContextProvider> compositor_context_provider) = 0;
};
diff --git a/cc/test/test_compositor_frame_sink.cc b/cc/test/test_layer_tree_frame_sink.cc
similarity index 80%
rename from cc/test/test_compositor_frame_sink.cc
rename to cc/test/test_layer_tree_frame_sink.cc
index f03d709c..36b7e98 100644
--- a/cc/test/test_compositor_frame_sink.cc
+++ b/cc/test/test_layer_tree_frame_sink.cc
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "cc/test/test_compositor_frame_sink.h"
+#include "cc/test/test_layer_tree_frame_sink.h"
#include <stdint.h>
#include <utility>
@@ -10,18 +10,18 @@
#include "base/memory/ptr_util.h"
#include "base/single_thread_task_runner.h"
#include "cc/output/begin_frame_args.h"
-#include "cc/output/compositor_frame_sink_client.h"
#include "cc/output/copy_output_request.h"
#include "cc/output/direct_renderer.h"
+#include "cc/output/layer_tree_frame_sink_client.h"
#include "cc/output/output_surface.h"
#include "cc/output/texture_mailbox_deleter.h"
#include "cc/surfaces/compositor_frame_sink_support.h"
namespace cc {
-static constexpr FrameSinkId kCompositorFrameSinkId(1, 1);
+static constexpr FrameSinkId kLayerTreeFrameSinkId(1, 1);
-TestCompositorFrameSink::TestCompositorFrameSink(
+TestLayerTreeFrameSink::TestLayerTreeFrameSink(
scoped_refptr<ContextProvider> compositor_context_provider,
scoped_refptr<ContextProvider> worker_context_provider,
SharedBitmapManager* shared_bitmap_manager,
@@ -31,16 +31,16 @@
bool synchronous_composite,
bool disable_display_vsync,
double refresh_rate)
- : CompositorFrameSink(std::move(compositor_context_provider),
- std::move(worker_context_provider),
- gpu_memory_buffer_manager,
- shared_bitmap_manager),
+ : LayerTreeFrameSink(std::move(compositor_context_provider),
+ std::move(worker_context_provider),
+ gpu_memory_buffer_manager,
+ shared_bitmap_manager),
synchronous_composite_(synchronous_composite),
disable_display_vsync_(disable_display_vsync),
renderer_settings_(renderer_settings),
refresh_rate_(refresh_rate),
task_runner_(std::move(task_runner)),
- frame_sink_id_(kCompositorFrameSinkId),
+ frame_sink_id_(kLayerTreeFrameSinkId),
surface_manager_(new SurfaceManager),
local_surface_id_allocator_(new LocalSurfaceIdAllocator()),
external_begin_frame_source_(this),
@@ -50,17 +50,17 @@
capabilities_.delegated_sync_points_required = true;
}
-TestCompositorFrameSink::~TestCompositorFrameSink() {
+TestLayerTreeFrameSink::~TestLayerTreeFrameSink() {
DCHECK(copy_requests_.empty());
}
-void TestCompositorFrameSink::RequestCopyOfOutput(
+void TestLayerTreeFrameSink::RequestCopyOfOutput(
std::unique_ptr<CopyOutputRequest> request) {
copy_requests_.push_back(std::move(request));
}
-bool TestCompositorFrameSink::BindToClient(CompositorFrameSinkClient* client) {
- if (!CompositorFrameSink::BindToClient(client))
+bool TestLayerTreeFrameSink::BindToClient(LayerTreeFrameSinkClient* client) {
+ if (!LayerTreeFrameSink::BindToClient(client))
return false;
std::unique_ptr<OutputSurface> display_output_surface =
@@ -113,7 +113,7 @@
return true;
}
-void TestCompositorFrameSink::DetachFromClient() {
+void TestLayerTreeFrameSink::DetachFromClient() {
if (begin_frame_source_)
surface_manager_->UnregisterBeginFrameSource(begin_frame_source_.get());
client_->SetBeginFrameSource(nullptr);
@@ -123,15 +123,15 @@
local_surface_id_allocator_ = nullptr;
surface_manager_ = nullptr;
test_client_ = nullptr;
- CompositorFrameSink::DetachFromClient();
+ LayerTreeFrameSink::DetachFromClient();
}
-void TestCompositorFrameSink::SetLocalSurfaceId(
+void TestLayerTreeFrameSink::SetLocalSurfaceId(
const LocalSurfaceId& local_surface_id) {
test_client_->DisplayReceivedLocalSurfaceId(local_surface_id);
}
-void TestCompositorFrameSink::SubmitCompositorFrame(CompositorFrame frame) {
+void TestLayerTreeFrameSink::SubmitCompositorFrame(CompositorFrame frame) {
DCHECK(frame.metadata.begin_frame_ack.has_damage);
DCHECK_LE(BeginFrameArgs::kStartingFrameNumber,
frame.metadata.begin_frame_ack.sequence_number);
@@ -163,18 +163,18 @@
// calling the client to tell it that it is done.
task_runner_->PostTask(
FROM_HERE,
- base::BindOnce(&TestCompositorFrameSink::SendCompositorFrameAckToClient,
+ base::BindOnce(&TestLayerTreeFrameSink::SendCompositorFrameAckToClient,
weak_ptr_factory_.GetWeakPtr()));
}
}
-void TestCompositorFrameSink::DidNotProduceFrame(const BeginFrameAck& ack) {
+void TestLayerTreeFrameSink::DidNotProduceFrame(const BeginFrameAck& ack) {
DCHECK(!ack.has_damage);
DCHECK_LE(BeginFrameArgs::kStartingFrameNumber, ack.sequence_number);
support_->DidNotProduceFrame(ack);
}
-void TestCompositorFrameSink::DidReceiveCompositorFrameAck(
+void TestLayerTreeFrameSink::DidReceiveCompositorFrameAck(
const ReturnedResourceArray& resources) {
ReclaimResources(resources);
// In synchronous mode, we manually send acks and this method should not be
@@ -184,38 +184,38 @@
client_->DidReceiveCompositorFrameAck();
}
-void TestCompositorFrameSink::OnBeginFrame(const BeginFrameArgs& args) {
+void TestLayerTreeFrameSink::OnBeginFrame(const BeginFrameArgs& args) {
external_begin_frame_source_.OnBeginFrame(args);
}
-void TestCompositorFrameSink::ReclaimResources(
+void TestLayerTreeFrameSink::ReclaimResources(
const ReturnedResourceArray& resources) {
client_->ReclaimResources(resources);
}
-void TestCompositorFrameSink::WillDrawSurface(
+void TestLayerTreeFrameSink::WillDrawSurface(
const LocalSurfaceId& local_surface_id,
const gfx::Rect& damage_rect) {}
-void TestCompositorFrameSink::DisplayOutputSurfaceLost() {
- client_->DidLoseCompositorFrameSink();
+void TestLayerTreeFrameSink::DisplayOutputSurfaceLost() {
+ client_->DidLoseLayerTreeFrameSink();
}
-void TestCompositorFrameSink::DisplayWillDrawAndSwap(
+void TestLayerTreeFrameSink::DisplayWillDrawAndSwap(
bool will_draw_and_swap,
const RenderPassList& render_passes) {
test_client_->DisplayWillDrawAndSwap(will_draw_and_swap, render_passes);
}
-void TestCompositorFrameSink::DisplayDidDrawAndSwap() {
+void TestLayerTreeFrameSink::DisplayDidDrawAndSwap() {
test_client_->DisplayDidDrawAndSwap();
}
-void TestCompositorFrameSink::OnNeedsBeginFrames(bool needs_begin_frames) {
+void TestLayerTreeFrameSink::OnNeedsBeginFrames(bool needs_begin_frames) {
support_->SetNeedsBeginFrame(needs_begin_frames);
}
-void TestCompositorFrameSink::SendCompositorFrameAckToClient() {
+void TestLayerTreeFrameSink::SendCompositorFrameAckToClient() {
client_->DidReceiveCompositorFrameAck();
}
diff --git a/cc/test/test_compositor_frame_sink.h b/cc/test/test_layer_tree_frame_sink.h
similarity index 80%
rename from cc/test/test_compositor_frame_sink.h
rename to cc/test/test_layer_tree_frame_sink.h
index 7c27af4..569c039 100644
--- a/cc/test/test_compositor_frame_sink.h
+++ b/cc/test/test_layer_tree_frame_sink.h
@@ -2,12 +2,12 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef CC_TEST_TEST_COMPOSITOR_FRAME_SINK_H_
-#define CC_TEST_TEST_COMPOSITOR_FRAME_SINK_H_
+#ifndef CC_TEST_TEST_LAYER_TREE_FRAME_SINK_H_
+#define CC_TEST_TEST_LAYER_TREE_FRAME_SINK_H_
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
-#include "cc/output/compositor_frame_sink.h"
+#include "cc/output/layer_tree_frame_sink.h"
#include "cc/output/renderer_settings.h"
#include "cc/scheduler/begin_frame_source.h"
#include "cc/surfaces/compositor_frame_sink_support_client.h"
@@ -25,9 +25,9 @@
class CopyOutputRequest;
class OutputSurface;
-class TestCompositorFrameSinkClient {
+class TestLayerTreeFrameSinkClient {
public:
- virtual ~TestCompositorFrameSinkClient() {}
+ virtual ~TestLayerTreeFrameSinkClient() {}
// This passes the ContextProvider being used by LayerTreeHostImpl which
// can be used for the OutputSurface optionally.
@@ -42,15 +42,15 @@
virtual void DisplayDidDrawAndSwap() = 0;
};
-// CompositorFrameSink that owns and forwards frames to a Display.
-class TestCompositorFrameSink : public CompositorFrameSink,
- public CompositorFrameSinkSupportClient,
- public DisplayClient,
- public ExternalBeginFrameSourceClient {
+// LayerTreeFrameSink that owns and forwards frames to a Display.
+class TestLayerTreeFrameSink : public LayerTreeFrameSink,
+ public CompositorFrameSinkSupportClient,
+ public DisplayClient,
+ public ExternalBeginFrameSourceClient {
public:
// Pass true for |force_disable_reclaim_resources| to act like the Display
// is out-of-process and can't return resources synchronously.
- TestCompositorFrameSink(
+ TestLayerTreeFrameSink(
scoped_refptr<ContextProvider> compositor_context_provider,
scoped_refptr<ContextProvider> worker_context_provider,
SharedBitmapManager* shared_bitmap_manager,
@@ -60,10 +60,10 @@
bool synchronous_composite,
bool disable_display_vsync,
double refresh_rate);
- ~TestCompositorFrameSink() override;
+ ~TestLayerTreeFrameSink() override;
// This client must be set before BindToClient() happens.
- void SetClient(TestCompositorFrameSinkClient* client) {
+ void SetClient(TestLayerTreeFrameSinkClient* client) {
test_client_ = client;
}
void SetEnlargePassTextureAmount(const gfx::Size& s) {
@@ -75,8 +75,8 @@
// Will be included with the next SubmitCompositorFrame.
void RequestCopyOfOutput(std::unique_ptr<CopyOutputRequest> request);
- // CompositorFrameSink implementation.
- bool BindToClient(CompositorFrameSinkClient* client) override;
+ // LayerTreeFrameSink implementation.
+ bool BindToClient(LayerTreeFrameSinkClient* client) override;
void DetachFromClient() override;
void SetLocalSurfaceId(const LocalSurfaceId& local_surface_id) override;
void SubmitCompositorFrame(CompositorFrame frame) override;
@@ -111,7 +111,7 @@
FrameSinkId frame_sink_id_;
// TODO(danakj): These don't need to be stored in unique_ptrs when
- // CompositorFrameSink is owned/destroyed on the compositor thread.
+ // LayerTreeFrameSink is owned/destroyed on the compositor thread.
std::unique_ptr<SurfaceManager> surface_manager_;
std::unique_ptr<LocalSurfaceIdAllocator> local_surface_id_allocator_;
LocalSurfaceId local_surface_id_;
@@ -127,14 +127,14 @@
// Uses surface_manager_ and begin_frame_source_.
std::unique_ptr<Display> display_;
- TestCompositorFrameSinkClient* test_client_ = nullptr;
+ TestLayerTreeFrameSinkClient* test_client_ = nullptr;
gfx::Size enlarge_pass_texture_amount_;
std::vector<std::unique_ptr<CopyOutputRequest>> copy_requests_;
- base::WeakPtrFactory<TestCompositorFrameSink> weak_ptr_factory_;
+ base::WeakPtrFactory<TestLayerTreeFrameSink> weak_ptr_factory_;
};
} // namespace cc
-#endif // CC_TEST_TEST_COMPOSITOR_FRAME_SINK_H_
+#endif // CC_TEST_TEST_LAYER_TREE_FRAME_SINK_H_
diff --git a/cc/test/test_layer_tree_host_base.cc b/cc/test/test_layer_tree_host_base.cc
index fa79157..a252a59 100644
--- a/cc/test/test_layer_tree_host_base.cc
+++ b/cc/test/test_layer_tree_host_base.cc
@@ -6,7 +6,7 @@
#include "base/memory/ptr_util.h"
#include "base/threading/thread_task_runner_handle.h"
-#include "cc/test/fake_compositor_frame_sink.h"
+#include "cc/test/fake_layer_tree_frame_sink.h"
#include "cc/test/fake_raster_source.h"
#include "cc/trees/layer_tree_impl.h"
@@ -23,7 +23,7 @@
TestLayerTreeHostBase::~TestLayerTreeHostBase() = default;
void TestLayerTreeHostBase::SetUp() {
- compositor_frame_sink_ = CreateCompositorFrameSink();
+ layer_tree_frame_sink_ = CreateLayerTreeFrameSink();
task_graph_runner_ = CreateTaskGraphRunner();
host_impl_ = CreateHostImpl(CreateSettings(), &task_runner_provider_,
task_graph_runner_.get());
@@ -36,9 +36,9 @@
return settings;
}
-std::unique_ptr<CompositorFrameSink>
-TestLayerTreeHostBase::CreateCompositorFrameSink() {
- return FakeCompositorFrameSink::Create3d();
+std::unique_ptr<LayerTreeFrameSink>
+TestLayerTreeHostBase::CreateLayerTreeFrameSink() {
+ return FakeLayerTreeFrameSink::Create3d();
}
std::unique_ptr<FakeLayerTreeHostImpl> TestLayerTreeHostBase::CreateHostImpl(
@@ -56,15 +56,15 @@
void TestLayerTreeHostBase::InitializeRenderer() {
host_impl_->SetVisible(true);
- host_impl_->InitializeRenderer(compositor_frame_sink_.get());
+ host_impl_->InitializeRenderer(layer_tree_frame_sink_.get());
}
-void TestLayerTreeHostBase::ResetCompositorFrameSink(
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink) {
- host_impl()->DidLoseCompositorFrameSink();
+void TestLayerTreeHostBase::ResetLayerTreeFrameSink(
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink) {
+ host_impl()->DidLoseLayerTreeFrameSink();
host_impl()->SetVisible(true);
- host_impl()->InitializeRenderer(compositor_frame_sink.get());
- compositor_frame_sink_ = std::move(compositor_frame_sink);
+ host_impl()->InitializeRenderer(layer_tree_frame_sink.get());
+ layer_tree_frame_sink_ = std::move(layer_tree_frame_sink);
}
std::unique_ptr<FakeLayerTreeHostImpl> TestLayerTreeHostBase::TakeHostImpl() {
diff --git a/cc/test/test_layer_tree_host_base.h b/cc/test/test_layer_tree_host_base.h
index e05cf42..4bbd512 100644
--- a/cc/test/test_layer_tree_host_base.h
+++ b/cc/test/test_layer_tree_host_base.h
@@ -7,7 +7,7 @@
#include <memory>
-#include "cc/output/compositor_frame_sink.h"
+#include "cc/output/layer_tree_frame_sink.h"
#include "cc/test/fake_impl_task_runner_provider.h"
#include "cc/test/fake_layer_tree_host_impl.h"
#include "cc/test/fake_picture_layer_impl.h"
@@ -26,7 +26,7 @@
void SetUp() override;
virtual LayerTreeSettings CreateSettings();
- virtual std::unique_ptr<CompositorFrameSink> CreateCompositorFrameSink();
+ virtual std::unique_ptr<LayerTreeFrameSink> CreateLayerTreeFrameSink();
virtual std::unique_ptr<FakeLayerTreeHostImpl> CreateHostImpl(
const LayerTreeSettings& settings,
TaskRunnerProvider* task_runner_provider,
@@ -34,8 +34,8 @@
virtual std::unique_ptr<TaskGraphRunner> CreateTaskGraphRunner();
virtual void InitializeRenderer();
- void ResetCompositorFrameSink(
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink);
+ void ResetLayerTreeFrameSink(
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink);
std::unique_ptr<FakeLayerTreeHostImpl> TakeHostImpl();
void SetupDefaultTrees(const gfx::Size& layer_bounds);
@@ -53,8 +53,8 @@
TaskGraphRunner* task_graph_runner() const {
return task_graph_runner_.get();
}
- CompositorFrameSink* compositor_frame_sink() const {
- return compositor_frame_sink_.get();
+ LayerTreeFrameSink* layer_tree_frame_sink() const {
+ return layer_tree_frame_sink_.get();
}
FakePictureLayerImpl* pending_layer() const { return pending_layer_; }
FakePictureLayerImpl* active_layer() const { return active_layer_; }
@@ -66,7 +66,7 @@
FakeImplTaskRunnerProvider task_runner_provider_;
std::unique_ptr<TaskGraphRunner> task_graph_runner_;
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink_;
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink_;
std::unique_ptr<FakeLayerTreeHostImpl> host_impl_;
FakePictureLayerImpl* pending_layer_;
diff --git a/cc/tiles/tile_manager_perftest.cc b/cc/tiles/tile_manager_perftest.cc
index c87e217..483f76dd 100644
--- a/cc/tiles/tile_manager_perftest.cc
+++ b/cc/tiles/tile_manager_perftest.cc
@@ -13,9 +13,9 @@
#include "cc/base/lap_timer.h"
#include "cc/raster/raster_buffer.h"
#include "cc/test/begin_frame_args_test.h"
-#include "cc/test/fake_compositor_frame_sink.h"
-#include "cc/test/fake_compositor_frame_sink_client.h"
#include "cc/test/fake_impl_task_runner_provider.h"
+#include "cc/test/fake_layer_tree_frame_sink.h"
+#include "cc/test/fake_layer_tree_frame_sink_client.h"
#include "cc/test/fake_layer_tree_host_impl.h"
#include "cc/test/fake_picture_layer_impl.h"
#include "cc/test/fake_raster_source.h"
@@ -48,7 +48,7 @@
void InitializeRenderer() override {
host_impl()->SetVisible(true);
- host_impl()->InitializeRenderer(compositor_frame_sink());
+ host_impl()->InitializeRenderer(layer_tree_frame_sink());
tile_manager()->SetTileTaskManagerForTesting(
base::MakeUnique<FakeTileTaskManagerImpl>());
}
diff --git a/cc/tiles/tile_manager_unittest.cc b/cc/tiles/tile_manager_unittest.cc
index d36a7824..5e11640 100644
--- a/cc/tiles/tile_manager_unittest.cc
+++ b/cc/tiles/tile_manager_unittest.cc
@@ -19,9 +19,9 @@
#include "cc/raster/synchronous_task_graph_runner.h"
#include "cc/resources/resource_pool.h"
#include "cc/test/begin_frame_args_test.h"
-#include "cc/test/fake_compositor_frame_sink.h"
-#include "cc/test/fake_compositor_frame_sink_client.h"
#include "cc/test/fake_impl_task_runner_provider.h"
+#include "cc/test/fake_layer_tree_frame_sink.h"
+#include "cc/test/fake_layer_tree_frame_sink_client.h"
#include "cc/test/fake_layer_tree_host_impl.h"
#include "cc/test/fake_picture_layer_impl.h"
#include "cc/test/fake_picture_layer_tiling_client.h"
@@ -1550,8 +1550,8 @@
}
// By default use software compositing (no context provider).
- std::unique_ptr<CompositorFrameSink> CreateCompositorFrameSink() override {
- return FakeCompositorFrameSink::CreateSoftware();
+ std::unique_ptr<LayerTreeFrameSink> CreateLayerTreeFrameSink() override {
+ return FakeLayerTreeFrameSink::CreateSoftware();
}
MockLayerTreeHostImpl& MockHostImpl() {
@@ -1756,8 +1756,8 @@
return base::MakeUnique<SynchronousTaskGraphRunner>();
}
- std::unique_ptr<CompositorFrameSink> CreateCompositorFrameSink() override {
- return FakeCompositorFrameSink::Create3d();
+ std::unique_ptr<LayerTreeFrameSink> CreateLayerTreeFrameSink() override {
+ return FakeLayerTreeFrameSink::Create3d();
}
LayerTreeSettings CreateSettings() override {
diff --git a/cc/trees/layer_tree_host.cc b/cc/trees/layer_tree_host.cc
index 57dec2e..763c62d 100644
--- a/cc/trees/layer_tree_host.cc
+++ b/cc/trees/layer_tree_host.cc
@@ -404,43 +404,42 @@
}
}
-void LayerTreeHost::SetCompositorFrameSink(
- std::unique_ptr<CompositorFrameSink> surface) {
- TRACE_EVENT0("cc", "LayerTreeHostInProcess::SetCompositorFrameSink");
+void LayerTreeHost::SetLayerTreeFrameSink(
+ std::unique_ptr<LayerTreeFrameSink> surface) {
+ TRACE_EVENT0("cc", "LayerTreeHostInProcess::SetLayerTreeFrameSink");
DCHECK(surface);
- DCHECK(!new_compositor_frame_sink_);
- new_compositor_frame_sink_ = std::move(surface);
- proxy_->SetCompositorFrameSink(new_compositor_frame_sink_.get());
+ DCHECK(!new_layer_tree_frame_sink_);
+ new_layer_tree_frame_sink_ = std::move(surface);
+ proxy_->SetLayerTreeFrameSink(new_layer_tree_frame_sink_.get());
}
-std::unique_ptr<CompositorFrameSink>
-LayerTreeHost::ReleaseCompositorFrameSink() {
+std::unique_ptr<LayerTreeFrameSink> LayerTreeHost::ReleaseLayerTreeFrameSink() {
DCHECK(!visible_);
- DidLoseCompositorFrameSink();
- proxy_->ReleaseCompositorFrameSink();
- return std::move(current_compositor_frame_sink_);
+ DidLoseLayerTreeFrameSink();
+ proxy_->ReleaseLayerTreeFrameSink();
+ return std::move(current_layer_tree_frame_sink_);
}
-void LayerTreeHost::RequestNewCompositorFrameSink() {
- client_->RequestNewCompositorFrameSink();
+void LayerTreeHost::RequestNewLayerTreeFrameSink() {
+ client_->RequestNewLayerTreeFrameSink();
}
-void LayerTreeHost::DidInitializeCompositorFrameSink() {
- DCHECK(new_compositor_frame_sink_);
- current_compositor_frame_sink_ = std::move(new_compositor_frame_sink_);
- client_->DidInitializeCompositorFrameSink();
+void LayerTreeHost::DidInitializeLayerTreeFrameSink() {
+ DCHECK(new_layer_tree_frame_sink_);
+ current_layer_tree_frame_sink_ = std::move(new_layer_tree_frame_sink_);
+ client_->DidInitializeLayerTreeFrameSink();
}
-void LayerTreeHost::DidFailToInitializeCompositorFrameSink() {
- DCHECK(new_compositor_frame_sink_);
+void LayerTreeHost::DidFailToInitializeLayerTreeFrameSink() {
+ DCHECK(new_layer_tree_frame_sink_);
// Note: It is safe to drop all output surface references here as
// LayerTreeHostImpl will not keep a pointer to either the old or
- // new CompositorFrameSink after failing to initialize the new one.
- current_compositor_frame_sink_ = nullptr;
- new_compositor_frame_sink_ = nullptr;
- client_->DidFailToInitializeCompositorFrameSink();
+ // new LayerTreeFrameSink after failing to initialize the new one.
+ current_layer_tree_frame_sink_ = nullptr;
+ new_layer_tree_frame_sink_ = nullptr;
+ client_->DidFailToInitializeLayerTreeFrameSink();
}
std::unique_ptr<LayerTreeHostImpl>
@@ -464,8 +463,8 @@
return host_impl;
}
-void LayerTreeHost::DidLoseCompositorFrameSink() {
- TRACE_EVENT0("cc", "LayerTreeHostInProcess::DidLoseCompositorFrameSink");
+void LayerTreeHost::DidLoseLayerTreeFrameSink() {
+ TRACE_EVENT0("cc", "LayerTreeHostInProcess::DidLoseLayerTreeFrameSink");
DCHECK(task_runner_provider_->IsMainThread());
SetNeedsCommit();
}
@@ -643,9 +642,9 @@
return;
bool gpu_rasterization_enabled = false;
- if (host_impl->compositor_frame_sink()) {
+ if (host_impl->layer_tree_frame_sink()) {
ContextProvider* compositor_context_provider =
- host_impl->compositor_frame_sink()->context_provider();
+ host_impl->layer_tree_frame_sink()->context_provider();
if (compositor_context_provider) {
gpu_rasterization_enabled =
compositor_context_provider->ContextCapabilities().gpu_rasterization;
diff --git a/cc/trees/layer_tree_host.h b/cc/trees/layer_tree_host.h
index f283e39f..7aa95ec9 100644
--- a/cc/trees/layer_tree_host.h
+++ b/cc/trees/layer_tree_host.h
@@ -33,7 +33,7 @@
#include "cc/input/scrollbar.h"
#include "cc/layers/layer_collections.h"
#include "cc/layers/layer_list_iterator.h"
-#include "cc/output/compositor_frame_sink.h"
+#include "cc/output/layer_tree_frame_sink.h"
#include "cc/output/swap_promise.h"
#include "cc/resources/resource_format.h"
#include "cc/surfaces/surface_reference_owner.h"
@@ -131,23 +131,23 @@
// Sets whether the content is suitable to use Gpu Rasterization.
void SetHasGpuRasterizationTrigger(bool has_trigger);
- // Visibility and CompositorFrameSink -------------------------------
+ // Visibility and LayerTreeFrameSink -------------------------------
void SetVisible(bool visible);
bool IsVisible() const;
- // Called in response to an CompositorFrameSink request made to the client
- // using LayerTreeHostClient::RequestNewCompositorFrameSink. The client will
- // be informed of the CompositorFrameSink initialization status using
- // DidInitializaCompositorFrameSink or DidFailToInitializeCompositorFrameSink.
+ // Called in response to a LayerTreeFrameSink request made to the client
+ // using LayerTreeHostClient::RequestNewLayerTreeFrameSink. The client will
+ // be informed of the LayerTreeFrameSink initialization status using
+ // DidInitializaLayerTreeFrameSink or DidFailToInitializeLayerTreeFrameSink.
// The request is completed when the host successfully initializes an
- // CompositorFrameSink.
- void SetCompositorFrameSink(
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink);
+ // LayerTreeFrameSink.
+ void SetLayerTreeFrameSink(
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink);
// Forces the host to immediately release all references to the
- // CompositorFrameSink, if any. Can be safely called any time.
- std::unique_ptr<CompositorFrameSink> ReleaseCompositorFrameSink();
+ // LayerTreeFrameSink, if any. Can be safely called any time.
+ std::unique_ptr<LayerTreeFrameSink> ReleaseLayerTreeFrameSink();
// Frame Scheduling (main and compositor frames) requests -------
@@ -416,12 +416,12 @@
void FinishCommitOnImplThread(LayerTreeHostImpl* host_impl);
void WillCommit();
void CommitComplete();
- void RequestNewCompositorFrameSink();
- void DidInitializeCompositorFrameSink();
- void DidFailToInitializeCompositorFrameSink();
+ void RequestNewLayerTreeFrameSink();
+ void DidInitializeLayerTreeFrameSink();
+ void DidFailToInitializeLayerTreeFrameSink();
virtual std::unique_ptr<LayerTreeHostImpl> CreateLayerTreeHostImpl(
LayerTreeHostImplClient* client);
- void DidLoseCompositorFrameSink();
+ void DidLoseLayerTreeFrameSink();
void DidCommitAndDrawFrame() { client_->DidCommitAndDrawFrame(); }
void DidReceiveCompositorFrameAck() {
client_->DidReceiveCompositorFrameAck();
@@ -551,13 +551,13 @@
SwapPromiseManager swap_promise_manager_;
- // |current_compositor_frame_sink_| can't be updated until we've successfully
- // initialized a new CompositorFrameSink. |new_compositor_frame_sink_|
- // contains the new CompositorFrameSink that is currently being initialized.
- // If initialization is successful then |new_compositor_frame_sink_| replaces
- // |current_compositor_frame_sink_|.
- std::unique_ptr<CompositorFrameSink> new_compositor_frame_sink_;
- std::unique_ptr<CompositorFrameSink> current_compositor_frame_sink_;
+ // |current_layer_tree_frame_sink_| can't be updated until we've successfully
+ // initialized a new LayerTreeFrameSink. |new_layer_tree_frame_sink_|
+ // contains the new LayerTreeFrameSink that is currently being initialized.
+ // If initialization is successful then |new_layer_tree_frame_sink_| replaces
+ // |current_layer_tree_frame_sink_|.
+ std::unique_ptr<LayerTreeFrameSink> new_layer_tree_frame_sink_;
+ std::unique_ptr<LayerTreeFrameSink> current_layer_tree_frame_sink_;
const LayerTreeSettings settings_;
LayerTreeDebugState debug_state_;
diff --git a/cc/trees/layer_tree_host_client.h b/cc/trees/layer_tree_host_client.h
index f54a69b0..1b06e89 100644
--- a/cc/trees/layer_tree_host_client.h
+++ b/cc/trees/layer_tree_host_client.h
@@ -15,7 +15,6 @@
}
namespace cc {
-class CompositorFrameSink;
struct BeginFrameArgs;
class LayerTreeHostClient {
@@ -48,13 +47,13 @@
virtual void RecordWheelAndTouchScrollingCount(
bool has_scrolled_by_wheel,
bool has_scrolled_by_touch) = 0;
- // Request an CompositorFrameSink from the client. When the client has one it
- // should call LayerTreeHost::SetCompositorFrameSink. This will result in
- // either DidFailToInitializeCompositorFrameSink or
- // DidInitializeCompositorFrameSink being called.
- virtual void RequestNewCompositorFrameSink() = 0;
- virtual void DidInitializeCompositorFrameSink() = 0;
- virtual void DidFailToInitializeCompositorFrameSink() = 0;
+ // Request a LayerTreeFrameSink from the client. When the client has one it
+ // should call LayerTreeHost::SetLayerTreeFrameSink. This will result in
+ // either DidFailToInitializeLayerTreeFrameSink or
+ // DidInitializeLayerTreeFrameSink being called.
+ virtual void RequestNewLayerTreeFrameSink() = 0;
+ virtual void DidInitializeLayerTreeFrameSink() = 0;
+ virtual void DidFailToInitializeLayerTreeFrameSink() = 0;
virtual void WillCommit() = 0;
virtual void DidCommit() = 0;
virtual void DidCommitAndDrawFrame() = 0;
diff --git a/cc/trees/layer_tree_host_common_unittest.cc b/cc/trees/layer_tree_host_common_unittest.cc
index f5b9502..1fe36ba 100644
--- a/cc/trees/layer_tree_host_common_unittest.cc
+++ b/cc/trees/layer_tree_host_common_unittest.cc
@@ -29,9 +29,9 @@
#include "cc/output/copy_output_request.h"
#include "cc/output/copy_output_result.h"
#include "cc/test/animation_test_common.h"
-#include "cc/test/fake_compositor_frame_sink.h"
#include "cc/test/fake_content_layer_client.h"
#include "cc/test/fake_impl_task_runner_provider.h"
+#include "cc/test/fake_layer_tree_frame_sink.h"
#include "cc/test/fake_layer_tree_host.h"
#include "cc/test/fake_layer_tree_host_impl.h"
#include "cc/test/fake_picture_layer.h"
@@ -3020,8 +3020,8 @@
TEST_F(LayerTreeHostCommonTest, OcclusionBySiblingOfTarget) {
FakeImplTaskRunnerProvider task_runner_provider;
TestTaskGraphRunner task_graph_runner;
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink =
- FakeCompositorFrameSink::Create3d();
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink =
+ FakeLayerTreeFrameSink::Create3d();
FakeLayerTreeHostImpl host_impl(&task_runner_provider, &task_graph_runner);
std::unique_ptr<LayerImpl> root =
@@ -3071,7 +3071,7 @@
root->test_properties()->AddChild(std::move(child));
host_impl.active_tree()->SetRootLayerForTesting(std::move(root));
host_impl.SetVisible(true);
- host_impl.InitializeRenderer(compositor_frame_sink.get());
+ host_impl.InitializeRenderer(layer_tree_frame_sink.get());
host_impl.active_tree()->BuildLayerListAndPropertyTreesForTesting();
bool update_lcd_text = false;
host_impl.active_tree()->UpdateDrawProperties(update_lcd_text);
@@ -3095,8 +3095,8 @@
TEST_F(LayerTreeHostCommonTest, TextureLayerSnapping) {
FakeImplTaskRunnerProvider task_runner_provider;
TestTaskGraphRunner task_graph_runner;
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink =
- FakeCompositorFrameSink::Create3d();
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink =
+ FakeLayerTreeFrameSink::Create3d();
FakeLayerTreeHostImpl host_impl(&task_runner_provider, &task_graph_runner);
std::unique_ptr<LayerImpl> root =
@@ -3118,7 +3118,7 @@
root->test_properties()->AddChild(std::move(child));
host_impl.active_tree()->SetRootLayerForTesting(std::move(root));
host_impl.SetVisible(true);
- host_impl.InitializeRenderer(compositor_frame_sink.get());
+ host_impl.InitializeRenderer(layer_tree_frame_sink.get());
host_impl.active_tree()->BuildLayerListAndPropertyTreesForTesting();
bool update_lcd_text = false;
host_impl.active_tree()->UpdateDrawProperties(update_lcd_text);
@@ -3137,8 +3137,8 @@
OcclusionForLayerWithUninvertibleDrawTransform) {
FakeImplTaskRunnerProvider task_runner_provider;
TestTaskGraphRunner task_graph_runner;
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink =
- FakeCompositorFrameSink::Create3d();
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink =
+ FakeLayerTreeFrameSink::Create3d();
FakeLayerTreeHostImpl host_impl(&task_runner_provider, &task_graph_runner);
std::unique_ptr<LayerImpl> root =
@@ -3181,7 +3181,7 @@
root->test_properties()->AddChild(std::move(occluding_child));
host_impl.active_tree()->SetRootLayerForTesting(std::move(root));
host_impl.SetVisible(true);
- host_impl.InitializeRenderer(compositor_frame_sink.get());
+ host_impl.InitializeRenderer(layer_tree_frame_sink.get());
host_impl.active_tree()->BuildLayerListAndPropertyTreesForTesting();
bool update_lcd_text = false;
host_impl.active_tree()->UpdateDrawProperties(update_lcd_text);
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index 44c03b0..67f5b43ff 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -48,8 +48,8 @@
#include "cc/layers/viewport.h"
#include "cc/output/compositor_frame.h"
#include "cc/output/compositor_frame_metadata.h"
-#include "cc/output/compositor_frame_sink.h"
#include "cc/output/copy_output_request.h"
+#include "cc/output/layer_tree_frame_sink.h"
#include "cc/quads/render_pass_draw_quad.h"
#include "cc/quads/shared_quad_state.h"
#include "cc/quads/solid_color_draw_quad.h"
@@ -196,7 +196,7 @@
: client_(client),
task_runner_provider_(task_runner_provider),
current_begin_frame_tracker_(BEGINFRAMETRACKER_FROM_HERE),
- compositor_frame_sink_(nullptr),
+ layer_tree_frame_sink_(nullptr),
need_update_gpu_rasterization_status_(false),
content_is_suitable_for_gpu_rasterization_(true),
has_gpu_rasterization_trigger_(false),
@@ -237,7 +237,7 @@
id_(id),
requires_high_res_to_draw_(false),
is_likely_to_require_a_draw_(false),
- has_valid_compositor_frame_sink_(false),
+ has_valid_layer_tree_frame_sink_(false),
mutator_(nullptr),
scroll_animating_latched_node_id_(ScrollTree::kInvalidNodeId),
has_scrolled_by_wheel_(false),
@@ -277,7 +277,7 @@
"cc::LayerTreeHostImpl", id_);
// It is released before shutdown.
- DCHECK(!compositor_frame_sink_);
+ DCHECK(!layer_tree_frame_sink_);
DCHECK(!resource_provider_);
DCHECK(!resource_pool_);
@@ -396,9 +396,9 @@
// client_->OnCanDrawStateChanged in the proper places and update the
// NotifyIfCanDrawChanged test.
- if (!compositor_frame_sink_) {
+ if (!layer_tree_frame_sink_) {
TRACE_EVENT_INSTANT0("cc",
- "LayerTreeHostImpl::CanDraw no CompositorFrameSink",
+ "LayerTreeHostImpl::CanDraw no LayerTreeFrameSink",
TRACE_EVENT_SCOPE_THREAD);
return false;
}
@@ -727,7 +727,7 @@
DrawMode LayerTreeHostImpl::GetDrawMode() const {
if (resourceless_software_draw_) {
return DRAW_MODE_RESOURCELESS_SOFTWARE;
- } else if (compositor_frame_sink_->context_provider()) {
+ } else if (layer_tree_frame_sink_->context_provider()) {
return DRAW_MODE_HARDWARE;
} else {
return DRAW_MODE_SOFTWARE;
@@ -802,7 +802,7 @@
bool hud_wants_to_draw_ = active_tree_->hud_layer() &&
active_tree_->hud_layer()->IsAnimatingHUDContents();
bool must_always_swap =
- compositor_frame_sink_->capabilities().must_always_swap;
+ layer_tree_frame_sink_->capabilities().must_always_swap;
// When touch handle visibility changes there is no visible damage
// because touch handles are composited in the browser. However we
// still want the browser to be notified that the handles changed
@@ -1035,7 +1035,7 @@
// would be animating checkerboards, because failing under those conditions
// triggers a new main frame, which may cause the copy request layer to be
// destroyed.
- // TODO(weiliangc): Test copy request w/ CompositorFrameSink recreation. Would
+ // TODO(weiliangc): Test copy request w/ LayerTreeFrameSink recreation. Would
// trigger this DCHECK.
DCHECK(!have_copy_request || draw_result == DRAW_SUCCESS);
@@ -1510,7 +1510,7 @@
if (pending_tree_)
pending_tree_->set_needs_update_draw_properties();
- // Compositor, not CompositorFrameSink, is responsible for setting damage
+ // Compositor, not LayerTreeFrameSink, is responsible for setting damage
// and triggering redraw for constraint changes.
SetFullViewportDamage();
SetNeedsRedraw();
@@ -1582,7 +1582,7 @@
client_->OnCanDrawStateChanged(CanDraw());
}
- client_->OnDrawForCompositorFrameSink(resourceless_software_draw_);
+ client_->OnDrawForLayerTreeFrameSink(resourceless_software_draw_);
}
if (resourceless_software_draw) {
@@ -1671,7 +1671,7 @@
}
fps_counter_->SaveTimeStamp(CurrentBeginFrameArgs().frame_time,
- !compositor_frame_sink_->context_provider());
+ !layer_tree_frame_sink_->context_provider());
rendering_stats_instrumentation_->IncrementFrameCount(1);
memory_history_->SaveEntry(tile_manager_.memory_stats_from_last_assign());
@@ -1709,7 +1709,7 @@
TRACE_EVENT0("cc", "DrawLayers.UpdateHudTexture");
active_tree_->hud_layer()->UpdateHudTexture(
draw_mode, resource_provider_.get(),
- compositor_frame_sink_->context_provider());
+ layer_tree_frame_sink_->context_provider());
}
CompositorFrameMetadata metadata = MakeCompositorFrameMetadata();
@@ -1752,10 +1752,10 @@
// the LocalSurfaceId should hang off CompositorFrameMetadata.
if (settings_.enable_surface_synchronization &&
active_tree()->local_surface_id().is_valid()) {
- compositor_frame_sink_->SetLocalSurfaceId(
+ layer_tree_frame_sink_->SetLocalSurfaceId(
active_tree()->local_surface_id());
}
- compositor_frame_sink_->SubmitCompositorFrame(std::move(compositor_frame));
+ layer_tree_frame_sink_->SubmitCompositorFrame(std::move(compositor_frame));
// Clears the list of swap promises after calling DidSwap on each of them to
// signal that the swap is over.
@@ -1814,12 +1814,12 @@
}
bool LayerTreeHostImpl::CanUseGpuRasterization() {
- if (!(compositor_frame_sink_ && compositor_frame_sink_->context_provider() &&
- compositor_frame_sink_->worker_context_provider()))
+ if (!(layer_tree_frame_sink_ && layer_tree_frame_sink_->context_provider() &&
+ layer_tree_frame_sink_->worker_context_provider()))
return false;
ContextProvider* context_provider =
- compositor_frame_sink_->worker_context_provider();
+ layer_tree_frame_sink_->worker_context_provider();
ContextProvider::ScopedContextLock scoped_context(context_provider);
if (!context_provider->GrContext())
return false;
@@ -1829,16 +1829,16 @@
bool LayerTreeHostImpl::UpdateGpuRasterizationStatus() {
// TODO(danakj): Can we avoid having this run when there's no
- // CompositorFrameSink?
+ // LayerTreeFrameSink?
// For now just early out and leave things unchanged, we'll come back here
- // when we get an CompositorFrameSink.
- if (!compositor_frame_sink_)
+ // when we get a LayerTreeFrameSink.
+ if (!layer_tree_frame_sink_)
return false;
int requested_msaa_samples = RequestedMSAASampleCount();
int max_msaa_samples = 0;
ContextProvider* compositor_context_provider =
- compositor_frame_sink_->context_provider();
+ layer_tree_frame_sink_->context_provider();
bool gpu_rasterization_enabled = false;
if (compositor_context_provider) {
const auto& caps = compositor_context_provider->ContextCapabilities();
@@ -1945,8 +1945,8 @@
}
void LayerTreeHostImpl::DidNotProduceFrame(const BeginFrameAck& ack) {
- if (compositor_frame_sink_)
- compositor_frame_sink_->DidNotProduceFrame(ack);
+ if (layer_tree_frame_sink_)
+ layer_tree_frame_sink_->DidNotProduceFrame(ack);
}
void LayerTreeHostImpl::UpdateViewportContainerSizes() {
@@ -1999,11 +1999,11 @@
single_thread_synchronous_task_graph_runner_->RunUntilIdle();
}
-void LayerTreeHostImpl::DidLoseCompositorFrameSink() {
+void LayerTreeHostImpl::DidLoseLayerTreeFrameSink() {
if (resource_provider_)
resource_provider_->DidLoseContextProvider();
- has_valid_compositor_frame_sink_ = false;
- client_->DidLoseCompositorFrameSinkOnImplThread();
+ has_valid_layer_tree_frame_sink_ = false;
+ client_->DidLoseLayerTreeFrameSinkOnImplThread();
}
bool LayerTreeHostImpl::HaveRootScrollLayer() const {
@@ -2268,7 +2268,7 @@
if (use_gpu_rasterization_) {
image_decode_cache_ = base::MakeUnique<GpuImageDecodeCache>(
- compositor_frame_sink_->worker_context_provider(),
+ layer_tree_frame_sink_->worker_context_provider(),
settings_.preferred_tile_format,
settings_.decoded_image_working_set_budget_bytes,
settings_.decoded_image_cache_budget_bytes);
@@ -2307,7 +2307,7 @@
CHECK(resource_provider_);
ContextProvider* compositor_context_provider =
- compositor_frame_sink_->context_provider();
+ layer_tree_frame_sink_->context_provider();
if (!compositor_context_provider) {
*resource_pool =
ResourcePool::Create(resource_provider_.get(), GetTaskRunner(),
@@ -2321,7 +2321,7 @@
}
ContextProvider* worker_context_provider =
- compositor_frame_sink_->worker_context_provider();
+ layer_tree_frame_sink_->worker_context_provider();
if (use_gpu_rasterization_) {
DCHECK(worker_context_provider);
@@ -2443,26 +2443,26 @@
// We've potentially just freed a large number of resources on our various
// contexts. Flushing now helps ensure these are cleaned up quickly
// preventing driver cache growth. See crbug.com/643251
- if (compositor_frame_sink_) {
- if (auto* compositor_context = compositor_frame_sink_->context_provider())
+ if (layer_tree_frame_sink_) {
+ if (auto* compositor_context = layer_tree_frame_sink_->context_provider())
compositor_context->ContextGL()->ShallowFlushCHROMIUM();
if (auto* worker_context =
- compositor_frame_sink_->worker_context_provider()) {
+ layer_tree_frame_sink_->worker_context_provider()) {
ContextProvider::ScopedContextLock hold(worker_context);
worker_context->ContextGL()->ShallowFlushCHROMIUM();
}
}
}
-void LayerTreeHostImpl::ReleaseCompositorFrameSink() {
- TRACE_EVENT0("cc", "LayerTreeHostImpl::ReleaseCompositorFrameSink");
+void LayerTreeHostImpl::ReleaseLayerTreeFrameSink() {
+ TRACE_EVENT0("cc", "LayerTreeHostImpl::ReleaseLayerTreeFrameSink");
- if (!compositor_frame_sink_) {
- DCHECK(!has_valid_compositor_frame_sink_);
+ if (!layer_tree_frame_sink_) {
+ DCHECK(!has_valid_layer_tree_frame_sink_);
return;
}
- has_valid_compositor_frame_sink_ = false;
+ has_valid_layer_tree_frame_sink_ = false;
// Since we will create a new resource provider, we cannot continue to use
// the old resources (i.e. render_surfaces and texture IDs). Clear them
@@ -2473,27 +2473,27 @@
CleanUpTileManagerAndUIResources();
resource_provider_ = nullptr;
- // Release any context visibility before we destroy the CompositorFrameSink.
+ // Release any context visibility before we destroy the LayerTreeFrameSink.
SetContextVisibility(false);
- // Detach from the old CompositorFrameSink and reset |compositor_frame_sink_|
+ // Detach from the old LayerTreeFrameSink and reset |layer_tree_frame_sink_|
// pointer as this surface is going to be destroyed independent of if binding
- // the new CompositorFrameSink succeeds or not.
- compositor_frame_sink_->DetachFromClient();
- compositor_frame_sink_ = nullptr;
+ // the new LayerTreeFrameSink succeeds or not.
+ layer_tree_frame_sink_->DetachFromClient();
+ layer_tree_frame_sink_ = nullptr;
- // We don't know if the next CompositorFrameSink will support GPU
+ // We don't know if the next LayerTreeFrameSink will support GPU
// rasterization. Make sure to clear the flag so that we force a
// re-computation.
use_gpu_rasterization_ = false;
}
bool LayerTreeHostImpl::InitializeRenderer(
- CompositorFrameSink* compositor_frame_sink) {
+ LayerTreeFrameSink* layer_tree_frame_sink) {
TRACE_EVENT0("cc", "LayerTreeHostImpl::InitializeRenderer");
- ReleaseCompositorFrameSink();
- if (!compositor_frame_sink->BindToClient(this)) {
+ ReleaseLayerTreeFrameSink();
+ if (!layer_tree_frame_sink->BindToClient(this)) {
// Avoid recreating tree resources because we might not have enough
// information to do this yet (eg. we don't have a TileManager at this
// point).
@@ -2503,17 +2503,17 @@
// When using software compositing, change to the limits specified for it.
// Since this is a one way trip, we don't need to worry about going back to
// GPU compositing.
- if (!compositor_frame_sink->context_provider())
+ if (!layer_tree_frame_sink->context_provider())
SetMemoryPolicy(settings_.software_memory_policy);
- compositor_frame_sink_ = compositor_frame_sink;
- has_valid_compositor_frame_sink_ = true;
+ layer_tree_frame_sink_ = layer_tree_frame_sink;
+ has_valid_layer_tree_frame_sink_ = true;
resource_provider_ = base::MakeUnique<ResourceProvider>(
- compositor_frame_sink_->context_provider(),
- compositor_frame_sink_->shared_bitmap_manager(),
- compositor_frame_sink_->gpu_memory_buffer_manager(),
+ layer_tree_frame_sink_->context_provider(),
+ layer_tree_frame_sink_->shared_bitmap_manager(),
+ layer_tree_frame_sink_->gpu_memory_buffer_manager(),
task_runner_provider_->blocking_main_thread_task_runner(),
- compositor_frame_sink_->capabilities().delegated_sync_points_required,
+ layer_tree_frame_sink_->capabilities().delegated_sync_points_required,
settings_.enable_color_correct_rasterization,
settings_.resource_settings);
@@ -2522,7 +2522,7 @@
// already.
UpdateGpuRasterizationStatus();
- // See note in LayerTreeImpl::UpdateDrawProperties, new CompositorFrameSink
+ // See note in LayerTreeImpl::UpdateDrawProperties, new LayerTreeFrameSink
// means a new max texture size which affects draw properties. Also, if the
// draw properties were up to date, layers still lost resources and we need to
// UpdateDrawProperties() after calling RecreateTreeResources().
@@ -3937,7 +3937,7 @@
if (id)
DeleteUIResource(uid);
- if (!has_valid_compositor_frame_sink_) {
+ if (!has_valid_layer_tree_frame_sink_) {
evicted_ui_resources_.insert(uid);
return;
}
@@ -4023,7 +4023,7 @@
void LayerTreeHostImpl::DeleteUIResource(UIResourceId uid) {
ResourceId id = ResourceIdForUIResource(uid);
if (id) {
- if (has_valid_compositor_frame_sink_)
+ if (has_valid_layer_tree_frame_sink_)
resource_provider_->DeleteResource(id);
ui_resource_map_.erase(uid);
}
@@ -4272,13 +4272,13 @@
}
void LayerTreeHostImpl::SetContextVisibility(bool is_visible) {
- if (!compositor_frame_sink_)
+ if (!layer_tree_frame_sink_)
return;
// Update the compositor context. If we are already in the correct visibility
// state, skip. This can happen if we transition invisible/visible rapidly,
// before we get a chance to go invisible in NotifyAllTileTasksComplete.
- auto* compositor_context = compositor_frame_sink_->context_provider();
+ auto* compositor_context = layer_tree_frame_sink_->context_provider();
if (compositor_context && is_visible != !!compositor_context_visibility_) {
if (is_visible) {
compositor_context_visibility_ =
@@ -4292,7 +4292,7 @@
// Update the worker context. If we are already in the correct visibility
// state, skip. This can happen if we transition invisible/visible rapidly,
// before we get a chance to go invisible in NotifyAllTileTasksComplete.
- auto* worker_context = compositor_frame_sink_->worker_context_provider();
+ auto* worker_context = layer_tree_frame_sink_->worker_context_provider();
if (worker_context && is_visible != !!worker_context_visibility_) {
ContextProvider::ScopedContextLock hold(worker_context);
if (is_visible) {
diff --git a/cc/trees/layer_tree_host_impl.h b/cc/trees/layer_tree_host_impl.h
index 07405dc54..611f24b 100644
--- a/cc/trees/layer_tree_host_impl.h
+++ b/cc/trees/layer_tree_host_impl.h
@@ -26,8 +26,8 @@
#include "cc/input/scrollbar_animation_controller.h"
#include "cc/layers/layer_collections.h"
#include "cc/output/begin_frame_args.h"
-#include "cc/output/compositor_frame_sink_client.h"
#include "cc/output/context_cache_controller.h"
+#include "cc/output/layer_tree_frame_sink_client.h"
#include "cc/output/managed_memory_policy.h"
#include "cc/quads/render_pass.h"
#include "cc/resources/resource_provider.h"
@@ -55,7 +55,7 @@
class BrowserControlsOffsetManager;
class CompositorFrameMetadata;
-class CompositorFrameSink;
+class LayerTreeFrameSink;
class DebugRectHistory;
class EvictionTilePriorityQueue;
class FrameRateCounter;
@@ -97,7 +97,7 @@
// LayerTreeHost->Proxy callback interface.
class LayerTreeHostImplClient {
public:
- virtual void DidLoseCompositorFrameSinkOnImplThread() = 0;
+ virtual void DidLoseLayerTreeFrameSinkOnImplThread() = 0;
virtual void SetBeginFrameSource(BeginFrameSource* source) = 0;
virtual void DidReceiveCompositorFrameAckOnImplThread() = 0;
virtual void OnCanDrawStateChanged(bool can_draw) = 0;
@@ -124,8 +124,7 @@
virtual void DidCompletePageScaleAnimationOnImplThread() = 0;
// Called when output surface asks for a draw.
- virtual void OnDrawForCompositorFrameSink(
- bool resourceless_software_draw) = 0;
+ virtual void OnDrawForLayerTreeFrameSink(bool resourceless_software_draw) = 0;
virtual void NeedsImplSideInvalidation() = 0;
// Called when a requested image decode completes.
@@ -142,7 +141,7 @@
class CC_EXPORT LayerTreeHostImpl
: public InputHandler,
public TileManagerClient,
- public CompositorFrameSinkClient,
+ public LayerTreeFrameSinkClient,
public BrowserControlsOffsetManagerClient,
public ScrollbarAnimationControllerClient,
public VideoFrameControllerClient,
@@ -366,12 +365,12 @@
void AddVideoFrameController(VideoFrameController* controller) override;
void RemoveVideoFrameController(VideoFrameController* controller) override;
- // CompositorFrameSinkClient implementation.
+ // LayerTreeFrameSinkClient implementation.
void SetBeginFrameSource(BeginFrameSource* source) override;
void SetExternalTilePriorityConstraints(
const gfx::Rect& viewport_rect,
const gfx::Transform& transform) override;
- void DidLoseCompositorFrameSink() override;
+ void DidLoseLayerTreeFrameSink() override;
void DidReceiveCompositorFrameAck() override;
void ReclaimResources(const ReturnedResourceArray& resources) override;
void SetMemoryPolicy(const ManagedMemoryPolicy& policy) override;
@@ -389,17 +388,17 @@
// Implementation.
int id() const { return id_; }
bool CanDraw() const;
- CompositorFrameSink* compositor_frame_sink() const {
- return compositor_frame_sink_;
+ LayerTreeFrameSink* layer_tree_frame_sink() const {
+ return layer_tree_frame_sink_;
}
- void ReleaseCompositorFrameSink();
+ void ReleaseLayerTreeFrameSink();
std::string LayerTreeAsJson() const;
int RequestedMSAASampleCount() const;
// TODO(danakj): Rename this, there is no renderer.
- virtual bool InitializeRenderer(CompositorFrameSink* compositor_frame_sink);
+ virtual bool InitializeRenderer(LayerTreeFrameSink* layer_tree_frame_sink);
TileManager* tile_manager() { return &tile_manager_; }
void SetHasGpuRasterizationTrigger(bool flag);
@@ -727,12 +726,12 @@
// request queue.
std::set<UIResourceId> evicted_ui_resources_;
- CompositorFrameSink* compositor_frame_sink_;
+ LayerTreeFrameSink* layer_tree_frame_sink_;
LocalSurfaceId local_surface_id_;
// The following scoped variables must not outlive the
- // |compositor_frame_sink_|.
+ // |layer_tree_frame_sink_|.
// These should be transfered to ContextCacheController's
// ClientBecameNotVisible() before the output surface is destroyed.
std::unique_ptr<ContextCacheController::ScopedVisibility>
@@ -813,7 +812,7 @@
// overridden.
gfx::Size device_viewport_size_;
- // Optional top-level constraints that can be set by the CompositorFrameSink.
+ // Optional top-level constraints that can be set by the LayerTreeFrameSink.
// - external_transform_ applies a transform above the root layer
// - external_viewport_ is used DrawProperties, tile management and
// glViewport/window projection matrix.
@@ -852,9 +851,9 @@
bool requires_high_res_to_draw_;
bool is_likely_to_require_a_draw_;
- // TODO(danakj): Delete the compositor frame sink and all resources when
+ // TODO(danakj): Delete the LayerTreeFrameSink and all resources when
// it's lost instead of having this bool.
- bool has_valid_compositor_frame_sink_;
+ bool has_valid_layer_tree_frame_sink_;
std::unique_ptr<Viewport> viewport_;
diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index 28c61eb6..5137129 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -49,7 +49,7 @@
#include "cc/resources/ui_resource_manager.h"
#include "cc/test/animation_test_common.h"
#include "cc/test/begin_frame_args_test.h"
-#include "cc/test/fake_compositor_frame_sink.h"
+#include "cc/test/fake_layer_tree_frame_sink.h"
#include "cc/test/fake_layer_tree_host_impl.h"
#include "cc/test/fake_mask_layer_impl.h"
#include "cc/test/fake_output_surface.h"
@@ -61,7 +61,7 @@
#include "cc/test/layer_test_common.h"
#include "cc/test/layer_tree_test.h"
#include "cc/test/skia_common.h"
-#include "cc/test/test_compositor_frame_sink.h"
+#include "cc/test/test_layer_tree_frame_sink.h"
#include "cc/test/test_task_graph_runner.h"
#include "cc/test/test_web_graphics_context_3d.h"
#include "cc/trees/effect_node.h"
@@ -137,15 +137,15 @@
}
void SetUp() override {
- CreateHostImpl(DefaultSettings(), CreateCompositorFrameSink());
+ CreateHostImpl(DefaultSettings(), CreateLayerTreeFrameSink());
}
void TearDown() override {
if (host_impl_)
- host_impl_->ReleaseCompositorFrameSink();
+ host_impl_->ReleaseLayerTreeFrameSink();
}
- void DidLoseCompositorFrameSinkOnImplThread() override {}
+ void DidLoseLayerTreeFrameSinkOnImplThread() override {}
void SetBeginFrameSource(BeginFrameSource* source) override {}
void DidReceiveCompositorFrameAckOnImplThread() override {}
void OnCanDrawStateChanged(bool can_draw) override {
@@ -180,7 +180,7 @@
void DidCompletePageScaleAnimationOnImplThread() override {
did_complete_page_scale_animation_ = true;
}
- void OnDrawForCompositorFrameSink(bool resourceless_software_draw) override {
+ void OnDrawForLayerTreeFrameSink(bool resourceless_software_draw) override {
std::unique_ptr<TestFrameData> frame(new TestFrameData);
EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(frame.get()));
last_on_draw_render_passes_.clear();
@@ -201,9 +201,9 @@
virtual bool CreateHostImpl(
const LayerTreeSettings& settings,
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink) {
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink) {
return CreateHostImplWithTaskRunnerProvider(
- settings, std::move(compositor_frame_sink), &task_runner_provider_);
+ settings, std::move(layer_tree_frame_sink), &task_runner_provider_);
}
AnimationHost* GetImplAnimationHost() const {
@@ -212,10 +212,10 @@
virtual bool CreateHostImplWithTaskRunnerProvider(
const LayerTreeSettings& settings,
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink,
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink,
TaskRunnerProvider* task_runner_provider) {
if (host_impl_)
- host_impl_->ReleaseCompositorFrameSink();
+ host_impl_->ReleaseLayerTreeFrameSink();
host_impl_.reset();
InitializeImageWorker(settings);
host_impl_ = LayerTreeHostImpl::Create(
@@ -223,9 +223,9 @@
&task_graph_runner_,
AnimationHost::CreateForTesting(ThreadInstance::IMPL), 0,
image_worker_ ? image_worker_->task_runner() : nullptr);
- compositor_frame_sink_ = std::move(compositor_frame_sink);
+ layer_tree_frame_sink_ = std::move(layer_tree_frame_sink);
host_impl_->SetVisible(true);
- bool init = host_impl_->InitializeRenderer(compositor_frame_sink_.get());
+ bool init = host_impl_->InitializeRenderer(layer_tree_frame_sink_.get());
host_impl_->SetViewportSize(gfx::Size(10, 10));
host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, 1.f, 1.f);
// Set the BeginFrameArgs so that methods which use it are able to.
@@ -581,8 +581,8 @@
scoped_refptr<AnimationTimeline> timeline() { return timeline_; }
protected:
- virtual std::unique_ptr<CompositorFrameSink> CreateCompositorFrameSink() {
- return FakeCompositorFrameSink::Create3dForGpuRasterization();
+ virtual std::unique_ptr<LayerTreeFrameSink> CreateLayerTreeFrameSink() {
+ return FakeLayerTreeFrameSink::Create3dForGpuRasterization();
}
void DrawOneFrame() {
@@ -623,7 +623,7 @@
DebugScopedSetMainThreadBlocked always_main_thread_blocked_;
TestTaskGraphRunner task_graph_runner_;
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink_;
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink_;
std::unique_ptr<LayerTreeHostImpl> host_impl_;
FakeRenderingStatsInstrumentation stats_instrumentation_;
bool on_can_draw_state_changed_called_;
@@ -647,7 +647,7 @@
class LayerTreeHostImplTimelinesTest : public LayerTreeHostImplTest {
public:
void SetUp() override {
- CreateHostImpl(DefaultSettings(), CreateCompositorFrameSink());
+ CreateHostImpl(DefaultSettings(), CreateLayerTreeFrameSink());
}
};
@@ -741,7 +741,7 @@
}
TEST_F(LayerTreeHostImplTest, ResourcelessDrawWithEmptyViewport) {
- CreateHostImpl(DefaultSettings(), FakeCompositorFrameSink::CreateSoftware());
+ CreateHostImpl(DefaultSettings(), FakeLayerTreeFrameSink::CreateSoftware());
SetupScrollAndContentsLayers(gfx::Size(100, 100));
host_impl_->active_tree()->BuildPropertyTreesForTesting();
@@ -749,18 +749,17 @@
host_impl_->SetViewportSize(gfx::Size());
EXPECT_FALSE(host_impl_->CanDraw());
- FakeCompositorFrameSink* fake_compositor_frame_sink =
- static_cast<FakeCompositorFrameSink*>(
- host_impl_->compositor_frame_sink());
- EXPECT_EQ(fake_compositor_frame_sink->num_sent_frames(), 0u);
+ auto* fake_layer_tree_frame_sink =
+ static_cast<FakeLayerTreeFrameSink*>(host_impl_->layer_tree_frame_sink());
+ EXPECT_EQ(fake_layer_tree_frame_sink->num_sent_frames(), 0u);
gfx::Transform identity;
gfx::Rect viewport(100, 100);
const bool resourceless_software_draw = true;
host_impl_->OnDraw(identity, viewport, resourceless_software_draw);
- ASSERT_EQ(fake_compositor_frame_sink->num_sent_frames(), 1u);
+ ASSERT_EQ(fake_layer_tree_frame_sink->num_sent_frames(), 1u);
EXPECT_EQ(
gfx::SizeF(100.f, 100.f),
- fake_compositor_frame_sink->last_sent_frame()->metadata.root_layer_size);
+ fake_layer_tree_frame_sink->last_sent_frame()->metadata.root_layer_size);
}
TEST_F(LayerTreeHostImplTest, ScrollDeltaNoLayers) {
@@ -970,7 +969,7 @@
// Initialization will fail.
EXPECT_FALSE(CreateHostImpl(
DefaultSettings(),
- FakeCompositorFrameSink::Create3d(std::move(context_owned))));
+ FakeLayerTreeFrameSink::Create3d(std::move(context_owned))));
SetupScrollAndContentsLayers(gfx::Size(100, 100));
@@ -1634,7 +1633,7 @@
TEST_F(LayerTreeHostImplTest, AnimationSchedulingCommitToActiveTree) {
FakeImplTaskRunnerProvider provider(nullptr);
CreateHostImplWithTaskRunnerProvider(DefaultSettings(),
- CreateCompositorFrameSink(), &provider);
+ CreateLayerTreeFrameSink(), &provider);
EXPECT_TRUE(host_impl_->CommitToActiveTree());
host_impl_->SetViewportSize(gfx::Size(50, 50));
@@ -1676,7 +1675,7 @@
EXPECT_FALSE(did_request_commit_);
// Delete the LayerTreeHostImpl before the TaskRunnerProvider goes away.
- host_impl_->ReleaseCompositorFrameSink();
+ host_impl_->ReleaseLayerTreeFrameSink();
host_impl_ = nullptr;
}
@@ -1833,7 +1832,7 @@
TEST_F(LayerTreeHostImplTest, ViewportScrollOrder) {
LayerTreeSettings settings = DefaultSettings();
- CreateHostImpl(settings, CreateCompositorFrameSink());
+ CreateHostImpl(settings, CreateLayerTreeFrameSink());
host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, 0.25f, 4.f);
const gfx::Size content_size(1000, 1000);
@@ -1892,7 +1891,7 @@
// dropped. crbug.com/539334.
TEST_F(LayerTreeHostImplTest, ScrollViewportWithFractionalAmounts) {
LayerTreeSettings settings = DefaultSettings();
- CreateHostImpl(settings, CreateCompositorFrameSink());
+ CreateHostImpl(settings, CreateLayerTreeFrameSink());
host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, 1.f, 2.f);
const gfx::Size content_size(1000, 1000);
@@ -1941,7 +1940,7 @@
// to the outer viewport.
TEST_F(LayerTreeHostImplTest, ScrollDuringPinchGesture) {
LayerTreeSettings settings = DefaultSettings();
- CreateHostImpl(settings, CreateCompositorFrameSink());
+ CreateHostImpl(settings, CreateLayerTreeFrameSink());
host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, 1.f, 2.f);
const gfx::Size content_size(1000, 1000);
@@ -1995,7 +1994,7 @@
// should assume the user means to scroll into the edge of the screen.
TEST_F(LayerTreeHostImplTest, PinchZoomSnapsToScreenEdge) {
LayerTreeSettings settings = DefaultSettings();
- CreateHostImpl(settings, CreateCompositorFrameSink());
+ CreateHostImpl(settings, CreateLayerTreeFrameSink());
host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, 1.f, 2.f);
const gfx::Size content_size(1000, 1000);
@@ -2843,7 +2842,7 @@
class LayerTreeHostImplTestScrollbarAnimation : public LayerTreeHostImplTest {
protected:
void SetupLayers(LayerTreeSettings settings) {
- host_impl_->ReleaseCompositorFrameSink();
+ host_impl_->ReleaseLayerTreeFrameSink();
host_impl_ = nullptr;
gfx::Size content_size(100, 100);
@@ -2853,9 +2852,9 @@
settings, this, &task_runner_provider_, &task_graph_runner_,
&stats_instrumentation_);
host_impl_ = base::WrapUnique(host_impl_override_time);
- compositor_frame_sink_ = CreateCompositorFrameSink();
+ layer_tree_frame_sink_ = CreateLayerTreeFrameSink();
host_impl_->SetVisible(true);
- host_impl_->InitializeRenderer(compositor_frame_sink_.get());
+ host_impl_->InitializeRenderer(layer_tree_frame_sink_.get());
SetupScrollAndContentsLayers(content_size);
host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, 1.f, 4.f);
@@ -3065,7 +3064,7 @@
// If no animator is set, scrollbar won't show and no animation is expected.
bool expecting_animations = animator != LayerTreeSettings::NO_ANIMATOR;
- CreateHostImpl(settings, CreateCompositorFrameSink());
+ CreateHostImpl(settings, CreateLayerTreeFrameSink());
host_impl_->CreatePendingTree();
CreateScrollAndContentsLayers(host_impl_->pending_tree(), content_size);
std::unique_ptr<SolidColorScrollbarLayerImpl> scrollbar =
@@ -3158,7 +3157,7 @@
settings.scrollbar_fade_duration = base::TimeDelta::FromMilliseconds(20);
gfx::Size content_size(100, 100);
- CreateHostImpl(settings, CreateCompositorFrameSink());
+ CreateHostImpl(settings, CreateLayerTreeFrameSink());
host_impl_->CreatePendingTree();
CreateScrollAndContentsLayers(host_impl_->pending_tree(), content_size);
std::unique_ptr<SolidColorScrollbarLayerImpl> scrollbar =
@@ -3225,7 +3224,7 @@
TEST_F(LayerTreeHostImplTest, ScrollbarInnerLargerThanOuter) {
LayerTreeSettings settings = DefaultSettings();
- CreateHostImpl(settings, CreateCompositorFrameSink());
+ CreateHostImpl(settings, CreateLayerTreeFrameSink());
gfx::Size inner_viewport_size(315, 200);
gfx::Size outer_viewport_size(300, 200);
@@ -3265,7 +3264,7 @@
settings.scrollbar_animator = LayerTreeSettings::ANDROID_OVERLAY;
settings.scrollbar_fade_delay = base::TimeDelta::FromMilliseconds(20);
settings.scrollbar_fade_duration = base::TimeDelta::FromMilliseconds(20);
- CreateHostImpl(settings, CreateCompositorFrameSink());
+ CreateHostImpl(settings, CreateLayerTreeFrameSink());
gfx::Size viewport_size(300, 200);
gfx::Size content_size(1000, 1000);
@@ -3286,27 +3285,23 @@
container->test_properties()->AddChild(SolidColorScrollbarLayerImpl::Create(
host_impl_->active_tree(), vert_1_id, VERTICAL, 5, 5, true, true));
- SolidColorScrollbarLayerImpl* vert_1_scrollbar =
- static_cast<SolidColorScrollbarLayerImpl*>(
- container->test_properties()->children[1]);
+ auto* vert_1_scrollbar = static_cast<SolidColorScrollbarLayerImpl*>(
+ container->test_properties()->children[1]);
container->test_properties()->AddChild(SolidColorScrollbarLayerImpl::Create(
host_impl_->active_tree(), horiz_1_id, HORIZONTAL, 5, 5, true, true));
- SolidColorScrollbarLayerImpl* horiz_1_scrollbar =
- static_cast<SolidColorScrollbarLayerImpl*>(
- container->test_properties()->children[2]);
+ auto* horiz_1_scrollbar = static_cast<SolidColorScrollbarLayerImpl*>(
+ container->test_properties()->children[2]);
container->test_properties()->AddChild(SolidColorScrollbarLayerImpl::Create(
host_impl_->active_tree(), vert_2_id, VERTICAL, 5, 5, true, true));
- SolidColorScrollbarLayerImpl* vert_2_scrollbar =
- static_cast<SolidColorScrollbarLayerImpl*>(
- container->test_properties()->children[3]);
+ auto* vert_2_scrollbar = static_cast<SolidColorScrollbarLayerImpl*>(
+ container->test_properties()->children[3]);
container->test_properties()->AddChild(SolidColorScrollbarLayerImpl::Create(
host_impl_->active_tree(), horiz_2_id, HORIZONTAL, 5, 5, true, true));
- SolidColorScrollbarLayerImpl* horiz_2_scrollbar =
- static_cast<SolidColorScrollbarLayerImpl*>(
- container->test_properties()->children[4]);
+ auto* horiz_2_scrollbar = static_cast<SolidColorScrollbarLayerImpl*>(
+ container->test_properties()->children[4]);
std::unique_ptr<LayerImpl> child =
LayerImpl::Create(host_impl_->active_tree(), child_scroll_id);
@@ -3401,7 +3396,7 @@
settings.scrollbar_animator = LayerTreeSettings::AURA_OVERLAY;
settings.scrollbar_fade_delay = base::TimeDelta::FromMilliseconds(20);
settings.scrollbar_fade_duration = base::TimeDelta::FromMilliseconds(20);
- CreateHostImpl(settings, CreateCompositorFrameSink());
+ CreateHostImpl(settings, CreateLayerTreeFrameSink());
gfx::Size viewport_size(300, 200);
gfx::Size content_size(1000, 1000);
@@ -3413,9 +3408,8 @@
container->test_properties()->AddChild(SolidColorScrollbarLayerImpl::Create(
host_impl_->active_tree(), 10, VERTICAL, 5, 0, false, true));
- SolidColorScrollbarLayerImpl* vert_scrollbar =
- static_cast<SolidColorScrollbarLayerImpl*>(
- container->test_properties()->children[1]);
+ auto* vert_scrollbar = static_cast<SolidColorScrollbarLayerImpl*>(
+ container->test_properties()->children[1]);
vert_scrollbar->SetScrollElementId(root_scroll->element_id());
vert_scrollbar->SetBounds(gfx::Size(10, 200));
@@ -3476,7 +3470,7 @@
gfx::Size content_size(1000, 1000);
gfx::Size scrollbar_size(gfx::Size(15, viewport_size.height()));
- CreateHostImpl(settings, CreateCompositorFrameSink());
+ CreateHostImpl(settings, CreateLayerTreeFrameSink());
host_impl_->active_tree()->SetDeviceScaleFactor(device_scale_factor);
host_impl_->SetViewportSize(device_viewport_size);
@@ -3596,11 +3590,10 @@
host_impl_->active_tree()->SetSurfaceLayerIds(fallback_surfaces_set);
DrawFrame();
- FakeCompositorFrameSink* fake_compositor_frame_sink =
- static_cast<FakeCompositorFrameSink*>(
- host_impl_->compositor_frame_sink());
+ auto* fake_layer_tree_frame_sink =
+ static_cast<FakeLayerTreeFrameSink*>(host_impl_->layer_tree_frame_sink());
const CompositorFrameMetadata& metadata =
- fake_compositor_frame_sink->last_sent_frame()->metadata;
+ fake_layer_tree_frame_sink->last_sent_frame()->metadata;
EXPECT_THAT(
metadata.activation_dependencies,
testing::UnorderedElementsAre(primary_surfaces[0], primary_surfaces[1]));
@@ -3811,13 +3804,13 @@
// will be masked out by the root layer's bounds.
host_impl_->active_tree()->SetRootLayerForTesting(
DidDrawCheckLayer::Create(host_impl_->active_tree(), 1));
- DidDrawCheckLayer* root =
+ auto* root =
static_cast<DidDrawCheckLayer*>(*host_impl_->active_tree()->begin());
root->test_properties()->AddChild(
DidDrawCheckLayer::Create(host_impl_->active_tree(), 2));
root->test_properties()->force_render_surface = true;
- DidDrawCheckLayer* layer =
+ auto* layer =
static_cast<DidDrawCheckLayer*>(root->test_properties()->children[0]);
host_impl_->active_tree()->BuildPropertyTreesForTesting();
@@ -3855,13 +3848,13 @@
// will be masked out by the root layer's bounds.
host_impl_->active_tree()->SetRootLayerForTesting(
DidDrawCheckLayer::Create(host_impl_->active_tree(), 1));
- DidDrawCheckLayer* root =
+ auto* root =
static_cast<DidDrawCheckLayer*>(*host_impl_->active_tree()->begin());
root->SetMasksToBounds(true);
root->test_properties()->force_render_surface = true;
root->test_properties()->AddChild(
DidDrawCheckLayer::Create(host_impl_->active_tree(), 2));
- DidDrawCheckLayer* layer =
+ auto* layer =
static_cast<DidDrawCheckLayer*>(root->test_properties()->children[0]);
// Ensure visible_layer_rect for layer is empty.
layer->SetPosition(gfx::PointF(100.f, 100.f));
@@ -3906,18 +3899,18 @@
host_impl_->active_tree()->SetRootLayerForTesting(
DidDrawCheckLayer::Create(host_impl_->active_tree(), 1));
- DidDrawCheckLayer* root =
+ auto* root =
static_cast<DidDrawCheckLayer*>(*host_impl_->active_tree()->begin());
root->test_properties()->AddChild(
DidDrawCheckLayer::Create(host_impl_->active_tree(), 2));
- DidDrawCheckLayer* occluded_layer =
+ auto* occluded_layer =
static_cast<DidDrawCheckLayer*>(root->test_properties()->children[0]);
root->test_properties()->AddChild(
DidDrawCheckLayer::Create(host_impl_->active_tree(), 3));
root->test_properties()->force_render_surface = true;
- DidDrawCheckLayer* top_layer =
+ auto* top_layer =
static_cast<DidDrawCheckLayer*>(root->test_properties()->children[1]);
// This layer covers the occluded_layer above. Make this layer large so it can
// occlude.
@@ -3945,18 +3938,18 @@
TEST_F(LayerTreeHostImplTest, DidDrawCalledOnAllLayers) {
host_impl_->active_tree()->SetRootLayerForTesting(
DidDrawCheckLayer::Create(host_impl_->active_tree(), 1));
- DidDrawCheckLayer* root =
+ auto* root =
static_cast<DidDrawCheckLayer*>(*host_impl_->active_tree()->begin());
root->test_properties()->AddChild(
DidDrawCheckLayer::Create(host_impl_->active_tree(), 2));
root->test_properties()->force_render_surface = true;
- DidDrawCheckLayer* layer1 =
+ auto* layer1 =
static_cast<DidDrawCheckLayer*>(root->test_properties()->children[0]);
layer1->test_properties()->AddChild(
DidDrawCheckLayer::Create(host_impl_->active_tree(), 3));
- DidDrawCheckLayer* layer2 =
+ auto* layer2 =
static_cast<DidDrawCheckLayer*>(layer1->test_properties()->children[0]);
layer1->test_properties()->force_render_surface = true;
@@ -4052,7 +4045,7 @@
root->layer_tree_impl(), layer_id++, state.has_missing_tile,
state.has_incomplete_tile, state.is_animating,
root->layer_tree_impl()->resource_provider(), timeline));
- DidDrawCheckLayer* layer =
+ auto* layer =
static_cast<DidDrawCheckLayer*>(root->test_properties()->children.back());
if (state.has_copy_request)
layer->AddCopyRequest();
@@ -4131,7 +4124,7 @@
host_impl_->active_tree()->SetRootLayerForTesting(
DidDrawCheckLayer::Create(host_impl_->active_tree(), 1));
- DidDrawCheckLayer* root =
+ auto* root =
static_cast<DidDrawCheckLayer*>(*host_impl_->active_tree()->begin());
root->test_properties()->force_render_surface = true;
host_impl_->active_tree()->BuildPropertyTreesForTesting();
@@ -4172,7 +4165,7 @@
TEST_F(LayerTreeHostImplTest,
PrepareToDrawWhenDrawAndSwapFullViewportEveryFrame) {
- CreateHostImpl(DefaultSettings(), FakeCompositorFrameSink::CreateSoftware());
+ CreateHostImpl(DefaultSettings(), FakeLayerTreeFrameSink::CreateSoftware());
const gfx::Transform external_transform;
const gfx::Rect external_viewport;
@@ -4199,7 +4192,7 @@
host_impl_->active_tree()->SetRootLayerForTesting(
DidDrawCheckLayer::Create(host_impl_->active_tree(), 1));
- DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(
+ auto* root = static_cast<DidDrawCheckLayer*>(
host_impl_->active_tree()->root_layer_for_testing());
root->test_properties()->force_render_surface = true;
host_impl_->active_tree()->BuildPropertyTreesForTesting();
@@ -4290,9 +4283,9 @@
bool CreateHostImpl(
const LayerTreeSettings& settings,
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink) override {
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink) override {
bool init = LayerTreeHostImplTest::CreateHostImpl(
- settings, std::move(compositor_frame_sink));
+ settings, std::move(layer_tree_frame_sink));
if (init) {
host_impl_->active_tree()->set_top_controls_height(top_controls_height_);
host_impl_->active_tree()->SetCurrentBrowserControlsShownRatio(1.f);
@@ -4306,7 +4299,7 @@
const gfx::Size& outer_viewport_size,
const gfx::Size& scroll_layer_size) {
settings_ = DefaultSettings();
- CreateHostImpl(settings_, CreateCompositorFrameSink());
+ CreateHostImpl(settings_, CreateLayerTreeFrameSink());
SetupBrowserControlsAndScrollLayerWithVirtualViewport(
host_impl_->active_tree(), inner_viewport_size, outer_viewport_size,
scroll_layer_size);
@@ -4491,9 +4484,8 @@
LayerImpl* inner_container = active_tree->InnerViewportContainerLayer();
LayerImpl* outer_container = active_tree->OuterViewportContainerLayer();
- SolidColorScrollbarLayerImpl* scrollbar_layer =
- static_cast<SolidColorScrollbarLayerImpl*>(
- active_tree->LayerById(scrollbar_id));
+ auto* scrollbar_layer = static_cast<SolidColorScrollbarLayerImpl*>(
+ active_tree->LayerById(scrollbar_id));
// The browser controls should start off showing so the viewport should be
// shrunk.
@@ -4828,7 +4820,7 @@
TEST_F(LayerTreeHostImplBrowserControlsTest,
PositionBrowserControlsExplicitly) {
settings_ = DefaultSettings();
- CreateHostImpl(settings_, CreateCompositorFrameSink());
+ CreateHostImpl(settings_, CreateLayerTreeFrameSink());
SetupBrowserControlsAndScrollLayerWithVirtualViewport(
layer_size_, layer_size_, layer_size_);
DrawFrame();
@@ -4863,7 +4855,7 @@
// change after the activation.
TEST_F(LayerTreeHostImplBrowserControlsTest, ApplyDeltaOnTreeActivation) {
settings_ = DefaultSettings();
- CreateHostImpl(settings_, CreateCompositorFrameSink());
+ CreateHostImpl(settings_, CreateLayerTreeFrameSink());
SetupBrowserControlsAndScrollLayerWithVirtualViewport(
layer_size_, layer_size_, layer_size_);
DrawFrame();
@@ -4913,7 +4905,7 @@
TEST_F(LayerTreeHostImplBrowserControlsTest,
BrowserControlsLayoutHeightChanged) {
settings_ = DefaultSettings();
- CreateHostImpl(settings_, CreateCompositorFrameSink());
+ CreateHostImpl(settings_, CreateLayerTreeFrameSink());
SetupBrowserControlsAndScrollLayerWithVirtualViewport(
layer_size_, layer_size_, layer_size_);
DrawFrame();
@@ -5152,7 +5144,7 @@
TEST_F(LayerTreeHostImplBrowserControlsTest,
ScrollNonScrollableRootWithBrowserControls) {
settings_ = DefaultSettings();
- CreateHostImpl(settings_, CreateCompositorFrameSink());
+ CreateHostImpl(settings_, CreateLayerTreeFrameSink());
SetupBrowserControlsAndScrollLayerWithVirtualViewport(
layer_size_, layer_size_, layer_size_);
DrawFrame();
@@ -5846,7 +5838,7 @@
host_impl_->DidFinishImplFrame();
// Tear down the LayerTreeHostImpl before the InputHandlerClient.
- host_impl_->ReleaseCompositorFrameSink();
+ host_impl_->ReleaseLayerTreeFrameSink();
host_impl_ = nullptr;
}
@@ -6528,7 +6520,7 @@
EXPECT_EQ(gfx::SizeF(new_size), scroll_watcher.scrollable_size());
// Tear down the LayerTreeHostImpl before the InputHandlerClient.
- host_impl_->ReleaseCompositorFrameSink();
+ host_impl_->ReleaseLayerTreeFrameSink();
host_impl_ = nullptr;
}
@@ -6844,7 +6836,7 @@
TEST_F(LayerTreeHostImplTest, OverscrollAlways) {
InputHandlerScrollResult scroll_result;
LayerTreeSettings settings = DefaultSettings();
- CreateHostImpl(settings, CreateCompositorFrameSink());
+ CreateHostImpl(settings, CreateLayerTreeFrameSink());
LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(50, 50));
LayerImpl* clip_layer =
@@ -6948,7 +6940,7 @@
TEST_F(LayerTreeHostImplTest, OverscrollOnMainThread) {
InputHandlerScrollResult scroll_result;
LayerTreeSettings settings = DefaultSettings();
- CreateHostImpl(settings, CreateCompositorFrameSink());
+ CreateHostImpl(settings, CreateLayerTreeFrameSink());
const gfx::Size content_size(50, 50);
const gfx::Size viewport_size(50, 50);
@@ -7398,7 +7390,7 @@
TEST_F(LayerTreeHostImplTest, OverscrollOnImplThread) {
InputHandlerScrollResult scroll_result;
LayerTreeSettings settings = DefaultSettings();
- CreateHostImpl(settings, CreateCompositorFrameSink());
+ CreateHostImpl(settings, CreateLayerTreeFrameSink());
const gfx::Size content_size(50, 50);
const gfx::Size viewport_size(50, 50);
@@ -7529,7 +7521,7 @@
root->test_properties()->AddChild(BlendStateCheckLayer::Create(
host_impl_->active_tree(), 2, host_impl_->resource_provider()));
- BlendStateCheckLayer* layer1 =
+ auto* layer1 =
static_cast<BlendStateCheckLayer*>(root->test_properties()->children[0]);
layer1->SetPosition(gfx::PointF(2.f, 2.f));
@@ -7582,7 +7574,7 @@
layer1->test_properties()->AddChild(BlendStateCheckLayer::Create(
host_impl_->active_tree(), 3, host_impl_->resource_provider()));
- BlendStateCheckLayer* layer2 = static_cast<BlendStateCheckLayer*>(
+ auto* layer2 = static_cast<BlendStateCheckLayer*>(
layer1->test_properties()->children[0]);
layer2->SetPosition(gfx::PointF(4.f, 4.f));
@@ -7787,12 +7779,12 @@
int layer_id = 1;
host_impl_->active_tree()->SetRootLayerForTesting(
DidDrawCheckLayer::Create(host_impl_->active_tree(), layer_id++));
- DidDrawCheckLayer* root =
+ auto* root =
static_cast<DidDrawCheckLayer*>(*host_impl_->active_tree()->begin());
root->test_properties()->AddChild(
DidDrawCheckLayer::Create(host_impl_->active_tree(), layer_id++));
- DidDrawCheckLayer* video_layer =
+ auto* video_layer =
static_cast<DidDrawCheckLayer*>(root->test_properties()->children.back());
video_layer->set_may_contain_video(true);
EXPECT_TRUE(MayContainVideoBitSetOnFrameData(host_impl_.get()));
@@ -7800,7 +7792,7 @@
// Test with the video layer occluded.
root->test_properties()->AddChild(
DidDrawCheckLayer::Create(host_impl_->active_tree(), layer_id++));
- DidDrawCheckLayer* large_layer =
+ auto* large_layer =
static_cast<DidDrawCheckLayer*>(root->test_properties()->children.back());
large_layer->SetBounds(big_size);
large_layer->SetContentsOpaque(true);
@@ -7826,11 +7818,11 @@
child_(NULL),
did_activate_pending_tree_(false) {}
- std::unique_ptr<CompositorFrameSink> CreateFakeCompositorFrameSink(
+ std::unique_ptr<LayerTreeFrameSink> CreateFakeLayerTreeFrameSink(
bool software) {
if (software)
- return FakeCompositorFrameSink::CreateSoftware();
- return FakeCompositorFrameSink::Create3d();
+ return FakeLayerTreeFrameSink::CreateSoftware();
+ return FakeLayerTreeFrameSink::Create3d();
}
void SetupActiveTreeLayers() {
@@ -8047,7 +8039,7 @@
viewport_size_ = gfx::Size(1000, 1000);
bool software = false;
- CreateHostImpl(DefaultSettings(), CreateFakeCompositorFrameSink(software));
+ CreateHostImpl(DefaultSettings(), CreateFakeLayerTreeFrameSink(software));
host_impl_->SetViewportSize(DipSizeToPixelSize(viewport_size_));
SetupActiveTreeLayers();
@@ -8061,7 +8053,7 @@
viewport_size_ = gfx::Size(1000, 1000);
bool software = false;
- CreateHostImpl(DefaultSettings(), CreateFakeCompositorFrameSink(software));
+ CreateHostImpl(DefaultSettings(), CreateFakeLayerTreeFrameSink(software));
host_impl_->active_tree()->SetDeviceScaleFactor(2.f);
host_impl_->SetViewportSize(DipSizeToPixelSize(viewport_size_));
@@ -8076,7 +8068,7 @@
viewport_size_ = gfx::Size(1000, 1000);
bool software = true;
- CreateHostImpl(DefaultSettings(), CreateFakeCompositorFrameSink(software));
+ CreateHostImpl(DefaultSettings(), CreateFakeLayerTreeFrameSink(software));
// Pending tree to force active_tree size invalid. Not used otherwise.
host_impl_->CreatePendingTree();
@@ -8093,7 +8085,7 @@
viewport_size_ = gfx::Size(1000, 1000);
bool software = true;
- CreateHostImpl(DefaultSettings(), CreateFakeCompositorFrameSink(software));
+ CreateHostImpl(DefaultSettings(), CreateFakeLayerTreeFrameSink(software));
// Set larger viewport and activate it to active tree.
host_impl_->CreatePendingTree();
@@ -8128,7 +8120,7 @@
};
// Make sure damage tracking propagates all the way to the CompositorFrame
-// submitted to the CompositorFrameSink, where it should request to swap only
+// submitted to the LayerTreeFrameSink, where it should request to swap only
// the sub-buffer that is damaged.
TEST_F(LayerTreeHostImplTest, PartialSwapReceivesDamageRect) {
scoped_refptr<TestContextProvider> context_provider(
@@ -8136,10 +8128,10 @@
context_provider->BindToCurrentThread();
context_provider->TestContext3d()->set_have_post_sub_buffer(true);
- std::unique_ptr<FakeCompositorFrameSink> compositor_frame_sink(
- FakeCompositorFrameSink::Create3d(context_provider));
- FakeCompositorFrameSink* fake_compositor_frame_sink =
- compositor_frame_sink.get();
+ std::unique_ptr<FakeLayerTreeFrameSink> layer_tree_frame_sink(
+ FakeLayerTreeFrameSink::Create3d(context_provider));
+ FakeLayerTreeFrameSink* fake_layer_tree_frame_sink =
+ layer_tree_frame_sink.get();
// This test creates its own LayerTreeHostImpl, so
// that we can force partial swap enabled.
@@ -8150,7 +8142,7 @@
&task_graph_runner_,
AnimationHost::CreateForTesting(ThreadInstance::IMPL), 0, nullptr);
layer_tree_host_impl->SetVisible(true);
- layer_tree_host_impl->InitializeRenderer(compositor_frame_sink.get());
+ layer_tree_host_impl->InitializeRenderer(layer_tree_frame_sink.get());
layer_tree_host_impl->WillBeginImplFrame(
CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 2));
layer_tree_host_impl->SetViewportSize(gfx::Size(500, 500));
@@ -8177,7 +8169,7 @@
layer_tree_host_impl->DidDrawAllLayers(frame);
gfx::Rect expected_swap_rect(500, 500);
EXPECT_EQ(expected_swap_rect.ToString(),
- fake_compositor_frame_sink->last_swap_rect().ToString());
+ fake_layer_tree_frame_sink->last_swap_rect().ToString());
// Second frame, only the damaged area should get swapped. Damage should be
// the union of old and new child rects: gfx::Rect(26, 28).
@@ -8198,7 +8190,7 @@
expected_swap_rect = gfx::Rect(26, 28);
EXPECT_EQ(expected_swap_rect.ToString(),
- fake_compositor_frame_sink->last_swap_rect().ToString());
+ fake_layer_tree_frame_sink->last_swap_rect().ToString());
layer_tree_host_impl->SetViewportSize(gfx::Size(10, 10));
// This will damage everything.
@@ -8211,9 +8203,9 @@
expected_swap_rect = gfx::Rect(10, 10);
EXPECT_EQ(expected_swap_rect.ToString(),
- fake_compositor_frame_sink->last_swap_rect().ToString());
+ fake_layer_tree_frame_sink->last_swap_rect().ToString());
- layer_tree_host_impl->ReleaseCompositorFrameSink();
+ layer_tree_host_impl->ReleaseLayerTreeFrameSink();
}
TEST_F(LayerTreeHostImplTest, RootLayerDoesntCreateExtraSurface) {
@@ -8269,9 +8261,9 @@
std::unique_ptr<TestWebGraphicsContext3D> context =
TestWebGraphicsContext3D::Create();
TestWebGraphicsContext3D* context3d = context.get();
- std::unique_ptr<CompositorFrameSink> compositor_frame_sink(
- FakeCompositorFrameSink::Create3d(std::move(context)));
- CreateHostImpl(DefaultSettings(), std::move(compositor_frame_sink));
+ std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink(
+ FakeLayerTreeFrameSink::Create3d(std::move(context)));
+ CreateHostImpl(DefaultSettings(), std::move(layer_tree_frame_sink));
std::unique_ptr<LayerImpl> root_layer =
LayerImpl::Create(host_impl_->active_tree(), 1);
@@ -8348,8 +8340,8 @@
class LayerTreeHostImplTestDrawAndTestDamage : public LayerTreeHostImplTest {
protected:
- std::unique_ptr<CompositorFrameSink> CreateCompositorFrameSink() override {
- return FakeCompositorFrameSink::Create3d();
+ std::unique_ptr<LayerTreeFrameSink> CreateLayerTreeFrameSink() override {
+ return FakeLayerTreeFrameSink::Create3d();
}
void DrawFrameAndTestDamage(const gfx::Rect& expected_damage) {
@@ -8554,7 +8546,7 @@
ForcedDrawToSoftwareDeviceSkipsUnsupportedLayers) {
set_reduce_memory_result(false);
EXPECT_TRUE(CreateHostImpl(DefaultSettings(),
- FakeCompositorFrameSink::CreateSoftware()));
+ FakeLayerTreeFrameSink::CreateSoftware()));
const gfx::Transform external_transform;
const gfx::Rect external_viewport;
@@ -8586,7 +8578,7 @@
// Checks that we use the memory limits provided.
TEST_F(LayerTreeHostImplTest, MemoryLimits) {
- host_impl_->ReleaseCompositorFrameSink();
+ host_impl_->ReleaseLayerTreeFrameSink();
host_impl_ = nullptr;
const size_t kGpuByteLimit = 1234321;
@@ -8620,10 +8612,10 @@
AnimationHost::CreateForTesting(ThreadInstance::IMPL), 0, nullptr);
// Gpu compositing.
- compositor_frame_sink_ =
- FakeCompositorFrameSink::Create3d(TestWebGraphicsContext3D::Create());
+ layer_tree_frame_sink_ =
+ FakeLayerTreeFrameSink::Create3d(TestWebGraphicsContext3D::Create());
host_impl_->SetVisible(true);
- host_impl_->InitializeRenderer(compositor_frame_sink_.get());
+ host_impl_->InitializeRenderer(layer_tree_frame_sink_.get());
{
const auto& state = host_impl_->global_tile_state();
EXPECT_EQ(kGpuByteLimit, state.hard_memory_limit_in_bytes);
@@ -8649,9 +8641,9 @@
}
// Software compositing.
- host_impl_->ReleaseCompositorFrameSink();
- compositor_frame_sink_ = FakeCompositorFrameSink::CreateSoftware();
- host_impl_->InitializeRenderer(compositor_frame_sink_.get());
+ host_impl_->ReleaseLayerTreeFrameSink();
+ layer_tree_frame_sink_ = FakeLayerTreeFrameSink::CreateSoftware();
+ host_impl_->InitializeRenderer(layer_tree_frame_sink_.get());
{
const auto& state = host_impl_->global_tile_state();
EXPECT_EQ(kSoftwareByteLimit, state.hard_memory_limit_in_bytes);
@@ -8762,9 +8754,9 @@
fake_host_impl_ = new FakeLayerTreeHostImpl(
LayerTreeSettings(), &task_runner_provider_, &task_graph_runner_);
host_impl_.reset(fake_host_impl_);
- compositor_frame_sink_ = CreateCompositorFrameSink();
+ layer_tree_frame_sink_ = CreateLayerTreeFrameSink();
host_impl_->SetVisible(true);
- host_impl_->InitializeRenderer(compositor_frame_sink_.get());
+ host_impl_->InitializeRenderer(layer_tree_frame_sink_.get());
host_impl_->SetViewportSize(gfx::Size(10, 10));
}
@@ -8783,9 +8775,9 @@
std::unique_ptr<TestWebGraphicsContext3D> context =
TestWebGraphicsContext3D::Create();
TestWebGraphicsContext3D* context3d = context.get();
- std::unique_ptr<FakeCompositorFrameSink> compositor_frame_sink =
- FakeCompositorFrameSink::Create3d();
- CreateHostImpl(DefaultSettings(), std::move(compositor_frame_sink));
+ std::unique_ptr<FakeLayerTreeFrameSink> layer_tree_frame_sink =
+ FakeLayerTreeFrameSink::Create3d();
+ CreateHostImpl(DefaultSettings(), std::move(layer_tree_frame_sink));
EXPECT_EQ(0u, context3d->NumTextures());
@@ -8827,7 +8819,7 @@
std::unique_ptr<TestWebGraphicsContext3D> context =
TestWebGraphicsContext3D::Create();
TestWebGraphicsContext3D* context3d = context.get();
- CreateHostImpl(DefaultSettings(), FakeCompositorFrameSink::Create3d());
+ CreateHostImpl(DefaultSettings(), FakeLayerTreeFrameSink::Create3d());
EXPECT_EQ(0u, context3d->NumTextures());
@@ -8850,7 +8842,7 @@
void ShutdownReleasesContext_Callback(
std::unique_ptr<CopyOutputResult> result) {}
-class FrameSinkClient : public TestCompositorFrameSinkClient {
+class FrameSinkClient : public TestLayerTreeFrameSinkClient {
public:
explicit FrameSinkClient(
scoped_refptr<ContextProvider> display_context_provider)
@@ -8880,13 +8872,13 @@
constexpr bool synchronous_composite = true;
constexpr bool disable_display_vsync = false;
constexpr double refresh_rate = 60.0;
- auto compositor_frame_sink = base::MakeUnique<TestCompositorFrameSink>(
+ auto layer_tree_frame_sink = base::MakeUnique<TestLayerTreeFrameSink>(
context_provider, TestContextProvider::CreateWorker(), nullptr, nullptr,
RendererSettings(), base::ThreadTaskRunnerHandle::Get().get(),
synchronous_composite, disable_display_vsync, refresh_rate);
- compositor_frame_sink->SetClient(&test_client_);
+ layer_tree_frame_sink->SetClient(&test_client_);
- CreateHostImpl(DefaultSettings(), std::move(compositor_frame_sink));
+ CreateHostImpl(DefaultSettings(), std::move(layer_tree_frame_sink));
SetupRootLayerImpl(LayerImpl::Create(host_impl_->active_tree(), 1));
@@ -8906,7 +8898,7 @@
EXPECT_FALSE(context_provider->HasOneRef());
EXPECT_EQ(1u, context_provider->TestContext3d()->NumTextures());
- host_impl_->ReleaseCompositorFrameSink();
+ host_impl_->ReleaseLayerTreeFrameSink();
host_impl_ = nullptr;
// The CopyOutputResult's callback was cancelled, the CopyOutputResult
@@ -9241,9 +9233,8 @@
host_impl_->active_tree()->SetRootLayerForTesting(std::move(root));
host_impl_->active_tree()->BuildPropertyTreesForTesting();
- FakeCompositorFrameSink* fake_compositor_frame_sink =
- static_cast<FakeCompositorFrameSink*>(
- host_impl_->compositor_frame_sink());
+ auto* fake_layer_tree_frame_sink =
+ static_cast<FakeLayerTreeFrameSink*>(host_impl_->layer_tree_frame_sink());
ui::LatencyInfo latency_info;
latency_info.AddLatencyNumber(ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT, 0,
@@ -9259,7 +9250,7 @@
host_impl_->DidDrawAllLayers(frame);
const std::vector<ui::LatencyInfo>& metadata_latency_after =
- fake_compositor_frame_sink->last_sent_frame()->metadata.latency_info;
+ fake_layer_tree_frame_sink->last_sent_frame()->metadata.latency_info;
EXPECT_EQ(1u, metadata_latency_after.size());
EXPECT_TRUE(metadata_latency_after[0].FindLatency(
ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT, 0, NULL));
@@ -9278,9 +9269,8 @@
host_impl_->active_tree()->BuildPropertyTreesForTesting();
// Ensure the default frame selection bounds are empty.
- FakeCompositorFrameSink* fake_compositor_frame_sink =
- static_cast<FakeCompositorFrameSink*>(
- host_impl_->compositor_frame_sink());
+ auto* fake_layer_tree_frame_sink =
+ static_cast<FakeLayerTreeFrameSink*>(host_impl_->layer_tree_frame_sink());
// Plumb the layer-local selection bounds.
gfx::Point selection_top(5, 0);
@@ -9304,7 +9294,7 @@
// Ensure the selection bounds have propagated to the frame metadata.
const Selection<gfx::SelectionBound>& selection_after =
- fake_compositor_frame_sink->last_sent_frame()->metadata.selection;
+ fake_layer_tree_frame_sink->last_sent_frame()->metadata.selection;
EXPECT_EQ(selection.start.type, selection_after.start.type());
EXPECT_EQ(selection.end.type, selection_after.end.type());
EXPECT_EQ(gfx::PointF(selection_bottom), selection_after.start.edge_bottom());
@@ -9443,7 +9433,7 @@
public:
void SetUp() override {
LayerTreeSettings settings = DefaultSettings();
- CreateHostImpl(settings, CreateCompositorFrameSink());
+ CreateHostImpl(settings, CreateLayerTreeFrameSink());
host_impl_->active_tree()->set_top_controls_height(top_controls_height_);
host_impl_->sync_tree()->set_top_controls_height(top_controls_height_);
host_impl_->active_tree()->SetCurrentBrowserControlsShownRatio(1.f);
@@ -10399,7 +10389,7 @@
void SetUp() override {
LayerTreeSettings settings = DefaultSettings();
settings.max_memory_for_prepaint_percentage = 50;
- CreateHostImpl(settings, CreateCompositorFrameSink());
+ CreateHostImpl(settings, CreateLayerTreeFrameSink());
}
};
@@ -10647,8 +10637,8 @@
class ResourcelessSoftwareLayerTreeHostImplTest : public LayerTreeHostImplTest {
protected:
- std::unique_ptr<CompositorFrameSink> CreateCompositorFrameSink() override {
- return FakeCompositorFrameSink::Create3d();
+ std::unique_ptr<LayerTreeFrameSink> CreateLayerTreeFrameSink() override {
+ return FakeLayerTreeFrameSink::Create3d();
}
};
@@ -11534,7 +11524,7 @@
Occlusion(), true);
host_impl_->pending_tree()->SetRootLayerForTesting(std::move(layer));
- FakePictureLayerImpl* root_layer = static_cast<FakePictureLayerImpl*>(
+ auto* root_layer = static_cast<FakePictureLayerImpl*>(
host_impl_->pending_tree()->root_layer_for_testing());
root_layer->set_has_valid_tile_priorities(true);
@@ -11632,7 +11622,7 @@
class LayerTreeHostImplCountingLostSurfaces : public LayerTreeHostImplTest {
public:
LayerTreeHostImplCountingLostSurfaces() : num_lost_surfaces_(0) {}
- void DidLoseCompositorFrameSinkOnImplThread() override {
+ void DidLoseLayerTreeFrameSinkOnImplThread() override {
num_lost_surfaces_++;
}
@@ -11645,9 +11635,9 @@
// we go from having a valid output surface to not having a valid output
// surface.
EXPECT_EQ(0, num_lost_surfaces_);
- host_impl_->DidLoseCompositorFrameSink();
+ host_impl_->DidLoseLayerTreeFrameSink();
EXPECT_EQ(1, num_lost_surfaces_);
- host_impl_->DidLoseCompositorFrameSink();
+ host_impl_->DidLoseLayerTreeFrameSink();
EXPECT_LE(1, num_lost_surfaces_);
}
@@ -11875,7 +11865,7 @@
context_with_msaa->set_gpu_rasterization(true);
LayerTreeSettings msaaSettings = DefaultSettings();
msaaSettings.gpu_rasterization_msaa_sample_count = 4;
- EXPECT_TRUE(CreateHostImpl(msaaSettings, FakeCompositorFrameSink::Create3d(
+ EXPECT_TRUE(CreateHostImpl(msaaSettings, FakeLayerTreeFrameSink::Create3d(
std::move(context_with_msaa))));
// Set initial state, before varying GPU rasterization suitability.
@@ -11911,7 +11901,7 @@
context_with_msaa->set_gpu_rasterization(true);
LayerTreeSettings msaaSettings = DefaultSettings();
msaaSettings.gpu_rasterization_msaa_sample_count = -1;
- EXPECT_TRUE(CreateHostImpl(msaaSettings, FakeCompositorFrameSink::Create3d(
+ EXPECT_TRUE(CreateHostImpl(msaaSettings, FakeLayerTreeFrameSink::Create3d(
std::move(context_with_msaa))));
// Set initial state, before varying scale factor.
@@ -11947,7 +11937,7 @@
context_with_msaa->set_gpu_rasterization(true);
LayerTreeSettings msaaSettings = DefaultSettings();
msaaSettings.gpu_rasterization_msaa_sample_count = 4;
- EXPECT_TRUE(CreateHostImpl(msaaSettings, FakeCompositorFrameSink::Create3d(
+ EXPECT_TRUE(CreateHostImpl(msaaSettings, FakeLayerTreeFrameSink::Create3d(
std::move(context_with_msaa))));
host_impl_->SetHasGpuRasterizationTrigger(true);
@@ -11962,8 +11952,8 @@
class GpuRasterizationDisabledLayerTreeHostImplTest
: public LayerTreeHostImplTest {
public:
- std::unique_ptr<CompositorFrameSink> CreateCompositorFrameSink() override {
- return FakeCompositorFrameSink::Create3d();
+ std::unique_ptr<LayerTreeFrameSink> CreateLayerTreeFrameSink() override {
+ return FakeLayerTreeFrameSink::Create3d();
}
};
@@ -11972,7 +11962,7 @@
GpuRasterizationStatusOverrides) {
// GPU rasterization explicitly disabled.
LayerTreeSettings settings = DefaultSettings();
- EXPECT_TRUE(CreateHostImpl(settings, FakeCompositorFrameSink::Create3d()));
+ EXPECT_TRUE(CreateHostImpl(settings, FakeLayerTreeFrameSink::Create3d()));
host_impl_->SetHasGpuRasterizationTrigger(true);
host_impl_->SetContentIsSuitableForGpuRasterization(true);
host_impl_->CommitComplete();
@@ -11982,7 +11972,7 @@
// GPU rasterization explicitly forced.
settings.gpu_rasterization_forced = true;
- EXPECT_TRUE(CreateHostImpl(settings, FakeCompositorFrameSink::Create3d()));
+ EXPECT_TRUE(CreateHostImpl(settings, FakeLayerTreeFrameSink::Create3d()));
host_impl_->SetHasGpuRasterizationTrigger(false);
host_impl_->SetContentIsSuitableForGpuRasterization(false);
@@ -12001,10 +11991,10 @@
context_provider->UnboundTestContext3d()->SetMaxSamples(4);
context_provider->UnboundTestContext3d()->set_msaa_is_slow(msaa_is_slow);
context_provider->UnboundTestContext3d()->set_gpu_rasterization(true);
- auto msaa_is_normal_compositor_frame_sink =
- FakeCompositorFrameSink::Create3d(context_provider);
+ auto msaa_is_normal_layer_tree_frame_sink =
+ FakeLayerTreeFrameSink::Create3d(context_provider);
EXPECT_TRUE(CreateHostImpl(
- settings, std::move(msaa_is_normal_compositor_frame_sink)));
+ settings, std::move(msaa_is_normal_layer_tree_frame_sink)));
}
};
@@ -12172,13 +12162,11 @@
}
}
-// Checks that if we lose a GPU raster enabled CompositorFrameSink and replace
-// it
-// with a software CompositorFrameSink, LayerTreeHostImpl correctly re-computes
-// GPU
-// rasterization status.
-TEST_F(LayerTreeHostImplTest, RecomputeGpuRasterOnCompositorFrameSinkChange) {
- host_impl_->ReleaseCompositorFrameSink();
+// Checks that if we lose a GPU raster enabled LayerTreeFrameSink and replace
+// it with a software LayerTreeFrameSink, LayerTreeHostImpl correctly
+// re-computes GPU rasterization status.
+TEST_F(LayerTreeHostImplTest, RecomputeGpuRasterOnLayerTreeFrameSinkChange) {
+ host_impl_->ReleaseLayerTreeFrameSink();
host_impl_ = nullptr;
LayerTreeSettings settings = DefaultSettings();
@@ -12191,14 +12179,14 @@
host_impl_->SetVisible(true);
// InitializeRenderer with a gpu-raster enabled output surface.
- auto gpu_raster_compositor_frame_sink =
- FakeCompositorFrameSink::Create3d(TestWebGraphicsContext3D::Create());
- host_impl_->InitializeRenderer(gpu_raster_compositor_frame_sink.get());
+ auto gpu_raster_layer_tree_frame_sink =
+ FakeLayerTreeFrameSink::Create3d(TestWebGraphicsContext3D::Create());
+ host_impl_->InitializeRenderer(gpu_raster_layer_tree_frame_sink.get());
EXPECT_TRUE(host_impl_->use_gpu_rasterization());
// Re-initialize with a software output surface.
- compositor_frame_sink_ = FakeCompositorFrameSink::CreateSoftware();
- host_impl_->InitializeRenderer(compositor_frame_sink_.get());
+ layer_tree_frame_sink_ = FakeLayerTreeFrameSink::CreateSoftware();
+ host_impl_->InitializeRenderer(layer_tree_frame_sink_.get());
EXPECT_FALSE(host_impl_->use_gpu_rasterization());
}
@@ -12220,7 +12208,7 @@
const int child_clip_id = 12;
const int child_scroll_id = 13;
- CreateHostImpl(settings, CreateCompositorFrameSink());
+ CreateHostImpl(settings, CreateLayerTreeFrameSink());
host_impl_->active_tree()->SetDeviceScaleFactor(1);
host_impl_->SetViewportSize(viewport_size);
CreateScrollAndContentsLayers(host_impl_->active_tree(), content_size);
@@ -12466,7 +12454,7 @@
settings.enable_checker_imaging = true;
settings.default_tile_size = gfx::Size(256, 256);
settings.max_untiled_layer_size = gfx::Size(256, 256);
- CreateHostImpl(settings, CreateCompositorFrameSink());
+ CreateHostImpl(settings, CreateLayerTreeFrameSink());
gfx::Size layer_size = gfx::Size(750, 750);
std::unique_ptr<FakeRecordingSource> recording_source =
@@ -12494,8 +12482,7 @@
pending_tree->SetRootLayerForTesting(
FakePictureLayerImpl::CreateWithRasterSource(pending_tree, 1,
raster_source));
- FakePictureLayerImpl* root =
- static_cast<FakePictureLayerImpl*>(*pending_tree->begin());
+ auto* root = static_cast<FakePictureLayerImpl*>(*pending_tree->begin());
root->SetBounds(layer_size);
root->SetDrawsContent(true);
pending_tree->BuildPropertyTreesForTesting();
@@ -12538,14 +12525,14 @@
TEST_F(LayerTreeHostImplTest, RasterColorSpaceNoColorCorrection) {
LayerTreeSettings settings = DefaultSettings();
- CreateHostImpl(settings, CreateCompositorFrameSink());
+ CreateHostImpl(settings, CreateLayerTreeFrameSink());
EXPECT_FALSE(host_impl_->GetRasterColorSpace().IsValid());
}
TEST_F(LayerTreeHostImplTest, RasterColorSpace) {
LayerTreeSettings settings = DefaultSettings();
settings.enable_color_correct_rasterization = true;
- CreateHostImpl(settings, CreateCompositorFrameSink());
+ CreateHostImpl(settings, CreateLayerTreeFrameSink());
EXPECT_EQ(host_impl_->GetRasterColorSpace(), gfx::ColorSpace::CreateSRGB());
}
diff --git a/cc/trees/layer_tree_host_perftest.cc b/cc/trees/layer_tree_host_perftest.cc
index c18633e..df03b17 100644
--- a/cc/trees/layer_tree_host_perftest.cc
+++ b/cc/trees/layer_tree_host_perftest.cc
@@ -23,7 +23,7 @@
#include "cc/test/layer_tree_json_parser.h"
#include "cc/test/layer_tree_test.h"
#include "cc/test/paths.h"
-#include "cc/test/test_compositor_frame_sink.h"
+#include "cc/test/test_layer_tree_frame_sink.h"
#include "cc/trees/layer_tree_impl.h"
#include "testing/perf/perf_test.h"
@@ -46,7 +46,7 @@
measure_commit_cost_(false) {
}
- std::unique_ptr<TestCompositorFrameSink> CreateCompositorFrameSink(
+ std::unique_ptr<TestLayerTreeFrameSink> CreateLayerTreeFrameSink(
const RendererSettings& renderer_settings,
double refresh_rate,
scoped_refptr<ContextProvider> compositor_context_provider,
@@ -55,7 +55,7 @@
bool synchronous_composite =
!HasImplThread() &&
!layer_tree_host()->GetSettings().single_thread_proxy_scheduler;
- return base::MakeUnique<TestCompositorFrameSink>(
+ return base::MakeUnique<TestLayerTreeFrameSink>(
compositor_context_provider, std::move(worker_context_provider),
shared_bitmap_manager(), gpu_memory_buffer_manager(), renderer_settings,
ImplThreadTaskRunner(), synchronous_composite, disable_display_vsync,
diff --git a/cc/trees/layer_tree_host_pixeltest_blending.cc b/cc/trees/layer_tree_host_pixeltest_blending.cc
index f8367bfb..8cecb9e 100644
--- a/cc/trees/layer_tree_host_pixeltest_blending.cc
+++ b/cc/trees/layer_tree_host_pixeltest_blending.cc
@@ -9,7 +9,7 @@
#include "cc/paint/paint_image.h"
#include "cc/test/layer_tree_pixel_resource_test.h"
#include "cc/test/pixel_comparator.h"
-#include "cc/test/test_compositor_frame_sink.h"
+#include "cc/test/test_layer_tree_frame_sink.h"
#include "third_party/skia/include/core/SkImage.h"
#include "third_party/skia/include/core/SkSurface.h"
@@ -69,7 +69,7 @@
}
protected:
- std::unique_ptr<TestCompositorFrameSink> CreateCompositorFrameSink(
+ std::unique_ptr<TestLayerTreeFrameSink> CreateLayerTreeFrameSink(
const RendererSettings& renderer_settings,
double refresh_rate,
scoped_refptr<ContextProvider> compositor_context_provider,
@@ -78,7 +78,7 @@
modified_renderer_settings.force_antialiasing = force_antialiasing_;
modified_renderer_settings.force_blending_with_shaders =
force_blending_with_shaders_;
- return LayerTreeHostPixelResourceTest::CreateCompositorFrameSink(
+ return LayerTreeHostPixelResourceTest::CreateLayerTreeFrameSink(
modified_renderer_settings, refresh_rate, compositor_context_provider,
worker_context_provider);
}
diff --git a/cc/trees/layer_tree_host_pixeltest_tiles.cc b/cc/trees/layer_tree_host_pixeltest_tiles.cc
index 5e5499d..c4ff86c 100644
--- a/cc/trees/layer_tree_host_pixeltest_tiles.cc
+++ b/cc/trees/layer_tree_host_pixeltest_tiles.cc
@@ -11,7 +11,7 @@
#include "cc/paint/paint_flags.h"
#include "cc/paint/paint_op_buffer.h"
#include "cc/test/layer_tree_pixel_test.h"
-#include "cc/test/test_compositor_frame_sink.h"
+#include "cc/test/test_layer_tree_frame_sink.h"
#include "gpu/command_buffer/client/gles2_interface.h"
#if !defined(OS_ANDROID)
@@ -178,7 +178,7 @@
// Issue a GL finish before preparing tiles to ensure resources become
// available for use in a timely manner. Needed for the one-copy path.
ContextProvider* context_provider =
- host_impl->compositor_frame_sink()->worker_context_provider();
+ host_impl->layer_tree_frame_sink()->worker_context_provider();
if (!context_provider)
return;
diff --git a/cc/trees/layer_tree_host_single_thread_client.h b/cc/trees/layer_tree_host_single_thread_client.h
index 00cc3dba..416b5de 100644
--- a/cc/trees/layer_tree_host_single_thread_client.h
+++ b/cc/trees/layer_tree_host_single_thread_client.h
@@ -22,10 +22,10 @@
// limiting.
virtual void DidSubmitCompositorFrame() = 0;
- // Called when the active CompositorFrameSink is lost and needs to be
+ // Called when the active LayerTreeFrameSink is lost and needs to be
// replaced. This allows the embedder to schedule a composite which will
- // run the machinery to acquire a new CompositorFrameSink.
- virtual void DidLoseCompositorFrameSink() = 0;
+ // run the machinery to acquire a new LayerTreeFrameSink.
+ virtual void DidLoseLayerTreeFrameSink() = 0;
protected:
virtual ~LayerTreeHostSingleThreadClient() {}
diff --git a/cc/trees/layer_tree_host_unittest.cc b/cc/trees/layer_tree_host_unittest.cc
index acffb0a..cd297d7f 100644
--- a/cc/trees/layer_tree_host_unittest.cc
+++ b/cc/trees/layer_tree_host_unittest.cc
@@ -52,7 +52,7 @@
#include "cc/test/push_properties_counting_layer_impl.h"
#include "cc/test/render_pass_test_utils.h"
#include "cc/test/skia_common.h"
-#include "cc/test/test_compositor_frame_sink.h"
+#include "cc/test/test_layer_tree_frame_sink.h"
#include "cc/test/test_web_graphics_context_3d.h"
#include "cc/trees/clip_node.h"
#include "cc/trees/effect_node.h"
@@ -441,7 +441,7 @@
class LayerTreeHostContextCacheTest : public LayerTreeHostTest {
public:
- std::unique_ptr<TestCompositorFrameSink> CreateCompositorFrameSink(
+ std::unique_ptr<TestLayerTreeFrameSink> CreateLayerTreeFrameSink(
const RendererSettings& renderer_settings,
double refresh_rate,
scoped_refptr<ContextProvider> compositor_context_provider,
@@ -466,7 +466,7 @@
EXPECT_CALL(*mock_worker_context_support_,
SetAggressivelyFreeResources(false));
- return LayerTreeHostTest::CreateCompositorFrameSink(
+ return LayerTreeHostTest::CreateLayerTreeFrameSink(
renderer_settings, refresh_rate, std::move(test_main_context_provider),
std::move(test_worker_context_provider));
}
@@ -579,13 +579,13 @@
SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostFreeContextResourcesOnDestroy);
// Test if the LTH successfully frees and stops freeing context resources
-// when the CompositorFrameSink is lost and recreated.
-class LayerTreeHostCacheBehaviorOnCompositorFrameSinkRecreated
+// when the LayerTreeFrameSink is lost and recreated.
+class LayerTreeHostCacheBehaviorOnLayerTreeFrameSinkRecreated
: public LayerTreeHostContextCacheTest {
public:
void WillBeginImplFrameOnThread(LayerTreeHostImpl* host_impl,
const BeginFrameArgs& args) override {
- // This code is run once, to trigger recreation of our CompositorFrameSink.
+ // This code is run once, to trigger recreation of our LayerTreeFrameSink.
if (test_state_ != TestState::INIT)
return;
@@ -593,18 +593,18 @@
Mock::VerifyAndClearExpectations(mock_main_context_support_);
Mock::VerifyAndClearExpectations(mock_worker_context_support_);
- // CompositorFrameSink lost expectations.
+ // LayerTreeFrameSink lost expectations.
EXPECT_CALL(*mock_worker_context_support_,
SetAggressivelyFreeResources(true));
EXPECT_CALL(*mock_main_context_support_,
SetAggressivelyFreeResources(true));
- host_impl->DidLoseCompositorFrameSink();
+ host_impl->DidLoseLayerTreeFrameSink();
test_state_ = TestState::RECREATED;
}
void InitializedRendererOnThread(LayerTreeHostImpl* host_impl,
bool success) override {
- // This is run after we have recreated our CompositorFrameSink.
+ // This is run after we have recreated our LayerTreeFrameSink.
if (test_state_ != TestState::RECREATED)
return;
@@ -627,7 +627,7 @@
};
SINGLE_AND_MULTI_THREAD_TEST_F(
- LayerTreeHostCacheBehaviorOnCompositorFrameSinkRecreated);
+ LayerTreeHostCacheBehaviorOnLayerTreeFrameSinkRecreated);
// Two setNeedsCommits in a row should lead to at least 1 commit and at least 1
// draw with frame 0.
@@ -3359,9 +3359,9 @@
int commit_complete_count_;
};
-class OnDrawCompositorFrameSink : public TestCompositorFrameSink {
+class OnDrawLayerTreeFrameSink : public TestLayerTreeFrameSink {
public:
- explicit OnDrawCompositorFrameSink(
+ explicit OnDrawLayerTreeFrameSink(
scoped_refptr<ContextProvider> compositor_context_provider,
scoped_refptr<ContextProvider> worker_context_provider,
SharedBitmapManager* shared_bitmap_manager,
@@ -3371,18 +3371,18 @@
bool synchronous_composite,
double refresh_rate,
base::Closure invalidate_callback)
- : TestCompositorFrameSink(std::move(compositor_context_provider),
- std::move(worker_context_provider),
- shared_bitmap_manager,
- gpu_memory_buffer_manager,
- renderer_settings,
- task_runner,
- synchronous_composite,
- false /* disable_display_vsync */,
- refresh_rate),
+ : TestLayerTreeFrameSink(std::move(compositor_context_provider),
+ std::move(worker_context_provider),
+ shared_bitmap_manager,
+ gpu_memory_buffer_manager,
+ renderer_settings,
+ task_runner,
+ synchronous_composite,
+ false /* disable_display_vsync */,
+ refresh_rate),
invalidate_callback_(std::move(invalidate_callback)) {}
- // TestCompositorFrameSink overrides.
+ // TestLayerTreeFrameSink overrides.
void Invalidate() override { invalidate_callback_.Run(); }
void OnDraw(bool resourceless_software_draw) {
@@ -3403,7 +3403,7 @@
settings->using_synchronous_renderer_compositor = true;
}
- std::unique_ptr<TestCompositorFrameSink> CreateCompositorFrameSink(
+ std::unique_ptr<TestLayerTreeFrameSink> CreateLayerTreeFrameSink(
const RendererSettings& renderer_settings,
double refresh_rate,
scoped_refptr<ContextProvider> compositor_context_provider,
@@ -3412,12 +3412,12 @@
&LayerTreeHostTestAbortedCommitDoesntStallSynchronousCompositor::
CallOnDraw,
base::Unretained(this));
- auto frame_sink = base::MakeUnique<OnDrawCompositorFrameSink>(
+ auto frame_sink = base::MakeUnique<OnDrawLayerTreeFrameSink>(
compositor_context_provider, std::move(worker_context_provider),
shared_bitmap_manager(), gpu_memory_buffer_manager(), renderer_settings,
ImplThreadTaskRunner(), false /* synchronous_composite */, refresh_rate,
std::move(on_draw_callback));
- compositor_frame_sink_ = frame_sink.get();
+ layer_tree_frame_sink_ = frame_sink.get();
return std::move(frame_sink);
}
@@ -3427,13 +3427,13 @@
// surface. But it needs to be done on a new stack frame.
bool resourceless_software_draw = false;
ImplThreadTaskRunner()->PostTask(
- FROM_HERE, base::BindOnce(&OnDrawCompositorFrameSink::OnDraw,
- base::Unretained(compositor_frame_sink_),
+ FROM_HERE, base::BindOnce(&OnDrawLayerTreeFrameSink::OnDraw,
+ base::Unretained(layer_tree_frame_sink_),
resourceless_software_draw));
}
}
- OnDrawCompositorFrameSink* compositor_frame_sink_ = nullptr;
+ OnDrawLayerTreeFrameSink* layer_tree_frame_sink_ = nullptr;
};
MULTI_THREAD_TEST_F(
@@ -3561,7 +3561,7 @@
void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
auto* context = static_cast<TestContextProvider*>(
- impl->compositor_frame_sink()->context_provider())
+ impl->layer_tree_frame_sink()->context_provider())
->TestContext3d();
int frame = impl->active_tree()->source_frame_number();
@@ -5534,7 +5534,7 @@
class LayerTreeHostWithGpuRasterizationTest : public LayerTreeHostTest {
protected:
- std::unique_ptr<TestCompositorFrameSink> CreateCompositorFrameSink(
+ std::unique_ptr<TestLayerTreeFrameSink> CreateLayerTreeFrameSink(
const RendererSettings& renderer_settings,
double refresh_rate,
scoped_refptr<ContextProvider> compositor_context_provider,
@@ -5542,7 +5542,7 @@
auto context = TestWebGraphicsContext3D::Create();
context->set_gpu_rasterization(true);
auto context_provider = TestContextProvider::Create(std::move(context));
- return LayerTreeHostTest::CreateCompositorFrameSink(
+ return LayerTreeHostTest::CreateLayerTreeFrameSink(
renderer_settings, refresh_rate, std::move(context_provider),
std::move(worker_context_provider));
}
@@ -5619,7 +5619,7 @@
settings->gpu_rasterization_msaa_sample_count = 4;
}
- std::unique_ptr<TestCompositorFrameSink> CreateCompositorFrameSink(
+ std::unique_ptr<TestLayerTreeFrameSink> CreateLayerTreeFrameSink(
const RendererSettings& renderer_settings,
double refresh_rate,
scoped_refptr<ContextProvider> compositor_context_provider,
@@ -5630,7 +5630,7 @@
context->set_gpu_rasterization(true);
compositor_context_provider =
TestContextProvider::Create(std::move(context));
- return LayerTreeTest::CreateCompositorFrameSink(
+ return LayerTreeTest::CreateLayerTreeFrameSink(
renderer_settings, refresh_rate, compositor_context_provider,
worker_context_provider);
}
@@ -6044,7 +6044,7 @@
settings->use_zero_copy = true;
}
- std::unique_ptr<TestCompositorFrameSink> CreateCompositorFrameSink(
+ std::unique_ptr<TestLayerTreeFrameSink> CreateLayerTreeFrameSink(
const RendererSettings& renderer_settings,
double refresh_rate,
scoped_refptr<ContextProvider> compositor_context_provider,
@@ -6053,7 +6053,7 @@
bool synchronous_composite =
!HasImplThread() &&
!layer_tree_host()->GetSettings().single_thread_proxy_scheduler;
- return base::MakeUnique<TestCompositorFrameSink>(
+ return base::MakeUnique<TestLayerTreeFrameSink>(
compositor_context_provider, std::move(worker_context_provider),
shared_bitmap_manager(), gpu_memory_buffer_manager(), renderer_settings,
ImplThreadTaskRunner(), synchronous_composite, disable_display_vsync,
@@ -7434,7 +7434,7 @@
};
SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestPaintedDeviceScaleFactor);
-// Makes sure that LocalSurfaceId is propagated to the CompositorFrameSink.
+// Makes sure that LocalSurfaceId is propagated to the LayerTreeFrameSink.
class LayerTreeHostTestLocalSurfaceId : public LayerTreeHostTest {
protected:
void InitializeSettings(LayerTreeSettings* settings) override {
@@ -7521,7 +7521,7 @@
// Retrieve max texture size from Skia.
ContextProvider* context_provider =
- host_impl->compositor_frame_sink()->context_provider();
+ host_impl->layer_tree_frame_sink()->context_provider();
ASSERT_TRUE(context_provider);
ContextProvider::ScopedContextLock context_lock(context_provider);
@@ -7865,7 +7865,7 @@
SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestHudLayerWithLayerLists);
// Verifies that LayerTreeHostClient does not receive frame acks from a released
-// CompositorFrameSink.
+// LayerTreeFrameSink.
class LayerTreeHostTestDiscardAckAfterRelease : public LayerTreeHostTest {
protected:
void SetupTree() override {
@@ -7891,14 +7891,14 @@
void WillReceiveCompositorFrameAck() {
switch (layer_tree_host()->SourceFrameNumber()) {
case 1:
- // For the first commit, don't release the CompositorFrameSink. We must
+ // For the first commit, don't release the LayerTreeFrameSink. We must
// receive the ack later on.
break;
case 2:
- // Release the CompositorFrameSink for the second commit. We'll later
+ // Release the LayerTreeFrameSink for the second commit. We'll later
// check that the ack is discarded.
layer_tree_host()->SetVisible(false);
- layer_tree_host()->ReleaseCompositorFrameSink();
+ layer_tree_host()->ReleaseLayerTreeFrameSink();
break;
default:
NOTREACHED();
@@ -7921,13 +7921,13 @@
void CheckFrameAck() {
switch (layer_tree_host()->SourceFrameNumber()) {
case 1:
- // CompositorFrameSink was not released. We must receive the ack.
+ // LayerTreeFrameSink was not released. We must receive the ack.
EXPECT_TRUE(received_ack_);
// Cause damage so that we draw and swap.
layer_tree_host()->root_layer()->SetBackgroundColor(SK_ColorGREEN);
break;
case 2:
- // CompositorFrameSink was released. The ack must be discarded.
+ // LayerTreeFrameSink was released. The ack must be discarded.
EXPECT_FALSE(received_ack_);
EndTest();
break;
diff --git a/cc/trees/layer_tree_host_unittest_checkerimaging.cc b/cc/trees/layer_tree_host_unittest_checkerimaging.cc
index 0828b10..692bb747 100644
--- a/cc/trees/layer_tree_host_unittest_checkerimaging.cc
+++ b/cc/trees/layer_tree_host_unittest_checkerimaging.cc
@@ -9,7 +9,7 @@
#include "cc/test/fake_picture_layer.h"
#include "cc/test/layer_tree_test.h"
#include "cc/test/skia_common.h"
-#include "cc/test/test_compositor_frame_sink.h"
+#include "cc/test/test_layer_tree_frame_sink.h"
#include "cc/trees/layer_tree_impl.h"
namespace cc {
diff --git a/cc/trees/layer_tree_host_unittest_context.cc b/cc/trees/layer_tree_host_unittest_context.cc
index ac83a150..d56d3d4 100644
--- a/cc/trees/layer_tree_host_unittest_context.cc
+++ b/cc/trees/layer_tree_host_unittest_context.cc
@@ -29,8 +29,8 @@
#include "cc/test/fake_video_frame_provider.h"
#include "cc/test/layer_tree_test.h"
#include "cc/test/render_pass_test_utils.h"
-#include "cc/test/test_compositor_frame_sink.h"
#include "cc/test/test_context_provider.h"
+#include "cc/test/test_layer_tree_frame_sink.h"
#include "cc/test/test_shared_bitmap_manager.h"
#include "cc/test/test_web_graphics_context_3d.h"
#include "cc/trees/layer_tree_host.h"
@@ -60,12 +60,12 @@
committed_at_least_once_(false),
context_should_support_io_surface_(false),
fallback_context_works_(false),
- async_compositor_frame_sink_creation_(false) {
+ async_layer_tree_frame_sink_creation_(false) {
media::InitializeMediaLibrary();
}
void LoseContext() {
- // CreateDisplayCompositorFrameSink happens on a different thread, so lock
+ // CreateDisplayLayerTreeFrameSink happens on a different thread, so lock
// context3d_ to make sure we don't set it to null after recreating it
// there.
base::AutoLock lock(context3d_lock_);
@@ -77,7 +77,7 @@
context3d_ = nullptr;
}
- std::unique_ptr<TestCompositorFrameSink> CreateCompositorFrameSink(
+ std::unique_ptr<TestLayerTreeFrameSink> CreateLayerTreeFrameSink(
const RendererSettings& renderer_settings,
double refresh_rate,
scoped_refptr<ContextProvider> compositor_context_provider,
@@ -99,7 +99,7 @@
GL_INNOCENT_CONTEXT_RESET_ARB);
}
- return LayerTreeTest::CreateCompositorFrameSink(
+ return LayerTreeTest::CreateLayerTreeFrameSink(
renderer_settings, refresh_rate,
TestContextProvider::Create(std::move(compositor_context3d)),
std::move(worker_context_provider));
@@ -139,7 +139,7 @@
times_to_fail_recreate_ = 0;
}
- void DidFailToInitializeCompositorFrameSink() override {
+ void DidFailToInitializeLayerTreeFrameSink() override {
++times_create_failed_;
}
@@ -152,7 +152,7 @@
protected:
// Protects use of context3d_ so LoseContext and
- // CreateDisplayCompositorFrameSink can both use it on different threads.
+ // CreateDisplayLayerTreeFrameSink can both use it on different threads.
base::Lock context3d_lock_;
TestWebGraphicsContext3D* context3d_;
@@ -165,7 +165,7 @@
bool committed_at_least_once_;
bool context_should_support_io_surface_;
bool fallback_context_works_;
- bool async_compositor_frame_sink_creation_;
+ bool async_layer_tree_frame_sink_creation_;
};
class LayerTreeHostContextTestLostContextSucceeds
@@ -181,23 +181,23 @@
void BeginTest() override { PostSetNeedsCommitToMainThread(); }
- void RequestNewCompositorFrameSink() override {
- if (async_compositor_frame_sink_creation_) {
+ void RequestNewLayerTreeFrameSink() override {
+ if (async_layer_tree_frame_sink_creation_) {
MainThreadTaskRunner()->PostTask(
FROM_HERE,
base::BindOnce(&LayerTreeHostContextTestLostContextSucceeds::
- AsyncRequestNewCompositorFrameSink,
+ AsyncRequestNewLayerTreeFrameSink,
base::Unretained(this)));
} else {
- AsyncRequestNewCompositorFrameSink();
+ AsyncRequestNewLayerTreeFrameSink();
}
}
- void AsyncRequestNewCompositorFrameSink() {
- LayerTreeHostContextTest::RequestNewCompositorFrameSink();
+ void AsyncRequestNewLayerTreeFrameSink() {
+ LayerTreeHostContextTest::RequestNewLayerTreeFrameSink();
}
- void DidInitializeCompositorFrameSink() override {
+ void DidInitializeLayerTreeFrameSink() override {
if (first_initialized_)
++num_losses_;
else
@@ -240,35 +240,35 @@
0, // times_to_lose_during_draw
0, // times_to_fail_recreate
false, // fallback_context_works
- false, // async_compositor_frame_sink_creation
+ false, // async_layer_tree_frame_sink_creation
},
{
0, // times_to_lose_during_commit
1, // times_to_lose_during_draw
0, // times_to_fail_recreate
false, // fallback_context_works
- false, // async_compositor_frame_sink_creation
+ false, // async_layer_tree_frame_sink_creation
},
{
1, // times_to_lose_during_commit
0, // times_to_lose_during_draw
3, // times_to_fail_recreate
false, // fallback_context_works
- false, // async_compositor_frame_sink_creation
+ false, // async_layer_tree_frame_sink_creation
},
{
0, // times_to_lose_during_commit
1, // times_to_lose_during_draw
3, // times_to_fail_recreate
false, // fallback_context_works
- false, // async_compositor_frame_sink_creation
+ false, // async_layer_tree_frame_sink_creation
},
{
0, // times_to_lose_during_commit
1, // times_to_lose_during_draw
3, // times_to_fail_recreate
false, // fallback_context_works
- true, // async_compositor_frame_sink_creation
+ true, // async_layer_tree_frame_sink_creation
},
// Losing the context and recreating it any number of times should
// succeed.
@@ -277,28 +277,28 @@
0, // times_to_lose_during_draw
0, // times_to_fail_recreate
false, // fallback_context_works
- false, // async_compositor_frame_sink_creation
+ false, // async_layer_tree_frame_sink_creation
},
{
0, // times_to_lose_during_commit
10, // times_to_lose_during_draw
0, // times_to_fail_recreate
false, // fallback_context_works
- false, // async_compositor_frame_sink_creation
+ false, // async_layer_tree_frame_sink_creation
},
{
10, // times_to_lose_during_commit
0, // times_to_lose_during_draw
0, // times_to_fail_recreate
false, // fallback_context_works
- true, // async_compositor_frame_sink_creation
+ true, // async_layer_tree_frame_sink_creation
},
{
0, // times_to_lose_during_commit
10, // times_to_lose_during_draw
0, // times_to_fail_recreate
false, // fallback_context_works
- true, // async_compositor_frame_sink_creation
+ true, // async_layer_tree_frame_sink_creation
},
// Losing the context, failing to reinitialize it, and making a fallback
// context should work.
@@ -307,14 +307,14 @@
1, // times_to_lose_during_draw
0, // times_to_fail_recreate
true, // fallback_context_works
- false, // async_compositor_frame_sink_creation
+ false, // async_layer_tree_frame_sink_creation
},
{
0, // times_to_lose_during_commit
1, // times_to_lose_during_draw
0, // times_to_fail_recreate
true, // fallback_context_works
- true, // async_compositor_frame_sink_creation
+ true, // async_layer_tree_frame_sink_creation
},
};
@@ -330,8 +330,8 @@
times_to_lose_during_draw_ = kTests[test_case_].times_to_lose_during_draw;
times_to_fail_recreate_ = kTests[test_case_].times_to_fail_recreate;
fallback_context_works_ = kTests[test_case_].fallback_context_works;
- async_compositor_frame_sink_creation_ =
- kTests[test_case_].async_compositor_frame_sink_creation;
+ async_layer_tree_frame_sink_creation_ =
+ kTests[test_case_].async_layer_tree_frame_sink_creation;
++test_case_;
return true;
}
@@ -341,7 +341,7 @@
int times_to_lose_during_draw;
int times_to_fail_recreate;
bool fallback_context_works;
- bool async_compositor_frame_sink_creation;
+ bool async_layer_tree_frame_sink_creation;
};
protected:
@@ -354,10 +354,10 @@
SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostContextTestLostContextSucceeds);
-class LayerTreeHostClientNotVisibleDoesNotCreateCompositorFrameSink
+class LayerTreeHostClientNotVisibleDoesNotCreateLayerTreeFrameSink
: public LayerTreeHostContextTest {
public:
- LayerTreeHostClientNotVisibleDoesNotCreateCompositorFrameSink()
+ LayerTreeHostClientNotVisibleDoesNotCreateLayerTreeFrameSink()
: LayerTreeHostContextTest() {}
void WillBeginTest() override {
@@ -370,60 +370,60 @@
EndTest();
}
- void RequestNewCompositorFrameSink() override {
- ADD_FAILURE() << "RequestNewCompositorFrameSink() should not be called";
+ void RequestNewLayerTreeFrameSink() override {
+ ADD_FAILURE() << "RequestNewLayerTreeFrameSink() should not be called";
}
- void DidInitializeCompositorFrameSink() override { EXPECT_TRUE(false); }
+ void DidInitializeLayerTreeFrameSink() override { EXPECT_TRUE(false); }
void AfterTest() override {}
};
SINGLE_AND_MULTI_THREAD_TEST_F(
- LayerTreeHostClientNotVisibleDoesNotCreateCompositorFrameSink);
+ LayerTreeHostClientNotVisibleDoesNotCreateLayerTreeFrameSink);
-// This tests the CompositorFrameSink release logic in the following sequence.
-// SetUp LTH and create and init CompositorFrameSink.
+// This tests the LayerTreeFrameSink release logic in the following sequence.
+// SetUp LTH and create and init LayerTreeFrameSink.
// LTH::SetVisible(false);
-// LTH::ReleaseCompositorFrameSink();
+// LTH::ReleaseLayerTreeFrameSink();
// ...
// LTH::SetVisible(true);
-// Create and init new CompositorFrameSink
-class LayerTreeHostClientTakeAwayCompositorFrameSink
+// Create and init new LayerTreeFrameSink
+class LayerTreeHostClientTakeAwayLayerTreeFrameSink
: public LayerTreeHostContextTest {
public:
- LayerTreeHostClientTakeAwayCompositorFrameSink()
+ LayerTreeHostClientTakeAwayLayerTreeFrameSink()
: LayerTreeHostContextTest(), setos_counter_(0) {}
void BeginTest() override { PostSetNeedsCommitToMainThread(); }
- void RequestNewCompositorFrameSink() override {
+ void RequestNewLayerTreeFrameSink() override {
if (layer_tree_host()->IsVisible()) {
setos_counter_++;
- LayerTreeHostContextTest::RequestNewCompositorFrameSink();
+ LayerTreeHostContextTest::RequestNewLayerTreeFrameSink();
}
}
- void HideAndReleaseCompositorFrameSink() {
+ void HideAndReleaseLayerTreeFrameSink() {
EXPECT_TRUE(layer_tree_host()->GetTaskRunnerProvider()->IsMainThread());
layer_tree_host()->SetVisible(false);
- std::unique_ptr<CompositorFrameSink> surface =
- layer_tree_host()->ReleaseCompositorFrameSink();
+ std::unique_ptr<LayerTreeFrameSink> surface =
+ layer_tree_host()->ReleaseLayerTreeFrameSink();
CHECK(surface);
MainThreadTaskRunner()->PostTask(
FROM_HERE,
base::BindOnce(
- &LayerTreeHostClientTakeAwayCompositorFrameSink::MakeVisible,
+ &LayerTreeHostClientTakeAwayLayerTreeFrameSink::MakeVisible,
base::Unretained(this)));
}
- void DidInitializeCompositorFrameSink() override {
+ void DidInitializeLayerTreeFrameSink() override {
EXPECT_TRUE(layer_tree_host()->IsVisible());
if (setos_counter_ == 1) {
MainThreadTaskRunner()->PostTask(
FROM_HERE,
- base::BindOnce(&LayerTreeHostClientTakeAwayCompositorFrameSink::
- HideAndReleaseCompositorFrameSink,
+ base::BindOnce(&LayerTreeHostClientTakeAwayLayerTreeFrameSink::
+ HideAndReleaseLayerTreeFrameSink,
base::Unretained(this)));
} else {
EndTest();
@@ -440,12 +440,12 @@
int setos_counter_;
};
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostClientTakeAwayCompositorFrameSink);
+SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostClientTakeAwayLayerTreeFrameSink);
-class MultipleCompositeDoesNotCreateCompositorFrameSink
+class MultipleCompositeDoesNotCreateLayerTreeFrameSink
: public LayerTreeHostContextTest {
public:
- MultipleCompositeDoesNotCreateCompositorFrameSink()
+ MultipleCompositeDoesNotCreateLayerTreeFrameSink()
: LayerTreeHostContextTest(), request_count_(0) {}
void InitializeSettings(LayerTreeSettings* settings) override {
@@ -453,7 +453,7 @@
settings->use_zero_copy = true;
}
- void RequestNewCompositorFrameSink() override {
+ void RequestNewLayerTreeFrameSink() override {
EXPECT_GE(1, ++request_count_);
EndTest();
}
@@ -463,7 +463,7 @@
layer_tree_host()->Composite(base::TimeTicks::FromInternalValue(2));
}
- void DidInitializeCompositorFrameSink() override { EXPECT_TRUE(false); }
+ void DidInitializeLayerTreeFrameSink() override { EXPECT_TRUE(false); }
void AfterTest() override {}
@@ -471,15 +471,15 @@
};
// This test uses Composite() which only exists for single thread.
-SINGLE_THREAD_TEST_F(MultipleCompositeDoesNotCreateCompositorFrameSink);
+SINGLE_THREAD_TEST_F(MultipleCompositeDoesNotCreateLayerTreeFrameSink);
// This test makes sure that once a SingleThreadProxy issues a
-// DidFailToInitializeCompositorFrameSink, that future Composite calls will not
+// DidFailToInitializeLayerTreeFrameSink, that future Composite calls will not
// trigger additional requests for output surfaces.
-class FailedCreateDoesNotCreateExtraCompositorFrameSink
+class FailedCreateDoesNotCreateExtraLayerTreeFrameSink
: public LayerTreeHostContextTest {
public:
- FailedCreateDoesNotCreateExtraCompositorFrameSink()
+ FailedCreateDoesNotCreateExtraLayerTreeFrameSink()
: LayerTreeHostContextTest(), num_requests_(0), has_failed_(false) {
times_to_fail_create_ = 1;
}
@@ -489,16 +489,16 @@
settings->use_zero_copy = true;
}
- void RequestNewCompositorFrameSink() override {
+ void RequestNewLayerTreeFrameSink() override {
num_requests_++;
// There should be one initial request and then one request from
- // the LayerTreeTest test hooks DidFailToInitializeCompositorFrameSink
+ // the LayerTreeTest test hooks DidFailToInitializeLayerTreeFrameSink
// (which is hard to skip). This second request is just ignored and is test
// cruft.
EXPECT_LE(num_requests_, 2);
if (num_requests_ > 1)
return;
- LayerTreeHostContextTest::RequestNewCompositorFrameSink();
+ LayerTreeHostContextTest::RequestNewLayerTreeFrameSink();
}
void BeginTest() override {
@@ -513,10 +513,10 @@
EndTest();
}
- void DidInitializeCompositorFrameSink() override { EXPECT_TRUE(false); }
+ void DidInitializeLayerTreeFrameSink() override { EXPECT_TRUE(false); }
- void DidFailToInitializeCompositorFrameSink() override {
- LayerTreeHostContextTest::DidFailToInitializeCompositorFrameSink();
+ void DidFailToInitializeLayerTreeFrameSink() override {
+ LayerTreeHostContextTest::DidFailToInitializeLayerTreeFrameSink();
EXPECT_FALSE(has_failed_);
has_failed_ = true;
}
@@ -528,12 +528,12 @@
};
// This test uses Composite() which only exists for single thread.
-SINGLE_THREAD_TEST_F(FailedCreateDoesNotCreateExtraCompositorFrameSink);
+SINGLE_THREAD_TEST_F(FailedCreateDoesNotCreateExtraLayerTreeFrameSink);
-class LayerTreeHostContextTestCommitAfterDelayedCompositorFrameSink
+class LayerTreeHostContextTestCommitAfterDelayedLayerTreeFrameSink
: public LayerTreeHostContextTest {
public:
- LayerTreeHostContextTestCommitAfterDelayedCompositorFrameSink()
+ LayerTreeHostContextTestCommitAfterDelayedLayerTreeFrameSink()
: LayerTreeHostContextTest(), creating_output_(false) {}
void InitializeSettings(LayerTreeSettings* settings) override {
@@ -541,18 +541,18 @@
settings->use_zero_copy = true;
}
- void RequestNewCompositorFrameSink() override {
+ void RequestNewLayerTreeFrameSink() override {
MainThreadTaskRunner()->PostTask(
FROM_HERE,
base::BindOnce(
- &LayerTreeHostContextTestCommitAfterDelayedCompositorFrameSink::
- CreateAndSetCompositorFrameSink,
+ &LayerTreeHostContextTestCommitAfterDelayedLayerTreeFrameSink::
+ CreateAndSetLayerTreeFrameSink,
base::Unretained(this)));
}
- void CreateAndSetCompositorFrameSink() {
+ void CreateAndSetLayerTreeFrameSink() {
creating_output_ = true;
- LayerTreeHostContextTest::RequestNewCompositorFrameSink();
+ LayerTreeHostContextTest::RequestNewLayerTreeFrameSink();
}
void BeginTest() override {
@@ -571,7 +571,7 @@
// This test uses Composite() which only exists for single thread.
SINGLE_THREAD_TEST_F(
- LayerTreeHostContextTestCommitAfterDelayedCompositorFrameSink);
+ LayerTreeHostContextTestCommitAfterDelayedLayerTreeFrameSink);
class LayerTreeHostContextTestAvoidUnnecessaryComposite
: public LayerTreeHostContextTest {
@@ -584,8 +584,8 @@
settings->use_zero_copy = true;
}
- void RequestNewCompositorFrameSink() override {
- LayerTreeHostContextTest::RequestNewCompositorFrameSink();
+ void RequestNewLayerTreeFrameSink() override {
+ LayerTreeHostContextTest::RequestNewLayerTreeFrameSink();
EndTest();
}
@@ -656,17 +656,17 @@
SINGLE_AND_MULTI_THREAD_TEST_F(
LayerTreeHostContextTestLostContextSucceedsWithContent);
-class LayerTreeHostContextTestCreateCompositorFrameSinkFailsOnce
+class LayerTreeHostContextTestCreateLayerTreeFrameSinkFailsOnce
: public LayerTreeHostContextTest {
public:
- LayerTreeHostContextTestCreateCompositorFrameSinkFailsOnce()
+ LayerTreeHostContextTestCreateLayerTreeFrameSinkFailsOnce()
: times_to_fail_(1), times_initialized_(0) {
times_to_fail_create_ = times_to_fail_;
}
void BeginTest() override { PostSetNeedsCommitToMainThread(); }
- void DidInitializeCompositorFrameSink() override { times_initialized_++; }
+ void DidInitializeLayerTreeFrameSink() override { times_initialized_++; }
void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override { EndTest(); }
@@ -681,7 +681,7 @@
};
SINGLE_AND_MULTI_THREAD_TEST_F(
- LayerTreeHostContextTestCreateCompositorFrameSinkFailsOnce);
+ LayerTreeHostContextTestCreateLayerTreeFrameSinkFailsOnce);
class LayerTreeHostContextTestLostContextAndEvictTextures
: public LayerTreeHostContextTest {
@@ -761,7 +761,7 @@
EndTest();
}
- void DidInitializeCompositorFrameSink() override {}
+ void DidInitializeLayerTreeFrameSink() override {}
void AfterTest() override {}
@@ -1005,14 +1005,14 @@
return draw_result;
}
- void RequestNewCompositorFrameSink() override {
+ void RequestNewLayerTreeFrameSink() override {
// This will get called twice:
- // First when we create the initial CompositorFrameSink...
+ // First when we create the initial LayerTreeFrameSink...
if (layer_tree_host()->SourceFrameNumber() > 0) {
// ... and then again after we forced the context to be lost.
lost_context_ = true;
}
- LayerTreeHostContextTest::RequestNewCompositorFrameSink();
+ LayerTreeHostContextTest::RequestNewLayerTreeFrameSink();
}
void DidCommitAndDrawFrame() override {
@@ -1079,7 +1079,7 @@
void AfterTest() override {}
- void DidInitializeCompositorFrameSink() override { EndTest(); }
+ void DidInitializeLayerTreeFrameSink() override { EndTest(); }
private:
FakeContentLayerClient client_;
@@ -1576,11 +1576,11 @@
// After the first frame, we will lose the context and then not start
// allowing commits until that happens. The 2nd frame should not happen
- // before DidInitializeCompositorFrameSink occurs.
+ // before DidInitializeLayerTreeFrameSink occurs.
lost_ = true;
}
- void DidInitializeCompositorFrameSink() override {
+ void DidInitializeLayerTreeFrameSink() override {
EXPECT_TRUE(lost_);
lost_ = false;
}
@@ -1627,7 +1627,7 @@
void WillPrepareTilesOnThread(LayerTreeHostImpl* host_impl) override {
ContextProvider::ScopedContextLock scoped_context(
- host_impl->compositor_frame_sink()->worker_context_provider());
+ host_impl->layer_tree_frame_sink()->worker_context_provider());
gpu::gles2::GLES2Interface* gl = scoped_context.ContextGL();
gl->LoseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
GL_INNOCENT_CONTEXT_RESET_ARB);
diff --git a/cc/trees/layer_tree_host_unittest_copyrequest.cc b/cc/trees/layer_tree_host_unittest_copyrequest.cc
index e468e60..02ab684 100644
--- a/cc/trees/layer_tree_host_unittest_copyrequest.cc
+++ b/cc/trees/layer_tree_host_unittest_copyrequest.cc
@@ -17,7 +17,7 @@
#include "cc/test/fake_output_surface.h"
#include "cc/test/fake_picture_layer.h"
#include "cc/test/layer_tree_test.h"
-#include "cc/test/test_compositor_frame_sink.h"
+#include "cc/test/test_layer_tree_frame_sink.h"
#include "cc/trees/layer_tree_impl.h"
#include "gpu/GLES2/gl2extchromium.h"
@@ -464,12 +464,12 @@
client_.set_bounds(root_->bounds());
}
- std::unique_ptr<TestCompositorFrameSink> CreateCompositorFrameSink(
+ std::unique_ptr<TestLayerTreeFrameSink> CreateLayerTreeFrameSink(
const RendererSettings& renderer_settings,
double refresh_rate,
scoped_refptr<ContextProvider> compositor_context_provider,
scoped_refptr<ContextProvider> worker_context_provider) override {
- auto frame_sink = LayerTreeHostCopyRequestTest::CreateCompositorFrameSink(
+ auto frame_sink = LayerTreeHostCopyRequestTest::CreateLayerTreeFrameSink(
renderer_settings, refresh_rate, std::move(compositor_context_provider),
std::move(worker_context_provider));
frame_sink_ = frame_sink.get();
@@ -536,7 +536,7 @@
RenderPassId parent_render_pass_id = 0;
RenderPassId copy_layer_render_pass_id = 0;
- TestCompositorFrameSink* frame_sink_ = nullptr;
+ TestLayerTreeFrameSink* frame_sink_ = nullptr;
bool did_swap_ = false;
FakeContentLayerClient client_;
scoped_refptr<FakePictureLayer> root_;
@@ -869,7 +869,7 @@
// These tests expect the LayerTreeHostImpl to share a context with
// the Display so that sync points are not needed and the texture counts
// are visible together.
- // Since this test does not override CreateCompositorFrameSink, the
+ // Since this test does not override CreateLayerTreeFrameSink, the
// |compositor_context_provider| will be a TestContextProvider.
display_context_provider_ =
static_cast<TestContextProvider*>(compositor_context_provider.get());
diff --git a/cc/trees/layer_tree_impl.cc b/cc/trees/layer_tree_impl.cc
index 9b361177..84ca462 100644
--- a/cc/trees/layer_tree_impl.cc
+++ b/cc/trees/layer_tree_impl.cc
@@ -30,7 +30,7 @@
#include "cc/layers/layer_list_iterator.h"
#include "cc/layers/render_surface_impl.h"
#include "cc/layers/scrollbar_layer_impl_base.h"
-#include "cc/output/compositor_frame_sink.h"
+#include "cc/output/layer_tree_frame_sink.h"
#include "cc/resources/ui_resource_request.h"
#include "cc/trees/clip_node.h"
#include "cc/trees/draw_property_utils.h"
@@ -1020,7 +1020,7 @@
// For max_texture_size. When a new output surface is received the needs
// update draw properties flag is set again.
- if (!layer_tree_host_impl_->compositor_frame_sink())
+ if (!layer_tree_host_impl_->layer_tree_frame_sink())
return false;
// Clear this after the renderer early out, as it should still be
@@ -1345,7 +1345,7 @@
}
ContextProvider* LayerTreeImpl::context_provider() const {
- return layer_tree_host_impl_->compositor_frame_sink()->context_provider();
+ return layer_tree_host_impl_->layer_tree_frame_sink()->context_provider();
}
ResourceProvider* LayerTreeImpl::resource_provider() const {
diff --git a/cc/trees/proxy.h b/cc/trees/proxy.h
index 020b94d..5e06000 100644
--- a/cc/trees/proxy.h
+++ b/cc/trees/proxy.h
@@ -23,8 +23,8 @@
}
namespace cc {
+class LayerTreeFrameSink;
class LayerTreeMutator;
-class CompositorFrameSink;
// Abstract interface responsible for proxying commands from the main-thread
// side of the compositor over to the compositor implementation.
@@ -35,12 +35,9 @@
virtual bool IsStarted() const = 0;
virtual bool CommitToActiveTree() const = 0;
- // Will call LayerTreeHost::OnCreateAndInitializeCompositorFrameSinkAttempted
- // with the result of this function.
- virtual void SetCompositorFrameSink(
- CompositorFrameSink* compositor_frame_sink) = 0;
-
- virtual void ReleaseCompositorFrameSink() = 0;
+ virtual void SetLayerTreeFrameSink(
+ LayerTreeFrameSink* layer_tree_frame_sink) = 0;
+ virtual void ReleaseLayerTreeFrameSink() = 0;
virtual void SetVisible(bool visible) = 0;
diff --git a/cc/trees/proxy_impl.cc b/cc/trees/proxy_impl.cc
index 4b2dba0..2a7e31a 100644
--- a/cc/trees/proxy_impl.cc
+++ b/cc/trees/proxy_impl.cc
@@ -19,8 +19,8 @@
#include "cc/base/devtools_instrumentation.h"
#include "cc/benchmarks/benchmark_instrumentation.h"
#include "cc/input/browser_controls_offset_manager.h"
-#include "cc/output/compositor_frame_sink.h"
#include "cc/output/context_provider.h"
+#include "cc/output/layer_tree_frame_sink.h"
#include "cc/scheduler/compositor_timing_history.h"
#include "cc/scheduler/delay_based_time_source.h"
#include "cc/trees/layer_tree_host.h"
@@ -98,9 +98,9 @@
// Prevent the scheduler from performing actions while we're in an
// inconsistent state.
scheduler_->Stop();
- // Take away the CompositorFrameSink before destroying things so it doesn't
+ // Take away the LayerTreeFrameSink before destroying things so it doesn't
// try to call into its client mid-shutdown.
- layer_tree_host_impl_->ReleaseCompositorFrameSink();
+ layer_tree_host_impl_->ReleaseLayerTreeFrameSink();
scheduler_ = nullptr;
layer_tree_host_impl_ = nullptr;
// We need to explicitly shutdown the notifier to destroy any weakptrs it is
@@ -125,21 +125,21 @@
constraints, current, animate);
}
-void ProxyImpl::InitializeCompositorFrameSinkOnImpl(
- CompositorFrameSink* compositor_frame_sink,
+void ProxyImpl::InitializeLayerTreeFrameSinkOnImpl(
+ LayerTreeFrameSink* layer_tree_frame_sink,
base::WeakPtr<ProxyMain> proxy_main_frame_sink_bound_weak_ptr) {
- TRACE_EVENT0("cc", "ProxyImpl::InitializeCompositorFrameSinkOnImplThread");
+ TRACE_EVENT0("cc", "ProxyImpl::InitializeLayerTreeFrameSinkOnImplThread");
DCHECK(IsImplThread());
proxy_main_frame_sink_bound_weak_ptr_ = proxy_main_frame_sink_bound_weak_ptr;
LayerTreeHostImpl* host_impl = layer_tree_host_impl_.get();
- bool success = host_impl->InitializeRenderer(compositor_frame_sink);
+ bool success = host_impl->InitializeRenderer(layer_tree_frame_sink);
MainThreadTaskRunner()->PostTask(
- FROM_HERE, base::BindOnce(&ProxyMain::DidInitializeCompositorFrameSink,
+ FROM_HERE, base::BindOnce(&ProxyMain::DidInitializeLayerTreeFrameSink,
proxy_main_weak_ptr_, success));
if (success)
- scheduler_->DidCreateAndInitializeCompositorFrameSink();
+ scheduler_->DidCreateAndInitializeLayerTreeFrameSink();
}
void ProxyImpl::MainThreadHasStoppedFlingingOnImpl() {
@@ -196,22 +196,22 @@
scheduler_->SetVisible(visible);
}
-void ProxyImpl::ReleaseCompositorFrameSinkOnImpl(CompletionEvent* completion) {
+void ProxyImpl::ReleaseLayerTreeFrameSinkOnImpl(CompletionEvent* completion) {
DCHECK(IsImplThread());
- // Unlike DidLoseCompositorFrameSinkOnImplThread, we don't need to call
- // LayerTreeHost::DidLoseCompositorFrameSink since it already knows.
- scheduler_->DidLoseCompositorFrameSink();
- layer_tree_host_impl_->ReleaseCompositorFrameSink();
+ // Unlike DidLoseLayerTreeFrameSinkOnImplThread, we don't need to call
+ // LayerTreeHost::DidLoseLayerTreeFrameSink since it already knows.
+ scheduler_->DidLoseLayerTreeFrameSink();
+ layer_tree_host_impl_->ReleaseLayerTreeFrameSink();
completion->Signal();
}
void ProxyImpl::FinishGLOnImpl(CompletionEvent* completion) {
TRACE_EVENT0("cc", "ProxyImpl::FinishGLOnImplThread");
DCHECK(IsImplThread());
- if (layer_tree_host_impl_->compositor_frame_sink()) {
+ if (layer_tree_host_impl_->layer_tree_frame_sink()) {
ContextProvider* context_provider =
- layer_tree_host_impl_->compositor_frame_sink()->context_provider();
+ layer_tree_host_impl_->layer_tree_frame_sink()->context_provider();
if (context_provider)
context_provider->ContextGL()->Finish();
}
@@ -222,7 +222,7 @@
CompletionEvent* completion,
bool* main_frame_will_happen) {
DCHECK(IsImplThread());
- if (layer_tree_host_impl_->compositor_frame_sink()) {
+ if (layer_tree_host_impl_->layer_tree_frame_sink()) {
*main_frame_will_happen = scheduler_->MainFrameForTestingWillHappen();
} else {
*main_frame_will_happen = false;
@@ -299,17 +299,17 @@
scheduler_->NotifyReadyToCommit();
}
-void ProxyImpl::DidLoseCompositorFrameSinkOnImplThread() {
- TRACE_EVENT0("cc", "ProxyImpl::DidLoseCompositorFrameSinkOnImplThread");
+void ProxyImpl::DidLoseLayerTreeFrameSinkOnImplThread() {
+ TRACE_EVENT0("cc", "ProxyImpl::DidLoseLayerTreeFrameSinkOnImplThread");
DCHECK(IsImplThread());
MainThreadTaskRunner()->PostTask(
- FROM_HERE, base::BindOnce(&ProxyMain::DidLoseCompositorFrameSink,
+ FROM_HERE, base::BindOnce(&ProxyMain::DidLoseLayerTreeFrameSink,
proxy_main_weak_ptr_));
- scheduler_->DidLoseCompositorFrameSink();
+ scheduler_->DidLoseLayerTreeFrameSink();
}
void ProxyImpl::SetBeginFrameSource(BeginFrameSource* source) {
- // During shutdown, destroying the CompositorFrameSink may unset the
+ // During shutdown, destroying the LayerTreeFrameSink may unset the
// BeginFrameSource.
if (scheduler_) {
// TODO(enne): this overrides any preexisting begin frame source. Those
@@ -471,9 +471,9 @@
proxy_main_weak_ptr_));
}
-void ProxyImpl::OnDrawForCompositorFrameSink(bool resourceless_software_draw) {
+void ProxyImpl::OnDrawForLayerTreeFrameSink(bool resourceless_software_draw) {
DCHECK(IsImplThread());
- scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
+ scheduler_->OnDrawForLayerTreeFrameSink(resourceless_software_draw);
}
void ProxyImpl::NeedsImplSideInvalidation() {
@@ -595,12 +595,12 @@
layer_tree_host_impl_->ActivateSyncTree();
}
-void ProxyImpl::ScheduledActionBeginCompositorFrameSinkCreation() {
+void ProxyImpl::ScheduledActionBeginLayerTreeFrameSinkCreation() {
TRACE_EVENT0("cc",
- "ProxyImpl::ScheduledActionBeginCompositorFrameSinkCreation");
+ "ProxyImpl::ScheduledActionBeginLayerTreeFrameSinkCreation");
DCHECK(IsImplThread());
MainThreadTaskRunner()->PostTask(
- FROM_HERE, base::BindOnce(&ProxyMain::RequestNewCompositorFrameSink,
+ FROM_HERE, base::BindOnce(&ProxyMain::RequestNewLayerTreeFrameSink,
proxy_main_weak_ptr_));
}
@@ -610,11 +610,11 @@
layer_tree_host_impl_->PrepareTiles();
}
-void ProxyImpl::ScheduledActionInvalidateCompositorFrameSink() {
- TRACE_EVENT0("cc", "ProxyImpl::ScheduledActionInvalidateCompositorFrameSink");
+void ProxyImpl::ScheduledActionInvalidateLayerTreeFrameSink() {
+ TRACE_EVENT0("cc", "ProxyImpl::ScheduledActionInvalidateLayerTreeFrameSink");
DCHECK(IsImplThread());
- DCHECK(layer_tree_host_impl_->compositor_frame_sink());
- layer_tree_host_impl_->compositor_frame_sink()->Invalidate();
+ DCHECK(layer_tree_host_impl_->layer_tree_frame_sink());
+ layer_tree_host_impl_->layer_tree_frame_sink()->Invalidate();
}
void ProxyImpl::ScheduledActionPerformImplSideInvalidation() {
@@ -677,7 +677,7 @@
if (draw_frame) {
if (layer_tree_host_impl_->DrawLayers(&frame))
- // Drawing implies we submitted a frame to the CompositorFrameSink.
+ // Drawing implies we submitted a frame to the LayerTreeFrameSink.
scheduler_->DidSubmitCompositorFrame();
result = DRAW_SUCCESS;
} else {
diff --git a/cc/trees/proxy_impl.h b/cc/trees/proxy_impl.h
index fd29646..c98285be 100644
--- a/cc/trees/proxy_impl.h
+++ b/cc/trees/proxy_impl.h
@@ -33,8 +33,8 @@
void UpdateBrowserControlsStateOnImpl(BrowserControlsState constraints,
BrowserControlsState current,
bool animate);
- void InitializeCompositorFrameSinkOnImpl(
- CompositorFrameSink* compositor_frame_sink,
+ void InitializeLayerTreeFrameSinkOnImpl(
+ LayerTreeFrameSink* layer_tree_frame_sink,
base::WeakPtr<ProxyMain> proxy_main_frame_sink_bound_weak_ptr);
void InitializeMutatorOnImpl(std::unique_ptr<LayerTreeMutator> mutator);
void MainThreadHasStoppedFlingingOnImpl();
@@ -47,7 +47,7 @@
base::TimeTicks main_thread_start_time,
std::vector<std::unique_ptr<SwapPromise>> swap_promises);
void SetVisibleOnImpl(bool visible);
- void ReleaseCompositorFrameSinkOnImpl(CompletionEvent* completion);
+ void ReleaseLayerTreeFrameSinkOnImpl(CompletionEvent* completion);
void FinishGLOnImpl(CompletionEvent* completion);
void NotifyReadyToCommitOnImpl(CompletionEvent* completion,
LayerTreeHost* layer_tree_host,
@@ -71,7 +71,7 @@
};
// LayerTreeHostImplClient implementation
- void DidLoseCompositorFrameSinkOnImplThread() override;
+ void DidLoseLayerTreeFrameSinkOnImplThread() override;
void SetBeginFrameSource(BeginFrameSource* source) override;
void DidReceiveCompositorFrameAckOnImplThread() override;
void OnCanDrawStateChanged(bool can_draw) override;
@@ -94,7 +94,7 @@
void WillPrepareTiles() override;
void DidPrepareTiles() override;
void DidCompletePageScaleAnimationOnImplThread() override;
- void OnDrawForCompositorFrameSink(bool resourceless_software_draw) override;
+ void OnDrawForLayerTreeFrameSink(bool resourceless_software_draw) override;
void NeedsImplSideInvalidation() override;
void NotifyImageDecodeRequestFinished() override;
@@ -107,9 +107,9 @@
DrawResult ScheduledActionDrawForced() override;
void ScheduledActionCommit() override;
void ScheduledActionActivateSyncTree() override;
- void ScheduledActionBeginCompositorFrameSinkCreation() override;
+ void ScheduledActionBeginLayerTreeFrameSinkCreation() override;
void ScheduledActionPrepareTiles() override;
- void ScheduledActionInvalidateCompositorFrameSink() override;
+ void ScheduledActionInvalidateLayerTreeFrameSink() override;
void ScheduledActionPerformImplSideInvalidation() override;
void SendBeginMainFrameNotExpectedSoon() override;
void ScheduledActionBeginMainFrameNotExpectedUntil(
@@ -156,7 +156,7 @@
// Used to post tasks to ProxyMain on the main thread.
base::WeakPtr<ProxyMain> proxy_main_weak_ptr_;
- // A weak pointer to ProxyMain that is invalidated when CompositorFrameSink is
+ // A weak pointer to ProxyMain that is invalidated when LayerTreeFrameSink is
// released.
base::WeakPtr<ProxyMain> proxy_main_frame_sink_bound_weak_ptr_;
diff --git a/cc/trees/proxy_main.cc b/cc/trees/proxy_main.cc
index 96058fa..7549d9d 100644
--- a/cc/trees/proxy_main.cc
+++ b/cc/trees/proxy_main.cc
@@ -14,7 +14,7 @@
#include "cc/base/completion_event.h"
#include "cc/base/devtools_instrumentation.h"
#include "cc/benchmarks/benchmark_instrumentation.h"
-#include "cc/output/compositor_frame_sink.h"
+#include "cc/output/layer_tree_frame_sink.h"
#include "cc/output/swap_promise.h"
#include "cc/resources/ui_resource_manager.h"
#include "cc/trees/blocking_task_runner.h"
@@ -92,26 +92,26 @@
layer_tree_host_->SetAnimationEvents(std::move(events));
}
-void ProxyMain::DidLoseCompositorFrameSink() {
- TRACE_EVENT0("cc", "ProxyMain::DidLoseCompositorFrameSink");
+void ProxyMain::DidLoseLayerTreeFrameSink() {
+ TRACE_EVENT0("cc", "ProxyMain::DidLoseLayerTreeFrameSink");
DCHECK(IsMainThread());
- layer_tree_host_->DidLoseCompositorFrameSink();
+ layer_tree_host_->DidLoseLayerTreeFrameSink();
}
-void ProxyMain::RequestNewCompositorFrameSink() {
- TRACE_EVENT0("cc", "ProxyMain::RequestNewCompositorFrameSink");
+void ProxyMain::RequestNewLayerTreeFrameSink() {
+ TRACE_EVENT0("cc", "ProxyMain::RequestNewLayerTreeFrameSink");
DCHECK(IsMainThread());
- layer_tree_host_->RequestNewCompositorFrameSink();
+ layer_tree_host_->RequestNewLayerTreeFrameSink();
}
-void ProxyMain::DidInitializeCompositorFrameSink(bool success) {
- TRACE_EVENT0("cc", "ProxyMain::DidInitializeCompositorFrameSink");
+void ProxyMain::DidInitializeLayerTreeFrameSink(bool success) {
+ TRACE_EVENT0("cc", "ProxyMain::DidInitializeLayerTreeFrameSink");
DCHECK(IsMainThread());
if (!success)
- layer_tree_host_->DidFailToInitializeCompositorFrameSink();
+ layer_tree_host_->DidFailToInitializeLayerTreeFrameSink();
else
- layer_tree_host_->DidInitializeCompositorFrameSink();
+ layer_tree_host_->DidInitializeLayerTreeFrameSink();
}
void ProxyMain::DidCompletePageScaleAnimation() {
@@ -292,12 +292,12 @@
return false;
}
-void ProxyMain::SetCompositorFrameSink(
- CompositorFrameSink* compositor_frame_sink) {
+void ProxyMain::SetLayerTreeFrameSink(
+ LayerTreeFrameSink* layer_tree_frame_sink) {
ImplThreadTaskRunner()->PostTask(
FROM_HERE,
- base::BindOnce(&ProxyImpl::InitializeCompositorFrameSinkOnImpl,
- base::Unretained(proxy_impl_.get()), compositor_frame_sink,
+ base::BindOnce(&ProxyImpl::InitializeLayerTreeFrameSinkOnImpl,
+ base::Unretained(proxy_impl_.get()), layer_tree_frame_sink,
frame_sink_bound_weak_factory_.GetWeakPtr()));
}
@@ -475,14 +475,14 @@
return main_frame_will_happen;
}
-void ProxyMain::ReleaseCompositorFrameSink() {
+void ProxyMain::ReleaseLayerTreeFrameSink() {
DCHECK(IsMainThread());
frame_sink_bound_weak_factory_.InvalidateWeakPtrs();
DebugScopedSetMainThreadBlocked main_thread_blocked(task_runner_provider_);
CompletionEvent completion;
ImplThreadTaskRunner()->PostTask(
FROM_HERE,
- base::BindOnce(&ProxyImpl::ReleaseCompositorFrameSinkOnImpl,
+ base::BindOnce(&ProxyImpl::ReleaseLayerTreeFrameSinkOnImpl,
base::Unretained(proxy_impl_.get()), &completion));
completion.Wait();
}
diff --git a/cc/trees/proxy_main.h b/cc/trees/proxy_main.h
index 8ca53fa..5007bb29 100644
--- a/cc/trees/proxy_main.h
+++ b/cc/trees/proxy_main.h
@@ -15,7 +15,7 @@
class MutatorEvents;
class CompletionEvent;
-class CompositorFrameSink;
+class LayerTreeFrameSink;
class LayerTreeHost;
class LayerTreeMutator;
class ProxyImpl;
@@ -45,9 +45,9 @@
void BeginMainFrameNotExpectedUntil(base::TimeTicks time);
void DidCommitAndDrawFrame();
void SetAnimationEvents(std::unique_ptr<MutatorEvents> events);
- void DidLoseCompositorFrameSink();
- void RequestNewCompositorFrameSink();
- void DidInitializeCompositorFrameSink(bool success);
+ void DidLoseLayerTreeFrameSink();
+ void RequestNewLayerTreeFrameSink();
+ void DidInitializeLayerTreeFrameSink(bool success);
void DidCompletePageScaleAnimation();
void BeginMainFrame(
std::unique_ptr<BeginMainFrameAndCommitState> begin_main_frame_state);
@@ -66,8 +66,8 @@
// Proxy implementation.
bool IsStarted() const override;
bool CommitToActiveTree() const override;
- void SetCompositorFrameSink(
- CompositorFrameSink* compositor_frame_sink) override;
+ void SetLayerTreeFrameSink(
+ LayerTreeFrameSink* layer_tree_frame_sink) override;
void SetVisible(bool visible) override;
void SetNeedsAnimate() override;
void SetNeedsUpdateLayers() override;
@@ -83,7 +83,7 @@
bool SupportsImplScrolling() const override;
void SetMutator(std::unique_ptr<LayerTreeMutator> mutator) override;
bool MainFrameWillHappenForTesting() override;
- void ReleaseCompositorFrameSink() override;
+ void ReleaseLayerTreeFrameSink() override;
void UpdateBrowserControlsState(BrowserControlsState constraints,
BrowserControlsState current,
bool animate) override;
@@ -132,7 +132,7 @@
std::unique_ptr<ProxyImpl> proxy_impl_;
// WeakPtrs generated by this factory will be invalidated when
- // CompositorFrameSink is released.
+ // LayerTreeFrameSink is released.
base::WeakPtrFactory<ProxyMain> frame_sink_bound_weak_factory_;
base::WeakPtrFactory<ProxyMain> weak_factory_;
diff --git a/cc/trees/single_thread_proxy.cc b/cc/trees/single_thread_proxy.cc
index eb32486..887c412 100644
--- a/cc/trees/single_thread_proxy.cc
+++ b/cc/trees/single_thread_proxy.cc
@@ -10,8 +10,8 @@
#include "base/trace_event/trace_event.h"
#include "cc/base/devtools_instrumentation.h"
#include "cc/benchmarks/benchmark_instrumentation.h"
-#include "cc/output/compositor_frame_sink.h"
#include "cc/output/context_provider.h"
+#include "cc/output/layer_tree_frame_sink.h"
#include "cc/quads/draw_quad.h"
#include "cc/resources/ui_resource_manager.h"
#include "cc/scheduler/commit_earlyout_reason.h"
@@ -50,8 +50,8 @@
animate_requested_(false),
commit_requested_(false),
inside_synchronous_composite_(false),
- compositor_frame_sink_creation_requested_(false),
- compositor_frame_sink_lost_(true),
+ layer_tree_frame_sink_creation_requested_(false),
+ layer_tree_frame_sink_lost_(true),
frame_sink_bound_weak_factory_(this),
weak_factory_(this) {
TRACE_EVENT0("cc", "SingleThreadProxy::SingleThreadProxy");
@@ -113,49 +113,49 @@
scheduler_on_impl_thread_->SetVisible(layer_tree_host_impl_->visible());
}
-void SingleThreadProxy::RequestNewCompositorFrameSink() {
+void SingleThreadProxy::RequestNewLayerTreeFrameSink() {
DCHECK(task_runner_provider_->IsMainThread());
- compositor_frame_sink_creation_callback_.Cancel();
- if (compositor_frame_sink_creation_requested_)
+ layer_tree_frame_sink_creation_callback_.Cancel();
+ if (layer_tree_frame_sink_creation_requested_)
return;
- compositor_frame_sink_creation_requested_ = true;
- layer_tree_host_->RequestNewCompositorFrameSink();
+ layer_tree_frame_sink_creation_requested_ = true;
+ layer_tree_host_->RequestNewLayerTreeFrameSink();
}
-void SingleThreadProxy::ReleaseCompositorFrameSink() {
- compositor_frame_sink_lost_ = true;
+void SingleThreadProxy::ReleaseLayerTreeFrameSink() {
+ layer_tree_frame_sink_lost_ = true;
frame_sink_bound_weak_factory_.InvalidateWeakPtrs();
if (scheduler_on_impl_thread_)
- scheduler_on_impl_thread_->DidLoseCompositorFrameSink();
- return layer_tree_host_impl_->ReleaseCompositorFrameSink();
+ scheduler_on_impl_thread_->DidLoseLayerTreeFrameSink();
+ return layer_tree_host_impl_->ReleaseLayerTreeFrameSink();
}
-void SingleThreadProxy::SetCompositorFrameSink(
- CompositorFrameSink* compositor_frame_sink) {
+void SingleThreadProxy::SetLayerTreeFrameSink(
+ LayerTreeFrameSink* layer_tree_frame_sink) {
DCHECK(task_runner_provider_->IsMainThread());
- DCHECK(compositor_frame_sink_creation_requested_);
+ DCHECK(layer_tree_frame_sink_creation_requested_);
bool success;
{
DebugScopedSetMainThreadBlocked main_thread_blocked(task_runner_provider_);
DebugScopedSetImplThread impl(task_runner_provider_);
- success = layer_tree_host_impl_->InitializeRenderer(compositor_frame_sink);
+ success = layer_tree_host_impl_->InitializeRenderer(layer_tree_frame_sink);
}
if (success) {
frame_sink_bound_weak_ptr_ = frame_sink_bound_weak_factory_.GetWeakPtr();
- layer_tree_host_->DidInitializeCompositorFrameSink();
+ layer_tree_host_->DidInitializeLayerTreeFrameSink();
if (scheduler_on_impl_thread_)
- scheduler_on_impl_thread_->DidCreateAndInitializeCompositorFrameSink();
+ scheduler_on_impl_thread_->DidCreateAndInitializeLayerTreeFrameSink();
else if (!inside_synchronous_composite_)
SetNeedsCommit();
- compositor_frame_sink_creation_requested_ = false;
- compositor_frame_sink_lost_ = false;
+ layer_tree_frame_sink_creation_requested_ = false;
+ layer_tree_frame_sink_lost_ = false;
} else {
- // DidFailToInitializeCompositorFrameSink is treated as a
- // RequestNewCompositorFrameSink, and so
- // compositor_frame_sink_creation_requested remains true.
- layer_tree_host_->DidFailToInitializeCompositorFrameSink();
+ // DidFailToInitializeLayerTreeFrameSink is treated as a
+ // RequestNewLayerTreeFrameSink, and so
+ // layer_tree_frame_sink_creation_requested remains true.
+ layer_tree_host_->DidFailToInitializeLayerTreeFrameSink();
}
}
@@ -300,9 +300,9 @@
// inconsistent state.
if (scheduler_on_impl_thread_)
scheduler_on_impl_thread_->Stop();
- // Take away the CompositorFrameSink before destroying things so it doesn't
+ // Take away the LayerTreeFrameSink before destroying things so it doesn't
// try to call into its client mid-shutdown.
- layer_tree_host_impl_->ReleaseCompositorFrameSink();
+ layer_tree_host_impl_->ReleaseLayerTreeFrameSink();
scheduler_on_impl_thread_ = nullptr;
layer_tree_host_impl_ = nullptr;
}
@@ -407,19 +407,19 @@
layer_tree_host_->DidCompletePageScaleAnimation();
}
-void SingleThreadProxy::DidLoseCompositorFrameSinkOnImplThread() {
+void SingleThreadProxy::DidLoseLayerTreeFrameSinkOnImplThread() {
TRACE_EVENT0("cc",
- "SingleThreadProxy::DidLoseCompositorFrameSinkOnImplThread");
+ "SingleThreadProxy::DidLoseLayerTreeFrameSinkOnImplThread");
{
DebugScopedSetMainThread main(task_runner_provider_);
// This must happen before we notify the scheduler as it may try to recreate
// the output surface if already in BEGIN_IMPL_FRAME_STATE_IDLE.
- layer_tree_host_->DidLoseCompositorFrameSink();
+ layer_tree_host_->DidLoseLayerTreeFrameSink();
}
- single_thread_client_->DidLoseCompositorFrameSink();
+ single_thread_client_->DidLoseLayerTreeFrameSink();
if (scheduler_on_impl_thread_)
- scheduler_on_impl_thread_->DidLoseCompositorFrameSink();
- compositor_frame_sink_lost_ = true;
+ scheduler_on_impl_thread_->DidLoseLayerTreeFrameSink();
+ layer_tree_frame_sink_lost_ = true;
}
void SingleThreadProxy::SetBeginFrameSource(BeginFrameSource* source) {
@@ -440,7 +440,7 @@
frame_sink_bound_weak_ptr_));
}
-void SingleThreadProxy::OnDrawForCompositorFrameSink(
+void SingleThreadProxy::OnDrawForLayerTreeFrameSink(
bool resourceless_software_draw) {
NOTREACHED() << "Implemented by ThreadProxy for synchronous compositor.";
}
@@ -478,11 +478,11 @@
#endif
base::AutoReset<bool> inside_composite(&inside_synchronous_composite_, true);
- if (compositor_frame_sink_lost_) {
- RequestNewCompositorFrameSink();
- // RequestNewCompositorFrameSink could have synchronously created an output
+ if (layer_tree_frame_sink_lost_) {
+ RequestNewLayerTreeFrameSink();
+ // RequestNewLayerTreeFrameSink could have synchronously created an output
// surface, so check again before returning.
- if (compositor_frame_sink_lost_)
+ if (layer_tree_frame_sink_lost_)
return;
}
@@ -548,14 +548,14 @@
return layer_tree_host_impl_->visible() && layer_tree_host_impl_->CanDraw();
}
-void SingleThreadProxy::ScheduleRequestNewCompositorFrameSink() {
- if (compositor_frame_sink_creation_callback_.IsCancelled() &&
- !compositor_frame_sink_creation_requested_) {
- compositor_frame_sink_creation_callback_.Reset(
- base::Bind(&SingleThreadProxy::RequestNewCompositorFrameSink,
+void SingleThreadProxy::ScheduleRequestNewLayerTreeFrameSink() {
+ if (layer_tree_frame_sink_creation_callback_.IsCancelled() &&
+ !layer_tree_frame_sink_creation_requested_) {
+ layer_tree_frame_sink_creation_callback_.Reset(
+ base::Bind(&SingleThreadProxy::RequestNewLayerTreeFrameSink,
weak_factory_.GetWeakPtr()));
task_runner_provider_->MainThreadTaskRunner()->PostTask(
- FROM_HERE, compositor_frame_sink_creation_callback_.callback());
+ FROM_HERE, layer_tree_frame_sink_creation_callback_.callback());
}
}
@@ -592,7 +592,7 @@
if (draw_frame) {
if (layer_tree_host_impl_->DrawLayers(frame)) {
if (scheduler_on_impl_thread_)
- // Drawing implies we submitted a frame to the CompositorFrameSink.
+ // Drawing implies we submitted a frame to the LayerTreeFrameSink.
scheduler_on_impl_thread_->DidSubmitCompositorFrame();
single_thread_client_->DidSubmitCompositorFrame();
}
@@ -775,7 +775,7 @@
layer_tree_host_impl_->ActivateSyncTree();
}
-void SingleThreadProxy::ScheduledActionBeginCompositorFrameSinkCreation() {
+void SingleThreadProxy::ScheduledActionBeginLayerTreeFrameSinkCreation() {
DebugScopedSetMainThread main(task_runner_provider_);
DCHECK(scheduler_on_impl_thread_);
// If possible, create the output surface in a post task. Synchronously
@@ -783,9 +783,9 @@
// from the ThreadProxy behavior. However, sometimes there is no
// task runner.
if (task_runner_provider_->MainThreadTaskRunner()) {
- ScheduleRequestNewCompositorFrameSink();
+ ScheduleRequestNewLayerTreeFrameSink();
} else {
- RequestNewCompositorFrameSink();
+ RequestNewLayerTreeFrameSink();
}
}
@@ -795,7 +795,7 @@
layer_tree_host_impl_->PrepareTiles();
}
-void SingleThreadProxy::ScheduledActionInvalidateCompositorFrameSink() {
+void SingleThreadProxy::ScheduledActionInvalidateLayerTreeFrameSink() {
NOTREACHED();
}
diff --git a/cc/trees/single_thread_proxy.h b/cc/trees/single_thread_proxy.h
index d5eca88a..6bbe3cf 100644
--- a/cc/trees/single_thread_proxy.h
+++ b/cc/trees/single_thread_proxy.h
@@ -37,9 +37,9 @@
// Proxy implementation
bool IsStarted() const override;
bool CommitToActiveTree() const override;
- void SetCompositorFrameSink(
- CompositorFrameSink* compositor_frame_sink) override;
- void ReleaseCompositorFrameSink() override;
+ void SetLayerTreeFrameSink(
+ LayerTreeFrameSink* layer_tree_frame_sink) override;
+ void ReleaseLayerTreeFrameSink() override;
void SetVisible(bool visible) override;
void SetNeedsAnimate() override;
void SetNeedsUpdateLayers() override;
@@ -68,16 +68,16 @@
DrawResult ScheduledActionDrawForced() override;
void ScheduledActionCommit() override;
void ScheduledActionActivateSyncTree() override;
- void ScheduledActionBeginCompositorFrameSinkCreation() override;
+ void ScheduledActionBeginLayerTreeFrameSinkCreation() override;
void ScheduledActionPrepareTiles() override;
- void ScheduledActionInvalidateCompositorFrameSink() override;
+ void ScheduledActionInvalidateLayerTreeFrameSink() override;
void ScheduledActionPerformImplSideInvalidation() override;
void SendBeginMainFrameNotExpectedSoon() override;
void ScheduledActionBeginMainFrameNotExpectedUntil(
base::TimeTicks time) override;
// LayerTreeHostImplClient implementation
- void DidLoseCompositorFrameSinkOnImplThread() override;
+ void DidLoseLayerTreeFrameSinkOnImplThread() override;
void SetBeginFrameSource(BeginFrameSource* source) override;
void DidReceiveCompositorFrameAckOnImplThread() override;
void OnCanDrawStateChanged(bool can_draw) override;
@@ -98,12 +98,12 @@
void WillPrepareTiles() override;
void DidPrepareTiles() override;
void DidCompletePageScaleAnimationOnImplThread() override;
- void OnDrawForCompositorFrameSink(bool resourceless_software_draw) override;
+ void OnDrawForLayerTreeFrameSink(bool resourceless_software_draw) override;
void NeedsImplSideInvalidation() override;
void RequestBeginMainFrameNotExpected(bool new_state) override;
void NotifyImageDecodeRequestFinished() override;
- void RequestNewCompositorFrameSink();
+ void RequestNewLayerTreeFrameSink();
// Called by the legacy path where RenderWidget does the scheduling.
void CompositeImmediately(base::TimeTicks frame_begin_time);
@@ -125,7 +125,7 @@
void CommitComplete();
bool ShouldComposite() const;
- void ScheduleRequestNewCompositorFrameSink();
+ void ScheduleRequestNewLayerTreeFrameSink();
void IssueImageDecodeFinishedCallbacks();
void DidReceiveCompositorFrameAck();
@@ -158,18 +158,18 @@
// True if a request to the LayerTreeHostClient to create an output surface
// is still outstanding.
- bool compositor_frame_sink_creation_requested_;
+ bool layer_tree_frame_sink_creation_requested_;
// When output surface is lost, is set to true until a new output surface is
// initialized.
- bool compositor_frame_sink_lost_;
+ bool layer_tree_frame_sink_lost_;
- // This is the callback for the scheduled RequestNewCompositorFrameSink.
- base::CancelableClosure compositor_frame_sink_creation_callback_;
+ // This is the callback for the scheduled RequestNewLayerTreeFrameSink.
+ base::CancelableClosure layer_tree_frame_sink_creation_callback_;
base::WeakPtr<SingleThreadProxy> frame_sink_bound_weak_ptr_;
// WeakPtrs generated by this factory will be invalidated when
- // CompositorFrameSink is released.
+ // LayerTreeFrameSink is released.
base::WeakPtrFactory<SingleThreadProxy> frame_sink_bound_weak_factory_;
base::WeakPtrFactory<SingleThreadProxy> weak_factory_;
diff --git a/components/exo/BUILD.gn b/components/exo/BUILD.gn
index 1829941..3981a9a 100644
--- a/components/exo/BUILD.gn
+++ b/components/exo/BUILD.gn
@@ -10,8 +10,6 @@
sources = [
"buffer.cc",
"buffer.h",
- "compositor_frame_sink_holder.cc",
- "compositor_frame_sink_holder.h",
"display.cc",
"display.h",
"gaming_seat.h",
@@ -19,6 +17,8 @@
"keyboard.h",
"keyboard_delegate.h",
"keyboard_device_configuration_delegate.h",
+ "layer_tree_frame_sink_holder.cc",
+ "layer_tree_frame_sink_holder.h",
"notification_surface.cc",
"notification_surface.h",
"notification_surface_manager.h",
diff --git a/components/exo/buffer.cc b/components/exo/buffer.cc
index 94dd9d1..56bdd0ee 100644
--- a/components/exo/buffer.cc
+++ b/components/exo/buffer.cc
@@ -24,7 +24,7 @@
#include "cc/output/context_provider.h"
#include "cc/resources/single_release_callback.h"
#include "cc/resources/texture_mailbox.h"
-#include "components/exo/compositor_frame_sink_holder.h"
+#include "components/exo/layer_tree_frame_sink_holder.h"
#include "gpu/command_buffer/client/context_support.h"
#include "gpu/command_buffer/client/gles2_interface.h"
#include "ui/aura/env.h"
@@ -408,7 +408,7 @@
Buffer::~Buffer() {}
bool Buffer::ProduceTransferableResource(
- CompositorFrameSinkHolder* compositor_frame_sink_holder,
+ LayerTreeFrameSinkHolder* layer_tree_frame_sink_holder,
cc::ResourceId resource_id,
bool secure_output_only,
bool client_usage,
@@ -470,7 +470,7 @@
// The contents texture will be released when no longer used by the
// compositor.
- compositor_frame_sink_holder->SetResourceReleaseCallback(
+ layer_tree_frame_sink_holder->SetResourceReleaseCallback(
resource_id,
base::Bind(&Buffer::Texture::ReleaseTexImage,
base::Unretained(contents_texture),
@@ -500,7 +500,7 @@
// The mailbox texture will be released when no longer used by the
// compositor.
- compositor_frame_sink_holder->SetResourceReleaseCallback(
+ layer_tree_frame_sink_holder->SetResourceReleaseCallback(
resource_id,
base::Bind(&Buffer::Texture::Release, base::Unretained(texture),
base::Bind(&Buffer::ReleaseTexture, AsWeakPtr(),
diff --git a/components/exo/buffer.h b/components/exo/buffer.h
index 54097d3..890edf4 100644
--- a/components/exo/buffer.h
+++ b/components/exo/buffer.h
@@ -26,7 +26,7 @@
namespace exo {
-class CompositorFrameSinkHolder;
+class LayerTreeFrameSinkHolder;
// This class provides the content for a Surface. The mechanism by which a
// client provides and updates the contents is the responsibility of the client
@@ -53,7 +53,7 @@
// be called before a new texture mailbox can be acquired unless
// |non_client_usage| is true.
bool ProduceTransferableResource(
- CompositorFrameSinkHolder* compositor_frame_sink_holder,
+ LayerTreeFrameSinkHolder* layer_tree_frame_sink_holder,
cc::ResourceId resource_id,
bool secure_output_only,
bool client_usage,
diff --git a/components/exo/buffer_unittest.cc b/components/exo/buffer_unittest.cc
index 9fa7379..69e187af 100644
--- a/components/exo/buffer_unittest.cc
+++ b/components/exo/buffer_unittest.cc
@@ -33,8 +33,8 @@
new Buffer(exo_test_helper()->CreateGpuMemoryBuffer(buffer_size)));
std::unique_ptr<Surface> surface(new Surface);
const cc::FrameSinkId arbitrary_frame_sink_id(1, 1);
- CompositorFrameSinkHolder* compositor_frame_sink_holder =
- surface->compositor_frame_sink_holder();
+ LayerTreeFrameSinkHolder* layer_tree_frame_sink_holder =
+ surface->layer_tree_frame_sink_holder();
// Set the release callback.
int release_call_count = 0;
@@ -44,7 +44,7 @@
buffer->OnAttach();
cc::TransferableResource resource;
// Produce a transferable resource for the contents of the buffer.
- bool rv = buffer->ProduceTransferableResource(compositor_frame_sink_holder, 0,
+ bool rv = buffer->ProduceTransferableResource(layer_tree_frame_sink_holder, 0,
false, true, &resource);
ASSERT_TRUE(rv);
@@ -54,7 +54,7 @@
returned_resource.sync_token = resource.mailbox_holder.sync_token;
returned_resource.lost = false;
cc::ReturnedResourceArray resources = {returned_resource};
- compositor_frame_sink_holder->ReclaimResources(resources);
+ layer_tree_frame_sink_holder->ReclaimResources(resources);
RunAllPendingInMessageLoop();
ASSERT_EQ(release_call_count, 0);
@@ -71,15 +71,15 @@
new Buffer(exo_test_helper()->CreateGpuMemoryBuffer(buffer_size)));
const cc::FrameSinkId arbitrary_frame_sink_id(1, 1);
std::unique_ptr<Surface> surface(new Surface);
- CompositorFrameSinkHolder* compositor_frame_sink_holder =
- surface->compositor_frame_sink_holder();
+ LayerTreeFrameSinkHolder* layer_tree_frame_sink_holder =
+ surface->layer_tree_frame_sink_holder();
cc::ResourceId resource_id = 0;
buffer->OnAttach();
// Acquire a texture transferable resource for the contents of the buffer.
cc::TransferableResource resource;
bool rv = buffer->ProduceTransferableResource(
- compositor_frame_sink_holder, resource_id, false, true, &resource);
+ layer_tree_frame_sink_holder, resource_id, false, true, &resource);
ASSERT_TRUE(rv);
scoped_refptr<cc::ContextProvider> context_provider =
@@ -99,7 +99,7 @@
returned_resource.sync_token = gpu::SyncToken();
returned_resource.lost = is_lost;
cc::ReturnedResourceArray resources = {returned_resource};
- compositor_frame_sink_holder->ReclaimResources(resources);
+ layer_tree_frame_sink_holder->ReclaimResources(resources);
RunAllPendingInMessageLoop();
// Producing a new texture transferable resource for the contents of the
@@ -107,7 +107,7 @@
++resource_id;
cc::TransferableResource new_resource;
rv = buffer->ProduceTransferableResource(
- compositor_frame_sink_holder, resource_id, false, false, &new_resource);
+ layer_tree_frame_sink_holder, resource_id, false, false, &new_resource);
ASSERT_TRUE(rv);
buffer->OnDetach();
@@ -116,7 +116,7 @@
returned_resource2.sync_token = gpu::SyncToken();
returned_resource2.lost = false;
cc::ReturnedResourceArray resources2 = {returned_resource2};
- compositor_frame_sink_holder->ReclaimResources(resources2);
+ layer_tree_frame_sink_holder->ReclaimResources(resources2);
RunAllPendingInMessageLoop();
}
diff --git a/components/exo/compositor_frame_sink_holder.cc b/components/exo/layer_tree_frame_sink_holder.cc
similarity index 68%
rename from components/exo/compositor_frame_sink_holder.cc
rename to components/exo/layer_tree_frame_sink_holder.cc
index f63c358..a71950a 100644
--- a/components/exo/compositor_frame_sink_holder.cc
+++ b/components/exo/layer_tree_frame_sink_holder.cc
@@ -2,20 +2,20 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "components/exo/compositor_frame_sink_holder.h"
+#include "components/exo/layer_tree_frame_sink_holder.h"
-#include "cc/output/compositor_frame_sink.h"
+#include "cc/output/layer_tree_frame_sink.h"
#include "cc/resources/returned_resource.h"
#include "components/exo/surface.h"
namespace exo {
////////////////////////////////////////////////////////////////////////////////
-// CompositorFrameSinkHolder, public:
+// LayerTreeFrameSinkHolder, public:
-CompositorFrameSinkHolder::CompositorFrameSinkHolder(
+LayerTreeFrameSinkHolder::LayerTreeFrameSinkHolder(
Surface* surface,
- std::unique_ptr<cc::CompositorFrameSink> frame_sink)
+ std::unique_ptr<cc::LayerTreeFrameSink> frame_sink)
: surface_(surface),
frame_sink_(std::move(frame_sink)),
weak_factory_(this) {
@@ -23,22 +23,22 @@
frame_sink_->BindToClient(this);
}
-CompositorFrameSinkHolder::~CompositorFrameSinkHolder() {
+LayerTreeFrameSinkHolder::~LayerTreeFrameSinkHolder() {
frame_sink_->DetachFromClient();
if (surface_)
surface_->RemoveSurfaceObserver(this);
- // Release all resources which aren't returned from CompositorFrameSink.
+ // Release all resources which aren't returned from LayerTreeFrameSink.
for (auto& callback : release_callbacks_)
callback.second.Run(gpu::SyncToken(), false);
}
-bool CompositorFrameSinkHolder::HasReleaseCallbackForResource(
+bool LayerTreeFrameSinkHolder::HasReleaseCallbackForResource(
cc::ResourceId id) {
return release_callbacks_.find(id) != release_callbacks_.end();
}
-void CompositorFrameSinkHolder::SetResourceReleaseCallback(
+void LayerTreeFrameSinkHolder::SetResourceReleaseCallback(
cc::ResourceId id,
const cc::ReleaseCallback& callback) {
DCHECK(!callback.is_null());
@@ -46,15 +46,15 @@
}
////////////////////////////////////////////////////////////////////////////////
-// cc::CompositorFrameSinkClient overrides:
+// cc::LayerTreeFrameSinkClient overrides:
-void CompositorFrameSinkHolder::SetBeginFrameSource(
+void LayerTreeFrameSinkHolder::SetBeginFrameSource(
cc::BeginFrameSource* source) {
if (surface_)
surface_->SetBeginFrameSource(source);
}
-void CompositorFrameSinkHolder::ReclaimResources(
+void LayerTreeFrameSinkHolder::ReclaimResources(
const cc::ReturnedResourceArray& resources) {
for (auto& resource : resources) {
auto it = release_callbacks_.find(resource.id);
@@ -66,7 +66,7 @@
}
}
-void CompositorFrameSinkHolder::DidReceiveCompositorFrameAck() {
+void LayerTreeFrameSinkHolder::DidReceiveCompositorFrameAck() {
if (surface_)
surface_->DidReceiveCompositorFrameAck();
}
@@ -74,7 +74,7 @@
////////////////////////////////////////////////////////////////////////////////
// SurfaceObserver overrides:
-void CompositorFrameSinkHolder::OnSurfaceDestroying(Surface* surface) {
+void LayerTreeFrameSinkHolder::OnSurfaceDestroying(Surface* surface) {
surface_->RemoveSurfaceObserver(this);
surface_ = nullptr;
}
diff --git a/components/exo/compositor_frame_sink_holder.h b/components/exo/layer_tree_frame_sink_holder.h
similarity index 65%
rename from components/exo/compositor_frame_sink_holder.h
rename to components/exo/layer_tree_frame_sink_holder.h
index 5325561..f3e7f87c 100644
--- a/components/exo/compositor_frame_sink_holder.h
+++ b/components/exo/layer_tree_frame_sink_holder.h
@@ -2,18 +2,18 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef COMPONENTS_EXO_COMPOSITOR_FRAME_SINK_HOLDER_H_
-#define COMPONENTS_EXO_COMPOSITOR_FRAME_SINK_HOLDER_H_
+#ifndef COMPONENTS_EXO_LAYER_TREE_FRAME_SINK_HOLDER_H_
+#define COMPONENTS_EXO_LAYER_TREE_FRAME_SINK_HOLDER_H_
#include <memory>
#include "base/containers/flat_map.h"
-#include "cc/output/compositor_frame_sink_client.h"
+#include "cc/output/layer_tree_frame_sink_client.h"
#include "cc/resources/release_callback.h"
#include "components/exo/surface_observer.h"
namespace cc {
-class CompositorFrameSink;
+class LayerTreeFrameSink;
}
namespace exo {
@@ -23,32 +23,29 @@
// the contents of Buffers. It's keeped alive by references from
// release_callbacks_. It's destroyed when its owning Surface is destroyed and
// the last outstanding release callback is called.
-class CompositorFrameSinkHolder : public cc::CompositorFrameSinkClient,
- public SurfaceObserver {
+class LayerTreeFrameSinkHolder : public cc::LayerTreeFrameSinkClient,
+ public SurfaceObserver {
public:
- CompositorFrameSinkHolder(
- Surface* surface,
- std::unique_ptr<cc::CompositorFrameSink> frame_sink);
- ~CompositorFrameSinkHolder() override;
+ LayerTreeFrameSinkHolder(Surface* surface,
+ std::unique_ptr<cc::LayerTreeFrameSink> frame_sink);
+ ~LayerTreeFrameSinkHolder() override;
bool HasReleaseCallbackForResource(cc::ResourceId id);
void SetResourceReleaseCallback(cc::ResourceId id,
const cc::ReleaseCallback& callback);
- cc::CompositorFrameSink* GetCompositorFrameSink() {
- return frame_sink_.get();
- }
+ cc::LayerTreeFrameSink* GetLayerTreeFrameSink() { return frame_sink_.get(); }
- base::WeakPtr<CompositorFrameSinkHolder> GetWeakPtr() {
+ base::WeakPtr<LayerTreeFrameSinkHolder> GetWeakPtr() {
return weak_factory_.GetWeakPtr();
}
- // Overridden from cc::CompositorFrameSinkClient:
+ // Overridden from cc::LayerTreeFrameSinkClient:
void SetBeginFrameSource(cc::BeginFrameSource* source) override;
void ReclaimResources(const cc::ReturnedResourceArray& resources) override;
void SetTreeActivationCallback(const base::Closure& callback) override {}
void DidReceiveCompositorFrameAck() override;
- void DidLoseCompositorFrameSink() override {}
+ void DidLoseLayerTreeFrameSink() override {}
void OnDraw(const gfx::Transform& transform,
const gfx::Rect& viewport,
bool resourceless_software_draw) override {}
@@ -61,19 +58,18 @@
void OnSurfaceDestroying(Surface* surface) override;
private:
-
// A collection of callbacks used to release resources.
using ResourceReleaseCallbackMap = base::flat_map<int, cc::ReleaseCallback>;
ResourceReleaseCallbackMap release_callbacks_;
Surface* surface_;
- std::unique_ptr<cc::CompositorFrameSink> frame_sink_;
+ std::unique_ptr<cc::LayerTreeFrameSink> frame_sink_;
- base::WeakPtrFactory<CompositorFrameSinkHolder> weak_factory_;
+ base::WeakPtrFactory<LayerTreeFrameSinkHolder> weak_factory_;
- DISALLOW_COPY_AND_ASSIGN(CompositorFrameSinkHolder);
+ DISALLOW_COPY_AND_ASSIGN(LayerTreeFrameSinkHolder);
};
} // namespace exo
-#endif // COMPONENTS_EXO_COMPOSITOR_FRAME_SINK_HOLDER_H_
+#endif // COMPONENTS_EXO_LAYER_TREE_FRAME_SINK_HOLDER_H_
diff --git a/components/exo/surface.cc b/components/exo/surface.cc
index c83338c..5184110 100644
--- a/components/exo/surface.cc
+++ b/components/exo/surface.cc
@@ -12,7 +12,7 @@
#include "base/memory/ptr_util.h"
#include "base/trace_event/trace_event.h"
#include "base/trace_event/trace_event_argument.h"
-#include "cc/output/compositor_frame_sink.h"
+#include "cc/output/layer_tree_frame_sink.h"
#include "cc/quads/render_pass.h"
#include "cc/quads/shared_quad_state.h"
#include "cc/quads/solid_color_draw_quad.h"
@@ -194,8 +194,8 @@
window_->set_owned_by_parent(false);
window_->AddObserver(this);
aura::Env::GetInstance()->context_factory()->AddObserver(this);
- compositor_frame_sink_holder_ = base::MakeUnique<CompositorFrameSinkHolder>(
- this, window_->CreateCompositorFrameSink());
+ layer_tree_frame_sink_holder_ = base::MakeUnique<LayerTreeFrameSinkHolder>(
+ this, window_->CreateLayerTreeFrameSink());
}
Surface::~Surface() {
@@ -447,7 +447,7 @@
if (current_begin_frame_ack_.sequence_number !=
cc::BeginFrameArgs::kInvalidFrameNumber) {
if (!current_begin_frame_ack_.has_damage) {
- compositor_frame_sink_holder_->GetCompositorFrameSink()
+ layer_tree_frame_sink_holder_->GetLayerTreeFrameSink()
->DidNotProduceFrame(current_begin_frame_ack_);
}
current_begin_frame_ack_.sequence_number =
@@ -491,7 +491,7 @@
// Reset damage.
pending_damage_.setEmpty();
DCHECK(!current_resource_.id ||
- compositor_frame_sink_holder_->HasReleaseCallbackForResource(
+ layer_tree_frame_sink_holder_->HasReleaseCallbackForResource(
current_resource_.id));
// Synchronize window hierarchy. This will position and update the stacking
@@ -744,7 +744,7 @@
void Surface::UpdateResource(bool client_usage) {
if (current_buffer_.buffer() &&
current_buffer_.buffer()->ProduceTransferableResource(
- compositor_frame_sink_holder_.get(), next_resource_id_++,
+ layer_tree_frame_sink_holder_.get(), next_resource_id_++,
state_.only_visible_on_secure_output, client_usage,
¤t_resource_)) {
current_resource_has_alpha_ =
@@ -776,7 +776,7 @@
content_size_ = layer_size;
// We need update window_'s bounds with content size, because the
- // CompositorFrameSink may not update the window's size base the size of
+ // LayerTreeFrameSink may not update the window's size base the size of
// the lastest submitted CompositorFrame.
window_->SetBounds(gfx::Rect(window_->bounds().origin(), content_size_));
// TODO(jbauman): Figure out how this interacts with the pixel size of
@@ -859,8 +859,8 @@
}
frame.render_pass_list.push_back(std::move(render_pass));
- compositor_frame_sink_holder_->GetCompositorFrameSink()
- ->SubmitCompositorFrame(std::move(frame));
+ layer_tree_frame_sink_holder_->GetLayerTreeFrameSink()->SubmitCompositorFrame(
+ std::move(frame));
}
} // namespace exo
diff --git a/components/exo/surface.h b/components/exo/surface.h
index d0d5974..7dabdda 100644
--- a/components/exo/surface.h
+++ b/components/exo/surface.h
@@ -16,7 +16,7 @@
#include "base/observer_list.h"
#include "cc/resources/transferable_resource.h"
#include "cc/scheduler/begin_frame_source.h"
-#include "components/exo/compositor_frame_sink_holder.h"
+#include "components/exo/layer_tree_frame_sink_holder.h"
#include "third_party/skia/include/core/SkBlendMode.h"
#include "third_party/skia/include/core/SkRegion.h"
#include "ui/aura/window.h"
@@ -70,8 +70,8 @@
cc::SurfaceId GetSurfaceId() const;
- CompositorFrameSinkHolder* compositor_frame_sink_holder() {
- return compositor_frame_sink_holder_.get();
+ LayerTreeFrameSinkHolder* layer_tree_frame_sink_holder() {
+ return layer_tree_frame_sink_holder_.get();
}
// Set a buffer as the content of this surface. A buffer can only be attached
@@ -302,7 +302,7 @@
// The device scale factor sent in CompositorFrames.
float device_scale_factor_ = 1.0f;
- std::unique_ptr<CompositorFrameSinkHolder> compositor_frame_sink_holder_;
+ std::unique_ptr<LayerTreeFrameSinkHolder> layer_tree_frame_sink_holder_;
// The next resource id the buffer will be attached to.
int next_resource_id_ = 1;
diff --git a/components/exo/surface_unittest.cc b/components/exo/surface_unittest.cc
index 7e9ad52..dc79726 100644
--- a/components/exo/surface_unittest.cc
+++ b/components/exo/surface_unittest.cc
@@ -52,7 +52,7 @@
// attached buffer.
surface->Attach(nullptr);
surface->Commit();
- // CompositorFrameSinkHolder::ReclaimResources() gets called via
+ // LayerTreeFrameSinkHolder::ReclaimResources() gets called via
// MojoCompositorFrameSinkClient interface. We need to wait here for the mojo
// call to finish so that the release callback finishes running before
// the assertion below.
diff --git a/components/viz/client/BUILD.gn b/components/viz/client/BUILD.gn
index 1e73b925..bde56a9 100644
--- a/components/viz/client/BUILD.gn
+++ b/components/viz/client/BUILD.gn
@@ -4,8 +4,8 @@
source_set("client") {
sources = [
- "client_compositor_frame_sink.cc",
- "client_compositor_frame_sink.h",
+ "client_layer_tree_frame_sink.cc",
+ "client_layer_tree_frame_sink.h",
"local_surface_id_provider.cc",
"local_surface_id_provider.h",
]
diff --git a/components/viz/client/client_compositor_frame_sink.cc b/components/viz/client/client_layer_tree_frame_sink.cc
similarity index 76%
rename from components/viz/client/client_compositor_frame_sink.cc
rename to components/viz/client/client_layer_tree_frame_sink.cc
index 9c9299a..60b27d3 100644
--- a/components/viz/client/client_compositor_frame_sink.cc
+++ b/components/viz/client/client_layer_tree_frame_sink.cc
@@ -2,18 +2,18 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "components/viz/client/client_compositor_frame_sink.h"
+#include "components/viz/client/client_layer_tree_frame_sink.h"
#include "base/bind.h"
#include "base/memory/ptr_util.h"
#include "cc/output/begin_frame_args.h"
#include "cc/output/compositor_frame.h"
-#include "cc/output/compositor_frame_sink_client.h"
+#include "cc/output/layer_tree_frame_sink_client.h"
#include "components/viz/client/local_surface_id_provider.h"
namespace viz {
-ClientCompositorFrameSink::ClientCompositorFrameSink(
+ClientLayerTreeFrameSink::ClientLayerTreeFrameSink(
scoped_refptr<cc::ContextProvider> context_provider,
scoped_refptr<cc::ContextProvider> worker_context_provider,
gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
@@ -23,10 +23,10 @@
cc::mojom::MojoCompositorFrameSinkClientRequest client_request,
std::unique_ptr<LocalSurfaceIdProvider> local_surface_id_provider,
bool enable_surface_synchronization)
- : cc::CompositorFrameSink(std::move(context_provider),
- std::move(worker_context_provider),
- gpu_memory_buffer_manager,
- shared_bitmap_manager),
+ : cc::LayerTreeFrameSink(std::move(context_provider),
+ std::move(worker_context_provider),
+ gpu_memory_buffer_manager,
+ shared_bitmap_manager),
local_surface_id_provider_(std::move(local_surface_id_provider)),
synthetic_begin_frame_source_(std::move(synthetic_begin_frame_source)),
compositor_frame_sink_info_(std::move(compositor_frame_sink_info)),
@@ -37,14 +37,14 @@
DETACH_FROM_THREAD(thread_checker_);
}
-ClientCompositorFrameSink::ClientCompositorFrameSink(
+ClientLayerTreeFrameSink::ClientLayerTreeFrameSink(
scoped_refptr<cc::VulkanContextProvider> vulkan_context_provider,
std::unique_ptr<cc::SyntheticBeginFrameSource> synthetic_begin_frame_source,
cc::mojom::MojoCompositorFrameSinkPtrInfo compositor_frame_sink_info,
cc::mojom::MojoCompositorFrameSinkClientRequest client_request,
std::unique_ptr<LocalSurfaceIdProvider> local_surface_id_provider,
bool enable_surface_synchronization)
- : cc::CompositorFrameSink(std::move(vulkan_context_provider)),
+ : cc::LayerTreeFrameSink(std::move(vulkan_context_provider)),
local_surface_id_provider_(std::move(local_surface_id_provider)),
synthetic_begin_frame_source_(std::move(synthetic_begin_frame_source)),
compositor_frame_sink_info_(std::move(compositor_frame_sink_info)),
@@ -55,24 +55,23 @@
DETACH_FROM_THREAD(thread_checker_);
}
-ClientCompositorFrameSink::~ClientCompositorFrameSink() {}
+ClientLayerTreeFrameSink::~ClientLayerTreeFrameSink() {}
-base::WeakPtr<ClientCompositorFrameSink>
-ClientCompositorFrameSink::GetWeakPtr() {
+base::WeakPtr<ClientLayerTreeFrameSink> ClientLayerTreeFrameSink::GetWeakPtr() {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
return weak_factory_.GetWeakPtr();
}
-bool ClientCompositorFrameSink::BindToClient(
- cc::CompositorFrameSinkClient* client) {
+bool ClientLayerTreeFrameSink::BindToClient(
+ cc::LayerTreeFrameSinkClient* client) {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
- if (!cc::CompositorFrameSink::BindToClient(client))
+ if (!cc::LayerTreeFrameSink::BindToClient(client))
return false;
compositor_frame_sink_.Bind(std::move(compositor_frame_sink_info_));
compositor_frame_sink_.set_connection_error_with_reason_handler(
- base::Bind(ClientCompositorFrameSink::OnMojoConnectionError));
+ base::Bind(ClientLayerTreeFrameSink::OnMojoConnectionError));
client_binding_.Bind(std::move(client_request_));
if (synthetic_begin_frame_source_) {
@@ -85,17 +84,17 @@
return true;
}
-void ClientCompositorFrameSink::DetachFromClient() {
+void ClientLayerTreeFrameSink::DetachFromClient() {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
client_->SetBeginFrameSource(nullptr);
begin_frame_source_.reset();
synthetic_begin_frame_source_.reset();
client_binding_.Close();
compositor_frame_sink_.reset();
- cc::CompositorFrameSink::DetachFromClient();
+ cc::LayerTreeFrameSink::DetachFromClient();
}
-void ClientCompositorFrameSink::SetLocalSurfaceId(
+void ClientLayerTreeFrameSink::SetLocalSurfaceId(
const cc::LocalSurfaceId& local_surface_id) {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
DCHECK(local_surface_id.is_valid());
@@ -103,7 +102,7 @@
local_surface_id_ = local_surface_id;
}
-void ClientCompositorFrameSink::SubmitCompositorFrame(
+void ClientLayerTreeFrameSink::SubmitCompositorFrame(
cc::CompositorFrame frame) {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
DCHECK(frame.metadata.begin_frame_ack.has_damage);
@@ -119,38 +118,38 @@
std::move(frame));
}
-void ClientCompositorFrameSink::DidNotProduceFrame(
+void ClientLayerTreeFrameSink::DidNotProduceFrame(
const cc::BeginFrameAck& ack) {
DCHECK(!ack.has_damage);
DCHECK_LE(cc::BeginFrameArgs::kStartingFrameNumber, ack.sequence_number);
compositor_frame_sink_->DidNotProduceFrame(ack);
}
-void ClientCompositorFrameSink::DidReceiveCompositorFrameAck(
+void ClientLayerTreeFrameSink::DidReceiveCompositorFrameAck(
const cc::ReturnedResourceArray& resources) {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
client_->ReclaimResources(resources);
client_->DidReceiveCompositorFrameAck();
}
-void ClientCompositorFrameSink::OnBeginFrame(
+void ClientLayerTreeFrameSink::OnBeginFrame(
const cc::BeginFrameArgs& begin_frame_args) {
if (begin_frame_source_)
begin_frame_source_->OnBeginFrame(begin_frame_args);
}
-void ClientCompositorFrameSink::ReclaimResources(
+void ClientLayerTreeFrameSink::ReclaimResources(
const cc::ReturnedResourceArray& resources) {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
client_->ReclaimResources(resources);
}
-void ClientCompositorFrameSink::OnNeedsBeginFrames(bool needs_begin_frames) {
+void ClientLayerTreeFrameSink::OnNeedsBeginFrames(bool needs_begin_frames) {
compositor_frame_sink_->SetNeedsBeginFrame(needs_begin_frames);
}
// static
-void ClientCompositorFrameSink::OnMojoConnectionError(
+void ClientLayerTreeFrameSink::OnMojoConnectionError(
uint32_t custom_reason,
const std::string& description) {
if (custom_reason)
diff --git a/components/viz/client/client_compositor_frame_sink.h b/components/viz/client/client_layer_tree_frame_sink.h
similarity index 81%
rename from components/viz/client/client_compositor_frame_sink.h
rename to components/viz/client/client_layer_tree_frame_sink.h
index c866188..bbc6e37 100644
--- a/components/viz/client/client_compositor_frame_sink.h
+++ b/components/viz/client/client_layer_tree_frame_sink.h
@@ -2,14 +2,14 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef COMPONENTS_VIZ_CLIENT_CLIENT_COMPOSITOR_FRAME_SINK_H_
-#define COMPONENTS_VIZ_CLIENT_CLIENT_COMPOSITOR_FRAME_SINK_H_
+#ifndef COMPONENTS_VIZ_CLIENT_CLIENT_LAYER_TREE_FRAME_SINK_H_
+#define COMPONENTS_VIZ_CLIENT_CLIENT_LAYER_TREE_FRAME_SINK_H_
#include "base/macros.h"
#include "base/memory/weak_ptr.h"
#include "cc/ipc/mojo_compositor_frame_sink.mojom.h"
-#include "cc/output/compositor_frame_sink.h"
#include "cc/output/context_provider.h"
+#include "cc/output/layer_tree_frame_sink.h"
#include "cc/scheduler/begin_frame_source.h"
#include "cc/surfaces/local_surface_id_allocator.h"
#include "cc/surfaces/surface_id.h"
@@ -19,12 +19,12 @@
class LocalSurfaceIdProvider;
-class ClientCompositorFrameSink
- : public cc::CompositorFrameSink,
+class ClientLayerTreeFrameSink
+ : public cc::LayerTreeFrameSink,
public cc::mojom::MojoCompositorFrameSinkClient,
public cc::ExternalBeginFrameSourceClient {
public:
- ClientCompositorFrameSink(
+ ClientLayerTreeFrameSink(
scoped_refptr<cc::ContextProvider> context_provider,
scoped_refptr<cc::ContextProvider> worker_context_provider,
gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
@@ -36,7 +36,7 @@
std::unique_ptr<LocalSurfaceIdProvider> local_surface_id_provider,
bool enable_surface_synchronization);
- ClientCompositorFrameSink(
+ ClientLayerTreeFrameSink(
scoped_refptr<cc::VulkanContextProvider> vulkan_context_provider,
std::unique_ptr<cc::SyntheticBeginFrameSource>
synthetic_begin_frame_source,
@@ -45,12 +45,12 @@
std::unique_ptr<LocalSurfaceIdProvider> local_surface_id_provider,
bool enable_surface_synchronization);
- ~ClientCompositorFrameSink() override;
+ ~ClientLayerTreeFrameSink() override;
- base::WeakPtr<ClientCompositorFrameSink> GetWeakPtr();
+ base::WeakPtr<ClientLayerTreeFrameSink> GetWeakPtr();
- // cc::CompositorFrameSink implementation.
- bool BindToClient(cc::CompositorFrameSinkClient* client) override;
+ // cc::LayerTreeFrameSink implementation.
+ bool BindToClient(cc::LayerTreeFrameSinkClient* client) override;
void DetachFromClient() override;
void SetLocalSurfaceId(const cc::LocalSurfaceId& local_surface_id) override;
void SubmitCompositorFrame(cc::CompositorFrame frame) override;
@@ -80,11 +80,11 @@
THREAD_CHECKER(thread_checker_);
const bool enable_surface_synchronization_;
- base::WeakPtrFactory<ClientCompositorFrameSink> weak_factory_;
+ base::WeakPtrFactory<ClientLayerTreeFrameSink> weak_factory_;
- DISALLOW_COPY_AND_ASSIGN(ClientCompositorFrameSink);
+ DISALLOW_COPY_AND_ASSIGN(ClientLayerTreeFrameSink);
};
} // namespace viz
-#endif // COMPONENTS_VIZ_CLIENT_CLIENT_COMPOSITOR_FRAME_SINK_H_
+#endif // COMPONENTS_VIZ_CLIENT_CLIENT_LAYER_TREE_FRAME_SINK_H_
diff --git a/content/browser/android/synchronous_compositor_browser_filter.cc b/content/browser/android/synchronous_compositor_browser_filter.cc
index c04a4fb3..74c4dc12 100644
--- a/content/browser/android/synchronous_compositor_browser_filter.cc
+++ b/content/browser/android/synchronous_compositor_browser_filter.cc
@@ -85,7 +85,7 @@
}
auto frame_ptr = base::MakeUnique<SynchronousCompositor::Frame>();
- frame_ptr->compositor_frame_sink_id = std::get<0>(param);
+ frame_ptr->layer_tree_frame_sink_id = std::get<0>(param);
base::Optional<cc::CompositorFrame>& compositor_frame = std::get<1>(param);
if (compositor_frame) {
BrowserThread::PostTask(
diff --git a/content/browser/android/synchronous_compositor_host.cc b/content/browser/android/synchronous_compositor_host.cc
index 257a3a52..c99d24c 100644
--- a/content/browser/android/synchronous_compositor_host.cc
+++ b/content/browser/android/synchronous_compositor_host.cc
@@ -73,8 +73,8 @@
bool SynchronousCompositorHost::OnMessageReceived(const IPC::Message& message) {
bool handled = true;
IPC_BEGIN_MESSAGE_MAP(SynchronousCompositorHost, message)
- IPC_MESSAGE_HANDLER(SyncCompositorHostMsg_CompositorFrameSinkCreated,
- CompositorFrameSinkCreated)
+ IPC_MESSAGE_HANDLER(SyncCompositorHostMsg_LayerTreeFrameSinkCreated,
+ LayerTreeFrameSinkCreated)
IPC_MESSAGE_HANDLER(SyncCompositorHostMsg_UpdateState, ProcessCommonParams)
IPC_MESSAGE_UNHANDLED(handled = false)
IPC_END_MESSAGE_MAP()
@@ -119,7 +119,7 @@
SyncCompositorDemandDrawHwParams params(viewport_size,
viewport_rect_for_tile_priority,
transform_for_tile_priority);
- uint32_t compositor_frame_sink_id;
+ uint32_t layer_tree_frame_sink_id;
base::Optional<cc::CompositorFrame> compositor_frame;
SyncCompositorCommonRendererParams common_renderer_params;
@@ -127,7 +127,7 @@
base::ThreadRestrictions::ScopedAllowWait wait;
if (!sender_->Send(new SyncCompositorMsg_DemandDrawHw(
routing_id_, params, &common_renderer_params,
- &compositor_frame_sink_id, &compositor_frame))) {
+ &layer_tree_frame_sink_id, &compositor_frame))) {
return SynchronousCompositor::Frame();
}
}
@@ -139,7 +139,7 @@
SynchronousCompositor::Frame frame;
frame.frame.reset(new cc::CompositorFrame);
- frame.compositor_frame_sink_id = compositor_frame_sink_id;
+ frame.layer_tree_frame_sink_id = layer_tree_frame_sink_id;
*frame.frame = std::move(*compositor_frame);
UpdateFrameMetaData(frame.frame->metadata.Clone());
return frame;
@@ -313,11 +313,11 @@
}
void SynchronousCompositorHost::ReturnResources(
- uint32_t compositor_frame_sink_id,
+ uint32_t layer_tree_frame_sink_id,
const cc::ReturnedResourceArray& resources) {
DCHECK(!resources.empty());
sender_->Send(new SyncCompositorMsg_ReclaimResources(
- routing_id_, compositor_frame_sink_id, resources));
+ routing_id_, layer_tree_frame_sink_id, resources));
}
void SynchronousCompositorHost::SetMemoryPolicy(size_t bytes_limit) {
@@ -378,8 +378,8 @@
filter->SyncStateAfterVSync(window_android, this);
}
-void SynchronousCompositorHost::CompositorFrameSinkCreated() {
- // New CompositorFrameSink is not aware of state from Browser side. So need to
+void SynchronousCompositorHost::LayerTreeFrameSinkCreated() {
+ // New LayerTreeFrameSink is not aware of state from Browser side. So need to
// re-send all browser side state here.
sender_->Send(
new SyncCompositorMsg_SetMemoryPolicy(routing_id_, bytes_limit_));
diff --git a/content/browser/android/synchronous_compositor_host.h b/content/browser/android/synchronous_compositor_host.h
index ec206c60..1ac04e5 100644
--- a/content/browser/android/synchronous_compositor_host.h
+++ b/content/browser/android/synchronous_compositor_host.h
@@ -54,7 +54,7 @@
const gfx::Rect& viewport_rect_for_tile_priority,
const gfx::Transform& transform_for_tile_priority) override;
bool DemandDrawSw(SkCanvas* canvas) override;
- void ReturnResources(uint32_t compositor_frame_sink_id,
+ void ReturnResources(uint32_t layer_tree_frame_sink_id,
const cc::ReturnedResourceArray& resources) override;
void SetMemoryPolicy(size_t bytes_limit) override;
void DidChangeRootLayerScrollOffset(
@@ -81,7 +81,7 @@
SynchronousCompositorHost(RenderWidgetHostViewAndroid* rwhva,
bool use_in_proc_software_draw);
- void CompositorFrameSinkCreated();
+ void LayerTreeFrameSinkCreated();
bool DemandDrawSwInProc(SkCanvas* canvas);
void SetSoftwareDrawSharedMemoryIfNeeded(size_t stride, size_t buffer_size);
void SendZeroMemory();
diff --git a/content/browser/compositor/gpu_process_transport_factory.cc b/content/browser/compositor/gpu_process_transport_factory.cc
index bef5b54..c7fbe80 100644
--- a/content/browser/compositor/gpu_process_transport_factory.cc
+++ b/content/browser/compositor/gpu_process_transport_factory.cc
@@ -26,7 +26,7 @@
#include "cc/raster/task_graph_runner.h"
#include "cc/scheduler/begin_frame_source.h"
#include "cc/scheduler/delay_based_time_source.h"
-#include "cc/surfaces/direct_compositor_frame_sink.h"
+#include "cc/surfaces/direct_layer_tree_frame_sink.h"
#include "cc/surfaces/display.h"
#include "cc/surfaces/display_scheduler.h"
#include "cc/surfaces/surface_manager.h"
@@ -302,7 +302,7 @@
return validator;
}
-static bool ShouldCreateGpuCompositorFrameSink(ui::Compositor* compositor) {
+static bool ShouldCreateGpuLayerTreeFrameSink(ui::Compositor* compositor) {
#if defined(OS_CHROMEOS)
// Software fallback does not happen on Chrome OS.
return true;
@@ -316,7 +316,7 @@
return GpuDataManagerImpl::GetInstance()->CanUseGpuBrowserCompositor();
}
-void GpuProcessTransportFactory::CreateCompositorFrameSink(
+void GpuProcessTransportFactory::CreateLayerTreeFrameSink(
base::WeakPtr<ui::Compositor> compositor) {
DCHECK(!!compositor);
PerCompositorData* data = per_compositor_data_[compositor.get()].get();
@@ -325,7 +325,7 @@
} else {
// TODO(danakj): We can destroy the |data->display| and
// |data->begin_frame_source| here when the compositor destroys its
- // CompositorFrameSink before calling back here.
+ // LayerTreeFrameSink before calling back here.
data->display_output_surface = nullptr;
}
@@ -336,7 +336,7 @@
const bool use_vulkan = static_cast<bool>(SharedVulkanContextProvider());
const bool create_gpu_output_surface =
- ShouldCreateGpuCompositorFrameSink(compositor.get());
+ ShouldCreateGpuLayerTreeFrameSink(compositor.get());
if (create_gpu_output_surface && !use_vulkan) {
gpu::GpuChannelEstablishedCallback callback(
base::Bind(&GpuProcessTransportFactory::EstablishedGpuChannel,
@@ -618,21 +618,21 @@
// The |delegated_output_surface| is given back to the compositor, it
// delegates to the Display as its root surface. Importantly, it shares the
// same ContextProvider as the Display's output surface.
- auto compositor_frame_sink =
+ auto layer_tree_frame_sink =
vulkan_context_provider
- ? base::MakeUnique<cc::DirectCompositorFrameSink>(
+ ? base::MakeUnique<cc::DirectLayerTreeFrameSink>(
compositor->frame_sink_id(), GetSurfaceManager(),
data->display.get(),
static_cast<scoped_refptr<cc::VulkanContextProvider>>(
vulkan_context_provider))
- : base::MakeUnique<cc::DirectCompositorFrameSink>(
+ : base::MakeUnique<cc::DirectLayerTreeFrameSink>(
compositor->frame_sink_id(), GetSurfaceManager(),
data->display.get(), context_provider,
shared_worker_context_provider_, GetGpuMemoryBufferManager(),
viz::HostSharedBitmapManager::current());
data->display->Resize(compositor->size());
data->display->SetOutputIsSecure(data->output_is_secure);
- compositor->SetCompositorFrameSink(std::move(compositor_frame_sink));
+ compositor->SetLayerTreeFrameSink(std::move(layer_tree_frame_sink));
}
std::unique_ptr<ui::Reflector> GpuProcessTransportFactory::CreateReflector(
diff --git a/content/browser/compositor/gpu_process_transport_factory.h b/content/browser/compositor/gpu_process_transport_factory.h
index 2669561d..201240dc 100644
--- a/content/browser/compositor/gpu_process_transport_factory.h
+++ b/content/browser/compositor/gpu_process_transport_factory.h
@@ -47,7 +47,7 @@
~GpuProcessTransportFactory() override;
// ui::ContextFactory implementation.
- void CreateCompositorFrameSink(
+ void CreateLayerTreeFrameSink(
base::WeakPtr<ui::Compositor> compositor) override;
scoped_refptr<cc::ContextProvider> SharedMainThreadContextProvider() override;
double GetRefreshRate() const override;
diff --git a/content/browser/renderer_host/compositor_impl_android.cc b/content/browser/renderer_host/compositor_impl_android.cc
index 0a2276fb..1fe7626 100644
--- a/content/browser/renderer_host/compositor_impl_android.cc
+++ b/content/browser/renderer_host/compositor_impl_android.cc
@@ -40,7 +40,7 @@
#include "cc/output/vulkan_in_process_context_provider.h"
#include "cc/raster/single_thread_task_graph_runner.h"
#include "cc/resources/ui_resource_manager.h"
-#include "cc/surfaces/direct_compositor_frame_sink.h"
+#include "cc/surfaces/direct_layer_tree_frame_sink.h"
#include "cc/surfaces/display.h"
#include "cc/surfaces/display_scheduler.h"
#include "cc/surfaces/frame_sink_id_allocator.h"
@@ -445,7 +445,7 @@
needs_animate_(false),
pending_frames_(0U),
num_successive_context_creation_failures_(0),
- compositor_frame_sink_request_pending_(false),
+ layer_tree_frame_sink_request_pending_(false),
weak_factory_(this) {
GetSurfaceManager()->RegisterFrameSinkId(frame_sink_id_);
DCHECK(client);
@@ -516,7 +516,7 @@
if (window) {
window_ = window;
ANativeWindow_acquire(window);
- // Register first, SetVisible() might create a CompositorFrameSink.
+ // Register first, SetVisible() might create a LayerTreeFrameSink.
surface_handle_ = tracker->AddSurfaceForNativeWidget(
gpu::GpuSurfaceTracker::SurfaceRecord(window, surface));
SetVisible(true);
@@ -569,8 +569,8 @@
display_->ForceImmediateDrawAndSwapIfPossible();
host_->SetVisible(false);
- host_->ReleaseCompositorFrameSink();
- has_compositor_frame_sink_ = false;
+ host_->ReleaseLayerTreeFrameSink();
+ has_layer_tree_frame_sink_ = false;
pending_frames_ = 0;
if (display_) {
GetSurfaceManager()->UnregisterBeginFrameSource(
@@ -579,8 +579,8 @@
display_.reset();
} else {
host_->SetVisible(true);
- if (compositor_frame_sink_request_pending_)
- HandlePendingCompositorFrameSinkRequest();
+ if (layer_tree_frame_sink_request_pending_)
+ HandlePendingLayerTreeFrameSinkRequest();
}
}
@@ -631,31 +631,31 @@
}
}
-void CompositorImpl::RequestNewCompositorFrameSink() {
- DCHECK(!compositor_frame_sink_request_pending_)
- << "Output Surface Request is already pending?";
+void CompositorImpl::RequestNewLayerTreeFrameSink() {
+ DCHECK(!layer_tree_frame_sink_request_pending_)
+ << "LayerTreeFrameSink request is already pending?";
- compositor_frame_sink_request_pending_ = true;
- HandlePendingCompositorFrameSinkRequest();
+ layer_tree_frame_sink_request_pending_ = true;
+ HandlePendingLayerTreeFrameSinkRequest();
}
-void CompositorImpl::DidInitializeCompositorFrameSink() {
- compositor_frame_sink_request_pending_ = false;
- has_compositor_frame_sink_ = true;
+void CompositorImpl::DidInitializeLayerTreeFrameSink() {
+ layer_tree_frame_sink_request_pending_ = false;
+ has_layer_tree_frame_sink_ = true;
for (auto& frame_sink_id : pending_child_frame_sink_ids_)
AddChildFrameSink(frame_sink_id);
pending_child_frame_sink_ids_.clear();
}
-void CompositorImpl::DidFailToInitializeCompositorFrameSink() {
+void CompositorImpl::DidFailToInitializeLayerTreeFrameSink() {
// The context is bound/initialized before handing it to the
- // CompositorFrameSink.
+ // LayerTreeFrameSink.
NOTREACHED();
}
-void CompositorImpl::HandlePendingCompositorFrameSinkRequest() {
- DCHECK(compositor_frame_sink_request_pending_);
+void CompositorImpl::HandlePendingLayerTreeFrameSinkRequest() {
+ DCHECK(layer_tree_frame_sink_request_pending_);
// We might have been made invisible now.
if (!host_->IsVisible())
@@ -719,13 +719,13 @@
establish_gpu_channel_timeout_.Stop();
// We might end up queing multiple GpuChannel requests for the same
- // CompositorFrameSink request as the visibility of the compositor changes, so
- // the CompositorFrameSink request could have been handled already.
- if (!compositor_frame_sink_request_pending_)
+ // LayerTreeFrameSink request as the visibility of the compositor changes, so
+ // the LayerTreeFrameSink request could have been handled already.
+ if (!layer_tree_frame_sink_request_pending_)
return;
if (!gpu_channel_host) {
- HandlePendingCompositorFrameSinkRequest();
+ HandlePendingLayerTreeFrameSinkRequest();
return;
}
@@ -758,7 +758,7 @@
LOG(ERROR) << "Failed to init ContextProvider for compositor.";
LOG_IF(FATAL, ++num_successive_context_creation_failures_ >= 2)
<< "Too many context creation failures. Giving up... ";
- HandlePendingCompositorFrameSinkRequest();
+ HandlePendingLayerTreeFrameSinkRequest();
return;
}
@@ -774,7 +774,7 @@
std::unique_ptr<cc::OutputSurface> display_output_surface,
scoped_refptr<cc::VulkanContextProvider> vulkan_context_provider,
scoped_refptr<cc::ContextProvider> context_provider) {
- DCHECK(compositor_frame_sink_request_pending_);
+ DCHECK(layer_tree_frame_sink_request_pending_);
pending_frames_ = 0;
num_successive_context_creation_failures_ = 0;
@@ -800,12 +800,12 @@
frame_sink_id_, std::move(display_output_surface), std::move(scheduler),
base::MakeUnique<cc::TextureMailboxDeleter>(task_runner)));
- auto compositor_frame_sink =
+ auto layer_tree_frame_sink =
vulkan_context_provider
- ? base::MakeUnique<cc::DirectCompositorFrameSink>(
+ ? base::MakeUnique<cc::DirectLayerTreeFrameSink>(
frame_sink_id_, manager, display_.get(),
vulkan_context_provider)
- : base::MakeUnique<cc::DirectCompositorFrameSink>(
+ : base::MakeUnique<cc::DirectLayerTreeFrameSink>(
frame_sink_id_, manager, display_.get(), context_provider,
nullptr, BrowserGpuMemoryBufferManager::current(),
viz::HostSharedBitmapManager::current());
@@ -814,7 +814,7 @@
display_->Resize(size_);
GetSurfaceManager()->RegisterBeginFrameSource(
root_window_->GetBeginFrameSource(), frame_sink_id_);
- host_->SetCompositorFrameSink(std::move(compositor_frame_sink));
+ host_->SetLayerTreeFrameSink(std::move(layer_tree_frame_sink));
}
void CompositorImpl::DidSwapBuffers() {
@@ -848,9 +848,9 @@
client_->DidSwapFrame(pending_frames_);
}
-void CompositorImpl::DidLoseCompositorFrameSink() {
- TRACE_EVENT0("compositor", "CompositorImpl::DidLoseCompositorFrameSink");
- has_compositor_frame_sink_ = false;
+void CompositorImpl::DidLoseLayerTreeFrameSink() {
+ TRACE_EVENT0("compositor", "CompositorImpl::DidLoseLayerTreeFrameSink");
+ has_layer_tree_frame_sink_ = false;
client_->DidSwapFrame(0);
}
@@ -881,7 +881,7 @@
}
void CompositorImpl::AddChildFrameSink(const cc::FrameSinkId& frame_sink_id) {
- if (has_compositor_frame_sink_) {
+ if (has_layer_tree_frame_sink_) {
GetSurfaceManager()->RegisterFrameSinkHierarchy(frame_sink_id_,
frame_sink_id);
} else {
diff --git a/content/browser/renderer_host/compositor_impl_android.h b/content/browser/renderer_host/compositor_impl_android.h
index 2488823..f4c897a 100644
--- a/content/browser/renderer_host/compositor_impl_android.h
+++ b/content/browser/renderer_host/compositor_impl_android.h
@@ -97,9 +97,9 @@
float top_controls_delta) override {}
void RecordWheelAndTouchScrollingCount(bool has_scrolled_by_wheel,
bool has_scrolled_by_touch) override {}
- void RequestNewCompositorFrameSink() override;
- void DidInitializeCompositorFrameSink() override;
- void DidFailToInitializeCompositorFrameSink() override;
+ void RequestNewLayerTreeFrameSink() override;
+ void DidInitializeLayerTreeFrameSink() override;
+ void DidFailToInitializeLayerTreeFrameSink() override;
void WillCommit() override {}
void DidCommit() override;
void DidCommitAndDrawFrame() override {}
@@ -109,7 +109,7 @@
// LayerTreeHostSingleThreadClient implementation.
void DidSubmitCompositorFrame() override;
- void DidLoseCompositorFrameSink() override;
+ void DidLoseLayerTreeFrameSink() override;
// WindowAndroidCompositor implementation.
void AttachLayerForReadback(scoped_refptr<cc::Layer> layer) override;
@@ -123,7 +123,7 @@
void SetVisible(bool visible);
void CreateLayerTreeHost();
- void HandlePendingCompositorFrameSinkRequest();
+ void HandlePendingLayerTreeFrameSinkRequest();
#if BUILDFLAG(ENABLE_VULKAN)
void CreateVulkanOutputSurface();
@@ -177,14 +177,14 @@
base::OneShotTimer establish_gpu_channel_timeout_;
- // Whether there is an CompositorFrameSink request pending from the current
- // |host_|. Becomes |true| if RequestNewCompositorFrameSink is called, and
+ // Whether there is a LayerTreeFrameSink request pending from the current
+ // |host_|. Becomes |true| if RequestNewLayerTreeFrameSink is called, and
// |false| if |host_| is deleted or we succeed in creating *and* initializing
- // a CompositorFrameSink (which is essentially the contract with cc).
- bool compositor_frame_sink_request_pending_;
+ // a LayerTreeFrameSink (which is essentially the contract with cc).
+ bool layer_tree_frame_sink_request_pending_;
gpu::Capabilities gpu_capabilities_;
- bool has_compositor_frame_sink_ = false;
+ bool has_layer_tree_frame_sink_ = false;
std::unordered_set<cc::FrameSinkId, cc::FrameSinkIdHash>
pending_child_frame_sink_ids_;
base::WeakPtrFactory<CompositorImpl> weak_factory_;
diff --git a/content/common/android/sync_compositor_messages.h b/content/common/android/sync_compositor_messages.h
index 4283fe0..d370ed4 100644
--- a/content/common/android/sync_compositor_messages.h
+++ b/content/common/android/sync_compositor_messages.h
@@ -131,7 +131,7 @@
IPC_SYNC_MESSAGE_ROUTED1_3(SyncCompositorMsg_DemandDrawHw,
content::SyncCompositorDemandDrawHwParams,
content::SyncCompositorCommonRendererParams,
- uint32_t /* compositor_frame_sink_id */,
+ uint32_t /* layer_tree_frame_sink_id */,
base::Optional<cc::CompositorFrame>);
IPC_SYNC_MESSAGE_ROUTED1_2(SyncCompositorMsg_SetSharedMemory,
@@ -155,7 +155,7 @@
uint32_t /* bytes_limit */);
IPC_MESSAGE_ROUTED2(SyncCompositorMsg_ReclaimResources,
- uint32_t /* compositor_frame_sink_id */,
+ uint32_t /* layer_tree_frame_sink_id */,
cc::ReturnedResourceArray /* resources */);
IPC_MESSAGE_ROUTED1(SyncCompositorMsg_SetScroll, gfx::ScrollOffset);
@@ -163,11 +163,11 @@
// -----------------------------------------------------------------------------
// Messages sent from the renderer to the browser.
-IPC_MESSAGE_ROUTED0(SyncCompositorHostMsg_CompositorFrameSinkCreated);
+IPC_MESSAGE_ROUTED0(SyncCompositorHostMsg_LayerTreeFrameSinkCreated);
IPC_MESSAGE_ROUTED1(SyncCompositorHostMsg_UpdateState,
content::SyncCompositorCommonRendererParams)
IPC_MESSAGE_ROUTED2(SyncCompositorHostMsg_ReturnFrame,
- uint32_t /* compositor_frame_sink_id */,
+ uint32_t /* layer_tree_frame_sink_id */,
base::Optional<cc::CompositorFrame>);
diff --git a/content/public/browser/android/synchronous_compositor.cc b/content/public/browser/android/synchronous_compositor.cc
index f1fdfee..76c820d5 100644
--- a/content/public/browser/android/synchronous_compositor.cc
+++ b/content/public/browser/android/synchronous_compositor.cc
@@ -11,12 +11,12 @@
namespace content {
-SynchronousCompositor::Frame::Frame() : compositor_frame_sink_id(0u) {}
+SynchronousCompositor::Frame::Frame() : layer_tree_frame_sink_id(0u) {}
SynchronousCompositor::Frame::~Frame() {}
SynchronousCompositor::Frame::Frame(Frame&& rhs)
- : compositor_frame_sink_id(rhs.compositor_frame_sink_id),
+ : layer_tree_frame_sink_id(rhs.layer_tree_frame_sink_id),
frame(std::move(rhs.frame)) {}
SynchronousCompositor::FrameFuture::FrameFuture()
@@ -44,7 +44,7 @@
SynchronousCompositor::Frame& SynchronousCompositor::Frame::operator=(
Frame&& rhs) {
- compositor_frame_sink_id = rhs.compositor_frame_sink_id;
+ layer_tree_frame_sink_id = rhs.layer_tree_frame_sink_id;
frame = std::move(rhs.frame);
return *this;
}
diff --git a/content/public/browser/android/synchronous_compositor.h b/content/public/browser/android/synchronous_compositor.h
index 9a133589..c9de9136 100644
--- a/content/public/browser/android/synchronous_compositor.h
+++ b/content/public/browser/android/synchronous_compositor.h
@@ -52,7 +52,7 @@
Frame(Frame&& rhs);
Frame& operator=(Frame&& rhs);
- uint32_t compositor_frame_sink_id;
+ uint32_t layer_tree_frame_sink_id;
std::unique_ptr<cc::CompositorFrame> frame;
private:
@@ -93,7 +93,7 @@
// For delegated rendering, return resources from parent compositor to this.
// Note that all resources must be returned before ReleaseHwDraw.
- virtual void ReturnResources(uint32_t compositor_frame_sink_id,
+ virtual void ReturnResources(uint32_t layer_tree_frame_sink_id,
const cc::ReturnedResourceArray& resources) = 0;
// "On demand" SW draw, into the supplied canvas (observing the transform
diff --git a/content/public/test/test_synchronous_compositor_android.cc b/content/public/test/test_synchronous_compositor_android.cc
index 4f33490..c368865c 100644
--- a/content/public/test/test_synchronous_compositor_android.cc
+++ b/content/public/test/test_synchronous_compositor_android.cc
@@ -42,10 +42,10 @@
}
void TestSynchronousCompositor::ReturnResources(
- uint32_t compositor_frame_sink_id,
+ uint32_t layer_tree_frame_sink_id,
const cc::ReturnedResourceArray& resources) {
ReturnedResources returned_resources;
- returned_resources.compositor_frame_sink_id = compositor_frame_sink_id;
+ returned_resources.layer_tree_frame_sink_id = layer_tree_frame_sink_id;
returned_resources.resources = resources;
frame_ack_array_.push_back(returned_resources);
}
@@ -61,14 +61,14 @@
}
void TestSynchronousCompositor::SetHardwareFrame(
- uint32_t compositor_frame_sink_id,
+ uint32_t layer_tree_frame_sink_id,
std::unique_ptr<cc::CompositorFrame> frame) {
- hardware_frame_.compositor_frame_sink_id = compositor_frame_sink_id;
+ hardware_frame_.layer_tree_frame_sink_id = layer_tree_frame_sink_id;
hardware_frame_.frame = std::move(frame);
}
TestSynchronousCompositor::ReturnedResources::ReturnedResources()
- : compositor_frame_sink_id(0u) {}
+ : layer_tree_frame_sink_id(0u) {}
TestSynchronousCompositor::ReturnedResources::ReturnedResources(
const ReturnedResources& other) = default;
diff --git a/content/public/test/test_synchronous_compositor_android.h b/content/public/test/test_synchronous_compositor_android.h
index 7e24dcb..8bc14bbd 100644
--- a/content/public/test/test_synchronous_compositor_android.h
+++ b/content/public/test/test_synchronous_compositor_android.h
@@ -32,7 +32,7 @@
const gfx::Size& viewport_size,
const gfx::Rect& viewport_rect_for_tile_priority,
const gfx::Transform& transform_for_tile_priority) override;
- void ReturnResources(uint32_t compositor_frame_sink_id,
+ void ReturnResources(uint32_t layer_tree_frame_sink_id,
const cc::ReturnedResourceArray& resources) override;
bool DemandDrawSw(SkCanvas* canvas) override;
void SetMemoryPolicy(size_t bytes_limit) override {}
@@ -42,7 +42,7 @@
const gfx::Point& anchor) override {}
void OnComputeScroll(base::TimeTicks animate_time) override {}
- void SetHardwareFrame(uint32_t compositor_frame_sink_id,
+ void SetHardwareFrame(uint32_t layer_tree_frame_sink_id,
std::unique_ptr<cc::CompositorFrame> frame);
struct ReturnedResources {
@@ -50,7 +50,7 @@
ReturnedResources(const ReturnedResources& other);
~ReturnedResources();
- uint32_t compositor_frame_sink_id;
+ uint32_t layer_tree_frame_sink_id;
cc::ReturnedResourceArray resources;
};
using FrameAckArray = std::vector<ReturnedResources>;
diff --git a/content/renderer/BUILD.gn b/content/renderer/BUILD.gn
index faf32e5f..3d5b36b53 100644
--- a/content/renderer/BUILD.gn
+++ b/content/renderer/BUILD.gn
@@ -41,11 +41,11 @@
"android/renderer_date_time_picker.h",
"android/synchronous_compositor_filter.cc",
"android/synchronous_compositor_filter.h",
- "android/synchronous_compositor_frame_sink.cc",
- "android/synchronous_compositor_frame_sink.h",
"android/synchronous_compositor_proxy.cc",
"android/synchronous_compositor_proxy.h",
"android/synchronous_compositor_registry.h",
+ "android/synchronous_layer_tree_frame_sink.cc",
+ "android/synchronous_layer_tree_frame_sink.h",
"browser_plugin/browser_plugin.cc",
"browser_plugin/browser_plugin.h",
"browser_plugin/browser_plugin_manager.cc",
diff --git a/content/renderer/android/synchronous_compositor_filter.cc b/content/renderer/android/synchronous_compositor_filter.cc
index 98ede7b..d045e9c 100644
--- a/content/renderer/android/synchronous_compositor_filter.cc
+++ b/content/renderer/android/synchronous_compositor_filter.cc
@@ -132,27 +132,27 @@
DCHECK(entry_pair.second);
int routing_id = entry_pair.first;
CreateSynchronousCompositorProxy(routing_id, entry_pair.second);
- auto compositor_frame_sink_entry =
- compositor_frame_sink_map_.find(routing_id);
- if (compositor_frame_sink_entry != compositor_frame_sink_map_.end()) {
- SetProxyCompositorFrameSink(routing_id,
- compositor_frame_sink_entry->second);
+ auto layer_tree_frame_sink_entry =
+ layer_tree_frame_sink_map_.find(routing_id);
+ if (layer_tree_frame_sink_entry != layer_tree_frame_sink_map_.end()) {
+ SetProxyLayerTreeFrameSink(routing_id,
+ layer_tree_frame_sink_entry->second);
}
}
}
-void SynchronousCompositorFilter::RegisterCompositorFrameSink(
+void SynchronousCompositorFilter::RegisterLayerTreeFrameSink(
int routing_id,
- SynchronousCompositorFrameSink* compositor_frame_sink) {
+ SynchronousLayerTreeFrameSink* layer_tree_frame_sink) {
DCHECK(compositor_task_runner_->BelongsToCurrentThread());
- DCHECK(compositor_frame_sink);
+ DCHECK(layer_tree_frame_sink);
SynchronousCompositorProxy* proxy = FindProxy(routing_id);
if (proxy) {
- proxy->SetCompositorFrameSink(compositor_frame_sink);
+ proxy->SetLayerTreeFrameSink(layer_tree_frame_sink);
} else {
- DCHECK(compositor_frame_sink_map_.find(routing_id) ==
- compositor_frame_sink_map_.end());
- compositor_frame_sink_map_[routing_id] = compositor_frame_sink;
+ DCHECK(layer_tree_frame_sink_map_.find(routing_id) ==
+ layer_tree_frame_sink_map_.end());
+ layer_tree_frame_sink_map_[routing_id] = layer_tree_frame_sink;
}
}
@@ -168,18 +168,18 @@
}
}
-void SynchronousCompositorFilter::UnregisterCompositorFrameSink(
+void SynchronousCompositorFilter::UnregisterLayerTreeFrameSink(
int routing_id,
- SynchronousCompositorFrameSink* compositor_frame_sink) {
+ SynchronousLayerTreeFrameSink* layer_tree_frame_sink) {
DCHECK(compositor_task_runner_->BelongsToCurrentThread());
- DCHECK(compositor_frame_sink);
+ DCHECK(layer_tree_frame_sink);
SynchronousCompositorProxy* proxy = FindProxy(routing_id);
if (proxy) {
- proxy->SetCompositorFrameSink(nullptr);
+ proxy->SetLayerTreeFrameSink(nullptr);
}
- auto entry = compositor_frame_sink_map_.find(routing_id);
- if (entry != compositor_frame_sink_map_.end())
- compositor_frame_sink_map_.erase(entry);
+ auto entry = layer_tree_frame_sink_map_.find(routing_id);
+ if (entry != layer_tree_frame_sink_map_.end())
+ layer_tree_frame_sink_map_.erase(entry);
}
void SynchronousCompositorFilter::CreateSynchronousCompositorProxy(
@@ -192,13 +192,13 @@
sync_compositor_map_[routing_id] = std::move(proxy);
}
-void SynchronousCompositorFilter::SetProxyCompositorFrameSink(
+void SynchronousCompositorFilter::SetProxyLayerTreeFrameSink(
int routing_id,
- SynchronousCompositorFrameSink* compositor_frame_sink) {
- DCHECK(compositor_frame_sink);
+ SynchronousLayerTreeFrameSink* layer_tree_frame_sink) {
+ DCHECK(layer_tree_frame_sink);
SynchronousCompositorProxy* proxy = FindProxy(routing_id);
DCHECK(proxy);
- proxy->SetCompositorFrameSink(compositor_frame_sink);
+ proxy->SetLayerTreeFrameSink(layer_tree_frame_sink);
}
void SynchronousCompositorFilter::DidAddSynchronousHandlerProxy(
@@ -209,9 +209,9 @@
if (filter_ready_) {
CreateSynchronousCompositorProxy(routing_id,
synchronous_input_handler_proxy);
- auto entry = compositor_frame_sink_map_.find(routing_id);
- if (entry != compositor_frame_sink_map_.end())
- SetProxyCompositorFrameSink(routing_id, entry->second);
+ auto entry = layer_tree_frame_sink_map_.find(routing_id);
+ if (entry != layer_tree_frame_sink_map_.end())
+ SetProxyLayerTreeFrameSink(routing_id, entry->second);
} else {
auto*& mapped_synchronous_input_handler_proxy =
synchronous_input_handler_proxy_map_[routing_id];
diff --git a/content/renderer/android/synchronous_compositor_filter.h b/content/renderer/android/synchronous_compositor_filter.h
index 1e973bdd8..57a2a6d 100644
--- a/content/renderer/android/synchronous_compositor_filter.h
+++ b/content/renderer/android/synchronous_compositor_filter.h
@@ -48,12 +48,12 @@
bool Send(IPC::Message* message) override;
// SynchronousCompositorRegistry overrides.
- void RegisterCompositorFrameSink(
+ void RegisterLayerTreeFrameSink(
int routing_id,
- SynchronousCompositorFrameSink* compositor_frame_sink) override;
- void UnregisterCompositorFrameSink(
+ SynchronousLayerTreeFrameSink* layer_tree_frame_sink) override;
+ void UnregisterLayerTreeFrameSink(
int routing_id,
- SynchronousCompositorFrameSink* compositor_frame_sink) override;
+ SynchronousLayerTreeFrameSink* layer_tree_frame_sink) override;
// SynchronousInputHandlerProxyClient overrides.
void DidAddSynchronousHandlerProxy(
@@ -74,9 +74,9 @@
void CreateSynchronousCompositorProxy(
int routing_id,
ui::SynchronousInputHandlerProxy* synchronous_input_handler_proxy);
- void SetProxyCompositorFrameSink(
+ void SetProxyLayerTreeFrameSink(
int routing_id,
- SynchronousCompositorFrameSink* compositor_frame_sink);
+ SynchronousLayerTreeFrameSink* layer_tree_frame_sink);
void UnregisterObjects(int routing_id);
void RemoveEntryIfNeeded(int routing_id);
SynchronousCompositorProxy* FindProxy(int routing_id);
@@ -99,14 +99,14 @@
bool filter_ready_;
using SynchronousInputHandlerProxyMap =
base::hash_map<int, ui::SynchronousInputHandlerProxy*>;
- using CompositorFrameSinkMap =
- base::hash_map<int, SynchronousCompositorFrameSink*>;
+ using LayerTreeFrameSinkMap =
+ base::hash_map<int, SynchronousLayerTreeFrameSink*>;
// This is only used before FilterReadyOnCompositorThread.
SynchronousInputHandlerProxyMap synchronous_input_handler_proxy_map_;
// This is only used if input_handler_proxy has not been registered.
- CompositorFrameSinkMap compositor_frame_sink_map_;
+ LayerTreeFrameSinkMap layer_tree_frame_sink_map_;
DISALLOW_COPY_AND_ASSIGN(SynchronousCompositorFilter);
};
diff --git a/content/renderer/android/synchronous_compositor_proxy.cc b/content/renderer/android/synchronous_compositor_proxy.cc
index 8f5bcd4..091ec0f 100644
--- a/content/renderer/android/synchronous_compositor_proxy.cc
+++ b/content/renderer/android/synchronous_compositor_proxy.cc
@@ -31,7 +31,7 @@
use_in_process_zero_copy_software_draw_(
base::CommandLine::ForCurrentProcess()->HasSwitch(
switches::kSingleProcess)),
- compositor_frame_sink_(nullptr),
+ layer_tree_frame_sink_(nullptr),
inside_receive_(false),
hardware_draw_reply_(nullptr),
software_draw_reply_(nullptr),
@@ -48,21 +48,21 @@
}
SynchronousCompositorProxy::~SynchronousCompositorProxy() {
- // The CompositorFrameSink is destroyed/removed by the compositor before
+ // The LayerTreeFrameSink is destroyed/removed by the compositor before
// shutting down everything.
- DCHECK_EQ(compositor_frame_sink_, nullptr);
+ DCHECK_EQ(layer_tree_frame_sink_, nullptr);
input_handler_proxy_->SetOnlySynchronouslyAnimateRootFlings(nullptr);
}
-void SynchronousCompositorProxy::SetCompositorFrameSink(
- SynchronousCompositorFrameSink* compositor_frame_sink) {
- DCHECK_NE(compositor_frame_sink_, compositor_frame_sink);
- if (compositor_frame_sink_) {
- compositor_frame_sink_->SetSyncClient(nullptr);
+void SynchronousCompositorProxy::SetLayerTreeFrameSink(
+ SynchronousLayerTreeFrameSink* layer_tree_frame_sink) {
+ DCHECK_NE(layer_tree_frame_sink_, layer_tree_frame_sink);
+ if (layer_tree_frame_sink_) {
+ layer_tree_frame_sink_->SetSyncClient(nullptr);
}
- compositor_frame_sink_ = compositor_frame_sink;
- if (compositor_frame_sink_) {
- compositor_frame_sink_->SetSyncClient(this);
+ layer_tree_frame_sink_ = layer_tree_frame_sink;
+ if (layer_tree_frame_sink_) {
+ layer_tree_frame_sink_->SetSyncClient(this);
}
}
@@ -129,8 +129,8 @@
void SynchronousCompositorProxy::OnMessageReceived(
const IPC::Message& message) {
- if (compositor_frame_sink_ &&
- compositor_frame_sink_->OnMessageReceived(message))
+ if (layer_tree_frame_sink_ &&
+ layer_tree_frame_sink_->OnMessageReceived(message))
return;
IPC_BEGIN_MESSAGE_MAP(SynchronousCompositorProxy, message)
@@ -169,17 +169,17 @@
DCHECK(!inside_receive_);
inside_receive_ = true;
- if (compositor_frame_sink_) {
+ if (layer_tree_frame_sink_) {
if (!reply_message) {
base::AutoReset<bool> scoped_hardware_draw_reply_async(
&hardware_draw_reply_async_, true);
- compositor_frame_sink_->DemandDrawHw(
+ layer_tree_frame_sink_->DemandDrawHw(
params.viewport_size, params.viewport_rect_for_tile_priority,
params.transform_for_tile_priority);
} else {
base::AutoReset<IPC::Message*> scoped_hardware_draw_reply(
&hardware_draw_reply_, reply_message);
- compositor_frame_sink_->DemandDrawHw(
+ layer_tree_frame_sink_->DemandDrawHw(
params.viewport_size, params.viewport_rect_for_tile_priority,
params.transform_for_tile_priority);
}
@@ -197,39 +197,39 @@
}
void SynchronousCompositorProxy::SubmitCompositorFrameHwAsync(
- uint32_t compositor_frame_sink_id,
+ uint32_t layer_tree_frame_sink_id,
cc::CompositorFrame frame) {
DCHECK(inside_receive_);
DCHECK(hardware_draw_reply_async_);
- SendDemandDrawHwReplyAsync(std::move(frame), compositor_frame_sink_id);
+ SendDemandDrawHwReplyAsync(std::move(frame), layer_tree_frame_sink_id);
inside_receive_ = false;
}
void SynchronousCompositorProxy::SubmitCompositorFrameHw(
- uint32_t compositor_frame_sink_id,
+ uint32_t layer_tree_frame_sink_id,
cc::CompositorFrame frame) {
DCHECK(inside_receive_);
DCHECK(hardware_draw_reply_);
- SendDemandDrawHwReply(std::move(frame), compositor_frame_sink_id,
+ SendDemandDrawHwReply(std::move(frame), layer_tree_frame_sink_id,
hardware_draw_reply_);
inside_receive_ = false;
}
void SynchronousCompositorProxy::SendDemandDrawHwReplyAsync(
base::Optional<cc::CompositorFrame> frame,
- uint32_t compositor_frame_sink_id) {
+ uint32_t layer_tree_frame_sink_id) {
Send(new SyncCompositorHostMsg_ReturnFrame(routing_id_,
- compositor_frame_sink_id, frame));
+ layer_tree_frame_sink_id, frame));
}
void SynchronousCompositorProxy::SendDemandDrawHwReply(
base::Optional<cc::CompositorFrame> frame,
- uint32_t compositor_frame_sink_id,
+ uint32_t layer_tree_frame_sink_id,
IPC::Message* reply_message) {
SyncCompositorCommonRendererParams common_renderer_params;
PopulateCommonParams(&common_renderer_params);
SyncCompositorMsg_DemandDrawHw::WriteReplyParams(
- reply_message, common_renderer_params, compositor_frame_sink_id, frame);
+ reply_message, common_renderer_params, layer_tree_frame_sink_id, frame);
Send(reply_message);
}
@@ -264,7 +264,7 @@
void SynchronousCompositorProxy::ZeroSharedMemory() {
// It is possible for this to get called twice, eg. if draw is called before
- // the CompositorFrameSink is ready. Just ignore duplicated calls rather than
+ // the LayerTreeFrameSink is ready. Just ignore duplicated calls rather than
// inventing a complicated system to avoid it.
if (software_draw_shm_->zeroed)
return;
@@ -278,13 +278,13 @@
IPC::Message* reply_message) {
DCHECK(!inside_receive_);
inside_receive_ = true;
- if (compositor_frame_sink_) {
+ if (layer_tree_frame_sink_) {
base::AutoReset<IPC::Message*> scoped_software_draw_reply(
&software_draw_reply_, reply_message);
SkCanvas* sk_canvas_for_draw = SynchronousCompositorGetSkCanvas();
if (use_in_process_zero_copy_software_draw_) {
DCHECK(sk_canvas_for_draw);
- compositor_frame_sink_->DemandDrawSw(sk_canvas_for_draw);
+ layer_tree_frame_sink_->DemandDrawSw(sk_canvas_for_draw);
} else {
DCHECK(!sk_canvas_for_draw);
DoDemandDrawSw(params);
@@ -299,7 +299,7 @@
void SynchronousCompositorProxy::DoDemandDrawSw(
const SyncCompositorDemandDrawSwParams& params) {
- DCHECK(compositor_frame_sink_);
+ DCHECK(layer_tree_frame_sink_);
DCHECK(software_draw_shm_->zeroed);
software_draw_shm_->zeroed = false;
@@ -316,7 +316,7 @@
canvas.clipRect(gfx::RectToSkRect(params.clip));
canvas.concat(params.transform.matrix());
- compositor_frame_sink_->DemandDrawSw(&canvas);
+ layer_tree_frame_sink_->DemandDrawSw(&canvas);
}
void SynchronousCompositorProxy::SubmitCompositorFrameSw(
@@ -338,7 +338,7 @@
}
void SynchronousCompositorProxy::SubmitCompositorFrame(
- uint32_t compositor_frame_sink_id,
+ uint32_t layer_tree_frame_sink_id,
cc::CompositorFrame frame) {
// Verify that exactly one of these is true.
DCHECK(hardware_draw_reply_async_ || hardware_draw_reply_ ||
@@ -347,9 +347,9 @@
(hardware_draw_reply_ && hardware_draw_reply_async_) ||
(software_draw_reply_ && hardware_draw_reply_async_)));
if (hardware_draw_reply_async_) {
- SubmitCompositorFrameHwAsync(compositor_frame_sink_id, std::move(frame));
+ SubmitCompositorFrameHwAsync(layer_tree_frame_sink_id, std::move(frame));
} else if (hardware_draw_reply_) {
- SubmitCompositorFrameHw(compositor_frame_sink_id, std::move(frame));
+ SubmitCompositorFrameHw(layer_tree_frame_sink_id, std::move(frame));
} else if (software_draw_reply_) {
SubmitCompositorFrameSw(std::move(frame));
}
diff --git a/content/renderer/android/synchronous_compositor_proxy.h b/content/renderer/android/synchronous_compositor_proxy.h
index cc09074..2036a5af 100644
--- a/content/renderer/android/synchronous_compositor_proxy.h
+++ b/content/renderer/android/synchronous_compositor_proxy.h
@@ -11,7 +11,7 @@
#include "base/macros.h"
#include "base/optional.h"
#include "content/common/input/input_event_ack_state.h"
-#include "content/renderer/android/synchronous_compositor_frame_sink.h"
+#include "content/renderer/android/synchronous_layer_tree_frame_sink.h"
#include "ui/events/blink/synchronous_input_handler_proxy.h"
#include "ui/gfx/geometry/scroll_offset.h"
#include "ui/gfx/geometry/size_f.h"
@@ -27,14 +27,14 @@
namespace content {
-class SynchronousCompositorFrameSink;
+class SynchronousLayerTreeFrameSink;
struct SyncCompositorCommonRendererParams;
struct SyncCompositorDemandDrawHwParams;
struct SyncCompositorDemandDrawSwParams;
struct SyncCompositorSetSharedMemoryParams;
class SynchronousCompositorProxy : public ui::SynchronousInputHandler,
- public SynchronousCompositorFrameSinkClient {
+ public SynchronousLayerTreeFrameSinkClient {
public:
SynchronousCompositorProxy(
int routing_id,
@@ -51,14 +51,14 @@
float min_page_scale_factor,
float max_page_scale_factor) override;
- // SynchronousCompositorFrameSinkClient overrides.
+ // SynchronousLayerTreeFrameSinkClient overrides.
void DidActivatePendingTree() override;
void Invalidate() override;
- void SubmitCompositorFrame(uint32_t compositor_frame_sink_id,
+ void SubmitCompositorFrame(uint32_t layer_tree_frame_sink_id,
cc::CompositorFrame frame) override;
- void SetCompositorFrameSink(
- SynchronousCompositorFrameSink* compositor_frame_sink);
+ void SetLayerTreeFrameSink(
+ SynchronousLayerTreeFrameSink* layer_tree_frame_sink);
void OnMessageReceived(const IPC::Message& message);
bool Send(IPC::Message* message);
void PopulateCommonParams(SyncCompositorCommonRendererParams* params) const;
@@ -84,15 +84,15 @@
SyncCompositorCommonRendererParams* common_renderer_params);
void SetScroll(const gfx::ScrollOffset& total_scroll_offset);
- void SubmitCompositorFrameHwAsync(uint32_t compositor_frame_sink_id,
+ void SubmitCompositorFrameHwAsync(uint32_t layer_tree_frame_sink_id,
cc::CompositorFrame frame);
- void SubmitCompositorFrameHw(uint32_t compositor_frame_sink_id,
+ void SubmitCompositorFrameHw(uint32_t layer_tree_frame_sink_id,
cc::CompositorFrame frame);
void SendDemandDrawHwReply(base::Optional<cc::CompositorFrame> frame,
- uint32_t compositor_frame_sink_id,
+ uint32_t layer_tree_frame_sink_id,
IPC::Message* reply_message);
void SendDemandDrawHwReplyAsync(base::Optional<cc::CompositorFrame> frame,
- uint32_t compositor_frame_sink_id);
+ uint32_t layer_tree_frame_sink_id);
void DoDemandDrawSw(const SyncCompositorDemandDrawSwParams& params);
void SubmitCompositorFrameSw(cc::CompositorFrame frame);
void SendDemandDrawSwReply(
@@ -106,7 +106,7 @@
IPC::Sender* const sender_;
ui::SynchronousInputHandlerProxy* const input_handler_proxy_;
const bool use_in_process_zero_copy_software_draw_;
- SynchronousCompositorFrameSink* compositor_frame_sink_;
+ SynchronousLayerTreeFrameSink* layer_tree_frame_sink_;
bool inside_receive_;
IPC::Message* hardware_draw_reply_;
IPC::Message* software_draw_reply_;
diff --git a/content/renderer/android/synchronous_compositor_registry.h b/content/renderer/android/synchronous_compositor_registry.h
index 52995bc..588343c 100644
--- a/content/renderer/android/synchronous_compositor_registry.h
+++ b/content/renderer/android/synchronous_compositor_registry.h
@@ -7,16 +7,16 @@
namespace content {
-class SynchronousCompositorFrameSink;
+class SynchronousLayerTreeFrameSink;
class SynchronousCompositorRegistry {
public:
- virtual void RegisterCompositorFrameSink(
+ virtual void RegisterLayerTreeFrameSink(
int routing_id,
- SynchronousCompositorFrameSink* compositor_frame_sink) = 0;
- virtual void UnregisterCompositorFrameSink(
+ SynchronousLayerTreeFrameSink* layer_tree_frame_sink) = 0;
+ virtual void UnregisterLayerTreeFrameSink(
int routing_id,
- SynchronousCompositorFrameSink* compositor_frame_sink) = 0;
+ SynchronousLayerTreeFrameSink* layer_tree_frame_sink) = 0;
protected:
virtual ~SynchronousCompositorRegistry() {}
diff --git a/content/renderer/android/synchronous_compositor_frame_sink.cc b/content/renderer/android/synchronous_layer_tree_frame_sink.cc
similarity index 85%
rename from content/renderer/android/synchronous_compositor_frame_sink.cc
rename to content/renderer/android/synchronous_layer_tree_frame_sink.cc
index 18fc973..2237321 100644
--- a/content/renderer/android/synchronous_compositor_frame_sink.cc
+++ b/content/renderer/android/synchronous_layer_tree_frame_sink.cc
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "content/renderer/android/synchronous_compositor_frame_sink.h"
+#include "content/renderer/android/synchronous_layer_tree_frame_sink.h"
#include <vector>
@@ -14,8 +14,8 @@
#include "base/single_thread_task_runner.h"
#include "base/threading/thread_task_runner_handle.h"
#include "cc/output/compositor_frame.h"
-#include "cc/output/compositor_frame_sink_client.h"
#include "cc/output/context_provider.h"
+#include "cc/output/layer_tree_frame_sink_client.h"
#include "cc/output/output_surface.h"
#include "cc/output/output_surface_frame.h"
#include "cc/output/renderer_settings.h"
@@ -76,7 +76,7 @@
} // namespace
-class SynchronousCompositorFrameSink::SoftwareOutputSurface
+class SynchronousLayerTreeFrameSink::SoftwareOutputSurface
: public cc::OutputSurface {
public:
SoftwareOutputSurface(std::unique_ptr<SoftwareDevice> software_device)
@@ -105,22 +105,22 @@
void ApplyExternalStencil() override {}
};
-SynchronousCompositorFrameSink::SynchronousCompositorFrameSink(
+SynchronousLayerTreeFrameSink::SynchronousLayerTreeFrameSink(
scoped_refptr<cc::ContextProvider> context_provider,
scoped_refptr<cc::ContextProvider> worker_context_provider,
gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
cc::SharedBitmapManager* shared_bitmap_manager,
int routing_id,
- uint32_t compositor_frame_sink_id,
+ uint32_t layer_tree_frame_sink_id,
std::unique_ptr<cc::BeginFrameSource> begin_frame_source,
SynchronousCompositorRegistry* registry,
scoped_refptr<FrameSwapMessageQueue> frame_swap_message_queue)
- : cc::CompositorFrameSink(std::move(context_provider),
- std::move(worker_context_provider),
- gpu_memory_buffer_manager,
- nullptr),
+ : cc::LayerTreeFrameSink(std::move(context_provider),
+ std::move(worker_context_provider),
+ gpu_memory_buffer_manager,
+ nullptr),
routing_id_(routing_id),
- compositor_frame_sink_id_(compositor_frame_sink_id),
+ layer_tree_frame_sink_id_(layer_tree_frame_sink_id),
registry_(registry),
shared_bitmap_manager_(shared_bitmap_manager),
sender_(RenderThreadImpl::current()->sync_compositor_message_filter()),
@@ -137,20 +137,20 @@
gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE;
}
-SynchronousCompositorFrameSink::~SynchronousCompositorFrameSink() = default;
+SynchronousLayerTreeFrameSink::~SynchronousLayerTreeFrameSink() = default;
-void SynchronousCompositorFrameSink::SetSyncClient(
- SynchronousCompositorFrameSinkClient* compositor) {
+void SynchronousLayerTreeFrameSink::SetSyncClient(
+ SynchronousLayerTreeFrameSinkClient* compositor) {
DCHECK(CalledOnValidThread());
sync_client_ = compositor;
if (sync_client_)
- Send(new SyncCompositorHostMsg_CompositorFrameSinkCreated(routing_id_));
+ Send(new SyncCompositorHostMsg_LayerTreeFrameSinkCreated(routing_id_));
}
-bool SynchronousCompositorFrameSink::OnMessageReceived(
+bool SynchronousLayerTreeFrameSink::OnMessageReceived(
const IPC::Message& message) {
bool handled = true;
- IPC_BEGIN_MESSAGE_MAP(SynchronousCompositorFrameSink, message)
+ IPC_BEGIN_MESSAGE_MAP(SynchronousLayerTreeFrameSink, message)
IPC_MESSAGE_HANDLER(SyncCompositorMsg_SetMemoryPolicy, SetMemoryPolicy)
IPC_MESSAGE_HANDLER(SyncCompositorMsg_ReclaimResources, OnReclaimResources)
IPC_MESSAGE_UNHANDLED(handled = false)
@@ -158,19 +158,19 @@
return handled;
}
-bool SynchronousCompositorFrameSink::BindToClient(
- cc::CompositorFrameSinkClient* sink_client) {
+bool SynchronousLayerTreeFrameSink::BindToClient(
+ cc::LayerTreeFrameSinkClient* sink_client) {
DCHECK(CalledOnValidThread());
- if (!cc::CompositorFrameSink::BindToClient(sink_client))
+ if (!cc::LayerTreeFrameSink::BindToClient(sink_client))
return false;
DCHECK(begin_frame_source_);
client_->SetBeginFrameSource(begin_frame_source_.get());
client_->SetMemoryPolicy(memory_policy_);
client_->SetTreeActivationCallback(
- base::Bind(&SynchronousCompositorFrameSink::DidActivatePendingTree,
+ base::Bind(&SynchronousLayerTreeFrameSink::DidActivatePendingTree,
base::Unretained(this)));
- registry_->RegisterCompositorFrameSink(routing_id_, this);
+ registry_->RegisterLayerTreeFrameSink(routing_id_, this);
constexpr bool root_support_is_root = true;
constexpr bool child_support_is_root = false;
@@ -205,12 +205,12 @@
return true;
}
-void SynchronousCompositorFrameSink::DetachFromClient() {
+void SynchronousLayerTreeFrameSink::DetachFromClient() {
DCHECK(CalledOnValidThread());
client_->SetBeginFrameSource(nullptr);
// Destroy the begin frame source on the same thread it was bound on.
begin_frame_source_ = nullptr;
- registry_->UnregisterCompositorFrameSink(routing_id_, this);
+ registry_->UnregisterLayerTreeFrameSink(routing_id_, this);
client_->SetTreeActivationCallback(base::Closure());
root_support_.reset();
child_support_.reset();
@@ -218,11 +218,11 @@
display_ = nullptr;
local_surface_id_allocator_ = nullptr;
surface_manager_ = nullptr;
- cc::CompositorFrameSink::DetachFromClient();
+ cc::LayerTreeFrameSink::DetachFromClient();
CancelFallbackTick();
}
-void SynchronousCompositorFrameSink::SubmitCompositorFrame(
+void SynchronousLayerTreeFrameSink::SubmitCompositorFrame(
cc::CompositorFrame frame) {
DCHECK(CalledOnValidThread());
DCHECK(sync_client_);
@@ -279,7 +279,7 @@
// Make a root frame that embeds the frame coming from the layer compositor
// and positions it based on the provided viewport.
// TODO(danakj): We could apply the transform here instead of passing it to
- // the CompositorFrameSink client too? (We'd have to do the same for
+ // the LayerTreeFrameSink client too? (We'd have to do the same for
// hardware frames in SurfacesInstance?)
cc::CompositorFrame embed_frame;
embed_frame.metadata.begin_frame_ack = frame.metadata.begin_frame_ack;
@@ -320,26 +320,26 @@
submit_frame = std::move(frame);
}
- sync_client_->SubmitCompositorFrame(compositor_frame_sink_id_,
+ sync_client_->SubmitCompositorFrame(layer_tree_frame_sink_id_,
std::move(submit_frame));
did_submit_frame_ = true;
}
-void SynchronousCompositorFrameSink::DidNotProduceFrame(
+void SynchronousLayerTreeFrameSink::DidNotProduceFrame(
const cc::BeginFrameAck& ack) {
DCHECK(!ack.has_damage);
DCHECK_LE(cc::BeginFrameArgs::kStartingFrameNumber, ack.sequence_number);
Send(new ViewHostMsg_DidNotProduceFrame(routing_id_, ack));
}
-void SynchronousCompositorFrameSink::CancelFallbackTick() {
+void SynchronousLayerTreeFrameSink::CancelFallbackTick() {
fallback_tick_.Cancel();
fallback_tick_pending_ = false;
}
-void SynchronousCompositorFrameSink::FallbackTickFired() {
+void SynchronousLayerTreeFrameSink::FallbackTickFired() {
DCHECK(CalledOnValidThread());
- TRACE_EVENT0("renderer", "SynchronousCompositorFrameSink::FallbackTickFired");
+ TRACE_EVENT0("renderer", "SynchronousLayerTreeFrameSink::FallbackTickFired");
base::AutoReset<bool> in_fallback_tick(&fallback_tick_running_, true);
frame_swap_message_queue_->NotifyFramesAreDiscarded(true);
SkBitmap bitmap;
@@ -351,14 +351,14 @@
frame_swap_message_queue_->NotifyFramesAreDiscarded(false);
}
-void SynchronousCompositorFrameSink::Invalidate() {
+void SynchronousLayerTreeFrameSink::Invalidate() {
DCHECK(CalledOnValidThread());
if (sync_client_)
sync_client_->Invalidate();
if (!fallback_tick_pending_) {
fallback_tick_.Reset(
- base::Bind(&SynchronousCompositorFrameSink::FallbackTickFired,
+ base::Bind(&SynchronousLayerTreeFrameSink::FallbackTickFired,
base::Unretained(this)));
base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
FROM_HERE, fallback_tick_.callback(),
@@ -367,7 +367,7 @@
}
}
-void SynchronousCompositorFrameSink::DemandDrawHw(
+void SynchronousLayerTreeFrameSink::DemandDrawHw(
const gfx::Size& viewport_size,
const gfx::Rect& viewport_rect_for_tile_priority,
const gfx::Transform& transform_for_tile_priority) {
@@ -381,7 +381,7 @@
InvokeComposite(gfx::Transform(), gfx::Rect(viewport_size));
}
-void SynchronousCompositorFrameSink::DemandDrawSw(SkCanvas* canvas) {
+void SynchronousLayerTreeFrameSink::DemandDrawSw(SkCanvas* canvas) {
DCHECK(CalledOnValidThread());
DCHECK(canvas);
DCHECK(!current_sw_canvas_);
@@ -403,7 +403,7 @@
InvokeComposite(transform, viewport);
}
-void SynchronousCompositorFrameSink::InvokeComposite(
+void SynchronousLayerTreeFrameSink::InvokeComposite(
const gfx::Transform& transform,
const gfx::Rect& viewport) {
did_submit_frame_ = false;
@@ -425,17 +425,17 @@
}
}
-void SynchronousCompositorFrameSink::OnReclaimResources(
- uint32_t compositor_frame_sink_id,
+void SynchronousLayerTreeFrameSink::OnReclaimResources(
+ uint32_t layer_tree_frame_sink_id,
const cc::ReturnedResourceArray& resources) {
// Ignore message if it's a stale one coming from a different output surface
// (e.g. after a lost context).
- if (compositor_frame_sink_id != compositor_frame_sink_id_)
+ if (layer_tree_frame_sink_id != layer_tree_frame_sink_id_)
return;
client_->ReclaimResources(resources);
}
-void SynchronousCompositorFrameSink::SetMemoryPolicy(size_t bytes_limit) {
+void SynchronousLayerTreeFrameSink::SetMemoryPolicy(size_t bytes_limit) {
DCHECK(CalledOnValidThread());
bool became_zero = memory_policy_.bytes_limit_when_visible && !bytes_limit;
bool became_non_zero =
@@ -457,14 +457,14 @@
}
}
-void SynchronousCompositorFrameSink::DidActivatePendingTree() {
+void SynchronousLayerTreeFrameSink::DidActivatePendingTree() {
DCHECK(CalledOnValidThread());
if (sync_client_)
sync_client_->DidActivatePendingTree();
DeliverMessages();
}
-void SynchronousCompositorFrameSink::DeliverMessages() {
+void SynchronousLayerTreeFrameSink::DeliverMessages() {
std::vector<std::unique_ptr<IPC::Message>> messages;
std::unique_ptr<FrameSwapMessageQueue::SendMessageScope> send_message_scope =
frame_swap_message_queue_->AcquireSendMessageScope();
@@ -474,30 +474,30 @@
}
}
-bool SynchronousCompositorFrameSink::Send(IPC::Message* message) {
+bool SynchronousLayerTreeFrameSink::Send(IPC::Message* message) {
DCHECK(CalledOnValidThread());
return sender_->Send(message);
}
-bool SynchronousCompositorFrameSink::CalledOnValidThread() const {
+bool SynchronousLayerTreeFrameSink::CalledOnValidThread() const {
return thread_checker_.CalledOnValidThread();
}
-void SynchronousCompositorFrameSink::DidReceiveCompositorFrameAck(
+void SynchronousLayerTreeFrameSink::DidReceiveCompositorFrameAck(
const cc::ReturnedResourceArray& resources) {
ReclaimResources(resources);
}
-void SynchronousCompositorFrameSink::OnBeginFrame(
+void SynchronousLayerTreeFrameSink::OnBeginFrame(
const cc::BeginFrameArgs& args) {}
-void SynchronousCompositorFrameSink::ReclaimResources(
+void SynchronousLayerTreeFrameSink::ReclaimResources(
const cc::ReturnedResourceArray& resources) {
DCHECK(resources.empty());
client_->ReclaimResources(resources);
}
-void SynchronousCompositorFrameSink::WillDrawSurface(
+void SynchronousLayerTreeFrameSink::WillDrawSurface(
const cc::LocalSurfaceId& local_surface_id,
const gfx::Rect& damage_rect) {}
diff --git a/content/renderer/android/synchronous_compositor_frame_sink.h b/content/renderer/android/synchronous_layer_tree_frame_sink.h
similarity index 80%
rename from content/renderer/android/synchronous_compositor_frame_sink.h
rename to content/renderer/android/synchronous_layer_tree_frame_sink.h
index d906795..cef49ac 100644
--- a/content/renderer/android/synchronous_compositor_frame_sink.h
+++ b/content/renderer/android/synchronous_layer_tree_frame_sink.h
@@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef CONTENT_RENDERER_ANDROID_SYNCHRONOUS_COMPOSITOR_FRAME_SINK_H_
-#define CONTENT_RENDERER_ANDROID_SYNCHRONOUS_COMPOSITOR_FRAME_SINK_H_
+#ifndef CONTENT_RENDERER_ANDROID_SYNCHRONOUS_LAYER_TREE_FRAME_SINK_H_
+#define CONTENT_RENDERER_ANDROID_SYNCHRONOUS_LAYER_TREE_FRAME_SINK_H_
#include <stddef.h>
@@ -16,7 +16,7 @@
#include "base/memory/ref_counted.h"
#include "base/threading/thread_checker.h"
#include "cc/output/compositor_frame.h"
-#include "cc/output/compositor_frame_sink.h"
+#include "cc/output/layer_tree_frame_sink.h"
#include "cc/output/managed_memory_policy.h"
#include "cc/surfaces/compositor_frame_sink_support_client.h"
#include "cc/surfaces/display_client.h"
@@ -32,58 +32,58 @@
class Display;
class LocalSurfaceIdAllocator;
class SurfaceManager;
-}
+} // namespace cc
namespace IPC {
class Message;
class Sender;
-}
+} // namespace IPC
namespace content {
class FrameSwapMessageQueue;
class SynchronousCompositorRegistry;
-class SynchronousCompositorFrameSinkClient {
+class SynchronousLayerTreeFrameSinkClient {
public:
virtual void DidActivatePendingTree() = 0;
virtual void Invalidate() = 0;
- virtual void SubmitCompositorFrame(uint32_t compositor_frame_sink_id,
+ virtual void SubmitCompositorFrame(uint32_t layer_tree_frame_sink_id,
cc::CompositorFrame frame) = 0;
protected:
- virtual ~SynchronousCompositorFrameSinkClient() {}
+ virtual ~SynchronousLayerTreeFrameSinkClient() {}
};
// Specialization of the output surface that adapts it to implement the
// content::SynchronousCompositor public API. This class effects an "inversion
// of control" - enabling drawing to be orchestrated by the embedding
// layer, instead of driven by the compositor internals - hence it holds two
-// 'client' pointers (|client_| in the CompositorFrameSink baseclass and
+// 'client' pointers (|client_| in the LayerTreeFrameSink baseclass and
// |delegate_|) which represent the consumers of the two roles in plays.
// This class can be created only on the main thread, but then becomes pinned
// to a fixed thread when BindToClient is called.
-class SynchronousCompositorFrameSink
- : NON_EXPORTED_BASE(public cc::CompositorFrameSink),
+class SynchronousLayerTreeFrameSink
+ : NON_EXPORTED_BASE(public cc::LayerTreeFrameSink),
public cc::CompositorFrameSinkSupportClient {
public:
- SynchronousCompositorFrameSink(
+ SynchronousLayerTreeFrameSink(
scoped_refptr<cc::ContextProvider> context_provider,
scoped_refptr<cc::ContextProvider> worker_context_provider,
gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
cc::SharedBitmapManager* shared_bitmap_manager,
int routing_id,
- uint32_t compositor_frame_sink_id,
+ uint32_t layer_tree_frame_sink_id,
std::unique_ptr<cc::BeginFrameSource> begin_frame_source,
SynchronousCompositorRegistry* registry,
scoped_refptr<FrameSwapMessageQueue> frame_swap_message_queue);
- ~SynchronousCompositorFrameSink() override;
+ ~SynchronousLayerTreeFrameSink() override;
- void SetSyncClient(SynchronousCompositorFrameSinkClient* compositor);
+ void SetSyncClient(SynchronousLayerTreeFrameSinkClient* compositor);
bool OnMessageReceived(const IPC::Message& message);
- // cc::CompositorFrameSink implementation.
- bool BindToClient(cc::CompositorFrameSinkClient* sink_client) override;
+ // cc::LayerTreeFrameSink implementation.
+ bool BindToClient(cc::LayerTreeFrameSinkClient* sink_client) override;
void DetachFromClient() override;
void SubmitCompositorFrame(cc::CompositorFrame frame) override;
void DidNotProduceFrame(const cc::BeginFrameAck& ack) override;
@@ -118,17 +118,17 @@
// IPC handlers.
void SetMemoryPolicy(size_t bytes_limit);
- void OnReclaimResources(uint32_t compositor_frame_sink_id,
+ void OnReclaimResources(uint32_t layer_tree_frame_sink_id,
const cc::ReturnedResourceArray& resources);
const int routing_id_;
- const uint32_t compositor_frame_sink_id_;
- SynchronousCompositorRegistry* const registry_; // Not owned.
+ const uint32_t layer_tree_frame_sink_id_;
+ SynchronousCompositorRegistry* const registry_; // Not owned.
cc::SharedBitmapManager* const shared_bitmap_manager_; // Not owned.
- IPC::Sender* const sender_; // Not owned.
+ IPC::Sender* const sender_; // Not owned.
// Not owned.
- SynchronousCompositorFrameSinkClient* sync_client_ = nullptr;
+ SynchronousLayerTreeFrameSinkClient* sync_client_ = nullptr;
// Only valid (non-NULL) during a DemandDrawSw() call.
SkCanvas* current_sw_canvas_ = nullptr;
@@ -174,9 +174,9 @@
base::ThreadChecker thread_checker_;
- DISALLOW_COPY_AND_ASSIGN(SynchronousCompositorFrameSink);
+ DISALLOW_COPY_AND_ASSIGN(SynchronousLayerTreeFrameSink);
};
} // namespace content
-#endif // CONTENT_RENDERER_ANDROID_SYNCHRONOUS_COMPOSITOR_FRAME_SINK_H_
+#endif // CONTENT_RENDERER_ANDROID_SYNCHRONOUS_LAYER_TREE_FRAME_SINK_H_
diff --git a/content/renderer/gpu/render_widget_compositor.cc b/content/renderer/gpu/render_widget_compositor.cc
index 68172ceb..c2c1b3f 100644
--- a/content/renderer/gpu/render_widget_compositor.cc
+++ b/content/renderer/gpu/render_widget_compositor.cc
@@ -971,13 +971,13 @@
}
}
-void RenderWidgetCompositor::SetCompositorFrameSink(
- std::unique_ptr<cc::CompositorFrameSink> compositor_frame_sink) {
- if (!compositor_frame_sink) {
- DidFailToInitializeCompositorFrameSink();
+void RenderWidgetCompositor::SetLayerTreeFrameSink(
+ std::unique_ptr<cc::LayerTreeFrameSink> layer_tree_frame_sink) {
+ if (!layer_tree_frame_sink) {
+ DidFailToInitializeLayerTreeFrameSink();
return;
}
- layer_tree_host_->SetCompositorFrameSink(std::move(compositor_frame_sink));
+ layer_tree_host_->SetLayerTreeFrameSink(std::move(layer_tree_frame_sink));
}
void RenderWidgetCompositor::LayoutAndUpdateLayers() {
@@ -1151,40 +1151,40 @@
has_scrolled_by_touch);
}
-void RenderWidgetCompositor::RequestNewCompositorFrameSink() {
+void RenderWidgetCompositor::RequestNewLayerTreeFrameSink() {
// If the host is closing, then no more compositing is possible. This
// prevents shutdown races between handling the close message and
- // the CreateCompositorFrameSink task.
+ // the CreateLayerTreeFrameSink task.
if (delegate_->IsClosing())
return;
bool fallback = num_failed_recreate_attempts_ >=
- COMPOSITOR_FRAME_SINK_RETRIES_BEFORE_FALLBACK;
+ LAYER_TREE_FRAME_SINK_RETRIES_BEFORE_FALLBACK;
#ifdef OS_ANDROID
LOG_IF(FATAL, fallback) << "Android does not support fallback frame sinks.";
#endif
- delegate_->RequestNewCompositorFrameSink(
- fallback, base::Bind(&RenderWidgetCompositor::SetCompositorFrameSink,
+ delegate_->RequestNewLayerTreeFrameSink(
+ fallback, base::Bind(&RenderWidgetCompositor::SetLayerTreeFrameSink,
weak_factory_.GetWeakPtr()));
}
-void RenderWidgetCompositor::DidInitializeCompositorFrameSink() {
+void RenderWidgetCompositor::DidInitializeLayerTreeFrameSink() {
num_failed_recreate_attempts_ = 0;
}
-void RenderWidgetCompositor::DidFailToInitializeCompositorFrameSink() {
+void RenderWidgetCompositor::DidFailToInitializeLayerTreeFrameSink() {
++num_failed_recreate_attempts_;
// Tolerate a certain number of recreation failures to work around races
// in the output-surface-lost machinery.
LOG_IF(FATAL,
- (num_failed_recreate_attempts_ >= MAX_COMPOSITOR_FRAME_SINK_RETRIES))
- << "Failed to create a fallback CompositorFrameSink.";
+ (num_failed_recreate_attempts_ >= MAX_LAYER_TREE_FRAME_SINK_RETRIES))
+ << "Failed to create a fallback LayerTreeFrameSink.";
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::Bind(&RenderWidgetCompositor::RequestNewCompositorFrameSink,
+ base::Bind(&RenderWidgetCompositor::RequestNewLayerTreeFrameSink,
weak_factory_.GetWeakPtr()));
}
@@ -1219,7 +1219,7 @@
void RenderWidgetCompositor::DidSubmitCompositorFrame() {}
-void RenderWidgetCompositor::DidLoseCompositorFrameSink() {}
+void RenderWidgetCompositor::DidLoseLayerTreeFrameSink() {}
void RenderWidgetCompositor::SetFrameSinkId(
const cc::FrameSinkId& frame_sink_id) {
diff --git a/content/renderer/gpu/render_widget_compositor.h b/content/renderer/gpu/render_widget_compositor.h
index 7afa1a68..84e8a29 100644
--- a/content/renderer/gpu/render_widget_compositor.h
+++ b/content/renderer/gpu/render_widget_compositor.h
@@ -32,6 +32,7 @@
class AnimationHost;
class InputHandler;
class Layer;
+class LayerTreeFrameSink;
class LayerTreeHost;
class MutatorHost;
}
@@ -199,9 +200,9 @@
float top_controls_delta) override;
void RecordWheelAndTouchScrollingCount(bool has_scrolled_by_wheel,
bool has_scrolled_by_touch) override;
- void RequestNewCompositorFrameSink() override;
- void DidInitializeCompositorFrameSink() override;
- void DidFailToInitializeCompositorFrameSink() override;
+ void RequestNewLayerTreeFrameSink() override;
+ void DidInitializeLayerTreeFrameSink() override;
+ void DidFailToInitializeLayerTreeFrameSink() override;
void WillCommit() override;
void DidCommit() override;
void DidCommitAndDrawFrame() override;
@@ -212,12 +213,12 @@
// cc::LayerTreeHostSingleThreadClient implementation.
void RequestScheduleAnimation() override;
void DidSubmitCompositorFrame() override;
- void DidLoseCompositorFrameSink() override;
+ void DidLoseLayerTreeFrameSink() override;
void RequestBeginMainFrameNotExpected(bool new_state) override;
enum {
- COMPOSITOR_FRAME_SINK_RETRIES_BEFORE_FALLBACK = 4,
- MAX_COMPOSITOR_FRAME_SINK_RETRIES = 5,
+ LAYER_TREE_FRAME_SINK_RETRIES_BEFORE_FALLBACK = 4,
+ MAX_LAYER_TREE_FRAME_SINK_RETRIES = 5,
};
protected:
@@ -229,8 +230,8 @@
cc::LayerTreeHost* layer_tree_host() { return layer_tree_host_.get(); }
private:
- void SetCompositorFrameSink(
- std::unique_ptr<cc::CompositorFrameSink> compositor_frame_sink);
+ void SetLayerTreeFrameSink(
+ std::unique_ptr<cc::LayerTreeFrameSink> layer_tree_frame_sink);
void LayoutAndUpdateLayers();
void InvokeLayoutAndPaintCallback();
bool CompositeIsSynchronous() const;
diff --git a/content/renderer/gpu/render_widget_compositor_delegate.h b/content/renderer/gpu/render_widget_compositor_delegate.h
index a9e7392..8683cef1 100644
--- a/content/renderer/gpu/render_widget_compositor_delegate.h
+++ b/content/renderer/gpu/render_widget_compositor_delegate.h
@@ -13,7 +13,7 @@
namespace cc {
class CopyOutputRequest;
-class CompositorFrameSink;
+class LayerTreeFrameSink;
class SwapPromise;
}
@@ -23,8 +23,8 @@
namespace content {
-using CompositorFrameSinkCallback =
- base::Callback<void(std::unique_ptr<cc::CompositorFrameSink>)>;
+using LayerTreeFrameSinkCallback =
+ base::Callback<void(std::unique_ptr<cc::LayerTreeFrameSink>)>;
// Consumers of RenderWidgetCompositor implement this delegate in order to
// transport compositing information across processes.
@@ -48,10 +48,10 @@
// Notifies that the compositor has issed a BeginMainFrame.
virtual void BeginMainFrame(double frame_time_sec) = 0;
- // Requests a CompositorFrameSink to submit CompositorFrames to.
- virtual void RequestNewCompositorFrameSink(
+ // Requests a LayerTreeFrameSink to submit CompositorFrames to.
+ virtual void RequestNewLayerTreeFrameSink(
bool fallback,
- const CompositorFrameSinkCallback& callback) = 0;
+ const LayerTreeFrameSinkCallback& callback) = 0;
// Notifies that the draw commands for a committed frame have been issued.
virtual void DidCommitAndDrawCompositorFrame() = 0;
diff --git a/content/renderer/gpu/render_widget_compositor_unittest.cc b/content/renderer/gpu/render_widget_compositor_unittest.cc
index eeb3e29..007194b 100644
--- a/content/renderer/gpu/render_widget_compositor_unittest.cc
+++ b/content/renderer/gpu/render_widget_compositor_unittest.cc
@@ -16,7 +16,7 @@
#include "cc/animation/animation_host.h"
#include "cc/output/begin_frame_args.h"
#include "cc/output/copy_output_request.h"
-#include "cc/test/fake_compositor_frame_sink.h"
+#include "cc/test/fake_layer_tree_frame_sink.h"
#include "cc/test/test_context_provider.h"
#include "cc/test/test_web_graphics_context_3d.h"
#include "cc/trees/layer_tree_host.h"
@@ -46,9 +46,9 @@
void RecordWheelAndTouchScrollingCount(bool has_scrolled_by_wheel,
bool has_scrolled_by_touch) override {}
void BeginMainFrame(double frame_time_sec) override {}
- void RequestNewCompositorFrameSink(
+ void RequestNewLayerTreeFrameSink(
bool fallback,
- const CompositorFrameSinkCallback& callback) override {
+ const LayerTreeFrameSinkCallback& callback) override {
callback.Run(nullptr);
}
void DidCommitAndDrawCompositorFrame() override {}
@@ -70,18 +70,18 @@
public:
FakeRenderWidgetCompositorDelegate() = default;
- void RequestNewCompositorFrameSink(
+ void RequestNewLayerTreeFrameSink(
bool fallback,
- const CompositorFrameSinkCallback& callback) override {
+ const LayerTreeFrameSinkCallback& callback) override {
EXPECT_EQ(num_requests_since_last_success_ >
RenderWidgetCompositor::
- COMPOSITOR_FRAME_SINK_RETRIES_BEFORE_FALLBACK,
+ LAYER_TREE_FRAME_SINK_RETRIES_BEFORE_FALLBACK,
fallback);
last_create_was_fallback_ = fallback;
bool success = num_failures_ >= num_failures_before_success_;
- if (!success && use_null_compositor_frame_sink_) {
- callback.Run(std::unique_ptr<cc::CompositorFrameSink>());
+ if (!success && use_null_layer_tree_frame_sink_) {
+ callback.Run(std::unique_ptr<cc::LayerTreeFrameSink>());
return;
}
@@ -91,7 +91,7 @@
GL_GUILTY_CONTEXT_RESET_ARB, GL_INNOCENT_CONTEXT_RESET_ARB);
}
callback.Run(
- cc::FakeCompositorFrameSink::Create3d(std::move(context_provider)));
+ cc::FakeLayerTreeFrameSink::Create3d(std::move(context_provider)));
}
void add_success() {
@@ -120,11 +120,11 @@
return num_failures_before_success_;
}
- void set_use_null_compositor_frame_sink(bool u) {
- use_null_compositor_frame_sink_ = u;
+ void set_use_null_layer_tree_frame_sink(bool u) {
+ use_null_layer_tree_frame_sink_ = u;
}
- bool use_null_compositor_frame_sink() const {
- return use_null_compositor_frame_sink_;
+ bool use_null_layer_tree_frame_sink() const {
+ return use_null_layer_tree_frame_sink_;
}
private:
@@ -135,7 +135,7 @@
int num_fallback_successes_ = 0;
int num_successes_ = 0;
bool last_create_was_fallback_ = false;
- bool use_null_compositor_frame_sink_ = true;
+ bool use_null_layer_tree_frame_sink_ = true;
DISALLOW_COPY_AND_ASSIGN(FakeRenderWidgetCompositorDelegate);
};
@@ -146,10 +146,10 @@
// The use null output surface parameter allows testing whether failures
// from RenderWidget (couldn't create an output surface) vs failures from
// the compositor (couldn't bind the output surface) are handled identically.
-class RenderWidgetCompositorFrameSink : public RenderWidgetCompositor {
+class RenderWidgetLayerTreeFrameSink : public RenderWidgetCompositor {
public:
- RenderWidgetCompositorFrameSink(FakeRenderWidgetCompositorDelegate* delegate,
- CompositorDependencies* compositor_deps)
+ RenderWidgetLayerTreeFrameSink(FakeRenderWidgetCompositorDelegate* delegate,
+ CompositorDependencies* compositor_deps)
: RenderWidgetCompositor(delegate, compositor_deps),
delegate_(delegate) {}
@@ -158,41 +158,41 @@
// Force a new output surface to be created.
void SynchronousComposite() {
layer_tree_host()->SetVisible(false);
- layer_tree_host()->ReleaseCompositorFrameSink();
+ layer_tree_host()->ReleaseLayerTreeFrameSink();
layer_tree_host()->SetVisible(true);
base::TimeTicks some_time;
layer_tree_host()->Composite(some_time);
}
- void RequestNewCompositorFrameSink() override {
+ void RequestNewLayerTreeFrameSink() override {
delegate_->add_request();
- RenderWidgetCompositor::RequestNewCompositorFrameSink();
+ RenderWidgetCompositor::RequestNewLayerTreeFrameSink();
}
- void DidInitializeCompositorFrameSink() override {
+ void DidInitializeLayerTreeFrameSink() override {
delegate_->add_success();
if (delegate_->num_requests() == expected_requests_) {
EndTest();
} else {
- RenderWidgetCompositor::DidInitializeCompositorFrameSink();
+ RenderWidgetCompositor::DidInitializeLayerTreeFrameSink();
// Post the synchronous composite task so that it is not called
- // reentrantly as a part of RequestNewCompositorFrameSink.
+ // reentrantly as a part of RequestNewLayerTreeFrameSink.
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::Bind(&RenderWidgetCompositorFrameSink::SynchronousComposite,
+ base::Bind(&RenderWidgetLayerTreeFrameSink::SynchronousComposite,
base::Unretained(this)));
}
}
- void DidFailToInitializeCompositorFrameSink() override {
+ void DidFailToInitializeLayerTreeFrameSink() override {
delegate_->add_failure();
if (delegate_->num_requests() == expected_requests_) {
EndTest();
return;
}
- RenderWidgetCompositor::DidFailToInitializeCompositorFrameSink();
+ RenderWidgetCompositor::DidFailToInitializeLayerTreeFrameSink();
}
void SetUp(int expected_successes, int expected_fallback_succeses) {
@@ -219,12 +219,12 @@
int expected_fallback_successes_ = 0;
int expected_requests_ = 0;
- DISALLOW_COPY_AND_ASSIGN(RenderWidgetCompositorFrameSink);
+ DISALLOW_COPY_AND_ASSIGN(RenderWidgetLayerTreeFrameSink);
};
-class RenderWidgetCompositorFrameSinkTest : public testing::Test {
+class RenderWidgetLayerTreeFrameSinkTest : public testing::Test {
public:
- RenderWidgetCompositorFrameSinkTest()
+ RenderWidgetLayerTreeFrameSinkTest()
: render_widget_compositor_(&compositor_delegate_, &compositor_deps_) {
auto animation_host = cc::AnimationHost::CreateMainInstance();
@@ -239,12 +239,12 @@
std::move(animation_host));
}
- void RunTest(bool use_null_compositor_frame_sink,
+ void RunTest(bool use_null_layer_tree_frame_sink,
int num_failures_before_success,
int expected_successes,
int expected_fallback_succeses) {
- compositor_delegate_.set_use_null_compositor_frame_sink(
- use_null_compositor_frame_sink);
+ compositor_delegate_.set_use_null_layer_tree_frame_sink(
+ use_null_layer_tree_frame_sink);
compositor_delegate_.set_num_failures_before_success(
num_failures_before_success);
render_widget_compositor_.SetUp(expected_successes,
@@ -252,7 +252,7 @@
render_widget_compositor_.SetVisible(true);
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::Bind(&RenderWidgetCompositorFrameSink::SynchronousComposite,
+ base::Bind(&RenderWidgetLayerTreeFrameSink::SynchronousComposite,
base::Unretained(&render_widget_compositor_)));
base::RunLoop().Run();
render_widget_compositor_.AfterTest();
@@ -263,31 +263,31 @@
MockRenderThread render_thread_;
FakeCompositorDependencies compositor_deps_;
FakeRenderWidgetCompositorDelegate compositor_delegate_;
- RenderWidgetCompositorFrameSink render_widget_compositor_;
+ RenderWidgetLayerTreeFrameSink render_widget_compositor_;
private:
- DISALLOW_COPY_AND_ASSIGN(RenderWidgetCompositorFrameSinkTest);
+ DISALLOW_COPY_AND_ASSIGN(RenderWidgetLayerTreeFrameSinkTest);
};
-TEST_F(RenderWidgetCompositorFrameSinkTest, SucceedOnce) {
+TEST_F(RenderWidgetLayerTreeFrameSinkTest, SucceedOnce) {
RunTest(false, 0, 1, 0);
}
-TEST_F(RenderWidgetCompositorFrameSinkTest, SucceedTwice) {
+TEST_F(RenderWidgetLayerTreeFrameSinkTest, SucceedTwice) {
RunTest(false, 0, 2, 0);
}
-TEST_F(RenderWidgetCompositorFrameSinkTest, FailOnceNull) {
+TEST_F(RenderWidgetLayerTreeFrameSinkTest, FailOnceNull) {
static_assert(
- RenderWidgetCompositor::COMPOSITOR_FRAME_SINK_RETRIES_BEFORE_FALLBACK >=
+ RenderWidgetCompositor::LAYER_TREE_FRAME_SINK_RETRIES_BEFORE_FALLBACK >=
2,
"Adjust the values of this test if this fails");
RunTest(true, 1, 1, 0);
}
-TEST_F(RenderWidgetCompositorFrameSinkTest, FailOnceBind) {
+TEST_F(RenderWidgetLayerTreeFrameSinkTest, FailOnceBind) {
static_assert(
- RenderWidgetCompositor::COMPOSITOR_FRAME_SINK_RETRIES_BEFORE_FALLBACK >=
+ RenderWidgetCompositor::LAYER_TREE_FRAME_SINK_RETRIES_BEFORE_FALLBACK >=
2,
"Adjust the values of this test if this fails");
RunTest(false, 1, 1, 0);
@@ -295,22 +295,22 @@
// Android doesn't support fallback frame sinks. (crbug.com/721102)
#ifndef OS_ANDROID
-TEST_F(RenderWidgetCompositorFrameSinkTest, FallbackSuccessNull) {
+TEST_F(RenderWidgetLayerTreeFrameSinkTest, FallbackSuccessNull) {
RunTest(true,
- RenderWidgetCompositor::COMPOSITOR_FRAME_SINK_RETRIES_BEFORE_FALLBACK,
+ RenderWidgetCompositor::LAYER_TREE_FRAME_SINK_RETRIES_BEFORE_FALLBACK,
0, 1);
}
-TEST_F(RenderWidgetCompositorFrameSinkTest, FallbackSuccessBind) {
+TEST_F(RenderWidgetLayerTreeFrameSinkTest, FallbackSuccessBind) {
RunTest(false,
- RenderWidgetCompositor::COMPOSITOR_FRAME_SINK_RETRIES_BEFORE_FALLBACK,
+ RenderWidgetCompositor::LAYER_TREE_FRAME_SINK_RETRIES_BEFORE_FALLBACK,
0, 1);
}
-TEST_F(RenderWidgetCompositorFrameSinkTest, FallbackSuccessNormalSuccess) {
+TEST_F(RenderWidgetLayerTreeFrameSinkTest, FallbackSuccessNormalSuccess) {
// The first success is a fallback, but the next should not be a fallback.
RunTest(false,
- RenderWidgetCompositor::COMPOSITOR_FRAME_SINK_RETRIES_BEFORE_FALLBACK,
+ RenderWidgetCompositor::LAYER_TREE_FRAME_SINK_RETRIES_BEFORE_FALLBACK,
1, 1);
}
#endif
diff --git a/content/renderer/layout_test_dependencies.h b/content/renderer/layout_test_dependencies.h
index 471cdca..df8feef 100644
--- a/content/renderer/layout_test_dependencies.h
+++ b/content/renderer/layout_test_dependencies.h
@@ -13,7 +13,7 @@
namespace cc {
class ContextProvider;
class CopyOutputRequest;
-class CompositorFrameSink;
+class LayerTreeFrameSink;
class SwapPromise;
}
@@ -29,7 +29,7 @@
// RenderThreadImpl.
class LayoutTestDependencies {
public:
- virtual std::unique_ptr<cc::CompositorFrameSink> CreateCompositorFrameSink(
+ virtual std::unique_ptr<cc::LayerTreeFrameSink> CreateLayerTreeFrameSink(
int32_t routing_id,
scoped_refptr<gpu::GpuChannelHost> gpu_channel,
scoped_refptr<cc::ContextProvider> compositor_context_provider,
diff --git a/content/renderer/mus/renderer_window_tree_client.cc b/content/renderer/mus/renderer_window_tree_client.cc
index 59b6a8b..5955dae 100644
--- a/content/renderer/mus/renderer_window_tree_client.cc
+++ b/content/renderer/mus/renderer_window_tree_client.cc
@@ -9,7 +9,7 @@
#include "base/command_line.h"
#include "base/lazy_instance.h"
#include "cc/base/switches.h"
-#include "components/viz/client/client_compositor_frame_sink.h"
+#include "components/viz/client/client_layer_tree_frame_sink.h"
#include "components/viz/client/local_surface_id_provider.h"
namespace content {
@@ -49,20 +49,20 @@
binding_.Bind(std::move(request));
}
-void RendererWindowTreeClient::RequestCompositorFrameSink(
+void RendererWindowTreeClient::RequestLayerTreeFrameSink(
scoped_refptr<cc::ContextProvider> context_provider,
gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
- const CompositorFrameSinkCallback& callback) {
- DCHECK(pending_compositor_frame_sink_callback_.is_null());
+ const LayerTreeFrameSinkCallback& callback) {
+ DCHECK(pending_layer_tree_frame_sink_callback_.is_null());
if (tree_) {
- RequestCompositorFrameSinkInternal(std::move(context_provider),
- gpu_memory_buffer_manager, callback);
+ RequestLayerTreeFrameSinkInternal(std::move(context_provider),
+ gpu_memory_buffer_manager, callback);
return;
}
pending_context_provider_ = std::move(context_provider);
pending_gpu_memory_buffer_manager_ = gpu_memory_buffer_manager;
- pending_compositor_frame_sink_callback_ = callback;
+ pending_layer_tree_frame_sink_callback_ = callback;
}
RendererWindowTreeClient::RendererWindowTreeClient(int routing_id)
@@ -73,10 +73,10 @@
g_connections.Get().erase(routing_id_);
}
-void RendererWindowTreeClient::RequestCompositorFrameSinkInternal(
+void RendererWindowTreeClient::RequestLayerTreeFrameSinkInternal(
scoped_refptr<cc::ContextProvider> context_provider,
gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
- const CompositorFrameSinkCallback& callback) {
+ const LayerTreeFrameSinkCallback& callback) {
cc::mojom::MojoCompositorFrameSinkPtrInfo sink_info;
cc::mojom::MojoCompositorFrameSinkRequest sink_request =
mojo::MakeRequest(&sink_info);
@@ -84,7 +84,7 @@
cc::mojom::MojoCompositorFrameSinkClientRequest client_request =
mojo::MakeRequest(&client);
constexpr bool enable_surface_synchronization = true;
- auto frame_sink = base::MakeUnique<viz::ClientCompositorFrameSink>(
+ auto frame_sink = base::MakeUnique<viz::ClientLayerTreeFrameSink>(
std::move(context_provider), nullptr /* worker_context_provider */,
gpu_memory_buffer_manager, nullptr /* shared_bitmap_manager */,
nullptr /* synthetic_begin_frame_source */, std::move(sink_info),
@@ -110,13 +110,13 @@
const base::Optional<cc::LocalSurfaceId>& local_surface_id) {
root_window_id_ = root->window_id;
tree_ = std::move(tree);
- if (!pending_compositor_frame_sink_callback_.is_null()) {
- RequestCompositorFrameSinkInternal(std::move(pending_context_provider_),
- pending_gpu_memory_buffer_manager_,
- pending_compositor_frame_sink_callback_);
+ if (!pending_layer_tree_frame_sink_callback_.is_null()) {
+ RequestLayerTreeFrameSinkInternal(std::move(pending_context_provider_),
+ pending_gpu_memory_buffer_manager_,
+ pending_layer_tree_frame_sink_callback_);
pending_context_provider_ = nullptr;
pending_gpu_memory_buffer_manager_ = nullptr;
- pending_compositor_frame_sink_callback_.Reset();
+ pending_layer_tree_frame_sink_callback_.Reset();
}
}
diff --git a/content/renderer/mus/renderer_window_tree_client.h b/content/renderer/mus/renderer_window_tree_client.h
index 271d162..f2c56fba 100644
--- a/content/renderer/mus/renderer_window_tree_client.h
+++ b/content/renderer/mus/renderer_window_tree_client.h
@@ -11,7 +11,7 @@
#include "services/ui/public/interfaces/window_tree.mojom.h"
namespace cc {
-class CompositorFrameSink;
+class LayerTreeFrameSink;
class ContextProvider;
}
@@ -40,21 +40,21 @@
void Bind(ui::mojom::WindowTreeClientRequest request);
- using CompositorFrameSinkCallback =
- base::Callback<void(std::unique_ptr<cc::CompositorFrameSink>)>;
- void RequestCompositorFrameSink(
+ using LayerTreeFrameSinkCallback =
+ base::Callback<void(std::unique_ptr<cc::LayerTreeFrameSink>)>;
+ void RequestLayerTreeFrameSink(
scoped_refptr<cc::ContextProvider> context_provider,
gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
- const CompositorFrameSinkCallback& callback);
+ const LayerTreeFrameSinkCallback& callback);
private:
explicit RendererWindowTreeClient(int routing_id);
~RendererWindowTreeClient() override;
- void RequestCompositorFrameSinkInternal(
+ void RequestLayerTreeFrameSinkInternal(
scoped_refptr<cc::ContextProvider> context_provider,
gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
- const CompositorFrameSinkCallback& callback);
+ const LayerTreeFrameSinkCallback& callback);
void DestroySelf();
@@ -162,7 +162,7 @@
ui::Id root_window_id_;
scoped_refptr<cc::ContextProvider> pending_context_provider_;
gpu::GpuMemoryBufferManager* pending_gpu_memory_buffer_manager_ = nullptr;
- CompositorFrameSinkCallback pending_compositor_frame_sink_callback_;
+ LayerTreeFrameSinkCallback pending_layer_tree_frame_sink_callback_;
ui::mojom::WindowTreePtr tree_;
mojo::Binding<ui::mojom::WindowTreeClient> binding_;
diff --git a/content/renderer/render_thread_impl.cc b/content/renderer/render_thread_impl.cc
index 25bfb8b..f8e4685a 100644
--- a/content/renderer/render_thread_impl.cc
+++ b/content/renderer/render_thread_impl.cc
@@ -46,8 +46,8 @@
#include "cc/base/switches.h"
#include "cc/blink/web_layer_impl.h"
#include "cc/output/buffer_to_texture_target_map.h"
-#include "cc/output/compositor_frame_sink.h"
#include "cc/output/copy_output_request.h"
+#include "cc/output/layer_tree_frame_sink.h"
#include "cc/output/vulkan_in_process_context_provider.h"
#include "cc/raster/task_graph_runner.h"
#include "cc/trees/layer_tree_host_common.h"
@@ -55,7 +55,7 @@
#include "components/discardable_memory/client/client_discardable_shared_memory_manager.h"
#include "components/metrics/public/interfaces/single_sample_metrics.mojom.h"
#include "components/metrics/single_sample_metrics.h"
-#include "components/viz/client/client_compositor_frame_sink.h"
+#include "components/viz/client/client_layer_tree_frame_sink.h"
#include "components/viz/client/local_surface_id_provider.h"
#include "content/child/appcache/appcache_dispatcher.h"
#include "content/child/appcache/appcache_frontend_impl.h"
@@ -182,7 +182,7 @@
#if defined(OS_ANDROID)
#include <cpu-features.h>
#include "content/renderer/android/synchronous_compositor_filter.h"
-#include "content/renderer/android/synchronous_compositor_frame_sink.h"
+#include "content/renderer/android/synchronous_layer_tree_frame_sink.h"
#include "content/renderer/media/android/stream_texture_factory.h"
#include "media/base/android/media_codec_util.h"
#endif
@@ -261,7 +261,7 @@
#if defined(OS_ANDROID)
// Unique identifier for each output surface created.
-uint32_t g_next_compositor_frame_sink_id = 1;
+uint32_t g_next_layer_tree_frame_sink_id = 1;
#endif
// An implementation of mojom::RenderMessageFilter which can be mocked out
@@ -1917,12 +1917,12 @@
return gpu_channel_;
}
-void RenderThreadImpl::RequestNewCompositorFrameSink(
+void RenderThreadImpl::RequestNewLayerTreeFrameSink(
bool use_software,
int routing_id,
scoped_refptr<FrameSwapMessageQueue> frame_swap_message_queue,
const GURL& url,
- const CompositorFrameSinkCallback& callback) {
+ const LayerTreeFrameSinkCallback& callback) {
const base::CommandLine& command_line =
*base::CommandLine::ForCurrentProcess();
if (command_line.HasSwitch(switches::kDisableGpuCompositing))
@@ -1949,7 +1949,7 @@
return;
}
RendererWindowTreeClient::Get(routing_id)
- ->RequestCompositorFrameSink(
+ ->RequestLayerTreeFrameSink(
gpu_->CreateContextProvider(std::move(channel)),
GetGpuMemoryBufferManager(), callback);
return;
@@ -1970,7 +1970,7 @@
DCHECK(!layout_test_mode());
frame_sink_provider_->CreateForWidget(routing_id, std::move(sink_request),
std::move(client));
- callback.Run(base::MakeUnique<viz::ClientCompositorFrameSink>(
+ callback.Run(base::MakeUnique<viz::ClientLayerTreeFrameSink>(
std::move(vulkan_context_provider),
std::move(synthetic_begin_frame_source), std::move(sink_info),
std::move(client_request),
@@ -2000,7 +2000,7 @@
DCHECK(!layout_test_mode());
frame_sink_provider_->CreateForWidget(routing_id, std::move(sink_request),
std::move(client));
- callback.Run(base::MakeUnique<viz::ClientCompositorFrameSink>(
+ callback.Run(base::MakeUnique<viz::ClientLayerTreeFrameSink>(
nullptr, nullptr, nullptr, shared_bitmap_manager(),
std::move(synthetic_begin_frame_source), std::move(sink_info),
std::move(client_request),
@@ -2051,7 +2051,7 @@
ui::command_buffer_metrics::RENDER_COMPOSITOR_CONTEXT));
if (layout_test_deps_) {
- callback.Run(layout_test_deps_->CreateCompositorFrameSink(
+ callback.Run(layout_test_deps_->CreateLayerTreeFrameSink(
routing_id, std::move(gpu_channel_host), std::move(context_provider),
std::move(worker_context_provider), GetGpuMemoryBufferManager(), this));
return;
@@ -2063,10 +2063,10 @@
synthetic_begin_frame_source
? std::move(synthetic_begin_frame_source)
: CreateExternalBeginFrameSource(routing_id);
- callback.Run(base::MakeUnique<SynchronousCompositorFrameSink>(
+ callback.Run(base::MakeUnique<SynchronousLayerTreeFrameSink>(
std::move(context_provider), std::move(worker_context_provider),
GetGpuMemoryBufferManager(), shared_bitmap_manager(), routing_id,
- g_next_compositor_frame_sink_id++, std::move(begin_frame_source),
+ g_next_layer_tree_frame_sink_id++, std::move(begin_frame_source),
sync_compositor_message_filter_.get(),
std::move(frame_swap_message_queue)));
return;
@@ -2074,7 +2074,7 @@
#endif
frame_sink_provider_->CreateForWidget(routing_id, std::move(sink_request),
std::move(client));
- callback.Run(base::MakeUnique<viz::ClientCompositorFrameSink>(
+ callback.Run(base::MakeUnique<viz::ClientLayerTreeFrameSink>(
std::move(context_provider), std::move(worker_context_provider),
GetGpuMemoryBufferManager(), nullptr,
std::move(synthetic_begin_frame_source), std::move(sink_info),
diff --git a/content/renderer/render_thread_impl.h b/content/renderer/render_thread_impl.h
index 23f3aee7..8520704 100644
--- a/content/renderer/render_thread_impl.h
+++ b/content/renderer/render_thread_impl.h
@@ -81,7 +81,7 @@
namespace cc {
class BeginFrameSource;
-class CompositorFrameSink;
+class LayerTreeFrameSink;
class SyntheticBeginFrameSource;
class TaskGraphRunner;
}
@@ -266,14 +266,14 @@
gpu::GpuMemoryBufferManager* GetGpuMemoryBufferManager();
- using CompositorFrameSinkCallback =
- base::Callback<void(std::unique_ptr<cc::CompositorFrameSink>)>;
- void RequestNewCompositorFrameSink(
+ using LayerTreeFrameSinkCallback =
+ base::Callback<void(std::unique_ptr<cc::LayerTreeFrameSink>)>;
+ void RequestNewLayerTreeFrameSink(
bool use_software,
int routing_id,
scoped_refptr<FrameSwapMessageQueue> frame_swap_message_queue,
const GURL& url,
- const CompositorFrameSinkCallback& callback);
+ const LayerTreeFrameSinkCallback& callback);
AssociatedInterfaceRegistry* GetAssociatedInterfaceRegistry();
diff --git a/content/renderer/render_widget.cc b/content/renderer/render_widget.cc
index 0577102e..2467953 100644
--- a/content/renderer/render_widget.cc
+++ b/content/renderer/render_widget.cc
@@ -26,8 +26,8 @@
#include "build/build_config.h"
#include "cc/animation/animation_host.h"
#include "cc/input/touch_action.h"
-#include "cc/output/compositor_frame_sink.h"
#include "cc/output/copy_output_request.h"
+#include "cc/output/layer_tree_frame_sink.h"
#include "cc/scheduler/begin_frame_source.h"
#include "cc/trees/layer_tree_host.h"
#include "content/common/content_switches_internal.h"
@@ -910,14 +910,14 @@
GetWebWidget()->BeginFrame(frame_time_sec);
}
-void RenderWidget::RequestNewCompositorFrameSink(
+void RenderWidget::RequestNewLayerTreeFrameSink(
bool fallback,
- const CompositorFrameSinkCallback& callback) {
+ const LayerTreeFrameSinkCallback& callback) {
DCHECK(GetWebWidget());
// For widgets that are never visible, we don't start the compositor, so we
- // never get a request for a cc::CompositorFrameSink.
+ // never get a request for a cc::LayerTreeFrameSink.
DCHECK(!compositor_never_visible_);
- RenderThreadImpl::current()->RequestNewCompositorFrameSink(
+ RenderThreadImpl::current()->RequestNewLayerTreeFrameSink(
fallback, routing_id_, frame_swap_message_queue_,
GetURLForGraphicsContext3D(), callback);
}
@@ -1320,7 +1320,7 @@
compositor_->SetContentSourceId(current_content_source_id_);
compositor_->SetLocalSurfaceId(local_surface_id_);
// For background pages and certain tests, we don't want to trigger
- // CompositorFrameSink creation.
+ // LayerTreeFrameSink creation.
bool should_generate_frame_sink =
!compositor_never_visible_ && RenderThreadImpl::current();
if (!should_generate_frame_sink)
diff --git a/content/renderer/render_widget.h b/content/renderer/render_widget.h
index ac63c77..68706214 100644
--- a/content/renderer/render_widget.h
+++ b/content/renderer/render_widget.h
@@ -241,9 +241,9 @@
void RecordWheelAndTouchScrollingCount(bool has_scrolled_by_wheel,
bool has_scrolled_by_touch) override;
void BeginMainFrame(double frame_time_sec) override;
- void RequestNewCompositorFrameSink(
+ void RequestNewLayerTreeFrameSink(
bool fallback,
- const CompositorFrameSinkCallback& callback) override;
+ const LayerTreeFrameSinkCallback& callback) override;
void DidCommitAndDrawCompositorFrame() override;
void DidCommitCompositorFrame() override;
void DidCompletePageScaleAnimation() override;
diff --git a/content/test/layouttest_support.cc b/content/test/layouttest_support.cc
index a3aa9a0..64cbf87 100644
--- a/content/test/layouttest_support.cc
+++ b/content/test/layouttest_support.cc
@@ -16,7 +16,7 @@
#include "cc/base/switches.h"
#include "cc/output/copy_output_request.h"
#include "cc/test/pixel_test_output_surface.h"
-#include "cc/test/test_compositor_frame_sink.h"
+#include "cc/test/test_layer_tree_frame_sink.h"
#include "content/browser/bluetooth/bluetooth_device_chooser_controller.h"
#include "content/browser/renderer_host/render_process_host_impl.h"
#include "content/browser/renderer_host/render_widget_host_impl.h"
@@ -286,24 +286,24 @@
// request at SwapBuffers time.
class CopyRequestSwapPromise : public cc::SwapPromise {
public:
- using FindCompositorFrameSinkCallback =
- base::Callback<cc::TestCompositorFrameSink*()>;
+ using FindLayerTreeFrameSinkCallback =
+ base::Callback<cc::TestLayerTreeFrameSink*()>;
CopyRequestSwapPromise(
std::unique_ptr<cc::CopyOutputRequest> request,
- FindCompositorFrameSinkCallback find_compositor_frame_sink_callback)
+ FindLayerTreeFrameSinkCallback find_layer_tree_frame_sink_callback)
: copy_request_(std::move(request)),
- find_compositor_frame_sink_callback_(
- std::move(find_compositor_frame_sink_callback)) {}
+ find_layer_tree_frame_sink_callback_(
+ std::move(find_layer_tree_frame_sink_callback)) {}
// cc::SwapPromise implementation.
void OnCommit() override {
- compositor_frame_sink_from_commit_ =
- find_compositor_frame_sink_callback_.Run();
- DCHECK(compositor_frame_sink_from_commit_);
+ layer_tree_frame_sink_from_commit_ =
+ find_layer_tree_frame_sink_callback_.Run();
+ DCHECK(layer_tree_frame_sink_from_commit_);
}
void DidActivate() override {}
void WillSwap(cc::CompositorFrameMetadata*) override {
- compositor_frame_sink_from_commit_->RequestCopyOfOutput(
+ layer_tree_frame_sink_from_commit_->RequestCopyOfOutput(
std::move(copy_request_));
}
void DidSwap() override {}
@@ -316,25 +316,25 @@
private:
std::unique_ptr<cc::CopyOutputRequest> copy_request_;
- FindCompositorFrameSinkCallback find_compositor_frame_sink_callback_;
- cc::TestCompositorFrameSink* compositor_frame_sink_from_commit_ = nullptr;
+ FindLayerTreeFrameSinkCallback find_layer_tree_frame_sink_callback_;
+ cc::TestLayerTreeFrameSink* layer_tree_frame_sink_from_commit_ = nullptr;
};
} // namespace
class LayoutTestDependenciesImpl : public LayoutTestDependencies,
- public cc::TestCompositorFrameSinkClient {
+ public cc::TestLayerTreeFrameSinkClient {
public:
- std::unique_ptr<cc::CompositorFrameSink> CreateCompositorFrameSink(
+ std::unique_ptr<cc::LayerTreeFrameSink> CreateLayerTreeFrameSink(
int32_t routing_id,
scoped_refptr<gpu::GpuChannelHost> gpu_channel,
scoped_refptr<cc::ContextProvider> compositor_context_provider,
scoped_refptr<cc::ContextProvider> worker_context_provider,
gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
CompositorDependencies* deps) override {
- // This could override the GpuChannel for a CompositorFrameSink that was
+ // This could override the GpuChannel for a LayerTreeFrameSink that was
// previously being created but in that case the old GpuChannel would be
- // lost as would the CompositorFrameSink.
+ // lost as would the LayerTreeFrameSink.
gpu_channel_ = gpu_channel;
auto* task_runner = deps->GetCompositorImplThreadTaskRunner().get();
@@ -352,33 +352,33 @@
constexpr bool disable_display_vsync = false;
constexpr double refresh_rate = 60.0;
- auto compositor_frame_sink = base::MakeUnique<cc::TestCompositorFrameSink>(
+ auto layer_tree_frame_sink = base::MakeUnique<cc::TestLayerTreeFrameSink>(
std::move(compositor_context_provider),
std::move(worker_context_provider), nullptr /* shared_bitmap_manager */,
gpu_memory_buffer_manager, renderer_settings, task_runner,
synchronous_composite, disable_display_vsync, refresh_rate);
- compositor_frame_sink->SetClient(this);
- compositor_frame_sinks_[routing_id] = compositor_frame_sink.get();
- return std::move(compositor_frame_sink);
+ layer_tree_frame_sink->SetClient(this);
+ layer_tree_frame_sinks_[routing_id] = layer_tree_frame_sink.get();
+ return std::move(layer_tree_frame_sink);
}
std::unique_ptr<cc::SwapPromise> RequestCopyOfOutput(
int32_t routing_id,
std::unique_ptr<cc::CopyOutputRequest> request) override {
- // Note that we can't immediately check compositor_frame_sinks_, since it
+ // Note that we can't immediately check layer_tree_frame_sinks_, since it
// may not have been created yet. Instead, we wait until OnCommit to find
- // the currently active CompositorFrameSink for the given RenderWidget
+ // the currently active LayerTreeFrameSink for the given RenderWidget
// routing_id.
return base::MakeUnique<CopyRequestSwapPromise>(
std::move(request),
base::Bind(
- &LayoutTestDependenciesImpl::FindCompositorFrameSink,
+ &LayoutTestDependenciesImpl::FindLayerTreeFrameSink,
// |this| will still be valid, because its lifetime is tied to
// RenderThreadImpl, which outlives layout test execution.
base::Unretained(this), routing_id));
}
- // TestCompositorFrameSinkClient implementation.
+ // TestLayerTreeFrameSinkClient implementation.
std::unique_ptr<cc::OutputSurface> CreateDisplayOutputSurface(
scoped_refptr<cc::ContextProvider> compositor_context_provider) override {
// This is for an offscreen context for the compositor. So the default
@@ -419,17 +419,17 @@
void DisplayDidDrawAndSwap() override {}
private:
- cc::TestCompositorFrameSink* FindCompositorFrameSink(int32_t routing_id) {
- auto it = compositor_frame_sinks_.find(routing_id);
- return it == compositor_frame_sinks_.end() ? nullptr : it->second;
+ cc::TestLayerTreeFrameSink* FindLayerTreeFrameSink(int32_t routing_id) {
+ auto it = layer_tree_frame_sinks_.find(routing_id);
+ return it == layer_tree_frame_sinks_.end() ? nullptr : it->second;
}
// Entries are not removed, so this map can grow. However, it is only used in
// layout tests, so this memory usage does not occur in production.
// Entries in this map will outlive the output surface, because this object is
// owned by RenderThreadImpl, which outlives layout test execution.
- std::unordered_map<int32_t, cc::TestCompositorFrameSink*>
- compositor_frame_sinks_;
+ std::unordered_map<int32_t, cc::TestLayerTreeFrameSink*>
+ layer_tree_frame_sinks_;
scoped_refptr<gpu::GpuChannelHost> gpu_channel_;
};
diff --git a/services/ui/ws/frame_generator.cc b/services/ui/ws/frame_generator.cc
index 4b72293..ca5b7c0 100644
--- a/services/ui/ws/frame_generator.cc
+++ b/services/ui/ws/frame_generator.cc
@@ -8,7 +8,6 @@
#include <vector>
#include "cc/output/compositor_frame.h"
-#include "cc/output/compositor_frame_sink.h"
#include "cc/quads/render_pass.h"
#include "cc/quads/render_pass_draw_quad.h"
#include "cc/quads/shared_quad_state.h"
diff --git a/services/ui/ws/frame_generator_unittest.cc b/services/ui/ws/frame_generator_unittest.cc
index 5ebd12d..ac156edf 100644
--- a/services/ui/ws/frame_generator_unittest.cc
+++ b/services/ui/ws/frame_generator_unittest.cc
@@ -5,7 +5,6 @@
#include "services/ui/ws/frame_generator.h"
#include "base/macros.h"
-#include "cc/output/compositor_frame_sink.h"
#include "cc/quads/render_pass.h"
#include "cc/scheduler/begin_frame_source.h"
#include "cc/test/begin_frame_args_test.h"
diff --git a/third_party/WebKit/Source/platform/graphics/CompositorMutableStateTest.cpp b/third_party/WebKit/Source/platform/graphics/CompositorMutableStateTest.cpp
index f8c49c24..12837a8 100644
--- a/third_party/WebKit/Source/platform/graphics/CompositorMutableStateTest.cpp
+++ b/third_party/WebKit/Source/platform/graphics/CompositorMutableStateTest.cpp
@@ -4,9 +4,11 @@
#include "platform/graphics/CompositorMutableState.h"
+#include <memory>
+
#include "base/message_loop/message_loop.h"
-#include "cc/test/fake_compositor_frame_sink.h"
#include "cc/test/fake_impl_task_runner_provider.h"
+#include "cc/test/fake_layer_tree_frame_sink.h"
#include "cc/test/fake_layer_tree_host_impl.h"
#include "cc/test/test_shared_bitmap_manager.h"
#include "cc/test/test_task_graph_runner.h"
@@ -17,13 +19,12 @@
#include "platform/graphics/CompositorMutableStateProvider.h"
#include "platform/graphics/CompositorMutation.h"
#include "testing/gtest/include/gtest/gtest.h"
-#include <memory>
namespace blink {
using cc::FakeImplTaskRunnerProvider;
using cc::FakeLayerTreeHostImpl;
-using cc::FakeCompositorFrameSink;
+using cc::FakeLayerTreeFrameSink;
using cc::LayerImpl;
using cc::LayerTreeSettings;
using cc::TestTaskGraphRunner;
@@ -32,13 +33,13 @@
class CompositorMutableStateTest : public testing::Test {
public:
CompositorMutableStateTest()
- : compositor_frame_sink_(FakeCompositorFrameSink::Create3d()) {
+ : layer_tree_frame_sink_(FakeLayerTreeFrameSink::Create3d()) {
LayerTreeSettings settings;
settings.layer_transforms_should_scale_layer_contents = true;
host_impl_.reset(new FakeLayerTreeHostImpl(settings, &task_runner_provider_,
&task_graph_runner_));
host_impl_->SetVisible(true);
- EXPECT_TRUE(host_impl_->InitializeRenderer(compositor_frame_sink_.get()));
+ EXPECT_TRUE(host_impl_->InitializeRenderer(layer_tree_frame_sink_.get()));
}
void SetLayerPropertiesForTesting(LayerImpl* layer) {
@@ -61,7 +62,7 @@
base::MessageLoop message_loop_;
TestTaskGraphRunner task_graph_runner_;
FakeImplTaskRunnerProvider task_runner_provider_;
- std::unique_ptr<FakeCompositorFrameSink> compositor_frame_sink_;
+ std::unique_ptr<FakeLayerTreeFrameSink> layer_tree_frame_sink_;
std::unique_ptr<FakeLayerTreeHostImpl> host_impl_;
};
diff --git a/third_party/WebKit/Source/platform/graphics/compositing/PaintArtifactCompositorTest.cpp b/third_party/WebKit/Source/platform/graphics/compositing/PaintArtifactCompositorTest.cpp
index e2d380b..9cb8d22 100644
--- a/third_party/WebKit/Source/platform/graphics/compositing/PaintArtifactCompositorTest.cpp
+++ b/third_party/WebKit/Source/platform/graphics/compositing/PaintArtifactCompositorTest.cpp
@@ -9,7 +9,7 @@
#include "base/test/test_simple_task_runner.h"
#include "base/threading/thread_task_runner_handle.h"
#include "cc/layers/layer.h"
-#include "cc/test/fake_compositor_frame_sink.h"
+#include "cc/test/fake_layer_tree_frame_sink.h"
#include "cc/test/geometry_test_utils.h"
#include "cc/trees/clip_node.h"
#include "cc/trees/effect_node.h"
@@ -65,16 +65,16 @@
return transform;
}
-class WebLayerTreeViewWithCompositorFrameSink
+class WebLayerTreeViewWithLayerTreeFrameSink
: public WebLayerTreeViewImplForTesting {
public:
- WebLayerTreeViewWithCompositorFrameSink(const cc::LayerTreeSettings& settings)
+ WebLayerTreeViewWithLayerTreeFrameSink(const cc::LayerTreeSettings& settings)
: WebLayerTreeViewImplForTesting(settings) {}
// cc::LayerTreeHostClient
- void RequestNewCompositorFrameSink() override {
- GetLayerTreeHost()->SetCompositorFrameSink(
- cc::FakeCompositorFrameSink::Create3d());
+ void RequestNewLayerTreeFrameSink() override {
+ GetLayerTreeHost()->SetLayerTreeFrameSink(
+ cc::FakeLayerTreeFrameSink::Create3d());
}
};
@@ -97,7 +97,7 @@
settings.single_thread_proxy_scheduler = false;
settings.use_layer_lists = true;
web_layer_tree_view_ =
- WTF::MakeUnique<WebLayerTreeViewWithCompositorFrameSink>(settings);
+ WTF::MakeUnique<WebLayerTreeViewWithLayerTreeFrameSink>(settings);
web_layer_tree_view_->SetRootLayer(
*paint_artifact_compositor_->GetWebLayer());
}
@@ -185,7 +185,7 @@
std::unique_ptr<PaintArtifactCompositor> paint_artifact_compositor_;
scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
base::ThreadTaskRunnerHandle task_runner_handle_;
- std::unique_ptr<WebLayerTreeViewWithCompositorFrameSink> web_layer_tree_view_;
+ std::unique_ptr<WebLayerTreeViewWithLayerTreeFrameSink> web_layer_tree_view_;
};
TEST_F(PaintArtifactCompositorTestWithPropertyTrees, EmptyPaintArtifact) {
diff --git a/third_party/WebKit/Source/platform/testing/WebLayerTreeViewImplForTesting.cpp b/third_party/WebKit/Source/platform/testing/WebLayerTreeViewImplForTesting.cpp
index 18b5bd1..6e8dc90 100644
--- a/third_party/WebKit/Source/platform/testing/WebLayerTreeViewImplForTesting.cpp
+++ b/third_party/WebKit/Source/platform/testing/WebLayerTreeViewImplForTesting.cpp
@@ -138,11 +138,11 @@
bool has_scrolled_by_wheel,
bool has_scrolled_by_touch) {}
-void WebLayerTreeViewImplForTesting::RequestNewCompositorFrameSink() {
- // Intentionally do not create and set an CompositorFrameSink.
+void WebLayerTreeViewImplForTesting::RequestNewLayerTreeFrameSink() {
+ // Intentionally do not create and set a LayerTreeFrameSink.
}
-void WebLayerTreeViewImplForTesting::DidFailToInitializeCompositorFrameSink() {
+void WebLayerTreeViewImplForTesting::DidFailToInitializeLayerTreeFrameSink() {
NOTREACHED();
}
diff --git a/third_party/WebKit/Source/platform/testing/WebLayerTreeViewImplForTesting.h b/third_party/WebKit/Source/platform/testing/WebLayerTreeViewImplForTesting.h
index c06b6a7..ddf923b 100644
--- a/third_party/WebKit/Source/platform/testing/WebLayerTreeViewImplForTesting.h
+++ b/third_party/WebKit/Source/platform/testing/WebLayerTreeViewImplForTesting.h
@@ -90,9 +90,9 @@
float browser_controls_delta) override;
void RecordWheelAndTouchScrollingCount(bool has_scrolled_by_wheel,
bool has_scrolled_by_touch) override;
- void RequestNewCompositorFrameSink() override;
- void DidInitializeCompositorFrameSink() override {}
- void DidFailToInitializeCompositorFrameSink() override;
+ void RequestNewLayerTreeFrameSink() override;
+ void DidInitializeLayerTreeFrameSink() override {}
+ void DidFailToInitializeLayerTreeFrameSink() override;
void WillCommit() override {}
void DidCommit() override {}
void DidCommitAndDrawFrame() override {}
@@ -103,7 +103,7 @@
// cc::LayerTreeHostSingleThreadClient implementation.
void DidSubmitCompositorFrame() override {}
- void DidLoseCompositorFrameSink() override {}
+ void DidLoseLayerTreeFrameSink() override {}
private:
cc::TestTaskGraphRunner task_graph_runner_;
diff --git a/ui/aura/BUILD.gn b/ui/aura/BUILD.gn
index 9b176e1..fad47943 100644
--- a/ui/aura/BUILD.gn
+++ b/ui/aura/BUILD.gn
@@ -33,7 +33,7 @@
"input_state_lookup.h",
"input_state_lookup_win.h",
"layout_manager.h",
- "local/compositor_frame_sink_local.h",
+ "local/layer_tree_frame_sink_local.h",
"local/window_port_local.h",
"mus/capture_synchronizer.h",
"mus/capture_synchronizer_delegate.h",
@@ -99,7 +99,7 @@
"input_state_lookup.cc",
"input_state_lookup_win.cc",
"layout_manager.cc",
- "local/compositor_frame_sink_local.cc",
+ "local/layer_tree_frame_sink_local.cc",
"local/window_port_local.cc",
"mus/capture_synchronizer.cc",
"mus/client_surface_embedder.cc",
diff --git a/ui/aura/local/compositor_frame_sink_local.cc b/ui/aura/local/layer_tree_frame_sink_local.cc
similarity index 76%
rename from ui/aura/local/compositor_frame_sink_local.cc
rename to ui/aura/local/layer_tree_frame_sink_local.cc
index a92bca4..f2bb69b 100644
--- a/ui/aura/local/compositor_frame_sink_local.cc
+++ b/ui/aura/local/layer_tree_frame_sink_local.cc
@@ -2,9 +2,9 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "ui/aura/local/compositor_frame_sink_local.h"
+#include "ui/aura/local/layer_tree_frame_sink_local.h"
-#include "cc/output/compositor_frame_sink_client.h"
+#include "cc/output/layer_tree_frame_sink_client.h"
#include "cc/surfaces/compositor_frame_sink_support.h"
#include "ui/aura/client/cursor_client.h"
#include "ui/aura/env.h"
@@ -15,18 +15,18 @@
namespace aura {
-CompositorFrameSinkLocal::CompositorFrameSinkLocal(
+LayerTreeFrameSinkLocal::LayerTreeFrameSinkLocal(
const cc::FrameSinkId& frame_sink_id,
cc::SurfaceManager* surface_manager)
- : cc::CompositorFrameSink(nullptr, nullptr, nullptr, nullptr),
+ : cc::LayerTreeFrameSink(nullptr, nullptr, nullptr, nullptr),
frame_sink_id_(frame_sink_id),
surface_manager_(surface_manager) {}
-CompositorFrameSinkLocal::~CompositorFrameSinkLocal() {}
+LayerTreeFrameSinkLocal::~LayerTreeFrameSinkLocal() {}
-bool CompositorFrameSinkLocal::BindToClient(
- cc::CompositorFrameSinkClient* client) {
- if (!cc::CompositorFrameSink::BindToClient(client))
+bool LayerTreeFrameSinkLocal::BindToClient(
+ cc::LayerTreeFrameSinkClient* client) {
+ if (!cc::LayerTreeFrameSink::BindToClient(client))
return false;
DCHECK(!thread_checker_);
thread_checker_ = base::MakeUnique<base::ThreadChecker>();
@@ -40,13 +40,13 @@
return true;
}
-void CompositorFrameSinkLocal::SetSurfaceChangedCallback(
+void LayerTreeFrameSinkLocal::SetSurfaceChangedCallback(
const SurfaceChangedCallback& callback) {
DCHECK(!surface_changed_callback_);
surface_changed_callback_ = callback;
}
-void CompositorFrameSinkLocal::DetachFromClient() {
+void LayerTreeFrameSinkLocal::DetachFromClient() {
DCHECK(thread_checker_);
DCHECK(thread_checker_->CalledOnValidThread());
client_->SetBeginFrameSource(nullptr);
@@ -54,11 +54,10 @@
support_->EvictCurrentSurface();
support_.reset();
thread_checker_.reset();
- cc::CompositorFrameSink::DetachFromClient();
+ cc::LayerTreeFrameSink::DetachFromClient();
}
-void CompositorFrameSinkLocal::SubmitCompositorFrame(
- cc::CompositorFrame frame) {
+void LayerTreeFrameSinkLocal::SubmitCompositorFrame(cc::CompositorFrame frame) {
DCHECK(thread_checker_);
DCHECK(thread_checker_->CalledOnValidThread());
DCHECK(frame.metadata.begin_frame_ack.has_damage);
@@ -84,8 +83,7 @@
}
}
-void CompositorFrameSinkLocal::DidNotProduceFrame(
- const cc::BeginFrameAck& ack) {
+void LayerTreeFrameSinkLocal::DidNotProduceFrame(const cc::BeginFrameAck& ack) {
DCHECK(thread_checker_);
DCHECK(thread_checker_->CalledOnValidThread());
DCHECK(!ack.has_damage);
@@ -93,7 +91,7 @@
support_->DidNotProduceFrame(ack);
}
-void CompositorFrameSinkLocal::DidReceiveCompositorFrameAck(
+void LayerTreeFrameSinkLocal::DidReceiveCompositorFrameAck(
const cc::ReturnedResourceArray& resources) {
DCHECK(thread_checker_);
DCHECK(thread_checker_->CalledOnValidThread());
@@ -104,13 +102,13 @@
client_->DidReceiveCompositorFrameAck();
}
-void CompositorFrameSinkLocal::OnBeginFrame(const cc::BeginFrameArgs& args) {
+void LayerTreeFrameSinkLocal::OnBeginFrame(const cc::BeginFrameArgs& args) {
DCHECK(thread_checker_);
DCHECK(thread_checker_->CalledOnValidThread());
begin_frame_source_->OnBeginFrame(args);
}
-void CompositorFrameSinkLocal::ReclaimResources(
+void LayerTreeFrameSinkLocal::ReclaimResources(
const cc::ReturnedResourceArray& resources) {
DCHECK(thread_checker_);
DCHECK(thread_checker_->CalledOnValidThread());
@@ -119,7 +117,7 @@
client_->ReclaimResources(resources);
}
-void CompositorFrameSinkLocal::OnNeedsBeginFrames(bool needs_begin_frames) {
+void LayerTreeFrameSinkLocal::OnNeedsBeginFrames(bool needs_begin_frames) {
DCHECK(thread_checker_);
DCHECK(thread_checker_->CalledOnValidThread());
support_->SetNeedsBeginFrame(needs_begin_frames);
diff --git a/ui/aura/local/compositor_frame_sink_local.h b/ui/aura/local/layer_tree_frame_sink_local.h
similarity index 70%
rename from ui/aura/local/compositor_frame_sink_local.h
rename to ui/aura/local/layer_tree_frame_sink_local.h
index 77e3c29a..611eb40 100644
--- a/ui/aura/local/compositor_frame_sink_local.h
+++ b/ui/aura/local/layer_tree_frame_sink_local.h
@@ -2,12 +2,12 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef UI_AURA_LOCAL_COMPOSITOR_FRAME_SINK_LOCAL_H_
-#define UI_AURA_LOCAL_COMPOSITOR_FRAME_SINK_LOCAL_H_
+#ifndef UI_AURA_LOCAL_LAYER_TREE_FRAME_SINK_LOCAL_H_
+#define UI_AURA_LOCAL_LAYER_TREE_FRAME_SINK_LOCAL_H_
#include "base/callback.h"
#include "base/macros.h"
-#include "cc/output/compositor_frame_sink.h"
+#include "cc/output/layer_tree_frame_sink.h"
#include "cc/scheduler/begin_frame_source.h"
#include "cc/surfaces/compositor_frame_sink_support_client.h"
#include "cc/surfaces/frame_sink_id.h"
@@ -18,29 +18,29 @@
namespace cc {
class CompositorFrameSinkSupport;
class SurfaceManager;
-}
+} // namespace cc
namespace aura {
-// cc::CompositorFrameSink implementation for classic aura, e.g. not mus.
-// aura::Window::CreateCompositorFramSink creates this class for a given
+// cc::LayerTreeFrameSink implementation for classic aura, e.g. not mus.
+// aura::Window::CreateLayerTreeFrameSink creates this class for a given
// aura::Window, and then the sink can be used for submitting frames to the
// aura::Window's ui::Layer.
-class CompositorFrameSinkLocal : public cc::CompositorFrameSink,
- public cc::CompositorFrameSinkSupportClient,
- public cc::ExternalBeginFrameSourceClient {
+class LayerTreeFrameSinkLocal : public cc::LayerTreeFrameSink,
+ public cc::CompositorFrameSinkSupportClient,
+ public cc::ExternalBeginFrameSourceClient {
public:
- CompositorFrameSinkLocal(const cc::FrameSinkId& frame_sink_id,
- cc::SurfaceManager* surface_manager);
- ~CompositorFrameSinkLocal() override;
+ LayerTreeFrameSinkLocal(const cc::FrameSinkId& frame_sink_id,
+ cc::SurfaceManager* surface_manager);
+ ~LayerTreeFrameSinkLocal() override;
using SurfaceChangedCallback =
base::Callback<void(const cc::SurfaceId&, const gfx::Size&)>;
// Set a callback which will be called when the surface is changed.
void SetSurfaceChangedCallback(const SurfaceChangedCallback& callback);
- // cc::CompositorFrameSink:
- bool BindToClient(cc::CompositorFrameSinkClient* client) override;
+ // cc::LayerTreeFrameSink:
+ bool BindToClient(cc::LayerTreeFrameSinkClient* client) override;
void DetachFromClient() override;
void SubmitCompositorFrame(cc::CompositorFrame frame) override;
void DidNotProduceFrame(const cc::BeginFrameAck& ack) override;
@@ -68,9 +68,9 @@
std::unique_ptr<base::ThreadChecker> thread_checker_;
SurfaceChangedCallback surface_changed_callback_;
- DISALLOW_COPY_AND_ASSIGN(CompositorFrameSinkLocal);
+ DISALLOW_COPY_AND_ASSIGN(LayerTreeFrameSinkLocal);
};
} // namespace aura
-#endif // UI_AURA_LOCAL_COMPOSITOR_FRAME_SINK_LOCAL_H_
+#endif // UI_AURA_LOCAL_LAYER_TREE_FRAME_SINK_LOCAL_H_
diff --git a/ui/aura/local/window_port_local.cc b/ui/aura/local/window_port_local.cc
index 8b2ceac..64540ba 100644
--- a/ui/aura/local/window_port_local.cc
+++ b/ui/aura/local/window_port_local.cc
@@ -7,7 +7,7 @@
#include "cc/surfaces/surface_manager.h"
#include "ui/aura/client/cursor_client.h"
#include "ui/aura/env.h"
-#include "ui/aura/local/compositor_frame_sink_local.h"
+#include "ui/aura/local/layer_tree_frame_sink_local.h"
#include "ui/aura/window.h"
#include "ui/aura/window_delegate.h"
#include "ui/display/display.h"
@@ -96,13 +96,13 @@
int64_t old_value,
std::unique_ptr<ui::PropertyData> data) {}
-std::unique_ptr<cc::CompositorFrameSink>
-WindowPortLocal::CreateCompositorFrameSink() {
+std::unique_ptr<cc::LayerTreeFrameSink>
+WindowPortLocal::CreateLayerTreeFrameSink() {
DCHECK(!frame_sink_id_.is_valid());
auto* context_factory_private =
aura::Env::GetInstance()->context_factory_private();
frame_sink_id_ = context_factory_private->AllocateFrameSinkId();
- auto frame_sink = base::MakeUnique<CompositorFrameSinkLocal>(
+ auto frame_sink = base::MakeUnique<LayerTreeFrameSinkLocal>(
frame_sink_id_, context_factory_private->GetSurfaceManager());
frame_sink->SetSurfaceChangedCallback(base::Bind(
&WindowPortLocal::OnSurfaceChanged, weak_factory_.GetWeakPtr()));
diff --git a/ui/aura/local/window_port_local.h b/ui/aura/local/window_port_local.h
index 6599abc..4bcc934 100644
--- a/ui/aura/local/window_port_local.h
+++ b/ui/aura/local/window_port_local.h
@@ -41,7 +41,7 @@
void OnPropertyChanged(const void* key,
int64_t old_value,
std::unique_ptr<ui::PropertyData> data) override;
- std::unique_ptr<cc::CompositorFrameSink> CreateCompositorFrameSink() override;
+ std::unique_ptr<cc::LayerTreeFrameSink> CreateLayerTreeFrameSink() override;
cc::SurfaceId GetSurfaceId() const override;
void OnWindowAddedToRootWindow() override;
void OnWillRemoveWindowFromRootWindow() override;
diff --git a/ui/aura/mus/DEPS b/ui/aura/mus/DEPS
index 1f61421..1fae0da 100644
--- a/ui/aura/mus/DEPS
+++ b/ui/aura/mus/DEPS
@@ -1,8 +1,8 @@
include_rules = [
"+cc/base/switches.h",
"+cc/ipc/mojo_compositor_frame_sink.mojom.h",
- "+cc/output/compositor_frame_sink_client.h",
- "+cc/output/compositor_frame_sink.h",
+ "+cc/output/layer_tree_frame_sink_client.h",
+ "+cc/output/layer_tree_frame_sink.h",
"+cc/scheduler/begin_frame_source.h",
"+cc/surfaces/local_surface_id.h",
"+cc/surfaces/local_surface_id_allocator.h",
@@ -20,6 +20,6 @@
"+services/ui/public/cpp/gpu",
"+services/ui/public/cpp/property_type_converters.h",
"+services/ui/public/cpp/raster_thread_helper.h",
- "+services/ui/public/cpp/client_compositor_frame_sink.h",
+ "+services/ui/public/cpp/client_layer_tree_frame_sink.h",
"+ui/gl/gl_bindings.h",
]
diff --git a/ui/aura/mus/mus_context_factory.cc b/ui/aura/mus/mus_context_factory.cc
index fd6cd92..c73271e 100644
--- a/ui/aura/mus/mus_context_factory.cc
+++ b/ui/aura/mus/mus_context_factory.cc
@@ -38,14 +38,14 @@
WindowTreeHost::GetForAcceleratedWidget(compositor->widget());
WindowPortMus* window_port = WindowPortMus::Get(host->window());
DCHECK(window_port);
- std::unique_ptr<cc::CompositorFrameSink> compositor_frame_sink =
- window_port->RequestCompositorFrameSink(
+ std::unique_ptr<cc::LayerTreeFrameSink> layer_tree_frame_sink =
+ window_port->RequestLayerTreeFrameSink(
gpu_->CreateContextProvider(std::move(gpu_channel)),
gpu_->gpu_memory_buffer_manager());
- compositor->SetCompositorFrameSink(std::move(compositor_frame_sink));
+ compositor->SetLayerTreeFrameSink(std::move(layer_tree_frame_sink));
}
-void MusContextFactory::CreateCompositorFrameSink(
+void MusContextFactory::CreateLayerTreeFrameSink(
base::WeakPtr<ui::Compositor> compositor) {
gpu_->EstablishGpuChannel(
base::Bind(&MusContextFactory::OnEstablishedGpuChannel,
diff --git a/ui/aura/mus/mus_context_factory.h b/ui/aura/mus/mus_context_factory.h
index 20d67f6b..ea0c5d74 100644
--- a/ui/aura/mus/mus_context_factory.h
+++ b/ui/aura/mus/mus_context_factory.h
@@ -44,7 +44,7 @@
scoped_refptr<gpu::GpuChannelHost> gpu_channel);
// ContextFactory:
- void CreateCompositorFrameSink(
+ void CreateLayerTreeFrameSink(
base::WeakPtr<ui::Compositor> compositor) override;
scoped_refptr<cc::ContextProvider> SharedMainThreadContextProvider() override;
void RemoveCompositor(ui::Compositor* compositor) override;
diff --git a/ui/aura/mus/window_mus.h b/ui/aura/mus/window_mus.h
index 7087bf54..329f71b 100644
--- a/ui/aura/mus/window_mus.h
+++ b/ui/aura/mus/window_mus.h
@@ -127,7 +127,7 @@
virtual void NotifyEmbeddedAppDisconnected() = 0;
- virtual bool HasLocalCompositorFrameSink() = 0;
+ virtual bool HasLocalLayerTreeFrameSink() = 0;
private:
// Just for set_server_id(), which other places should not call.
diff --git a/ui/aura/mus/window_port_mus.cc b/ui/aura/mus/window_port_mus.cc
index 72af5f3..2902086 100644
--- a/ui/aura/mus/window_port_mus.cc
+++ b/ui/aura/mus/window_port_mus.cc
@@ -96,8 +96,8 @@
window_tree_client_->Embed(window_, std::move(client), flags, callback);
}
-std::unique_ptr<viz::ClientCompositorFrameSink>
-WindowPortMus::RequestCompositorFrameSink(
+std::unique_ptr<viz::ClientLayerTreeFrameSink>
+WindowPortMus::RequestLayerTreeFrameSink(
scoped_refptr<cc::ContextProvider> context_provider,
gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager) {
cc::mojom::MojoCompositorFrameSinkPtrInfo sink_info;
@@ -107,7 +107,7 @@
cc::mojom::MojoCompositorFrameSinkClientRequest client_request =
mojo::MakeRequest(&client);
constexpr bool enable_surface_synchronization = true;
- auto compositor_frame_sink = base::MakeUnique<viz::ClientCompositorFrameSink>(
+ auto layer_tree_frame_sink = base::MakeUnique<viz::ClientLayerTreeFrameSink>(
std::move(context_provider), nullptr /* worker_context_provider */,
gpu_memory_buffer_manager, nullptr /* shared_bitmap_manager */,
nullptr /* synthetic_begin_frame_source */, std::move(sink_info),
@@ -116,7 +116,7 @@
enable_surface_synchronization);
window_tree_client_->AttachCompositorFrameSink(
server_id(), std::move(sink_request), std::move(client));
- return compositor_frame_sink;
+ return layer_tree_frame_sink;
}
WindowPortMus::ServerChangeIdType WindowPortMus::ScheduleChange(
@@ -307,8 +307,8 @@
if (frame_sink_id_.is_valid())
UpdatePrimarySurfaceInfo();
- if (local_compositor_frame_sink_)
- local_compositor_frame_sink_->SetLocalSurfaceId(local_surface_id_);
+ if (local_layer_tree_frame_sink_)
+ local_layer_tree_frame_sink_->SetLocalSurfaceId(local_surface_id_);
return local_surface_id_;
}
@@ -434,8 +434,8 @@
observer.OnEmbeddedAppDisconnected(window_);
}
-bool WindowPortMus::HasLocalCompositorFrameSink() {
- return !!local_compositor_frame_sink_;
+bool WindowPortMus::HasLocalLayerTreeFrameSink() {
+ return !!local_layer_tree_frame_sink_;
}
void WindowPortMus::OnPreInit(Window* window) {
@@ -531,14 +531,14 @@
std::move(data));
}
-std::unique_ptr<cc::CompositorFrameSink>
-WindowPortMus::CreateCompositorFrameSink() {
+std::unique_ptr<cc::LayerTreeFrameSink>
+WindowPortMus::CreateLayerTreeFrameSink() {
DCHECK_EQ(window_mus_type(), WindowMusType::LOCAL);
- DCHECK(!local_compositor_frame_sink_);
- auto frame_sink = RequestCompositorFrameSink(
+ DCHECK(!local_layer_tree_frame_sink_);
+ auto frame_sink = RequestLayerTreeFrameSink(
nullptr,
aura::Env::GetInstance()->context_factory()->GetGpuMemoryBufferManager());
- local_compositor_frame_sink_ = frame_sink->GetWeakPtr();
+ local_layer_tree_frame_sink_ = frame_sink->GetWeakPtr();
return std::move(frame_sink);
}
diff --git a/ui/aura/mus/window_port_mus.h b/ui/aura/mus/window_port_mus.h
index aa18c57c..14abb2d2 100644
--- a/ui/aura/mus/window_port_mus.h
+++ b/ui/aura/mus/window_port_mus.h
@@ -13,7 +13,7 @@
#include "base/logging.h"
#include "base/macros.h"
#include "cc/surfaces/surface_info.h"
-#include "components/viz/client/client_compositor_frame_sink.h"
+#include "components/viz/client/client_layer_tree_frame_sink.h"
#include "services/ui/public/interfaces/cursor/cursor.mojom.h"
#include "services/ui/public/interfaces/window_tree.mojom.h"
#include "services/ui/public/interfaces/window_tree_constants.mojom.h"
@@ -25,7 +25,7 @@
#include "ui/platform_window/mojo/text_input_state.mojom.h"
namespace viz {
-class ClientCompositorFrameSink;
+class ClientLayerTreeFrameSink;
}
namespace aura {
@@ -80,7 +80,7 @@
uint32_t flags,
const ui::mojom::WindowTree::EmbedCallback& callback);
- std::unique_ptr<viz::ClientCompositorFrameSink> RequestCompositorFrameSink(
+ std::unique_ptr<viz::ClientLayerTreeFrameSink> RequestLayerTreeFrameSink(
scoped_refptr<cc::ContextProvider> context_provider,
gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager);
@@ -242,7 +242,7 @@
void PrepareForTransientRestack(WindowMus* window) override;
void OnTransientRestackDone(WindowMus* window) override;
void NotifyEmbeddedAppDisconnected() override;
- bool HasLocalCompositorFrameSink() override;
+ bool HasLocalLayerTreeFrameSink() override;
// WindowPort:
void OnPreInit(Window* window) override;
@@ -260,7 +260,7 @@
void OnPropertyChanged(const void* key,
int64_t old_value,
std::unique_ptr<ui::PropertyData> data) override;
- std::unique_ptr<cc::CompositorFrameSink> CreateCompositorFrameSink() override;
+ std::unique_ptr<cc::LayerTreeFrameSink> CreateLayerTreeFrameSink() override;
cc::SurfaceId GetSurfaceId() const override;
void OnWindowAddedToRootWindow() override {}
void OnWillRemoveWindowFromRootWindow() override {}
@@ -292,7 +292,7 @@
// When a frame sink is created
// for a local aura::Window, we need keep a weak ptr of it, so we can update
// the local surface id when necessary.
- base::WeakPtr<viz::ClientCompositorFrameSink> local_compositor_frame_sink_;
+ base::WeakPtr<viz::ClientLayerTreeFrameSink> local_layer_tree_frame_sink_;
DISALLOW_COPY_AND_ASSIGN(WindowPortMus);
};
diff --git a/ui/aura/mus/window_tree_client.cc b/ui/aura/mus/window_tree_client.cc
index e5aa0bd..ee5791c 100644
--- a/ui/aura/mus/window_tree_client.cc
+++ b/ui/aura/mus/window_tree_client.cc
@@ -700,7 +700,7 @@
if (window->window_mus_type() == WindowMusType::TOP_LEVEL_IN_WM ||
window->window_mus_type() == WindowMusType::EMBED_IN_OWNER ||
window->window_mus_type() == WindowMusType::DISPLAY_MANUALLY_CREATED ||
- window->HasLocalCompositorFrameSink()) {
+ window->HasLocalLayerTreeFrameSink()) {
local_surface_id = window->GetOrAllocateLocalSurfaceId(new_bounds.size());
synchronizing_with_child_on_next_frame_ = true;
}
diff --git a/ui/aura/test/aura_test_helper.cc b/ui/aura/test/aura_test_helper.cc
index 6c3f1a9..7083d8a 100644
--- a/ui/aura/test/aura_test_helper.cc
+++ b/ui/aura/test/aura_test_helper.cc
@@ -11,7 +11,7 @@
#include "ui/aura/client/focus_client.h"
#include "ui/aura/env.h"
#include "ui/aura/input_state_lookup.h"
-#include "ui/aura/local/compositor_frame_sink_local.h"
+#include "ui/aura/local/layer_tree_frame_sink_local.h"
#include "ui/aura/mus/capture_synchronizer.h"
#include "ui/aura/mus/focus_synchronizer.h"
#include "ui/aura/mus/window_port_mus.h"
diff --git a/ui/aura/window.cc b/ui/aura/window.cc
index 5ed1291..d879c24 100644
--- a/ui/aura/window.cc
+++ b/ui/aura/window.cc
@@ -19,7 +19,7 @@
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
-#include "cc/output/compositor_frame_sink.h"
+#include "cc/output/layer_tree_frame_sink.h"
#include "ui/aura/client/aura_constants.h"
#include "ui/aura/client/capture_client.h"
#include "ui/aura/client/cursor_client.h"
@@ -30,7 +30,7 @@
#include "ui/aura/client/window_stacking_client.h"
#include "ui/aura/env.h"
#include "ui/aura/layout_manager.h"
-#include "ui/aura/local/compositor_frame_sink_local.h"
+#include "ui/aura/local/layer_tree_frame_sink_local.h"
#include "ui/aura/window_delegate.h"
#include "ui/aura/window_event_dispatcher.h"
#include "ui/aura/window_observer.h"
@@ -982,8 +982,8 @@
return state_modified;
}
-std::unique_ptr<cc::CompositorFrameSink> Window::CreateCompositorFrameSink() {
- return port_->CreateCompositorFrameSink();
+std::unique_ptr<cc::LayerTreeFrameSink> Window::CreateLayerTreeFrameSink() {
+ return port_->CreateLayerTreeFrameSink();
}
cc::SurfaceId Window::GetSurfaceId() const {
diff --git a/ui/aura/window.h b/ui/aura/window.h
index 22794c7..b719842 100644
--- a/ui/aura/window.h
+++ b/ui/aura/window.h
@@ -32,7 +32,7 @@
#include "ui/gfx/native_widget_types.h"
namespace cc {
-class CompositorFrameSink;
+class LayerTreeFrameSink;
}
namespace display {
@@ -309,8 +309,8 @@
// Returns true if there was state needing to be cleaned up.
bool CleanupGestureState();
- // Create a CompositorFrameSink for the aura::Window.
- std::unique_ptr<cc::CompositorFrameSink> CreateCompositorFrameSink();
+ // Create a LayerTreeFrameSink for the aura::Window.
+ std::unique_ptr<cc::LayerTreeFrameSink> CreateLayerTreeFrameSink();
// Get the current cc::SurfaceId.
cc::SurfaceId GetSurfaceId() const;
diff --git a/ui/aura/window_port.h b/ui/aura/window_port.h
index bd41ffb..f33170a 100644
--- a/ui/aura/window_port.h
+++ b/ui/aura/window_port.h
@@ -18,7 +18,7 @@
#include "ui/base/class_property.h"
namespace cc {
-class CompositorFrameSink;
+class LayerTreeFrameSink;
}
namespace gfx {
@@ -80,9 +80,9 @@
int64_t old_value,
std::unique_ptr<ui::PropertyData> data) = 0;
- // Called for creating a cc::CompositorFrameSink for the window.
- virtual std::unique_ptr<cc::CompositorFrameSink>
- CreateCompositorFrameSink() = 0;
+ // Called for creating a cc::LayerTreeFrameSink for the window.
+ virtual std::unique_ptr<cc::LayerTreeFrameSink>
+ CreateLayerTreeFrameSink() = 0;
// Get the current cc::SurfaceId.
virtual cc::SurfaceId GetSurfaceId() const = 0;
diff --git a/ui/aura/window_port_for_shutdown.cc b/ui/aura/window_port_for_shutdown.cc
index 3c1cc2e..84c66f7 100644
--- a/ui/aura/window_port_for_shutdown.cc
+++ b/ui/aura/window_port_for_shutdown.cc
@@ -5,7 +5,7 @@
#include "ui/aura/window_port_for_shutdown.h"
#include "base/memory/ptr_util.h"
-#include "cc/output/compositor_frame_sink.h"
+#include "cc/output/layer_tree_frame_sink.h"
#include "ui/aura/window.h"
namespace aura {
@@ -51,8 +51,8 @@
int64_t old_value,
std::unique_ptr<ui::PropertyData> data) {}
-std::unique_ptr<cc::CompositorFrameSink>
-WindowPortForShutdown::CreateCompositorFrameSink() {
+std::unique_ptr<cc::LayerTreeFrameSink>
+WindowPortForShutdown::CreateLayerTreeFrameSink() {
return nullptr;
}
diff --git a/ui/aura/window_port_for_shutdown.h b/ui/aura/window_port_for_shutdown.h
index 56473cd..b355141e 100644
--- a/ui/aura/window_port_for_shutdown.h
+++ b/ui/aura/window_port_for_shutdown.h
@@ -35,7 +35,7 @@
void OnPropertyChanged(const void* key,
int64_t old_value,
std::unique_ptr<ui::PropertyData> data) override;
- std::unique_ptr<cc::CompositorFrameSink> CreateCompositorFrameSink() override;
+ std::unique_ptr<cc::LayerTreeFrameSink> CreateLayerTreeFrameSink() override;
cc::SurfaceId GetSurfaceId() const override;
void OnWindowAddedToRootWindow() override;
void OnWillRemoveWindowFromRootWindow() override;
diff --git a/ui/compositor/compositor.cc b/ui/compositor/compositor.cc
index d8a0150..4303f63 100644
--- a/ui/compositor/compositor.cc
+++ b/ui/compositor/compositor.cc
@@ -236,10 +236,10 @@
host_->SetLocalSurfaceId(local_surface_id);
}
-void Compositor::SetCompositorFrameSink(
- std::unique_ptr<cc::CompositorFrameSink> compositor_frame_sink) {
- compositor_frame_sink_requested_ = false;
- host_->SetCompositorFrameSink(std::move(compositor_frame_sink));
+void Compositor::SetLayerTreeFrameSink(
+ std::unique_ptr<cc::LayerTreeFrameSink> layer_tree_frame_sink) {
+ layer_tree_frame_sink_requested_ = false;
+ host_->SetLayerTreeFrameSink(std::move(layer_tree_frame_sink));
// Display properties are reset when the output surface is lost, so update it
// to match the Compositor's.
if (context_factory_private_) {
@@ -392,13 +392,13 @@
DCHECK(!widget_valid_);
widget_ = widget;
widget_valid_ = true;
- if (compositor_frame_sink_requested_)
- context_factory_->CreateCompositorFrameSink(weak_ptr_factory_.GetWeakPtr());
+ if (layer_tree_frame_sink_requested_)
+ context_factory_->CreateLayerTreeFrameSink(weak_ptr_factory_.GetWeakPtr());
}
gfx::AcceleratedWidget Compositor::ReleaseAcceleratedWidget() {
DCHECK(!IsVisible());
- host_->ReleaseCompositorFrameSink();
+ host_->ReleaseLayerTreeFrameSink();
context_factory_->RemoveCompositor(this);
widget_valid_ = false;
gfx::AcceleratedWidget widget = widget_;
@@ -467,15 +467,15 @@
SendDamagedRectsRecursive(root_layer());
}
-void Compositor::RequestNewCompositorFrameSink() {
- DCHECK(!compositor_frame_sink_requested_);
- compositor_frame_sink_requested_ = true;
+void Compositor::RequestNewLayerTreeFrameSink() {
+ DCHECK(!layer_tree_frame_sink_requested_);
+ layer_tree_frame_sink_requested_ = true;
if (widget_valid_)
- context_factory_->CreateCompositorFrameSink(weak_ptr_factory_.GetWeakPtr());
+ context_factory_->CreateLayerTreeFrameSink(weak_ptr_factory_.GetWeakPtr());
}
-void Compositor::DidFailToInitializeCompositorFrameSink() {
- // The CompositorFrameSink should already be bound/initialized before being
+void Compositor::DidFailToInitializeLayerTreeFrameSink() {
+ // The LayerTreeFrameSink should already be bound/initialized before being
// given to
// the Compositor.
NOTREACHED();
diff --git a/ui/compositor/compositor.h b/ui/compositor/compositor.h
index 25c3e0c..9c72fc4 100644
--- a/ui/compositor/compositor.h
+++ b/ui/compositor/compositor.h
@@ -43,6 +43,7 @@
class ContextProvider;
class Layer;
class LayerTreeDebugState;
+class LayerTreeFrameSink;
class LayerTreeHost;
class LocalSurfaceId;
class ResourceSettings;
@@ -112,7 +113,7 @@
// Inform the display corresponding to this compositor if it is visible. When
// false it does not need to produce any frames. Visibility is reset for each
- // call to CreateCompositorFrameSink.
+ // call to CreateLayerTreeFrameSink.
virtual void SetDisplayVisible(ui::Compositor* compositor, bool visible) = 0;
// Resize the display corresponding to this compositor to a particular size.
@@ -128,7 +129,7 @@
virtual void SetAuthoritativeVSyncInterval(ui::Compositor* compositor,
base::TimeDelta interval) = 0;
// Mac path for transporting vsync parameters to the display. Other platforms
- // update it via the BrowserCompositorCompositorFrameSink directly.
+ // update it via the BrowserCompositorLayerTreeFrameSink directly.
virtual void SetDisplayVSyncParameters(ui::Compositor* compositor,
base::TimeTicks timebase,
base::TimeDelta interval) = 0;
@@ -145,7 +146,7 @@
// Creates an output surface for the given compositor. The factory may keep
// per-compositor data (e.g. a shared context), that needs to be cleaned up
// by calling RemoveCompositor when the compositor gets destroyed.
- virtual void CreateCompositorFrameSink(
+ virtual void CreateLayerTreeFrameSink(
base::WeakPtr<Compositor> compositor) = 0;
// Return a reference to a shared offscreen context provider usable from the
@@ -201,7 +202,7 @@
void SetLocalSurfaceId(const cc::LocalSurfaceId& local_surface_id);
- void SetCompositorFrameSink(std::unique_ptr<cc::CompositorFrameSink> surface);
+ void SetLayerTreeFrameSink(std::unique_ptr<cc::LayerTreeFrameSink> surface);
// Schedules a redraw of the layer tree associated with this compositor.
void ScheduleDraw();
@@ -274,9 +275,8 @@
void SetAuthoritativeVSyncInterval(const base::TimeDelta& interval);
// Most platforms set their vsync info via
- // BrowerCompositorCompositorFrameSink's
- // OnUpdateVSyncParametersFromGpu, but Mac routes vsync info via the
- // browser compositor instead through this path.
+ // BrowerCompositorLayerTreeFrameSink::OnUpdateVSyncParametersFromGpu(), but
+ // Mac routes vsync info via the browser compositor instead through this path.
void SetDisplayVSyncParameters(base::TimeTicks timebase,
base::TimeDelta interval);
@@ -341,9 +341,9 @@
float top_controls_delta) override {}
void RecordWheelAndTouchScrollingCount(bool has_scrolled_by_wheel,
bool has_scrolled_by_touch) override {}
- void RequestNewCompositorFrameSink() override;
- void DidInitializeCompositorFrameSink() override {}
- void DidFailToInitializeCompositorFrameSink() override;
+ void RequestNewLayerTreeFrameSink() override;
+ void DidInitializeLayerTreeFrameSink() override {}
+ void DidFailToInitializeLayerTreeFrameSink() override;
void WillCommit() override {}
void DidCommit() override;
void DidCommitAndDrawFrame() override {}
@@ -354,7 +354,7 @@
// cc::LayerTreeHostSingleThreadClient implementation.
void DidSubmitCompositorFrame() override;
- void DidLoseCompositorFrameSink() override {}
+ void DidLoseLayerTreeFrameSink() override {}
bool IsLocked() { return !active_locks_.empty(); }
@@ -405,7 +405,7 @@
// A map from child id to parent id.
std::unordered_set<cc::FrameSinkId, cc::FrameSinkIdHash> child_frame_sinks_;
bool widget_valid_ = false;
- bool compositor_frame_sink_requested_ = false;
+ bool layer_tree_frame_sink_requested_ = false;
const cc::FrameSinkId frame_sink_id_;
scoped_refptr<cc::Layer> root_web_layer_;
std::unique_ptr<cc::AnimationHost> animation_host_;
diff --git a/ui/compositor/test/fake_context_factory.cc b/ui/compositor/test/fake_context_factory.cc
index 906c1ee..1b396bd 100644
--- a/ui/compositor/test/fake_context_factory.cc
+++ b/ui/compositor/test/fake_context_factory.cc
@@ -8,10 +8,10 @@
#include "base/threading/thread_task_runner_handle.h"
#include "cc/base/switches.h"
#include "cc/output/compositor_frame.h"
-#include "cc/output/compositor_frame_sink_client.h"
+#include "cc/output/layer_tree_frame_sink_client.h"
#include "cc/scheduler/begin_frame_source.h"
#include "cc/scheduler/delay_based_time_source.h"
-#include "cc/test/fake_compositor_frame_sink.h"
+#include "cc/test/fake_layer_tree_frame_sink.h"
#include "ui/compositor/compositor_switches.h"
#include "ui/display/display_switches.h"
#include "ui/gfx/switches.h"
@@ -45,11 +45,11 @@
return *frame_sink_->last_sent_frame();
}
-void FakeContextFactory::CreateCompositorFrameSink(
+void FakeContextFactory::CreateLayerTreeFrameSink(
base::WeakPtr<ui::Compositor> compositor) {
- auto frame_sink = cc::FakeCompositorFrameSink::Create3d();
+ auto frame_sink = cc::FakeLayerTreeFrameSink::Create3d();
frame_sink_ = frame_sink.get();
- compositor->SetCompositorFrameSink(std::move(frame_sink));
+ compositor->SetLayerTreeFrameSink(std::move(frame_sink));
}
scoped_refptr<cc::ContextProvider>
diff --git a/ui/compositor/test/fake_context_factory.h b/ui/compositor/test/fake_context_factory.h
index 9be39d8..aadc8d6 100644
--- a/ui/compositor/test/fake_context_factory.h
+++ b/ui/compositor/test/fake_context_factory.h
@@ -13,7 +13,7 @@
namespace cc {
class CompositorFrame;
class ContextProvider;
-class FakeCompositorFrameSink;
+class FakeLayerTreeFrameSink;
class ResourceSettings;
class TestTaskGraphRunner;
class TestGpuMemoryBufferManager;
@@ -29,7 +29,7 @@
const cc::CompositorFrame& GetLastCompositorFrame() const;
// ui::ContextFactory:
- void CreateCompositorFrameSink(
+ void CreateLayerTreeFrameSink(
base::WeakPtr<ui::Compositor> compositor) override;
scoped_refptr<cc::ContextProvider> SharedMainThreadContextProvider() override;
void RemoveCompositor(ui::Compositor* compositor) override;
@@ -41,7 +41,7 @@
void RemoveObserver(ui::ContextFactoryObserver* observer) override {}
private:
- cc::FakeCompositorFrameSink* frame_sink_ = nullptr;
+ cc::FakeLayerTreeFrameSink* frame_sink_ = nullptr;
cc::TestTaskGraphRunner task_graph_runner_;
cc::TestGpuMemoryBufferManager gpu_memory_buffer_manager_;
cc::RendererSettings renderer_settings_;
diff --git a/ui/compositor/test/in_process_context_factory.cc b/ui/compositor/test/in_process_context_factory.cc
index ec253793..3d83f10 100644
--- a/ui/compositor/test/in_process_context_factory.cc
+++ b/ui/compositor/test/in_process_context_factory.cc
@@ -18,7 +18,7 @@
#include "cc/output/texture_mailbox_deleter.h"
#include "cc/scheduler/begin_frame_source.h"
#include "cc/scheduler/delay_based_time_source.h"
-#include "cc/surfaces/direct_compositor_frame_sink.h"
+#include "cc/surfaces/direct_layer_tree_frame_sink.h"
#include "cc/surfaces/display.h"
#include "cc/surfaces/display_scheduler.h"
#include "cc/surfaces/local_surface_id_allocator.h"
@@ -179,7 +179,7 @@
refresh_rate_ = 200.0;
}
-void InProcessContextFactory::CreateCompositorFrameSink(
+void InProcessContextFactory::CreateLayerTreeFrameSink(
base::WeakPtr<Compositor> compositor) {
// Try to reuse existing shared worker context provider.
bool shared_worker_context_provider_lost = false;
@@ -251,11 +251,11 @@
data->begin_frame_source = std::move(begin_frame_source);
auto* display = per_compositor_data_[compositor.get()]->display.get();
- auto compositor_frame_sink = base::MakeUnique<cc::DirectCompositorFrameSink>(
+ auto layer_tree_frame_sink = base::MakeUnique<cc::DirectLayerTreeFrameSink>(
compositor->frame_sink_id(), GetSurfaceManager(), display,
context_provider, shared_worker_context_provider_,
&gpu_memory_buffer_manager_, &shared_bitmap_manager_);
- compositor->SetCompositorFrameSink(std::move(compositor_frame_sink));
+ compositor->SetLayerTreeFrameSink(std::move(layer_tree_frame_sink));
data->display->Resize(compositor->size());
}
diff --git a/ui/compositor/test/in_process_context_factory.h b/ui/compositor/test/in_process_context_factory.h
index 3fbdbf5a..12f64ac 100644
--- a/ui/compositor/test/in_process_context_factory.h
+++ b/ui/compositor/test/in_process_context_factory.h
@@ -36,7 +36,7 @@
// Both |frame_sink_manager_host| and |surface_manager| must outlive the
// ContextFactory.
// TODO(crbug.com/657959): |surface_manager| should go away and we should use
- // the CompositorFrameSink from the FrameSinkManagerHost.
+ // the LayerTreeFrameSink from the FrameSinkManagerHost.
InProcessContextFactory(viz::FrameSinkManagerHost* frame_sink_manager_host,
cc::SurfaceManager* surface_manager);
~InProcessContextFactory() override;
@@ -55,8 +55,8 @@
// used for tests.
void SetUseFastRefreshRateForTests();
- // ContextFactory implementation
- void CreateCompositorFrameSink(base::WeakPtr<Compositor> compositor) override;
+ // ContextFactory implementation.
+ void CreateLayerTreeFrameSink(base::WeakPtr<Compositor> compositor) override;
std::unique_ptr<Reflector> CreateReflector(Compositor* mirrored_compositor,
Layer* mirroring_layer) override;