content: Rename RenderWidgetCompositor to LayerTreeView
In preparation for moving this class into the blink public platform
so blink can use it without going through WebLayerTreeView, rename
the class to mimic the interface it will replace in blink.
https://chromium-review.googlesource.com/c/chromium/src/+/1126490 did
this move and the rename together, but this CL splits out the rename.
[email protected]
TBR=piman
Bug: 838693
Cq-Include-Trybots: luci.chromium.try:linux_layout_tests_slimming_paint_v2;master.tryserver.blink:linux_trusty_blink_rel
Change-Id: I7e436862e5f5cbbf6d77c8eea1954fd31ecd3276
Reviewed-on: https://chromium-review.googlesource.com/1127447
Commit-Queue: danakj <[email protected]>
Reviewed-by: Kentaro Hara <[email protected]>
Cr-Commit-Position: refs/heads/master@{#572966}diff --git a/content/renderer/BUILD.gn b/content/renderer/BUILD.gn
index 37b050d2..32a46b9 100644
--- a/content/renderer/BUILD.gn
+++ b/content/renderer/BUILD.gn
@@ -134,11 +134,11 @@
"gpu/frame_swap_message_queue.h",
"gpu/gpu_benchmarking_extension.cc",
"gpu/gpu_benchmarking_extension.h",
+ "gpu/layer_tree_view.cc",
+ "gpu/layer_tree_view.h",
+ "gpu/layer_tree_view_delegate.h",
"gpu/queue_message_swap_promise.cc",
"gpu/queue_message_swap_promise.h",
- "gpu/render_widget_compositor.cc",
- "gpu/render_widget_compositor.h",
- "gpu/render_widget_compositor_delegate.h",
"gpu/stream_texture_host_android.cc",
"gpu/stream_texture_host_android.h",
"history_entry.cc",
diff --git a/content/renderer/gpu/gpu_benchmarking_extension.cc b/content/renderer/gpu/gpu_benchmarking_extension.cc
index be40e29..da74ef4 100644
--- a/content/renderer/gpu/gpu_benchmarking_extension.cc
+++ b/content/renderer/gpu/gpu_benchmarking_extension.cc
@@ -33,7 +33,7 @@
#include "content/public/renderer/render_thread.h"
#include "content/public/renderer/v8_value_converter.h"
#include "content/renderer/gpu/actions_parser.h"
-#include "content/renderer/gpu/render_widget_compositor.h"
+#include "content/renderer/gpu/layer_tree_view.h"
#include "content/renderer/render_thread_impl.h"
#include "content/renderer/render_view_impl.h"
#include "content/renderer/skia_benchmarking_extension.h"
@@ -182,11 +182,7 @@
class GpuBenchmarkingContext {
public:
- GpuBenchmarkingContext()
- : web_frame_(nullptr),
- web_view_(nullptr),
- render_view_impl_(nullptr),
- compositor_(nullptr) {}
+ GpuBenchmarkingContext() = default;
bool Init(bool init_compositor) {
web_frame_ = WebLocalFrame::FrameForCurrentContext();
@@ -209,8 +205,8 @@
if (!init_compositor)
return true;
- compositor_ = render_view_impl_->GetWidget()->compositor();
- if (!compositor_) {
+ layer_tree_view_ = render_view_impl_->GetWidget()->layer_tree_view();
+ if (!layer_tree_view_) {
web_frame_ = nullptr;
web_view_ = nullptr;
render_view_impl_ = nullptr;
@@ -232,16 +228,16 @@
DCHECK(render_view_impl_ != nullptr);
return render_view_impl_;
}
- RenderWidgetCompositor* compositor() const {
- DCHECK(compositor_ != nullptr);
- return compositor_;
+ LayerTreeView* layer_tree_view() const {
+ DCHECK(layer_tree_view_ != nullptr);
+ return layer_tree_view_;
}
private:
- WebLocalFrame* web_frame_;
- WebView* web_view_;
- RenderViewImpl* render_view_impl_;
- RenderWidgetCompositor* compositor_;
+ WebLocalFrame* web_frame_ = nullptr;
+ WebView* web_view_ = nullptr;
+ RenderViewImpl* render_view_impl_ = nullptr;
+ LayerTreeView* layer_tree_view_ = nullptr;
DISALLOW_COPY_AND_ASSIGN(GpuBenchmarkingContext);
};
@@ -558,7 +554,7 @@
if (!context.Init(true))
return;
- context.compositor()->SetNeedsDisplayOnAllLayers();
+ context.layer_tree_view()->SetNeedsDisplayOnAllLayers();
}
void GpuBenchmarking::SetRasterizeOnlyVisibleContent() {
@@ -566,7 +562,7 @@
if (!context.Init(true))
return;
- context.compositor()->SetRasterizeOnlyVisibleContent();
+ context.layer_tree_view()->SetRasterizeOnlyVisibleContent();
}
namespace {
@@ -596,7 +592,7 @@
if (!context.Init(true))
return;
- const cc::Layer* root_layer = context.compositor()->GetRootLayer();
+ const cc::Layer* root_layer = context.layer_tree_view()->GetRootLayer();
if (!root_layer)
return;
@@ -1040,10 +1036,10 @@
std::unique_ptr<base::Value> value =
V8ValueConverter::Create()->FromV8Value(arguments, v8_context);
- return context.compositor()->ScheduleMicroBenchmark(
+ return context.layer_tree_view()->ScheduleMicroBenchmark(
name, std::move(value),
- base::Bind(&OnMicroBenchmarkCompleted,
- base::RetainedRef(callback_and_context)));
+ base::BindOnce(&OnMicroBenchmarkCompleted,
+ base::RetainedRef(callback_and_context)));
}
bool GpuBenchmarking::SendMessageToMicroBenchmark(
@@ -1058,8 +1054,8 @@
std::unique_ptr<base::Value> value =
V8ValueConverter::Create()->FromV8Value(message, v8_context);
- return context.compositor()->SendMessageToMicroBenchmark(id,
- std::move(value));
+ return context.layer_tree_view()->SendMessageToMicroBenchmark(
+ id, std::move(value));
}
bool GpuBenchmarking::HasGpuChannel() {
diff --git a/content/renderer/gpu/render_widget_compositor.cc b/content/renderer/gpu/layer_tree_view.cc
similarity index 74%
rename from content/renderer/gpu/render_widget_compositor.cc
rename to content/renderer/gpu/layer_tree_view.cc
index aa95d79..a124ffa7 100644
--- a/content/renderer/gpu/render_widget_compositor.cc
+++ b/content/renderer/gpu/layer_tree_view.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/gpu/render_widget_compositor.h"
+#include "content/renderer/gpu/layer_tree_view.h"
#include <stddef.h>
#include <string>
@@ -37,7 +37,7 @@
#include "components/viz/common/frame_sinks/copy_output_result.h"
#include "components/viz/common/quads/compositor_frame_metadata.h"
#include "components/viz/common/resources/single_release_callback.h"
-#include "content/renderer/gpu/render_widget_compositor_delegate.h"
+#include "content/renderer/gpu/layer_tree_view_delegate.h"
#include "third_party/blink/public/platform/scheduler/web_thread_scheduler.h"
#include "third_party/blink/public/platform/web_runtime_features.h"
#include "third_party/blink/public/platform/web_size.h"
@@ -62,7 +62,7 @@
public:
ReportTimeSwapPromise(ReportTimeCallback callback,
scoped_refptr<base::SingleThreadTaskRunner> task_runner,
- base::WeakPtr<RenderWidgetCompositor> compositor);
+ base::WeakPtr<LayerTreeView> layer_tree_view);
~ReportTimeSwapPromise() override;
void DidActivate() override {}
@@ -74,7 +74,7 @@
private:
ReportTimeCallback callback_;
scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
- base::WeakPtr<RenderWidgetCompositor> compositor_;
+ base::WeakPtr<LayerTreeView> layer_tree_view_;
DISALLOW_COPY_AND_ASSIGN(ReportTimeSwapPromise);
};
@@ -82,10 +82,10 @@
ReportTimeSwapPromise::ReportTimeSwapPromise(
ReportTimeCallback callback,
scoped_refptr<base::SingleThreadTaskRunner> task_runner,
- base::WeakPtr<RenderWidgetCompositor> compositor)
+ base::WeakPtr<LayerTreeView> layer_tree_view)
: callback_(std::move(callback)),
task_runner_(std::move(task_runner)),
- compositor_(compositor) {}
+ layer_tree_view_(std::move(layer_tree_view)) {}
ReportTimeSwapPromise::~ReportTimeSwapPromise() {}
@@ -96,7 +96,7 @@
task_runner->PostTask(
FROM_HERE,
base::BindOnce(
- &RenderWidgetCompositor::AddPresentationCallback, compositor_,
+ &LayerTreeView::AddPresentationCallback, layer_tree_view_,
metadata->frame_token,
base::BindOnce(std::move(callback_),
blink::WebLayerTreeView::SwapResult::kDidSwap)));
@@ -167,7 +167,7 @@
return cc_selection;
}
-// Check cc::BrowserControlsState, and blink::WebBrowserControlsState
+// Check cc::BrowserControlsState, and WebBrowserControlsState
// are kept in sync.
static_assert(int(blink::kWebBrowserControlsBoth) == int(cc::BOTH),
"mismatching enums: BOTH");
@@ -183,8 +183,8 @@
} // namespace
-RenderWidgetCompositor::RenderWidgetCompositor(
- RenderWidgetCompositorDelegate* delegate,
+LayerTreeView::LayerTreeView(
+ LayerTreeViewDelegate* delegate,
scoped_refptr<base::SingleThreadTaskRunner> main_thread,
scoped_refptr<base::SingleThreadTaskRunner> compositor_thread,
cc::TaskGraphRunner* task_graph_runner,
@@ -197,9 +197,9 @@
animation_host_(cc::AnimationHost::CreateMainInstance()),
weak_factory_(this) {}
-RenderWidgetCompositor::~RenderWidgetCompositor() = default;
+LayerTreeView::~LayerTreeView() = default;
-void RenderWidgetCompositor::Initialize(
+void LayerTreeView::Initialize(
const cc::LayerTreeSettings& settings,
std::unique_ptr<cc::UkmRecorderFactory> ukm_recorder_factory) {
const bool is_threaded = !!compositor_thread_;
@@ -228,77 +228,75 @@
}
}
-void RenderWidgetCompositor::SetNeverVisible() {
+void LayerTreeView::SetNeverVisible() {
DCHECK(!layer_tree_host_->IsVisible());
never_visible_ = true;
}
-const base::WeakPtr<cc::InputHandler>&
-RenderWidgetCompositor::GetInputHandler() {
+const base::WeakPtr<cc::InputHandler>& LayerTreeView::GetInputHandler() {
return layer_tree_host_->GetInputHandler();
}
-void RenderWidgetCompositor::SetNeedsDisplayOnAllLayers() {
+void LayerTreeView::SetNeedsDisplayOnAllLayers() {
layer_tree_host_->SetNeedsDisplayOnAllLayers();
}
-void RenderWidgetCompositor::SetRasterizeOnlyVisibleContent() {
+void LayerTreeView::SetRasterizeOnlyVisibleContent() {
cc::LayerTreeDebugState current = layer_tree_host_->GetDebugState();
current.rasterize_only_visible_content = true;
layer_tree_host_->SetDebugState(current);
}
-void RenderWidgetCompositor::SetNeedsRedrawRect(gfx::Rect damage_rect) {
+void LayerTreeView::SetNeedsRedrawRect(gfx::Rect damage_rect) {
layer_tree_host_->SetNeedsRedrawRect(damage_rect);
}
-bool RenderWidgetCompositor::IsSurfaceSynchronizationEnabled() const {
+bool LayerTreeView::IsSurfaceSynchronizationEnabled() const {
return layer_tree_host_->GetSettings().enable_surface_synchronization;
}
-void RenderWidgetCompositor::SetNeedsForcedRedraw() {
+void LayerTreeView::SetNeedsForcedRedraw() {
layer_tree_host_->SetNeedsCommitWithForcedRedraw();
}
std::unique_ptr<cc::SwapPromiseMonitor>
-RenderWidgetCompositor::CreateLatencyInfoSwapPromiseMonitor(
- ui::LatencyInfo* latency) {
+LayerTreeView::CreateLatencyInfoSwapPromiseMonitor(ui::LatencyInfo* latency) {
return std::make_unique<cc::LatencyInfoSwapPromiseMonitor>(
latency, layer_tree_host_->GetSwapPromiseManager(), nullptr);
}
-void RenderWidgetCompositor::QueueSwapPromise(
+void LayerTreeView::QueueSwapPromise(
std::unique_ptr<cc::SwapPromise> swap_promise) {
layer_tree_host_->QueueSwapPromise(std::move(swap_promise));
}
-int RenderWidgetCompositor::GetSourceFrameNumber() const {
+int LayerTreeView::GetSourceFrameNumber() const {
return layer_tree_host_->SourceFrameNumber();
}
-void RenderWidgetCompositor::NotifyInputThrottledUntilCommit() {
+void LayerTreeView::NotifyInputThrottledUntilCommit() {
layer_tree_host_->NotifyInputThrottledUntilCommit();
}
-const cc::Layer* RenderWidgetCompositor::GetRootLayer() const {
+const cc::Layer* LayerTreeView::GetRootLayer() const {
return layer_tree_host_->root_layer();
}
-int RenderWidgetCompositor::ScheduleMicroBenchmark(
+int LayerTreeView::ScheduleMicroBenchmark(
const std::string& name,
std::unique_ptr<base::Value> value,
- const base::Callback<void(std::unique_ptr<base::Value>)>& callback) {
+ base::OnceCallback<void(std::unique_ptr<base::Value>)> callback) {
return layer_tree_host_->ScheduleMicroBenchmark(name, std::move(value),
- callback);
+ std::move(callback));
}
-bool RenderWidgetCompositor::SendMessageToMicroBenchmark(
+bool LayerTreeView::SendMessageToMicroBenchmark(
int id,
std::unique_ptr<base::Value> value) {
return layer_tree_host_->SendMessageToMicroBenchmark(id, std::move(value));
}
-void RenderWidgetCompositor::SetViewportSizeAndScale(
+void LayerTreeView::SetViewportSizeAndScale(
const gfx::Size& device_viewport_size,
float device_scale_factor,
const viz::LocalSurfaceId& local_surface_id) {
@@ -306,49 +304,44 @@
device_viewport_size, device_scale_factor, local_surface_id);
}
-void RenderWidgetCompositor::RequestNewLocalSurfaceId() {
+void LayerTreeView::RequestNewLocalSurfaceId() {
layer_tree_host_->RequestNewLocalSurfaceId();
}
-bool RenderWidgetCompositor::HasNewLocalSurfaceIdRequest() const {
- return layer_tree_host_->new_local_surface_id_request_for_testing();
-}
-
-void RenderWidgetCompositor::SetViewportVisibleRect(
- const gfx::Rect& visible_rect) {
+void LayerTreeView::SetViewportVisibleRect(const gfx::Rect& visible_rect) {
layer_tree_host_->SetViewportVisibleRect(visible_rect);
}
-viz::FrameSinkId RenderWidgetCompositor::GetFrameSinkId() {
+viz::FrameSinkId LayerTreeView::GetFrameSinkId() {
return frame_sink_id_;
}
-void RenderWidgetCompositor::SetRootLayer(scoped_refptr<cc::Layer> layer) {
+void LayerTreeView::SetRootLayer(scoped_refptr<cc::Layer> layer) {
layer_tree_host_->SetRootLayer(std::move(layer));
}
-void RenderWidgetCompositor::ClearRootLayer() {
+void LayerTreeView::ClearRootLayer() {
layer_tree_host_->SetRootLayer(nullptr);
}
-cc::AnimationHost* RenderWidgetCompositor::CompositorAnimationHost() {
+cc::AnimationHost* LayerTreeView::CompositorAnimationHost() {
return animation_host_.get();
}
-blink::WebSize RenderWidgetCompositor::GetViewportSize() const {
- return layer_tree_host_->device_viewport_size();
+blink::WebSize LayerTreeView::GetViewportSize() const {
+ return blink::WebSize(layer_tree_host_->device_viewport_size());
}
-blink::WebFloatPoint RenderWidgetCompositor::adjustEventPointForPinchZoom(
+blink::WebFloatPoint LayerTreeView::adjustEventPointForPinchZoom(
const blink::WebFloatPoint& point) const {
return point;
}
-void RenderWidgetCompositor::SetBackgroundColor(SkColor color) {
+void LayerTreeView::SetBackgroundColor(SkColor color) {
layer_tree_host_->set_background_color(color);
}
-void RenderWidgetCompositor::SetVisible(bool visible) {
+void LayerTreeView::SetVisible(bool visible) {
if (never_visible_)
return;
@@ -358,19 +351,17 @@
DidFailToInitializeLayerTreeFrameSink();
}
-void RenderWidgetCompositor::SetPageScaleFactorAndLimits(
- float page_scale_factor,
- float minimum,
- float maximum) {
+void LayerTreeView::SetPageScaleFactorAndLimits(float page_scale_factor,
+ float minimum,
+ float maximum) {
layer_tree_host_->SetPageScaleFactorAndLimits(page_scale_factor, minimum,
maximum);
}
-void RenderWidgetCompositor::StartPageScaleAnimation(
- const blink::WebPoint& destination,
- bool use_anchor,
- float new_page_scale,
- double duration_sec) {
+void LayerTreeView::StartPageScaleAnimation(const blink::WebPoint& destination,
+ bool use_anchor,
+ float new_page_scale,
+ double duration_sec) {
base::TimeDelta duration = base::TimeDelta::FromMicroseconds(
duration_sec * base::Time::kMicrosecondsPerSecond);
layer_tree_host_->StartPageScaleAnimation(
@@ -378,25 +369,24 @@
duration);
}
-bool RenderWidgetCompositor::HasPendingPageScaleAnimation() const {
+bool LayerTreeView::HasPendingPageScaleAnimation() const {
return layer_tree_host_->HasPendingPageScaleAnimation();
}
-void RenderWidgetCompositor::HeuristicsForGpuRasterizationUpdated(
+void LayerTreeView::HeuristicsForGpuRasterizationUpdated(
bool matches_heuristics) {
layer_tree_host_->SetHasGpuRasterizationTrigger(matches_heuristics);
}
-void RenderWidgetCompositor::SetNeedsBeginFrame() {
+void LayerTreeView::SetNeedsBeginFrame() {
layer_tree_host_->SetNeedsAnimate();
}
-void RenderWidgetCompositor::DidStopFlinging() {
+void LayerTreeView::DidStopFlinging() {
layer_tree_host_->DidStopFlinging();
}
-void RenderWidgetCompositor::RegisterViewportLayers(
- const blink::WebLayerTreeView::ViewportLayers& layers) {
+void LayerTreeView::RegisterViewportLayers(const ViewportLayers& layers) {
cc::LayerTreeHost::ViewportLayers viewport_layers;
viewport_layers.overscroll_elasticity = layers.overscroll_elasticity;
viewport_layers.page_scale = layers.page_scale;
@@ -407,27 +397,26 @@
layer_tree_host_->RegisterViewportLayers(viewport_layers);
}
-void RenderWidgetCompositor::ClearViewportLayers() {
+void LayerTreeView::ClearViewportLayers() {
layer_tree_host_->RegisterViewportLayers(cc::LayerTreeHost::ViewportLayers());
}
-void RenderWidgetCompositor::RegisterSelection(
- const blink::WebSelection& selection) {
+void LayerTreeView::RegisterSelection(const blink::WebSelection& selection) {
layer_tree_host_->RegisterSelection(ConvertFromWebSelection(selection));
}
-void RenderWidgetCompositor::ClearSelection() {
+void LayerTreeView::ClearSelection() {
cc::LayerSelection empty_selection;
layer_tree_host_->RegisterSelection(empty_selection);
}
-void RenderWidgetCompositor::SetMutatorClient(
+void LayerTreeView::SetMutatorClient(
std::unique_ptr<cc::LayerTreeMutator> client) {
- TRACE_EVENT0("cc", "RenderWidgetCompositor::setMutatorClient");
+ TRACE_EVENT0("cc", "LayerTreeView::setMutatorClient");
layer_tree_host_->SetLayerTreeMutator(std::move(client));
}
-void RenderWidgetCompositor::ForceRecalculateRasterScales() {
+void LayerTreeView::ForceRecalculateRasterScales() {
layer_tree_host_->SetNeedsRecalculateRasterScales();
}
@@ -457,7 +446,7 @@
cc::EventListenerProperties::kBlockingAndPassive,
"EventListener and WebEventListener enums must match");
-void RenderWidgetCompositor::SetEventListenerProperties(
+void LayerTreeView::SetEventListenerProperties(
blink::WebEventListenerClass eventClass,
blink::WebEventListenerProperties properties) {
layer_tree_host_->SetEventListenerProperties(
@@ -465,23 +454,22 @@
static_cast<cc::EventListenerProperties>(properties));
}
-blink::WebEventListenerProperties
-RenderWidgetCompositor::EventListenerProperties(
+blink::WebEventListenerProperties LayerTreeView::EventListenerProperties(
blink::WebEventListenerClass event_class) const {
return static_cast<blink::WebEventListenerProperties>(
layer_tree_host_->event_listener_properties(
static_cast<cc::EventListenerClass>(event_class)));
}
-void RenderWidgetCompositor::SetHaveScrollEventHandlers(bool has_handlers) {
+void LayerTreeView::SetHaveScrollEventHandlers(bool has_handlers) {
layer_tree_host_->SetHaveScrollEventHandlers(has_handlers);
}
-bool RenderWidgetCompositor::HaveScrollEventHandlers() const {
+bool LayerTreeView::HaveScrollEventHandlers() const {
return layer_tree_host_->have_scroll_event_handlers();
}
-bool RenderWidgetCompositor::CompositeIsSynchronous() const {
+bool LayerTreeView::CompositeIsSynchronous() const {
if (!compositor_thread_) {
DCHECK(!layer_tree_host_->GetSettings().single_thread_proxy_scheduler);
return true;
@@ -489,7 +477,7 @@
return false;
}
-void RenderWidgetCompositor::LayoutAndPaintAsync(base::OnceClosure callback) {
+void LayerTreeView::LayoutAndPaintAsync(base::OnceClosure callback) {
DCHECK(layout_and_paint_async_callback_.is_null());
layout_and_paint_async_callback_ = std::move(callback);
@@ -498,15 +486,14 @@
// dispatched after layout and paint for all compositing modes.
const bool raster = false;
layer_tree_host_->GetTaskRunnerProvider()->MainThreadTaskRunner()->PostTask(
- FROM_HERE,
- base::BindOnce(&RenderWidgetCompositor::SynchronouslyComposite,
- weak_factory_.GetWeakPtr(), raster, nullptr));
+ FROM_HERE, base::BindOnce(&LayerTreeView::SynchronouslyComposite,
+ weak_factory_.GetWeakPtr(), raster, nullptr));
} else {
layer_tree_host_->SetNeedsCommit();
}
}
-void RenderWidgetCompositor::SetLayerTreeFrameSink(
+void LayerTreeView::SetLayerTreeFrameSink(
std::unique_ptr<cc::LayerTreeFrameSink> layer_tree_frame_sink) {
if (!layer_tree_frame_sink) {
DidFailToInitializeLayerTreeFrameSink();
@@ -515,12 +502,12 @@
layer_tree_host_->SetLayerTreeFrameSink(std::move(layer_tree_frame_sink));
}
-void RenderWidgetCompositor::InvokeLayoutAndPaintCallback() {
+void LayerTreeView::InvokeLayoutAndPaintCallback() {
if (!layout_and_paint_async_callback_.is_null())
std::move(layout_and_paint_async_callback_).Run();
}
-void RenderWidgetCompositor::CompositeAndReadbackAsync(
+void LayerTreeView::CompositeAndReadbackAsync(
base::OnceCallback<void(const SkBitmap&)> callback) {
DCHECK(layout_and_paint_async_callback_.is_null());
scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner =
@@ -549,10 +536,9 @@
// with rasterization is done.
const bool raster = true;
layer_tree_host_->GetTaskRunnerProvider()->MainThreadTaskRunner()->PostTask(
- FROM_HERE,
- base::BindOnce(&RenderWidgetCompositor::SynchronouslyComposite,
- weak_factory_.GetWeakPtr(), raster,
- std::move(swap_promise)));
+ FROM_HERE, base::BindOnce(&LayerTreeView::SynchronouslyComposite,
+ weak_factory_.GetWeakPtr(), raster,
+ std::move(swap_promise)));
} else {
// Force a redraw to ensure that the copy swap promise isn't cancelled due
// to no damage.
@@ -562,15 +548,15 @@
}
}
-void RenderWidgetCompositor::SynchronouslyCompositeNoRasterForTesting() {
+void LayerTreeView::SynchronouslyCompositeNoRasterForTesting() {
SynchronouslyComposite(false /* raster */, nullptr /* swap_promise */);
}
-void RenderWidgetCompositor::CompositeWithRasterForTesting() {
+void LayerTreeView::CompositeWithRasterForTesting() {
SynchronouslyComposite(true /* raster */, nullptr /* swap_promise */);
}
-void RenderWidgetCompositor::SynchronouslyComposite(
+void LayerTreeView::SynchronouslyComposite(
bool raster,
std::unique_ptr<cc::SwapPromise> swap_promise) {
DCHECK(CompositeIsSynchronous());
@@ -600,27 +586,27 @@
layer_tree_host_->Composite(base::TimeTicks::Now(), raster);
}
-void RenderWidgetCompositor::SetDeferCommits(bool defer_commits) {
+void LayerTreeView::SetDeferCommits(bool defer_commits) {
layer_tree_host_->SetDeferCommits(defer_commits);
}
-int RenderWidgetCompositor::LayerTreeId() const {
+int LayerTreeView::LayerTreeId() const {
return layer_tree_host_->GetId();
}
-void RenderWidgetCompositor::SetShowFPSCounter(bool show) {
+void LayerTreeView::SetShowFPSCounter(bool show) {
cc::LayerTreeDebugState debug_state = layer_tree_host_->GetDebugState();
debug_state.show_fps_counter = show;
layer_tree_host_->SetDebugState(debug_state);
}
-void RenderWidgetCompositor::SetShowPaintRects(bool show) {
+void LayerTreeView::SetShowPaintRects(bool show) {
cc::LayerTreeDebugState debug_state = layer_tree_host_->GetDebugState();
debug_state.show_paint_rects = show;
layer_tree_host_->SetDebugState(debug_state);
}
-void RenderWidgetCompositor::SetShowDebugBorders(bool show) {
+void LayerTreeView::SetShowDebugBorders(bool show) {
cc::LayerTreeDebugState debug_state = layer_tree_host_->GetDebugState();
if (show)
debug_state.show_debug_borders.set();
@@ -629,7 +615,7 @@
layer_tree_host_->SetDebugState(debug_state);
}
-void RenderWidgetCompositor::SetShowScrollBottleneckRects(bool show) {
+void LayerTreeView::SetShowScrollBottleneckRects(bool show) {
cc::LayerTreeDebugState debug_state = layer_tree_host_->GetDebugState();
debug_state.show_touch_event_handler_rects = show;
debug_state.show_wheel_event_handler_rects = show;
@@ -637,7 +623,7 @@
layer_tree_host_->SetDebugState(debug_state);
}
-void RenderWidgetCompositor::UpdateBrowserControlsState(
+void LayerTreeView::UpdateBrowserControlsState(
blink::WebBrowserControlsState constraints,
blink::WebBrowserControlsState current,
bool animate) {
@@ -646,19 +632,18 @@
ConvertBrowserControlsState(current), animate);
}
-void RenderWidgetCompositor::SetBrowserControlsHeight(float top_height,
- float bottom_height,
- bool shrink) {
+void LayerTreeView::SetBrowserControlsHeight(float top_height,
+ float bottom_height,
+ bool shrink) {
layer_tree_host_->SetBrowserControlsHeight(top_height, bottom_height, shrink);
}
-void RenderWidgetCompositor::SetBrowserControlsShownRatio(float ratio) {
+void LayerTreeView::SetBrowserControlsShownRatio(float ratio) {
layer_tree_host_->SetBrowserControlsShownRatio(ratio);
}
-void RenderWidgetCompositor::RequestDecode(
- const cc::PaintImage& image,
- base::OnceCallback<void(bool)> callback) {
+void LayerTreeView::RequestDecode(const cc::PaintImage& image,
+ base::OnceCallback<void(bool)> callback) {
layer_tree_host_->QueueImageDecode(image, std::move(callback));
// If we're compositing synchronously, the SetNeedsCommit call which will be
@@ -669,43 +654,40 @@
if (CompositeIsSynchronous()) {
const bool raster = true;
layer_tree_host_->GetTaskRunnerProvider()->MainThreadTaskRunner()->PostTask(
- FROM_HERE,
- base::BindOnce(&RenderWidgetCompositor::SynchronouslyComposite,
- weak_factory_.GetWeakPtr(), raster, nullptr));
+ FROM_HERE, base::BindOnce(&LayerTreeView::SynchronouslyComposite,
+ weak_factory_.GetWeakPtr(), raster, nullptr));
}
}
-void RenderWidgetCompositor::SetOverscrollBehavior(
+void LayerTreeView::SetOverscrollBehavior(
const cc::OverscrollBehavior& behavior) {
layer_tree_host_->SetOverscrollBehavior(behavior);
}
-void RenderWidgetCompositor::WillBeginMainFrame() {
+void LayerTreeView::WillBeginMainFrame() {
delegate_->WillBeginCompositorFrame();
}
-void RenderWidgetCompositor::DidBeginMainFrame() {}
+void LayerTreeView::DidBeginMainFrame() {}
-void RenderWidgetCompositor::BeginMainFrame(const viz::BeginFrameArgs& args) {
+void LayerTreeView::BeginMainFrame(const viz::BeginFrameArgs& args) {
web_main_thread_scheduler_->WillBeginFrame(args);
delegate_->BeginMainFrame(args.frame_time);
}
-void RenderWidgetCompositor::BeginMainFrameNotExpectedSoon() {
+void LayerTreeView::BeginMainFrameNotExpectedSoon() {
web_main_thread_scheduler_->BeginFrameNotExpectedSoon();
}
-void RenderWidgetCompositor::BeginMainFrameNotExpectedUntil(
- base::TimeTicks time) {
+void LayerTreeView::BeginMainFrameNotExpectedUntil(base::TimeTicks time) {
web_main_thread_scheduler_->BeginMainFrameNotExpectedUntil(time);
}
-void RenderWidgetCompositor::UpdateLayerTreeHost(
- VisualStateUpdate requested_update) {
+void LayerTreeView::UpdateLayerTreeHost(VisualStateUpdate requested_update) {
delegate_->UpdateVisualState(requested_update);
}
-void RenderWidgetCompositor::ApplyViewportDeltas(
+void LayerTreeView::ApplyViewportDeltas(
const gfx::Vector2dF& inner_delta,
const gfx::Vector2dF& outer_delta,
const gfx::Vector2dF& elastic_overscroll_delta,
@@ -716,61 +698,58 @@
top_controls_delta);
}
-void RenderWidgetCompositor::RecordWheelAndTouchScrollingCount(
+void LayerTreeView::RecordWheelAndTouchScrollingCount(
bool has_scrolled_by_wheel,
bool has_scrolled_by_touch) {
delegate_->RecordWheelAndTouchScrollingCount(has_scrolled_by_wheel,
has_scrolled_by_touch);
}
-void RenderWidgetCompositor::RequestNewLayerTreeFrameSink() {
+void LayerTreeView::RequestNewLayerTreeFrameSink() {
// If the host is closing, then no more compositing is possible. This
// prevents shutdown races between handling the close message and
// the CreateLayerTreeFrameSink task.
if (delegate_->IsClosing())
return;
- delegate_->RequestNewLayerTreeFrameSink(
- base::Bind(&RenderWidgetCompositor::SetLayerTreeFrameSink,
- weak_factory_.GetWeakPtr()));
+ delegate_->RequestNewLayerTreeFrameSink(base::BindOnce(
+ &LayerTreeView::SetLayerTreeFrameSink, weak_factory_.GetWeakPtr()));
}
-void RenderWidgetCompositor::DidInitializeLayerTreeFrameSink() {
-}
+void LayerTreeView::DidInitializeLayerTreeFrameSink() {}
-void RenderWidgetCompositor::DidFailToInitializeLayerTreeFrameSink() {
+void LayerTreeView::DidFailToInitializeLayerTreeFrameSink() {
if (!layer_tree_host_->IsVisible()) {
layer_tree_frame_sink_request_failed_while_invisible_ = true;
return;
}
layer_tree_frame_sink_request_failed_while_invisible_ = false;
layer_tree_host_->GetTaskRunnerProvider()->MainThreadTaskRunner()->PostTask(
- FROM_HERE,
- base::BindOnce(&RenderWidgetCompositor::RequestNewLayerTreeFrameSink,
- weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&LayerTreeView::RequestNewLayerTreeFrameSink,
+ weak_factory_.GetWeakPtr()));
}
-void RenderWidgetCompositor::WillCommit() {
+void LayerTreeView::WillCommit() {
InvokeLayoutAndPaintCallback();
}
-void RenderWidgetCompositor::DidCommit() {
+void LayerTreeView::DidCommit() {
delegate_->DidCommitCompositorFrame();
web_main_thread_scheduler_->DidCommitFrameToCompositor();
}
-void RenderWidgetCompositor::DidCommitAndDrawFrame() {
+void LayerTreeView::DidCommitAndDrawFrame() {
delegate_->DidCommitAndDrawCompositorFrame();
}
-void RenderWidgetCompositor::DidReceiveCompositorFrameAck() {
+void LayerTreeView::DidReceiveCompositorFrameAck() {
delegate_->DidReceiveCompositorFrameAck();
}
-void RenderWidgetCompositor::DidCompletePageScaleAnimation() {
+void LayerTreeView::DidCompletePageScaleAnimation() {
delegate_->DidCompletePageScaleAnimation();
}
-void RenderWidgetCompositor::DidPresentCompositorFrame(
+void LayerTreeView::DidPresentCompositorFrame(
uint32_t frame_token,
const gfx::PresentationFeedback& feedback) {
DCHECK(layer_tree_host_->GetTaskRunnerProvider()
@@ -786,54 +765,51 @@
}
}
-void RenderWidgetCompositor::RequestScheduleAnimation() {
+void LayerTreeView::RequestScheduleAnimation() {
delegate_->RequestScheduleAnimation();
}
-void RenderWidgetCompositor::DidSubmitCompositorFrame() {}
+void LayerTreeView::DidSubmitCompositorFrame() {}
-void RenderWidgetCompositor::DidLoseLayerTreeFrameSink() {}
+void LayerTreeView::DidLoseLayerTreeFrameSink() {}
-void RenderWidgetCompositor::SetFrameSinkId(
- const viz::FrameSinkId& frame_sink_id) {
+void LayerTreeView::SetFrameSinkId(const viz::FrameSinkId& frame_sink_id) {
frame_sink_id_ = frame_sink_id;
}
-void RenderWidgetCompositor::SetRasterColorSpace(
- const gfx::ColorSpace& color_space) {
+void LayerTreeView::SetRasterColorSpace(const gfx::ColorSpace& color_space) {
layer_tree_host_->SetRasterColorSpace(color_space);
}
-void RenderWidgetCompositor::ClearCachesOnNextCommit() {
+void LayerTreeView::ClearCachesOnNextCommit() {
layer_tree_host_->ClearCachesOnNextCommit();
}
-void RenderWidgetCompositor::SetContentSourceId(uint32_t id) {
+void LayerTreeView::SetContentSourceId(uint32_t id) {
layer_tree_host_->SetContentSourceId(id);
}
-void RenderWidgetCompositor::NotifySwapTime(ReportTimeCallback callback) {
+void LayerTreeView::NotifySwapTime(ReportTimeCallback callback) {
QueueSwapPromise(std::make_unique<ReportTimeSwapPromise>(
std::move(callback),
layer_tree_host_->GetTaskRunnerProvider()->MainThreadTaskRunner(),
weak_factory_.GetWeakPtr()));
}
-void RenderWidgetCompositor::RequestBeginMainFrameNotExpected(bool new_state) {
+void LayerTreeView::RequestBeginMainFrameNotExpected(bool new_state) {
layer_tree_host_->RequestBeginMainFrameNotExpected(new_state);
}
-const cc::LayerTreeSettings& RenderWidgetCompositor::GetLayerTreeSettings()
- const {
+const cc::LayerTreeSettings& LayerTreeView::GetLayerTreeSettings() const {
return layer_tree_host_->GetSettings();
}
-void RenderWidgetCompositor::SetRenderFrameObserver(
+void LayerTreeView::SetRenderFrameObserver(
std::unique_ptr<cc::RenderFrameMetadataObserver> observer) {
layer_tree_host_->SetRenderFrameObserver(std::move(observer));
}
-void RenderWidgetCompositor::AddPresentationCallback(
+void LayerTreeView::AddPresentationCallback(
uint32_t frame_token,
base::OnceCallback<void(base::TimeTicks)> callback) {
if (!presentation_callbacks_.empty()) {
@@ -852,7 +828,7 @@
DCHECK_LE(presentation_callbacks_.size(), 25u);
}
-void RenderWidgetCompositor::SetURLForUkm(const GURL& url) {
+void LayerTreeView::SetURLForUkm(const GURL& url) {
layer_tree_host_->SetURLForUkm(url);
}
diff --git a/content/renderer/gpu/render_widget_compositor.h b/content/renderer/gpu/layer_tree_view.h
similarity index 90%
rename from content/renderer/gpu/render_widget_compositor.h
rename to content/renderer/gpu/layer_tree_view.h
index 4cfa450..ffabb08e 100644
--- a/content/renderer/gpu/render_widget_compositor.h
+++ b/content/renderer/gpu/layer_tree_view.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_GPU_RENDER_WIDGET_COMPOSITOR_H_
-#define CONTENT_RENDERER_GPU_RENDER_WIDGET_COMPOSITOR_H_
+#ifndef CONTENT_RENDERER_GPU_LAYER_TREE_VIEW_H_
+#define CONTENT_RENDERER_GPU_LAYER_TREE_VIEW_H_
#include <stdint.h>
@@ -40,7 +40,7 @@
class RenderFrameMetadataObserver;
class TaskGraphRunner;
class UkmRecorderFactory;
-}
+} // namespace cc
namespace gfx {
class ColorSpace;
@@ -51,9 +51,9 @@
}
namespace content {
-class RenderWidgetCompositorDelegate;
+class LayerTreeViewDelegate;
-class CONTENT_EXPORT RenderWidgetCompositor
+class CONTENT_EXPORT LayerTreeView
: public blink::WebLayerTreeView,
public cc::LayerTreeHostClient,
public cc::LayerTreeHostSingleThreadClient {
@@ -62,13 +62,12 @@
// main thread (where it is constructed). The |compositor_thread| is the task
// runner for the compositor thread, but is null if the compositor will run in
// single-threaded mode (in tests only).
- RenderWidgetCompositor(
- RenderWidgetCompositorDelegate* delegate,
- scoped_refptr<base::SingleThreadTaskRunner> main_thread,
- scoped_refptr<base::SingleThreadTaskRunner> compositor_thread,
- cc::TaskGraphRunner* task_graph_runner,
- blink::scheduler::WebThreadScheduler* scheduler);
- ~RenderWidgetCompositor() override;
+ LayerTreeView(LayerTreeViewDelegate* delegate,
+ scoped_refptr<base::SingleThreadTaskRunner> main_thread,
+ scoped_refptr<base::SingleThreadTaskRunner> compositor_thread,
+ cc::TaskGraphRunner* task_graph_runner,
+ blink::scheduler::WebThreadScheduler* scheduler);
+ ~LayerTreeView() override;
// The |ukm_recorder_factory| may be null to disable recording (in tests
// only).
@@ -102,7 +101,7 @@
int ScheduleMicroBenchmark(
const std::string& name,
std::unique_ptr<base::Value> value,
- const base::Callback<void(std::unique_ptr<base::Value>)>& callback);
+ base::OnceCallback<void(std::unique_ptr<base::Value>)> callback);
bool SendMessageToMicroBenchmark(int id, std::unique_ptr<base::Value> value);
void SetFrameSinkId(const viz::FrameSinkId& frame_sink_id);
void SetRasterColorSpace(const gfx::ColorSpace& color_space);
@@ -112,11 +111,10 @@
float device_scale_factor,
const viz::LocalSurfaceId& local_surface_id);
void RequestNewLocalSurfaceId();
- bool HasNewLocalSurfaceIdRequest() const;
void SetViewportVisibleRect(const gfx::Rect& visible_rect);
void SetURLForUkm(const GURL& url);
- // WebLayerTreeView implementation.
+ // blink::WebLayerTreeView implementation.
viz::FrameSinkId GetFrameSinkId() override;
void SetRootLayer(scoped_refptr<cc::Layer> layer) override;
void ClearRootLayer() override;
@@ -143,8 +141,7 @@
void SynchronouslyCompositeNoRasterForTesting() override;
void CompositeWithRasterForTesting() override;
void SetDeferCommits(bool defer_commits) override;
- void RegisterViewportLayers(
- const blink::WebLayerTreeView::ViewportLayers& viewport_layers) override;
+ void RegisterViewportLayers(const ViewportLayers& viewport_layers) override;
void ClearViewportLayers() override;
void RegisterSelection(const blink::WebSelection& selection) override;
void ClearSelection() override;
@@ -232,7 +229,7 @@
void SynchronouslyComposite(bool raster,
std::unique_ptr<cc::SwapPromise> swap_promise);
- RenderWidgetCompositorDelegate* const delegate_;
+ LayerTreeViewDelegate* const delegate_;
const scoped_refptr<base::SingleThreadTaskRunner> main_thread_;
const scoped_refptr<base::SingleThreadTaskRunner> compositor_thread_;
cc::TaskGraphRunner* const task_graph_runner_;
@@ -252,11 +249,11 @@
std::vector<base::OnceCallback<void(base::TimeTicks)>>>>
presentation_callbacks_;
- base::WeakPtrFactory<RenderWidgetCompositor> weak_factory_;
+ base::WeakPtrFactory<LayerTreeView> weak_factory_;
- DISALLOW_COPY_AND_ASSIGN(RenderWidgetCompositor);
+ DISALLOW_COPY_AND_ASSIGN(LayerTreeView);
};
} // namespace content
-#endif // CONTENT_RENDERER_GPU_RENDER_WIDGET_COMPOSITOR_H_
+#endif // CONTENT_RENDERER_GPU_LAYER_TREE_VIEW_H_
diff --git a/content/renderer/gpu/render_widget_compositor_delegate.h b/content/renderer/gpu/layer_tree_view_delegate.h
similarity index 81%
rename from content/renderer/gpu/render_widget_compositor_delegate.h
rename to content/renderer/gpu/layer_tree_view_delegate.h
index 24e9453d..51ab69a 100644
--- a/content/renderer/gpu/render_widget_compositor_delegate.h
+++ b/content/renderer/gpu/layer_tree_view_delegate.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_GPU_RENDER_WIDGET_COMPOSITOR_DELEGATE_H_
-#define CONTENT_RENDERER_GPU_RENDER_WIDGET_COMPOSITOR_DELEGATE_H_
+#ifndef CONTENT_RENDERER_GPU_LAYER_TREE_VIEW_DELEGATE_H_
+#define CONTENT_RENDERER_GPU_LAYER_TREE_VIEW_DELEGATE_H_
#include <memory>
#include <vector>
@@ -11,12 +11,11 @@
#include "base/callback.h"
#include "base/time/time.h"
#include "cc/trees/layer_tree_host_client.h"
-#include "content/common/content_export.h"
namespace cc {
class LayerTreeFrameSink;
class SwapPromise;
-}
+} // namespace cc
namespace gfx {
class Vector2dF;
@@ -28,13 +27,13 @@
namespace content {
-using LayerTreeFrameSinkCallback =
- base::Callback<void(std::unique_ptr<cc::LayerTreeFrameSink>)>;
-
-// Consumers of RenderWidgetCompositor implement this delegate in order to
+// Consumers of LayerTreeView implement this delegate in order to
// transport compositing information across processes.
-class CONTENT_EXPORT RenderWidgetCompositorDelegate {
+class LayerTreeViewDelegate {
public:
+ using LayerTreeFrameSinkCallback =
+ base::OnceCallback<void(std::unique_ptr<cc::LayerTreeFrameSink>)>;
+
// Report viewport related properties during a commit from the compositor
// thread.
virtual void ApplyViewportDeltas(
@@ -55,7 +54,7 @@
// Requests a LayerTreeFrameSink to submit CompositorFrames to.
virtual void RequestNewLayerTreeFrameSink(
- const LayerTreeFrameSinkCallback& callback) = 0;
+ LayerTreeFrameSinkCallback callback) = 0;
// Notifies that the draw commands for a committed frame have been issued.
virtual void DidCommitAndDrawCompositorFrame() = 0;
@@ -70,7 +69,7 @@
// will be displayed.
virtual void DidReceiveCompositorFrameAck() = 0;
- // Indicates whether the RenderWidgetCompositor is about to close.
+ // Indicates whether the LayerTreeView is about to close.
virtual bool IsClosing() const = 0;
// Requests that the client schedule a composite now, and calculate
@@ -93,9 +92,9 @@
std::unique_ptr<viz::CopyOutputRequest> request) = 0;
protected:
- virtual ~RenderWidgetCompositorDelegate() {}
+ virtual ~LayerTreeViewDelegate() {}
};
} // namespace content
-#endif // CONTENT_RENDERER_GPU_RENDER_WIDGET_COMPOSITOR_DELEGATE_H_
+#endif // CONTENT_RENDERER_GPU_LAYER_TREE_VIEW_DELEGATE_H_
diff --git a/content/renderer/gpu/render_widget_compositor_unittest.cc b/content/renderer/gpu/layer_tree_view_unittest.cc
similarity index 63%
rename from content/renderer/gpu/render_widget_compositor_unittest.cc
rename to content/renderer/gpu/layer_tree_view_unittest.cc
index 9d7e80b..abc5529 100644
--- a/content/renderer/gpu/render_widget_compositor_unittest.cc
+++ b/content/renderer/gpu/layer_tree_view_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 "content/renderer/gpu/render_widget_compositor.h"
+#include "content/renderer/gpu/layer_tree_view.h"
#include <utility>
@@ -19,11 +19,7 @@
#include "cc/trees/layer_tree_host.h"
#include "components/viz/common/frame_sinks/copy_output_request.h"
#include "components/viz/test/test_context_provider.h"
-#include "content/public/common/screen_info.h"
-#include "content/public/test/mock_render_thread.h"
-#include "content/renderer/render_widget.h"
-#include "content/test/fake_compositor_dependencies.h"
-#include "content/test/stub_render_widget_compositor_delegate.h"
+#include "content/test/stub_layer_tree_view_delegate.h"
#include "gpu/GLES2/gl2extchromium.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
@@ -42,17 +38,16 @@
GPU_CHANNEL_FAILURE,
};
-class FakeRenderWidgetCompositorDelegate
- : public StubRenderWidgetCompositorDelegate {
+class FakeLayerTreeViewDelegate : public StubLayerTreeViewDelegate {
public:
- FakeRenderWidgetCompositorDelegate() = default;
+ FakeLayerTreeViewDelegate() = default;
void RequestNewLayerTreeFrameSink(
- const LayerTreeFrameSinkCallback& callback) override {
+ LayerTreeFrameSinkCallback callback) override {
// Subtract one cuz the current request has already been counted but should
// not be included for this.
if (num_requests_since_last_success_ - 1 < num_requests_before_success_) {
- callback.Run(std::unique_ptr<cc::LayerTreeFrameSink>());
+ std::move(callback).Run(nullptr);
return;
}
@@ -61,7 +56,7 @@
context_provider->UnboundTestContextGL()->LoseContextCHROMIUM(
GL_GUILTY_CONTEXT_RESET_ARB, GL_INNOCENT_CONTEXT_RESET_ARB);
}
- callback.Run(
+ std::move(callback).Run(
cc::FakeLayerTreeFrameSink::Create3d(std::move(context_provider)));
}
@@ -113,7 +108,7 @@
int num_failures_since_last_success_ = 0;
int num_successes_ = 0;
- DISALLOW_COPY_AND_ASSIGN(FakeRenderWidgetCompositorDelegate);
+ DISALLOW_COPY_AND_ASSIGN(FakeLayerTreeViewDelegate);
};
// Verify that failing to create an output surface will cause the compositor
@@ -121,19 +116,19 @@
// 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 RenderWidgetLayerTreeFrameSink : public RenderWidgetCompositor {
+class LayerTreeViewWithFrameSinkTracking : public LayerTreeView {
public:
- RenderWidgetLayerTreeFrameSink(
- FakeRenderWidgetCompositorDelegate* delegate,
+ LayerTreeViewWithFrameSinkTracking(
+ FakeLayerTreeViewDelegate* delegate,
scoped_refptr<base::SingleThreadTaskRunner> main_thread,
scoped_refptr<base::SingleThreadTaskRunner> compositor_thread,
cc::TaskGraphRunner* task_graph_runner,
blink::scheduler::WebThreadScheduler* scheduler)
- : RenderWidgetCompositor(delegate,
- std::move(main_thread),
- std::move(compositor_thread),
- task_graph_runner,
- scheduler),
+ : LayerTreeView(delegate,
+ std::move(main_thread),
+ std::move(compositor_thread),
+ task_graph_runner,
+ scheduler),
delegate_(delegate) {}
// Force a new output surface to be created.
@@ -148,11 +143,11 @@
void RequestNewLayerTreeFrameSink() override {
delegate_->add_request();
- RenderWidgetCompositor::RequestNewLayerTreeFrameSink();
+ LayerTreeView::RequestNewLayerTreeFrameSink();
}
void DidInitializeLayerTreeFrameSink() override {
- RenderWidgetCompositor::DidInitializeLayerTreeFrameSink();
+ LayerTreeView::DidInitializeLayerTreeFrameSink();
delegate_->add_success();
if (delegate_->num_successes() == expected_successes_) {
EXPECT_EQ(delegate_->num_requests(), expected_requests_);
@@ -162,13 +157,14 @@
// reentrantly as a part of RequestNewLayerTreeFrameSink.
blink::scheduler::GetSingleThreadTaskRunnerForTesting()->PostTask(
FROM_HERE,
- base::BindOnce(&RenderWidgetLayerTreeFrameSink::SynchronousComposite,
- base::Unretained(this)));
+ base::BindOnce(
+ &LayerTreeViewWithFrameSinkTracking::SynchronousComposite,
+ base::Unretained(this)));
}
}
void DidFailToInitializeLayerTreeFrameSink() override {
- RenderWidgetCompositor::DidFailToInitializeLayerTreeFrameSink();
+ LayerTreeView::DidFailToInitializeLayerTreeFrameSink();
delegate_->add_failure();
if (delegate_->num_requests() == expected_requests_) {
EXPECT_EQ(delegate_->num_successes(), expected_successes_);
@@ -198,32 +194,32 @@
void EndTest() { run_loop_->Quit(); }
private:
- FakeRenderWidgetCompositorDelegate* delegate_;
+ FakeLayerTreeViewDelegate* delegate_;
base::RunLoop* run_loop_ = nullptr;
int expected_successes_ = 0;
int expected_requests_ = 0;
FailureMode failure_mode_ = NO_FAILURE;
- DISALLOW_COPY_AND_ASSIGN(RenderWidgetLayerTreeFrameSink);
+ DISALLOW_COPY_AND_ASSIGN(LayerTreeViewWithFrameSinkTracking);
};
-class RenderWidgetLayerTreeFrameSinkTest : public testing::Test {
+class LayerTreeViewWithFrameSinkTrackingTest : public testing::Test {
public:
- RenderWidgetLayerTreeFrameSinkTest()
- : render_widget_compositor_(
- &compositor_delegate_,
+ LayerTreeViewWithFrameSinkTrackingTest()
+ : layer_tree_view_(
+ &layer_tree_view_delegate_,
blink::scheduler::GetSingleThreadTaskRunnerForTesting(),
/*compositor_thread=*/nullptr,
&test_task_graph_runner_,
&fake_renderer_scheduler_) {
cc::LayerTreeSettings settings;
settings.single_thread_proxy_scheduler = false;
- render_widget_compositor_.Initialize(
- settings, std::make_unique<cc::TestUkmRecorderFactory>());
+ layer_tree_view_.Initialize(settings,
+ std::make_unique<cc::TestUkmRecorderFactory>());
}
void RunTest(int expected_successes, FailureMode failure_mode) {
- compositor_delegate_.Reset();
+ layer_tree_view_delegate_.Reset();
// 6 is just an artibrary "large" number to show it keeps trying.
const int kTries = 6;
// If it should fail, then it will fail every attempt, otherwise it fails
@@ -231,91 +227,90 @@
int tries_before_success = kTries - (expected_successes ? 1 : 0);
switch (failure_mode) {
case NO_FAILURE:
- compositor_delegate_.set_num_failures_before_success(0);
- compositor_delegate_.set_num_requests_before_success(0);
+ layer_tree_view_delegate_.set_num_failures_before_success(0);
+ layer_tree_view_delegate_.set_num_requests_before_success(0);
break;
case BIND_CONTEXT_FAILURE:
- compositor_delegate_.set_num_failures_before_success(
+ layer_tree_view_delegate_.set_num_failures_before_success(
tries_before_success);
- compositor_delegate_.set_num_requests_before_success(0);
+ layer_tree_view_delegate_.set_num_requests_before_success(0);
break;
case GPU_CHANNEL_FAILURE:
- compositor_delegate_.set_num_failures_before_success(0);
- compositor_delegate_.set_num_requests_before_success(
+ layer_tree_view_delegate_.set_num_failures_before_success(0);
+ layer_tree_view_delegate_.set_num_requests_before_success(
tries_before_success);
break;
}
base::RunLoop run_loop;
- render_widget_compositor_.SetUp(expected_successes, kTries, failure_mode,
- &run_loop);
- render_widget_compositor_.SetVisible(true);
+ layer_tree_view_.SetUp(expected_successes, kTries, failure_mode, &run_loop);
+ layer_tree_view_.SetVisible(true);
blink::scheduler::GetSingleThreadTaskRunnerForTesting()->PostTask(
FROM_HERE,
- base::BindOnce(&RenderWidgetLayerTreeFrameSink::SynchronousComposite,
- base::Unretained(&render_widget_compositor_)));
+ base::BindOnce(
+ &LayerTreeViewWithFrameSinkTracking::SynchronousComposite,
+ base::Unretained(&layer_tree_view_)));
run_loop.Run();
}
protected:
base::MessageLoop ye_olde_message_loope_;
- MockRenderThread render_thread_;
cc::TestTaskGraphRunner test_task_graph_runner_;
blink::scheduler::FakeRendererScheduler fake_renderer_scheduler_;
- FakeRenderWidgetCompositorDelegate compositor_delegate_;
- RenderWidgetLayerTreeFrameSink render_widget_compositor_;
+ FakeLayerTreeViewDelegate layer_tree_view_delegate_;
+ LayerTreeViewWithFrameSinkTracking layer_tree_view_;
private:
- DISALLOW_COPY_AND_ASSIGN(RenderWidgetLayerTreeFrameSinkTest);
+ DISALLOW_COPY_AND_ASSIGN(LayerTreeViewWithFrameSinkTrackingTest);
};
-TEST_F(RenderWidgetLayerTreeFrameSinkTest, SucceedOnce) {
+TEST_F(LayerTreeViewWithFrameSinkTrackingTest, SucceedOnce) {
RunTest(1, NO_FAILURE);
}
-TEST_F(RenderWidgetLayerTreeFrameSinkTest, SucceedOnce_AfterNullChannel) {
+TEST_F(LayerTreeViewWithFrameSinkTrackingTest, SucceedOnce_AfterNullChannel) {
RunTest(1, GPU_CHANNEL_FAILURE);
}
-TEST_F(RenderWidgetLayerTreeFrameSinkTest, SucceedOnce_AfterLostContext) {
+TEST_F(LayerTreeViewWithFrameSinkTrackingTest, SucceedOnce_AfterLostContext) {
RunTest(1, BIND_CONTEXT_FAILURE);
}
-TEST_F(RenderWidgetLayerTreeFrameSinkTest, SucceedTwice) {
+TEST_F(LayerTreeViewWithFrameSinkTrackingTest, SucceedTwice) {
RunTest(2, NO_FAILURE);
}
-TEST_F(RenderWidgetLayerTreeFrameSinkTest, SucceedTwice_AfterNullChannel) {
+TEST_F(LayerTreeViewWithFrameSinkTrackingTest, SucceedTwice_AfterNullChannel) {
RunTest(2, GPU_CHANNEL_FAILURE);
}
-TEST_F(RenderWidgetLayerTreeFrameSinkTest, SucceedTwice_AfterLostContext) {
+TEST_F(LayerTreeViewWithFrameSinkTrackingTest, SucceedTwice_AfterLostContext) {
RunTest(2, BIND_CONTEXT_FAILURE);
}
-TEST_F(RenderWidgetLayerTreeFrameSinkTest, FailWithNullChannel) {
+TEST_F(LayerTreeViewWithFrameSinkTrackingTest, FailWithNullChannel) {
RunTest(0, GPU_CHANNEL_FAILURE);
}
-TEST_F(RenderWidgetLayerTreeFrameSinkTest, FailWithLostContext) {
+TEST_F(LayerTreeViewWithFrameSinkTrackingTest, FailWithLostContext) {
RunTest(0, BIND_CONTEXT_FAILURE);
}
-class VisibilityTestRenderWidgetCompositor : public RenderWidgetCompositor {
+class VisibilityTestLayerTreeView : public LayerTreeView {
public:
- VisibilityTestRenderWidgetCompositor(
- StubRenderWidgetCompositorDelegate* delegate,
+ VisibilityTestLayerTreeView(
+ StubLayerTreeViewDelegate* delegate,
scoped_refptr<base::SingleThreadTaskRunner> main_thread,
scoped_refptr<base::SingleThreadTaskRunner> compositor_thread,
cc::TaskGraphRunner* task_graph_runner,
blink::scheduler::WebThreadScheduler* scheduler)
- : RenderWidgetCompositor(delegate,
- std::move(main_thread),
- std::move(compositor_thread),
- task_graph_runner,
- scheduler) {}
+ : LayerTreeView(delegate,
+ std::move(main_thread),
+ std::move(compositor_thread),
+ task_graph_runner,
+ scheduler) {}
void RequestNewLayerTreeFrameSink() override {
- RenderWidgetCompositor::RequestNewLayerTreeFrameSink();
+ LayerTreeView::RequestNewLayerTreeFrameSink();
num_requests_sent_++;
if (run_loop_)
run_loop_->Quit();
@@ -329,8 +324,8 @@
base::RunLoop* run_loop_;
};
-TEST(RenderWidgetCompositorTest, VisibilityTest) {
- // Test that RenderWidgetCompositor does not retry FrameSink request while
+TEST(LayerTreeViewTest, VisibilityTest) {
+ // Test that LayerTreeView does not retry FrameSink request while
// invisible.
base::MessageLoop message_loop;
@@ -338,42 +333,42 @@
cc::TestTaskGraphRunner test_task_graph_runner;
blink::scheduler::FakeRendererScheduler fake_renderer_scheduler;
// Synchronously callback with null FrameSink.
- StubRenderWidgetCompositorDelegate compositor_delegate;
- VisibilityTestRenderWidgetCompositor render_widget_compositor(
- &compositor_delegate,
+ StubLayerTreeViewDelegate layer_tree_view_delegate;
+ VisibilityTestLayerTreeView layer_tree_view(
+ &layer_tree_view_delegate,
blink::scheduler::GetSingleThreadTaskRunnerForTesting(),
/*compositor_thread=*/nullptr, &test_task_graph_runner,
&fake_renderer_scheduler);
- render_widget_compositor.Initialize(
- cc::LayerTreeSettings(), std::make_unique<cc::TestUkmRecorderFactory>());
+ layer_tree_view.Initialize(cc::LayerTreeSettings(),
+ std::make_unique<cc::TestUkmRecorderFactory>());
{
// Make one request and stop immediately while invisible.
base::RunLoop run_loop;
- render_widget_compositor.set_run_loop(&run_loop);
- render_widget_compositor.SetVisible(false);
- render_widget_compositor.RequestNewLayerTreeFrameSink();
+ layer_tree_view.set_run_loop(&run_loop);
+ layer_tree_view.SetVisible(false);
+ layer_tree_view.RequestNewLayerTreeFrameSink();
run_loop.Run();
- render_widget_compositor.set_run_loop(nullptr);
- EXPECT_EQ(1, render_widget_compositor.num_requests_sent());
+ layer_tree_view.set_run_loop(nullptr);
+ EXPECT_EQ(1, layer_tree_view.num_requests_sent());
}
{
// Make sure there are no more requests.
base::RunLoop run_loop;
run_loop.RunUntilIdle();
- EXPECT_EQ(1, render_widget_compositor.num_requests_sent());
+ EXPECT_EQ(1, layer_tree_view.num_requests_sent());
}
{
// Becoming visible retries request.
base::RunLoop run_loop;
- render_widget_compositor.set_run_loop(&run_loop);
- render_widget_compositor.SetVisible(true);
+ layer_tree_view.set_run_loop(&run_loop);
+ layer_tree_view.SetVisible(true);
run_loop.Run();
- render_widget_compositor.set_run_loop(nullptr);
- EXPECT_EQ(2, render_widget_compositor.num_requests_sent());
+ layer_tree_view.set_run_loop(nullptr);
+ EXPECT_EQ(2, layer_tree_view.num_requests_sent());
}
}
diff --git a/content/renderer/gpu/queue_message_swap_promise_unittest.cc b/content/renderer/gpu/queue_message_swap_promise_unittest.cc
index 73d68de3..098d92e 100644
--- a/content/renderer/gpu/queue_message_swap_promise_unittest.cc
+++ b/content/renderer/gpu/queue_message_swap_promise_unittest.cc
@@ -16,7 +16,7 @@
#include "content/common/render_frame_metadata.mojom.h"
#include "content/common/view_messages.h"
#include "content/renderer/gpu/frame_swap_message_queue.h"
-#include "content/renderer/gpu/render_widget_compositor.h"
+#include "content/renderer/gpu/layer_tree_view.h"
#include "content/renderer/render_widget.h"
#include "content/test/mock_render_process.h"
#include "ipc/ipc_message.h"
diff --git a/content/renderer/input/frame_input_handler_impl.cc b/content/renderer/input/frame_input_handler_impl.cc
index 4a43fdd8..206f518 100644
--- a/content/renderer/input/frame_input_handler_impl.cc
+++ b/content/renderer/input/frame_input_handler_impl.cc
@@ -10,7 +10,7 @@
#include "base/debug/stack_trace.h"
#include "base/logging.h"
#include "content/common/input/ime_text_span_conversions.h"
-#include "content/renderer/gpu/render_widget_compositor.h"
+#include "content/renderer/gpu/layer_tree_view.h"
#include "content/renderer/ime_event_guard.h"
#include "content/renderer/input/widget_input_handler_manager.h"
#include "content/renderer/render_thread_impl.h"
diff --git a/content/renderer/input/render_widget_input_handler.cc b/content/renderer/input/render_widget_input_handler.cc
index 046ea39..e463640 100644
--- a/content/renderer/input/render_widget_input_handler.cc
+++ b/content/renderer/input/render_widget_input_handler.cc
@@ -18,7 +18,7 @@
#include "content/public/common/content_switches.h"
#include "content/public/common/input_event_ack_state.h"
#include "content/public/renderer/render_frame.h"
-#include "content/renderer/gpu/render_widget_compositor.h"
+#include "content/renderer/gpu/layer_tree_view.h"
#include "content/renderer/ime_event_guard.h"
#include "content/renderer/input/render_widget_input_handler_delegate.h"
#include "content/renderer/render_frame_proxy.h"
@@ -305,9 +305,9 @@
swap_latency_info.AddLatencyNumber(
ui::LatencyComponentType::INPUT_EVENT_LATENCY_RENDERER_MAIN_COMPONENT);
- if (widget_->compositor()) {
+ if (widget_->layer_tree_view()) {
latency_info_swap_promise_monitor =
- widget_->compositor()->CreateLatencyInfoSwapPromiseMonitor(
+ widget_->layer_tree_view()->CreateLatencyInfoSwapPromiseMonitor(
&swap_latency_info);
}
diff --git a/content/renderer/input/widget_input_handler_impl.cc b/content/renderer/input/widget_input_handler_impl.cc
index 07a2cd8..09384ee 100644
--- a/content/renderer/input/widget_input_handler_impl.cc
+++ b/content/renderer/input/widget_input_handler_impl.cc
@@ -10,7 +10,7 @@
#include "base/logging.h"
#include "content/common/input/ime_text_span_conversions.h"
#include "content/common/input_messages.h"
-#include "content/renderer/gpu/render_widget_compositor.h"
+#include "content/renderer/gpu/layer_tree_view.h"
#include "content/renderer/ime_event_guard.h"
#include "content/renderer/input/widget_input_handler_manager.h"
#include "content/renderer/render_thread_impl.h"
diff --git a/content/renderer/input/widget_input_handler_manager.cc b/content/renderer/input/widget_input_handler_manager.cc
index 77d6094..422496df 100644
--- a/content/renderer/input/widget_input_handler_manager.cc
+++ b/content/renderer/input/widget_input_handler_manager.cc
@@ -9,7 +9,7 @@
#include "base/bind.h"
#include "base/logging.h"
#include "content/common/input_messages.h"
-#include "content/renderer/gpu/render_widget_compositor.h"
+#include "content/renderer/gpu/layer_tree_view.h"
#include "content/renderer/ime_event_guard.h"
#include "content/renderer/input/widget_input_handler_impl.h"
#include "content/renderer/render_thread_impl.h"
@@ -161,7 +161,7 @@
FROM_HERE,
base::BindOnce(
&WidgetInputHandlerManager::InitOnCompositorThread, this,
- render_widget_->compositor()->GetInputHandler(),
+ render_widget_->layer_tree_view()->GetInputHandler(),
render_widget_->compositor_deps()->IsScrollAnimatorEnabled(),
sync_compositing));
}
diff --git a/content/renderer/mus/renderer_window_tree_client.cc b/content/renderer/mus/renderer_window_tree_client.cc
index e12c2ff..0b4f41e2 100644
--- a/content/renderer/mus/renderer_window_tree_client.cc
+++ b/content/renderer/mus/renderer_window_tree_client.cc
@@ -6,6 +6,7 @@
#include <map>
+#include "base/bind_helpers.h"
#include "base/command_line.h"
#include "base/lazy_instance.h"
#include "cc/base/switches.h"
@@ -90,17 +91,18 @@
void RendererWindowTreeClient::RequestLayerTreeFrameSink(
scoped_refptr<viz::ContextProvider> context_provider,
gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
- const LayerTreeFrameSinkCallback& callback) {
+ LayerTreeFrameSinkCallback callback) {
DCHECK(pending_layer_tree_frame_sink_callback_.is_null());
if (tree_) {
RequestLayerTreeFrameSinkInternal(std::move(context_provider),
- gpu_memory_buffer_manager, callback);
+ gpu_memory_buffer_manager,
+ std::move(callback));
return;
}
pending_context_provider_ = std::move(context_provider);
pending_gpu_memory_buffer_manager_ = gpu_memory_buffer_manager;
- pending_layer_tree_frame_sink_callback_ = callback;
+ pending_layer_tree_frame_sink_callback_ = std::move(callback);
}
std::unique_ptr<MusEmbeddedFrame>
@@ -126,7 +128,7 @@
void RendererWindowTreeClient::RequestLayerTreeFrameSinkInternal(
scoped_refptr<viz::ContextProvider> context_provider,
gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
- const LayerTreeFrameSinkCallback& callback) {
+ LayerTreeFrameSinkCallback callback) {
viz::mojom::CompositorFrameSinkPtrInfo sink_info;
viz::mojom::CompositorFrameSinkRequest sink_request =
mojo::MakeRequest(&sink_info);
@@ -151,7 +153,7 @@
¶ms);
tree_->AttachCompositorFrameSink(root_window_id_, std::move(sink_request),
std::move(client));
- callback.Run(std::move(frame_sink));
+ std::move(callback).Run(std::move(frame_sink));
}
void RendererWindowTreeClient::OnEmbeddedFrameDestroyed(
@@ -208,9 +210,10 @@
}
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_);
+ RequestLayerTreeFrameSinkInternal(
+ std::move(pending_context_provider_),
+ pending_gpu_memory_buffer_manager_,
+ std::move(pending_layer_tree_frame_sink_callback_));
pending_context_provider_ = nullptr;
pending_gpu_memory_buffer_manager_ = nullptr;
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 a8e4e5d8..cfc4dab5 100644
--- a/content/renderer/mus/renderer_window_tree_client.h
+++ b/content/renderer/mus/renderer_window_tree_client.h
@@ -72,11 +72,11 @@
void SetVisible(bool visible);
using LayerTreeFrameSinkCallback =
- base::Callback<void(std::unique_ptr<cc::LayerTreeFrameSink>)>;
+ base::OnceCallback<void(std::unique_ptr<cc::LayerTreeFrameSink>)>;
void RequestLayerTreeFrameSink(
scoped_refptr<viz::ContextProvider> context_provider,
gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
- const LayerTreeFrameSinkCallback& callback);
+ LayerTreeFrameSinkCallback callback);
// Creates a new MusEmbeddedFrame. |token| is an UnguessableToken that was
// registered for an embedding with mus (specifically ui::mojom::WindowTree).
@@ -93,7 +93,7 @@
void RequestLayerTreeFrameSinkInternal(
scoped_refptr<viz::ContextProvider> context_provider,
gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
- const LayerTreeFrameSinkCallback& callback);
+ LayerTreeFrameSinkCallback callback);
// Called from ~MusEmbeddedFrame to cleanup up internall mapping.
void OnEmbeddedFrameDestroyed(MusEmbeddedFrame* frame);
diff --git a/content/renderer/render_frame_impl.cc b/content/renderer/render_frame_impl.cc
index 2deec13..c0bcc0ef 100644
--- a/content/renderer/render_frame_impl.cc
+++ b/content/renderer/render_frame_impl.cc
@@ -104,7 +104,7 @@
#include "content/renderer/external_popup_menu.h"
#include "content/renderer/frame_owner_properties.h"
#include "content/renderer/gpu/gpu_benchmarking_extension.h"
-#include "content/renderer/gpu/render_widget_compositor.h"
+#include "content/renderer/gpu/layer_tree_view.h"
#include "content/renderer/history_entry.h"
#include "content/renderer/history_serialization.h"
#include "content/renderer/image_downloader/image_downloader_impl.h"
@@ -3470,7 +3470,7 @@
const blink::WebString& sink_id,
blink::WebLayerTreeView* layer_tree_view) {
const cc::LayerTreeSettings& settings =
- GetRenderWidget()->compositor()->GetLayerTreeSettings();
+ GetRenderWidget()->layer_tree_view()->GetLayerTreeSettings();
return media_factory_.CreateMediaPlayer(source, client, encrypted_client,
initial_cdm, sink_id, layer_tree_view,
settings);
@@ -4222,8 +4222,8 @@
// URL.
// Note that this is only done for the main frame since the metrics for all
// frames are keyed to the main frame's URL.
- if (GetRenderWidget()->compositor())
- GetRenderWidget()->compositor()->SetURLForUkm(GetLoadingUrl());
+ if (GetRenderWidget()->layer_tree_view())
+ GetRenderWidget()->layer_tree_view()->SetURLForUkm(GetLoadingUrl());
}
service_manager::mojom::InterfaceProviderRequest
@@ -6686,7 +6686,7 @@
rect_for_scrolled_focused_editable_node_ = rect;
has_scrolled_focused_editable_node_into_rect_ = true;
- if (!GetRenderWidget()->compositor()->HasPendingPageScaleAnimation() &&
+ if (!GetRenderWidget()->layer_tree_view()->HasPendingPageScaleAnimation() &&
autofill_client) {
autofill_client->DidCompleteFocusChangeInFrame();
}
diff --git a/content/renderer/render_frame_impl.h b/content/renderer/render_frame_impl.h
index 586376a..1b10136 100644
--- a/content/renderer/render_frame_impl.h
+++ b/content/renderer/render_frame_impl.h
@@ -284,7 +284,7 @@
// See RenderFrameObserver::DidMeaningfulLayout declaration for details.
void DidMeaningfulLayout(blink::WebMeaningfulLayout layout_type);
- // Draw commands have been issued by RenderWidgetCompositor.
+ // Draw commands have been issued by blink::LayerTreeView.
void DidCommitAndDrawCompositorFrame();
// Returns the unique name of the RenderFrame.
diff --git a/content/renderer/render_frame_proxy.h b/content/renderer/render_frame_proxy.h
index 16f9e680..9ca7b54b 100644
--- a/content/renderer/render_frame_proxy.h
+++ b/content/renderer/render_frame_proxy.h
@@ -127,7 +127,7 @@
// IPC::Listener
bool OnMessageReceived(const IPC::Message& msg) override;
- // Out-of-process child frames receive a signal from RenderWidgetCompositor
+ // Out-of-process child frames receive a signal from blink::LayerTreeView
// when a compositor frame will begin.
void WillBeginCompositorFrame();
diff --git a/content/renderer/render_thread_impl.cc b/content/renderer/render_thread_impl.cc
index fc840f2..1bfe08b 100644
--- a/content/renderer/render_thread_impl.cc
+++ b/content/renderer/render_thread_impl.cc
@@ -1962,7 +1962,7 @@
int routing_id,
scoped_refptr<FrameSwapMessageQueue> frame_swap_message_queue,
const GURL& url,
- const LayerTreeFrameSinkCallback& callback,
+ LayerTreeFrameSinkCallback callback,
mojom::RenderFrameMetadataObserverClientRequest
render_frame_metadata_observer_client_request,
mojom::RenderFrameMetadataObserverPtr render_frame_metadata_observer_ptr) {
@@ -2001,20 +2001,20 @@
#if defined(USE_AURA)
if (!features::IsAshInBrowserProcess()) {
if (!RendererWindowTreeClient::Get(routing_id)) {
- callback.Run(nullptr);
+ std::move(callback).Run(nullptr);
return;
}
scoped_refptr<gpu::GpuChannelHost> channel = EstablishGpuChannelSync();
// If the channel could not be established correctly, then return null. This
// would cause the compositor to wait and try again at a later time.
if (!channel) {
- callback.Run(nullptr);
+ std::move(callback).Run(nullptr);
return;
}
RendererWindowTreeClient::Get(routing_id)
->RequestLayerTreeFrameSink(
gpu_->CreateContextProvider(std::move(channel)),
- GetGpuMemoryBufferManager(), callback);
+ GetGpuMemoryBufferManager(), std::move(callback));
frame_sink_provider_->RegisterRenderFrameMetadataObserver(
routing_id, std::move(render_frame_metadata_observer_client_request),
std::move(render_frame_metadata_observer_ptr));
@@ -2036,8 +2036,9 @@
frame_sink_provider_->RegisterRenderFrameMetadataObserver(
routing_id, std::move(render_frame_metadata_observer_client_request),
std::move(render_frame_metadata_observer_ptr));
- callback.Run(std::make_unique<cc::mojo_embedder::AsyncLayerTreeFrameSink>(
- nullptr, nullptr, ¶ms));
+ std::move(callback).Run(
+ std::make_unique<cc::mojo_embedder::AsyncLayerTreeFrameSink>(
+ nullptr, nullptr, ¶ms));
return;
}
@@ -2046,7 +2047,7 @@
if (!gpu_channel_host) {
// Wait and try again. We may hear that the compositing mode has switched
// to software in the meantime.
- callback.Run(nullptr);
+ std::move(callback).Run(nullptr);
return;
}
@@ -2054,7 +2055,7 @@
SharedCompositorWorkerContextProvider();
if (!worker_context_provider) {
// Cause the compositor to wait and try again.
- callback.Run(nullptr);
+ std::move(callback).Run(nullptr);
return;
}
@@ -2090,7 +2091,7 @@
if (layout_test_deps_) {
if (!layout_test_deps_->UseDisplayCompositorPixelDump()) {
- callback.Run(layout_test_deps_->CreateLayerTreeFrameSink(
+ std::move(callback).Run(layout_test_deps_->CreateLayerTreeFrameSink(
routing_id, std::move(gpu_channel_host), std::move(context_provider),
std::move(worker_context_provider), GetGpuMemoryBufferManager(),
this));
@@ -2107,7 +2108,7 @@
if (GetContentClient()->UsingSynchronousCompositing()) {
RenderViewImpl* view = RenderViewImpl::FromRoutingID(routing_id);
if (view) {
- callback.Run(std::make_unique<SynchronousLayerTreeFrameSink>(
+ std::move(callback).Run(std::make_unique<SynchronousLayerTreeFrameSink>(
std::move(context_provider), std::move(worker_context_provider),
compositor_task_runner_, GetGpuMemoryBufferManager(),
sync_message_filter(), routing_id, g_next_layer_tree_frame_sink_id++,
@@ -2129,9 +2130,10 @@
routing_id, std::move(render_frame_metadata_observer_client_request),
std::move(render_frame_metadata_observer_ptr));
params.gpu_memory_buffer_manager = GetGpuMemoryBufferManager();
- callback.Run(std::make_unique<cc::mojo_embedder::AsyncLayerTreeFrameSink>(
- std::move(context_provider), std::move(worker_context_provider),
- ¶ms));
+ std::move(callback).Run(
+ std::make_unique<cc::mojo_embedder::AsyncLayerTreeFrameSink>(
+ std::move(context_provider), std::move(worker_context_provider),
+ ¶ms));
}
blink::AssociatedInterfaceRegistry*
diff --git a/content/renderer/render_thread_impl.h b/content/renderer/render_thread_impl.h
index 8cfd19d9..78326bc 100644
--- a/content/renderer/render_thread_impl.h
+++ b/content/renderer/render_thread_impl.h
@@ -283,12 +283,12 @@
gpu::GpuMemoryBufferManager* GetGpuMemoryBufferManager();
using LayerTreeFrameSinkCallback =
- base::Callback<void(std::unique_ptr<cc::LayerTreeFrameSink>)>;
+ base::OnceCallback<void(std::unique_ptr<cc::LayerTreeFrameSink>)>;
void RequestNewLayerTreeFrameSink(
int routing_id,
scoped_refptr<FrameSwapMessageQueue> frame_swap_message_queue,
const GURL& url,
- const LayerTreeFrameSinkCallback& callback,
+ LayerTreeFrameSinkCallback callback,
mojom::RenderFrameMetadataObserverClientRequest
render_frame_metadata_observer_client_request,
mojom::RenderFrameMetadataObserverPtr render_frame_metadata_observer_ptr);
diff --git a/content/renderer/render_view_browsertest.cc b/content/renderer/render_view_browsertest.cc
index b46f677..5d53294 100644
--- a/content/renderer/render_view_browsertest.cc
+++ b/content/renderer/render_view_browsertest.cc
@@ -46,7 +46,7 @@
#include "content/public/test/render_view_test.h"
#include "content/public/test/test_utils.h"
#include "content/renderer/accessibility/render_accessibility_impl.h"
-#include "content/renderer/gpu/render_widget_compositor.h"
+#include "content/renderer/gpu/layer_tree_view.h"
#include "content/renderer/history_entry.h"
#include "content/renderer/history_serialization.h"
#include "content/renderer/loader/request_extra_data.h"
@@ -495,10 +495,8 @@
EXPECT_EQ(height, emulated_height);
EXPECT_TRUE(ExecuteJavaScriptAndReturnIntValue(get_dpr, &emulated_dpr));
EXPECT_EQ(static_cast<int>(dpr * 10), emulated_dpr);
- EXPECT_EQ(compositor_dsf, view()
- ->compositor()
- ->layer_tree_host()
- ->device_scale_factor());
+ cc::LayerTreeHost* host = view()->layer_tree_view()->layer_tree_host();
+ EXPECT_EQ(compositor_dsf, host->device_scale_factor());
}
};
diff --git a/content/renderer/render_view_impl.cc b/content/renderer/render_view_impl.cc
index 18b9150..41511b5 100644
--- a/content/renderer/render_view_impl.cc
+++ b/content/renderer/render_view_impl.cc
@@ -73,7 +73,7 @@
#include "content/renderer/browser_plugin/browser_plugin.h"
#include "content/renderer/browser_plugin/browser_plugin_manager.h"
#include "content/renderer/drop_data_builder.h"
-#include "content/renderer/gpu/render_widget_compositor.h"
+#include "content/renderer/gpu/layer_tree_view.h"
#include "content/renderer/history_serialization.h"
#include "content/renderer/idle_user_detector.h"
#include "content/renderer/ime_event_guard.h"
@@ -1206,11 +1206,11 @@
}
void RenderViewImpl::OnForceRedraw(int snapshot_id) {
- if (RenderWidgetCompositor* rwc = compositor()) {
- rwc->layer_tree_host()->RequestPresentationTimeForNextFrame(
+ if (LayerTreeView* ltv = layer_tree_view()) {
+ ltv->layer_tree_host()->RequestPresentationTimeForNextFrame(
base::BindOnce(&RenderViewImpl::OnForceDrawFramePresented,
weak_ptr_factory_.GetWeakPtr(), snapshot_id));
- rwc->SetNeedsForcedRedraw();
+ ltv->SetNeedsForcedRedraw();
}
}
@@ -2128,7 +2128,7 @@
void RenderViewImpl::SetScreenMetricsEmulationParameters(
bool enabled,
const blink::WebDeviceEmulationParams& params) {
- if (webview() && compositor()) {
+ if (webview() && layer_tree_view()) {
if (enabled)
webview()->EnableDeviceEmulation(params);
else
@@ -2342,8 +2342,8 @@
visual_properties.local_surface_id = local_surface_id_from_parent_;
// We are changing the device scale factor from the renderer, so allocate a
// new viz::LocalSurfaceId to avoid surface invariants violations in tests.
- if (compositor_)
- compositor_->RequestNewLocalSurfaceId();
+ if (layer_tree_view())
+ layer_tree_view()->RequestNewLocalSurfaceId();
OnSynchronizeVisualProperties(visual_properties);
}
@@ -2383,8 +2383,8 @@
visual_properties.local_surface_id = local_surface_id_from_parent_;
// We are changing the device color space from the renderer, so allocate a
// new viz::LocalSurfaceId to avoid surface invariants violations in tests.
- if (compositor_)
- compositor_->RequestNewLocalSurfaceId();
+ if (layer_tree_view())
+ layer_tree_view()->RequestNewLocalSurfaceId();
OnSynchronizeVisualProperties(visual_properties);
}
diff --git a/content/renderer/render_view_impl_android.cc b/content/renderer/render_view_impl_android.cc
index 2d9f48d..f9e581b 100644
--- a/content/renderer/render_view_impl_android.cc
+++ b/content/renderer/render_view_impl_android.cc
@@ -7,7 +7,7 @@
#include "base/command_line.h"
#include "cc/trees/layer_tree_host.h"
#include "content/common/view_messages.h"
-#include "content/renderer/gpu/render_widget_compositor.h"
+#include "content/renderer/gpu/layer_tree_view.h"
#include "third_party/blink/public/web/web_view.h"
namespace content {
diff --git a/content/renderer/render_widget.cc b/content/renderer/render_widget.cc
index 152dccd..f6da234 100644
--- a/content/renderer/render_widget.cc
+++ b/content/renderer/render_widget.cc
@@ -59,8 +59,8 @@
#include "content/renderer/drop_data_builder.h"
#include "content/renderer/external_popup_menu.h"
#include "content/renderer/gpu/frame_swap_message_queue.h"
+#include "content/renderer/gpu/layer_tree_view.h"
#include "content/renderer/gpu/queue_message_swap_promise.h"
-#include "content/renderer/gpu/render_widget_compositor.h"
#include "content/renderer/ime_event_guard.h"
#include "content/renderer/input/main_thread_event_queue.h"
#include "content/renderer/input/widget_input_handler_manager.h"
@@ -598,7 +598,7 @@
widget_input_handler_manager_ = WidgetInputHandlerManager::Create(
weak_ptr_factory_.GetWeakPtr(),
- compositor_thread_scheduler && compositor_
+ compositor_thread_scheduler && layer_tree_view_
? compositor_thread_scheduler->InputTaskRunner()
: nullptr,
render_thread_impl ? render_thread_impl->GetWebMainThreadScheduler()
@@ -749,8 +749,8 @@
visual_properties.local_surface_id = local_surface_id_from_parent_;
// We are resizing the window from the renderer, so allocate a new
// viz::LocalSurfaceId to avoid surface invariants violations in tests.
- if (compositor_)
- compositor_->RequestNewLocalSurfaceId();
+ if (layer_tree_view_)
+ layer_tree_view_->RequestNewLocalSurfaceId();
SynchronizeVisualProperties(visual_properties);
view_screen_rect_ = new_window_rect;
@@ -863,8 +863,8 @@
if (!needs_repainting)
return;
- if (compositor_ && !show_request_timestamp.is_null()) {
- compositor_->layer_tree_host()->RequestPresentationTimeForNextFrame(
+ if (layer_tree_view_ && !show_request_timestamp.is_null()) {
+ layer_tree_view_->layer_tree_host()->RequestPresentationTimeForNextFrame(
CreateTabSwitchingTimeRecorder(show_request_timestamp));
}
}
@@ -920,14 +920,14 @@
}
void RenderWidget::SetNeedsMainFrame() {
- RenderWidgetCompositor* rwc = compositor();
- if (!rwc)
+ LayerTreeView* ltv = layer_tree_view();
+ if (!ltv)
return;
- rwc->SetNeedsBeginFrame();
+ ltv->SetNeedsBeginFrame();
}
///////////////////////////////////////////////////////////////////////////////
-// RenderWidgetCompositorDelegate
+// LayerTreeViewDelegate
void RenderWidget::ApplyViewportDeltas(
const gfx::Vector2dF& inner_delta,
@@ -961,7 +961,7 @@
}
void RenderWidget::RequestNewLayerTreeFrameSink(
- const LayerTreeFrameSinkCallback& callback) {
+ 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::LayerTreeFrameSink.
@@ -977,11 +977,11 @@
auto render_frame_metadata_observer =
std::make_unique<RenderFrameMetadataObserverImpl>(std::move(request),
std::move(client_info));
- compositor_->SetRenderFrameObserver(
+ layer_tree_view_->SetRenderFrameObserver(
std::move(render_frame_metadata_observer));
RenderThreadImpl::current()->RequestNewLayerTreeFrameSink(
routing_id_, frame_swap_message_queue_, GetURLForGraphicsContext3D(),
- callback, std::move(client_request), std::move(ptr));
+ std::move(callback), std::move(client_request), std::move(ptr));
}
void RenderWidget::DidCommitAndDrawCompositorFrame() {
@@ -1251,8 +1251,8 @@
// RenderWidgetScreenMetricsDelegate
void RenderWidget::Redraw() {
- if (compositor_)
- compositor_->SetNeedsRedrawRect(gfx::Rect(size_));
+ if (layer_tree_view_)
+ layer_tree_view_->SetNeedsRedrawRect(gfx::Rect(size_));
}
void RenderWidget::ResizeWebWidget() {
@@ -1313,11 +1313,11 @@
params.local_surface_id.value_or(viz::LocalSurfaceId()),
new_compositor_viewport_pixel_size, params.screen_info);
UpdateCaptureSequenceNumber(params.capture_sequence_number);
- if (compositor_) {
- compositor_->SetBrowserControlsHeight(
+ if (layer_tree_view_) {
+ layer_tree_view_->SetBrowserControlsHeight(
params.top_controls_height, params.bottom_controls_height,
params.browser_controls_shrink_blink_size);
- compositor_->SetRasterColorSpace(
+ layer_tree_view_->SetRasterColorSpace(
screen_info_.color_space.GetRasterColorSpace());
}
@@ -1371,12 +1371,12 @@
blink::WebLayerTreeView* RenderWidget::InitializeLayerTreeView() {
DCHECK(!host_closing_);
- compositor_ = std::make_unique<RenderWidgetCompositor>(
+ layer_tree_view_ = std::make_unique<LayerTreeView>(
this, compositor_deps_->GetCompositorMainThreadTaskRunner(),
compositor_deps_->GetCompositorImplThreadTaskRunner(),
compositor_deps_->GetTaskGraphRunner(),
compositor_deps_->GetWebMainThreadScheduler());
- compositor_->Initialize(
+ layer_tree_view_->Initialize(
GenerateLayerTreeSettings(compositor_deps_, for_oopif_,
screen_info_.rect.size(),
screen_info_.device_scale_factor),
@@ -1384,19 +1384,19 @@
UpdateSurfaceAndScreenInfo(local_surface_id_from_parent_,
compositor_viewport_pixel_size_, screen_info_);
- compositor_->SetRasterColorSpace(
+ layer_tree_view_->SetRasterColorSpace(
screen_info_.color_space.GetRasterColorSpace());
- compositor_->SetContentSourceId(current_content_source_id_);
+ layer_tree_view_->SetContentSourceId(current_content_source_id_);
// For background pages and certain tests, we don't want to trigger
// LayerTreeFrameSink creation.
bool should_generate_frame_sink =
!compositor_never_visible_ && RenderThreadImpl::current();
if (!should_generate_frame_sink)
- compositor_->SetNeverVisible();
+ layer_tree_view_->SetNeverVisible();
StartCompositor();
DCHECK_NE(MSG_ROUTING_NONE, routing_id_);
- compositor_->SetFrameSinkId(
+ layer_tree_view_->SetFrameSinkId(
viz::FrameSinkId(RenderThread::Get()->GetClientId(), routing_id_));
RenderThreadImpl* render_thread = RenderThreadImpl::current();
@@ -1408,7 +1408,7 @@
UpdateURLForCompositorUkm();
- return compositor_.get();
+ return layer_tree_view_.get();
}
void RenderWidget::IntrinsicSizingInfoChanged(
@@ -1461,7 +1461,7 @@
void RenderWidget::QueueMessage(IPC::Message* msg,
MessageDeliveryPolicy policy) {
// RenderThreadImpl::current() is NULL in some tests.
- if (!compositor_ || !RenderThreadImpl::current()) {
+ if (!layer_tree_view_ || !RenderThreadImpl::current()) {
Send(msg);
return;
}
@@ -1469,10 +1469,10 @@
std::unique_ptr<cc::SwapPromise> swap_promise =
QueueMessageImpl(msg, policy, frame_swap_message_queue_.get(),
RenderThreadImpl::current()->sync_message_filter(),
- compositor_->GetSourceFrameNumber());
+ layer_tree_view_->GetSourceFrameNumber());
if (swap_promise)
- compositor_->QueueSwapPromise(std::move(swap_promise));
+ layer_tree_view_->QueueSwapPromise(std::move(swap_promise));
}
void RenderWidget::DidChangeCursor(const WebCursorInfo& cursor_info) {
@@ -1560,7 +1560,7 @@
void RenderWidget::Close() {
screen_metrics_emulator_.reset();
CloseWebWidget();
- compositor_.reset();
+ layer_tree_view_.reset();
}
void RenderWidget::CloseWebWidget() {
@@ -1804,11 +1804,11 @@
compositor_viewport_pixel_size_ = new_compositor_viewport_pixel_size;
screen_info_ = new_screen_info;
- if (compositor_) {
- compositor_->SetViewportVisibleRect(ViewportVisibleRect());
+ if (layer_tree_view_) {
+ layer_tree_view_->SetViewportVisibleRect(ViewportVisibleRect());
// Note carefully that the DSF specified in |new_screen_info| is not the
// DSF used by the compositor during device emulation!
- compositor_->SetViewportSizeAndScale(
+ layer_tree_view_->SetViewportSizeAndScale(
compositor_viewport_pixel_size_,
GetOriginalScreenInfo().device_scale_factor,
local_surface_id_from_parent_);
@@ -1874,7 +1874,7 @@
DCHECK_EQ(popup_type_, WebPopupType::kWebPopupTypeNone);
compositor_visible_rect_ = compositor_visible_rect;
frame_widget->SetRemoteViewportIntersection(viewport_intersection);
- compositor_->SetViewportVisibleRect(ViewportVisibleRect());
+ layer_tree_view_->SetViewportVisibleRect(ViewportVisibleRect());
}
}
@@ -2227,8 +2227,8 @@
// |size_| from |compositor_viewport_pixel_size_|. Also note that the
// calculation of |new_compositor_viewport_pixel_size| does not appear to
// take into account device emulation.
- if (compositor_)
- compositor_->RequestNewLocalSurfaceId();
+ if (layer_tree_view_)
+ layer_tree_view_->RequestNewLocalSurfaceId();
gfx::Size new_compositor_viewport_pixel_size =
gfx::ScaleToCeiledSize(size_, GetWebScreenInfo().device_scale_factor);
UpdateSurfaceAndScreenInfo(local_surface_id_from_parent_,
@@ -2811,11 +2811,7 @@
void RenderWidget::StartCompositor() {
if (!is_hidden())
- compositor_->SetVisible(true);
-}
-
-RenderWidgetCompositor* RenderWidget::compositor() const {
- return compositor_.get();
+ layer_tree_view_->SetVisible(true);
}
void RenderWidget::SetHandlingInputEventForTesting(bool handling_input_event) {
@@ -2934,10 +2930,10 @@
void RenderWidget::DidNavigate() {
++current_content_source_id_;
- if (!compositor_)
+ if (!layer_tree_view_)
return;
- compositor_->SetContentSourceId(current_content_source_id_);
- compositor_->ClearCachesOnNextCommit();
+ layer_tree_view_->SetContentSourceId(current_content_source_id_);
+ layer_tree_view_->ClearCachesOnNextCommit();
}
blink::WebWidget* RenderWidget::GetWebWidget() const {
@@ -2974,11 +2970,12 @@
}
bool RenderWidget::IsSurfaceSynchronizationEnabled() const {
- return compositor_ && compositor_->IsSurfaceSynchronizationEnabled();
+ return layer_tree_view_ &&
+ layer_tree_view_->IsSurfaceSynchronizationEnabled();
}
void RenderWidget::UpdateURLForCompositorUkm() {
- DCHECK(compositor_);
+ DCHECK(layer_tree_view_);
blink::WebFrameWidget* frame_widget = GetFrameWidget();
if (!frame_widget)
return;
@@ -2987,7 +2984,8 @@
if (!render_frame->IsMainFrame())
return;
- compositor_->SetURLForUkm(render_frame->GetWebFrame()->GetDocument().Url());
+ layer_tree_view_->SetURLForUkm(
+ render_frame->GetWebFrame()->GetDocument().Url());
}
blink::WebLocalFrame* RenderWidget::GetFocusedWebLocalFrameInWidget() const {
diff --git a/content/renderer/render_widget.h b/content/renderer/render_widget.h
index 9a1cfa0..5b318be2 100644
--- a/content/renderer/render_widget.h
+++ b/content/renderer/render_widget.h
@@ -38,7 +38,7 @@
#include "content/public/common/drop_data.h"
#include "content/public/common/screen_info.h"
#include "content/renderer/devtools/render_widget_screen_metrics_emulator_delegate.h"
-#include "content/renderer/gpu/render_widget_compositor_delegate.h"
+#include "content/renderer/gpu/layer_tree_view_delegate.h"
#include "content/renderer/input/main_thread_event_queue.h"
#include "content/renderer/input/render_widget_input_handler.h"
#include "content/renderer/input/render_widget_input_handler_delegate.h"
@@ -108,12 +108,12 @@
class ExternalPopupMenu;
class FrameSwapMessageQueue;
class ImeEventGuard;
+class LayerTreeView;
class MainThreadEventQueue;
class PepperPluginInstanceImpl;
class RenderFrameImpl;
class RenderFrameProxy;
class RenderViewImpl;
-class RenderWidgetCompositor;
class RenderWidgetOwnerDelegate;
class RenderWidgetScreenMetricsEmulator;
class ResizingModeSelector;
@@ -135,7 +135,7 @@
public IPC::Sender,
virtual public blink::WebWidgetClient,
public mojom::Widget,
- public RenderWidgetCompositorDelegate,
+ public LayerTreeViewDelegate,
public RenderWidgetInputHandlerDelegate,
public RenderWidgetScreenMetricsEmulatorDelegate,
public base::RefCounted<RenderWidget>,
@@ -251,7 +251,7 @@
// IPC::Sender
bool Send(IPC::Message* msg) override;
- // RenderWidgetCompositorDelegate
+ // LayerTreeViewDelegate
void ApplyViewportDeltas(const gfx::Vector2dF& inner_delta,
const gfx::Vector2dF& outer_delta,
const gfx::Vector2dF& elastic_overscroll_delta,
@@ -261,7 +261,7 @@
bool has_scrolled_by_touch) override;
void BeginMainFrame(base::TimeTicks frame_time) override;
void RequestNewLayerTreeFrameSink(
- const LayerTreeFrameSinkCallback& callback) override;
+ LayerTreeFrameSinkCallback callback) override;
void DidCommitAndDrawCompositorFrame() override;
void DidCommitCompositorFrame() override;
void DidCompletePageScaleAnimation() override;
@@ -360,7 +360,7 @@
// Stop compositing.
void WillCloseLayerTreeView();
- RenderWidgetCompositor* compositor() const;
+ LayerTreeView* layer_tree_view() const { return layer_tree_view_.get(); }
WidgetInputHandlerManager* widget_input_handler_manager() {
return widget_input_handler_manager_.get();
@@ -717,7 +717,7 @@
RenderWidgetOwnerDelegate* owner_delegate_;
// This is lazily constructed and must not outlive webwidget_.
- std::unique_ptr<RenderWidgetCompositor> compositor_;
+ std::unique_ptr<LayerTreeView> layer_tree_view_;
// The rect where this view should be initially shown.
gfx::Rect initial_rect_;
diff --git a/content/renderer/render_widget_fullscreen_pepper.cc b/content/renderer/render_widget_fullscreen_pepper.cc
index 83ae127..f19dbd3 100644
--- a/content/renderer/render_widget_fullscreen_pepper.cc
+++ b/content/renderer/render_widget_fullscreen_pepper.cc
@@ -14,7 +14,7 @@
#include "content/common/view_messages.h"
#include "content/public/common/content_switches.h"
#include "content/public/common/use_zoom_for_dsf_policy.h"
-#include "content/renderer/gpu/render_widget_compositor.h"
+#include "content/renderer/gpu/layer_tree_view.h"
#include "content/renderer/pepper/pepper_plugin_instance_impl.h"
#include "content/renderer/render_thread_impl.h"
#include "gpu/ipc/client/gpu_channel_host.h"
@@ -334,15 +334,15 @@
void RenderWidgetFullscreenPepper::SetLayer(cc::Layer* layer) {
layer_ = layer;
if (!layer_) {
- if (compositor_)
- compositor_->ClearRootLayer();
+ if (layer_tree_view())
+ layer_tree_view()->ClearRootLayer();
return;
}
- if (!compositor())
+ if (!layer_tree_view())
InitializeLayerTreeView();
UpdateLayerBounds();
layer_->SetIsDrawable(true);
- compositor_->SetRootLayer(layer_);
+ layer_tree_view()->SetRootLayer(layer_);
}
bool RenderWidgetFullscreenPepper::OnMessageReceived(const IPC::Message& msg) {
diff --git a/content/renderer/render_widget_unittest.cc b/content/renderer/render_widget_unittest.cc
index 242054e..19c6e84 100644
--- a/content/renderer/render_widget_unittest.cc
+++ b/content/renderer/render_widget_unittest.cc
@@ -13,6 +13,7 @@
#include "base/test/metrics/histogram_tester.h"
#include "base/test/scoped_task_environment.h"
#include "build/build_config.h"
+#include "cc/trees/layer_tree_host.h"
#include "components/viz/common/features.h"
#include "components/viz/common/surfaces/parent_local_surface_id_allocator.h"
#include "content/common/input/input_handler.mojom.h"
@@ -23,7 +24,7 @@
#include "content/public/common/content_features.h"
#include "content/public/test/mock_render_thread.h"
#include "content/renderer/devtools/render_widget_screen_metrics_emulator.h"
-#include "content/renderer/gpu/render_widget_compositor.h"
+#include "content/renderer/gpu/layer_tree_view.h"
#include "content/renderer/input/widget_input_handler_manager.h"
#include "content/test/fake_compositor_dependencies.h"
#include "content/test/mock_render_process.h"
@@ -386,13 +387,19 @@
widget()->SynchronizeVisualProperties(visual_properties);
EXPECT_EQ(allocator.GetCurrentLocalSurfaceId(),
widget()->local_surface_id_from_parent());
- EXPECT_FALSE(widget()->compositor()->HasNewLocalSurfaceIdRequest());
+ EXPECT_FALSE(widget()
+ ->layer_tree_view()
+ ->layer_tree_host()
+ ->new_local_surface_id_request_for_testing());
constexpr gfx::Size size(200, 200);
widget()->DidAutoResize(size);
EXPECT_EQ(allocator.GetCurrentLocalSurfaceId(),
widget()->local_surface_id_from_parent());
- EXPECT_TRUE(widget()->compositor()->HasNewLocalSurfaceIdRequest());
+ EXPECT_TRUE(widget()
+ ->layer_tree_view()
+ ->layer_tree_host()
+ ->new_local_surface_id_request_for_testing());
}
class PopupRenderWidget : public RenderWidget {
diff --git a/content/test/BUILD.gn b/content/test/BUILD.gn
index 2b89484..c04f067 100644
--- a/content/test/BUILD.gn
+++ b/content/test/BUILD.gn
@@ -248,8 +248,8 @@
"ppapi_unittest.h",
"storage_partition_test_utils.cc",
"storage_partition_test_utils.h",
- "stub_render_widget_compositor_delegate.cc",
- "stub_render_widget_compositor_delegate.h",
+ "stub_layer_tree_view_delegate.cc",
+ "stub_layer_tree_view_delegate.h",
"test_background_sync_context.cc",
"test_background_sync_context.h",
"test_background_sync_manager.cc",
@@ -1624,8 +1624,8 @@
"../renderer/dom_storage/mock_leveldb_wrapper.h",
"../renderer/fileapi/webfilewriter_base_unittest.cc",
"../renderer/gpu/frame_swap_message_queue_unittest.cc",
+ "../renderer/gpu/layer_tree_view_unittest.cc",
"../renderer/gpu/queue_message_swap_promise_unittest.cc",
- "../renderer/gpu/render_widget_compositor_unittest.cc",
"../renderer/ico_image_decoder_unittest.cc",
"../renderer/indexed_db/mock_webidbcallbacks.cc",
"../renderer/indexed_db/mock_webidbcallbacks.h",
diff --git a/content/test/layouttest_support.cc b/content/test/layouttest_support.cc
index b6816fd..44fb1da 100644
--- a/content/test/layouttest_support.cc
+++ b/content/test/layouttest_support.cc
@@ -32,7 +32,7 @@
#include "content/public/common/page_state.h"
#include "content/public/common/screen_info.h"
#include "content/public/renderer/renderer_gamepad_provider.h"
-#include "content/renderer/gpu/render_widget_compositor.h"
+#include "content/renderer/gpu/layer_tree_view.h"
#include "content/renderer/input/render_widget_input_handler_delegate.h"
#include "content/renderer/layout_test_dependencies.h"
#include "content/renderer/loader/request_extra_data.h"
diff --git a/content/test/stub_layer_tree_view_delegate.cc b/content/test/stub_layer_tree_view_delegate.cc
new file mode 100644
index 0000000..2d3dd56
--- /dev/null
+++ b/content/test/stub_layer_tree_view_delegate.cc
@@ -0,0 +1,30 @@
+// Copyright 2018 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 "content/test/stub_layer_tree_view_delegate.h"
+
+#include <utility>
+
+#include "cc/trees/layer_tree_frame_sink.h"
+#include "cc/trees/swap_promise.h"
+#include "components/viz/common/frame_sinks/copy_output_request.h"
+
+namespace content {
+
+void StubLayerTreeViewDelegate::RequestNewLayerTreeFrameSink(
+ LayerTreeFrameSinkCallback callback) {
+ std::move(callback).Run(nullptr);
+}
+
+bool StubLayerTreeViewDelegate::IsClosing() const {
+ return false;
+}
+
+std::unique_ptr<cc::SwapPromise>
+StubLayerTreeViewDelegate::RequestCopyOfOutputForLayoutTest(
+ std::unique_ptr<viz::CopyOutputRequest> request) {
+ return nullptr;
+}
+
+} // namespace content
diff --git a/content/test/stub_render_widget_compositor_delegate.h b/content/test/stub_layer_tree_view_delegate.h
similarity index 73%
rename from content/test/stub_render_widget_compositor_delegate.h
rename to content/test/stub_layer_tree_view_delegate.h
index 3fceec3..a51a8c8 100644
--- a/content/test/stub_render_widget_compositor_delegate.h
+++ b/content/test/stub_layer_tree_view_delegate.h
@@ -2,18 +2,16 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef CONTENT_TEST_STUB_RENDER_WIDGET_COMPOSITOR_DELEGATE_H_
-#define CONTENT_TEST_STUB_RENDER_WIDGET_COMPOSITOR_DELEGATE_H_
+#ifndef CONTENT_TEST_STUB_LAYER_TREE_VIEW_DELEGATE_H_
+#define CONTENT_TEST_STUB_LAYER_TREE_VIEW_DELEGATE_H_
-#include "base/macros.h"
-#include "content/renderer/gpu/render_widget_compositor_delegate.h"
+#include "content/renderer/gpu/layer_tree_view_delegate.h"
namespace content {
-class StubRenderWidgetCompositorDelegate
- : public RenderWidgetCompositorDelegate {
+class StubLayerTreeViewDelegate : public LayerTreeViewDelegate {
public:
- // RenderWidgetCompositorDelegate implementation.
+ // LayerTreeViewDelegate implementation.
void ApplyViewportDeltas(const gfx::Vector2dF& inner_delta,
const gfx::Vector2dF& outer_delta,
const gfx::Vector2dF& elastic_overscroll_delta,
@@ -23,7 +21,7 @@
bool has_scrolled_by_touch) override {}
void BeginMainFrame(base::TimeTicks frame_time) override {}
void RequestNewLayerTreeFrameSink(
- const LayerTreeFrameSinkCallback& callback) override;
+ LayerTreeFrameSinkCallback callback) override;
void DidCommitAndDrawCompositorFrame() override {}
void DidCommitCompositorFrame() override {}
void DidCompletePageScaleAnimation() override {}
@@ -38,4 +36,4 @@
} // namespace content
-#endif // CONTENT_TEST_STUB_RENDER_WIDGET_COMPOSITOR_DELEGATE_H_
+#endif // CONTENT_TEST_STUB_LAYER_TREE_VIEW_DELEGATE_H_
diff --git a/content/test/stub_render_widget_compositor_delegate.cc b/content/test/stub_render_widget_compositor_delegate.cc
deleted file mode 100644
index 7798bb8..0000000
--- a/content/test/stub_render_widget_compositor_delegate.cc
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright 2018 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 "content/test/stub_render_widget_compositor_delegate.h"
-
-#include "cc/trees/layer_tree_frame_sink.h"
-#include "cc/trees/swap_promise.h"
-#include "components/viz/common/frame_sinks/copy_output_request.h"
-
-namespace content {
-
-void StubRenderWidgetCompositorDelegate::RequestNewLayerTreeFrameSink(
- const LayerTreeFrameSinkCallback& callback) {
- callback.Run(nullptr);
-}
-
-bool StubRenderWidgetCompositorDelegate::IsClosing() const {
- return false;
-}
-
-std::unique_ptr<cc::SwapPromise>
-StubRenderWidgetCompositorDelegate::RequestCopyOfOutputForLayoutTest(
- std::unique_ptr<viz::CopyOutputRequest> request) {
- return nullptr;
-}
-
-} // namespace content
diff --git a/third_party/blink/renderer/core/DEPS b/third_party/blink/renderer/core/DEPS
index 4f10b20..22345ba 100644
--- a/third_party/blink/renderer/core/DEPS
+++ b/third_party/blink/renderer/core/DEPS
@@ -56,7 +56,7 @@
".*_test(_.*)?\.(cc|h)" : [
# Test harness may use cc directly instead of going through WebViewImpl etc.
"+cc",
- # TODO(crbug.com/838693): Test harnesses use RenderWidgetCompositor
+ # TODO(crbug.com/838693): Test harnesses use LayerTreeView
# from content instead of a fake WebLayerTreeView implementation, so
# that the Web abstraction can go away.
"+content/renderer/gpu",
diff --git a/third_party/blink/renderer/core/exported/web_frame_test.cc b/third_party/blink/renderer/core/exported/web_frame_test.cc
index d64e287..a3f40b2c 100644
--- a/third_party/blink/renderer/core/exported/web_frame_test.cc
+++ b/third_party/blink/renderer/core/exported/web_frame_test.cc
@@ -6296,7 +6296,7 @@
web_view_helper_.GetWebView()->UpdateAllLifecyclePhases();
cc::LayerTreeHost* layer_tree_host =
- web_view_client_.compositor()->layer_tree_host();
+ web_view_client_.layer_tree_view()->layer_tree_host();
const cc::LayerSelection& selection = layer_tree_host->selection();
ASSERT_EQ(selection, cc::LayerSelection());
@@ -6396,7 +6396,7 @@
.HandleGestureEvent(gesture_event);
cc::LayerTreeHost* layer_tree_host =
- web_view_client_.compositor()->layer_tree_host();
+ web_view_client_.layer_tree_view()->layer_tree_host();
const cc::LayerSelection& selection = layer_tree_host->selection();
ASSERT_NE(selection, cc::LayerSelection());
@@ -8901,7 +8901,7 @@
base_url_ + "fullscreen_video.html", nullptr, &web_view_client);
const cc::LayerTreeHost* layer_tree_host =
- web_view_client.compositor()->layer_tree_host();
+ web_view_client.layer_tree_view()->layer_tree_host();
LocalFrame* frame = web_view_impl->MainFrameImpl()->GetFrame();
std::unique_ptr<UserGestureIndicator> gesture =
diff --git a/third_party/blink/renderer/core/frame/frame_test_helpers.cc b/third_party/blink/renderer/core/frame/frame_test_helpers.cc
index abfe0bda..bbaac15 100644
--- a/third_party/blink/renderer/core/frame/frame_test_helpers.cc
+++ b/third_party/blink/renderer/core/frame/frame_test_helpers.cc
@@ -369,11 +369,11 @@
}
void WebViewHelper::SetViewportSize(const WebSize& size) {
- content::RenderWidgetCompositor* compositor =
- test_web_view_client_->compositor();
- compositor->SetViewportSizeAndScale(
+ content::LayerTreeView* layer_tree_view =
+ test_web_view_client_->layer_tree_view();
+ layer_tree_view->SetViewportSizeAndScale(
static_cast<gfx::Size>(size), /*device_scale_factor=*/1.f,
- compositor->layer_tree_host()->local_surface_id_from_parent());
+ layer_tree_view->layer_tree_host()->local_surface_id_from_parent());
}
void WebViewHelper::InitializeWebView(TestWebViewClient* web_view_client,
@@ -472,12 +472,12 @@
self_owned_.reset();
}
-content::RenderWidgetCompositor* RenderWidgetCompositorFactory::Initialize() {
+content::LayerTreeView* LayerTreeViewFactory::Initialize() {
return Initialize(/*delegate=*/nullptr);
}
-content::RenderWidgetCompositor* RenderWidgetCompositorFactory::Initialize(
- content::RenderWidgetCompositorDelegate* specified_delegate) {
+content::LayerTreeView* LayerTreeViewFactory::Initialize(
+ content::LayerTreeViewDelegate* specified_delegate) {
cc::LayerTreeSettings settings;
// Use synchronous compositing so that the MessageLoop becomes idle and the
// test makes progress.
@@ -491,23 +491,23 @@
if (RuntimeEnabledFeatures::BlinkGenPropertyTreesEnabled())
settings.use_layer_lists = true;
- compositor_ = std::make_unique<content::RenderWidgetCompositor>(
+ layer_tree_view_ = std::make_unique<content::LayerTreeView>(
specified_delegate ? specified_delegate : &delegate_,
Platform::Current()->CurrentThread()->GetTaskRunner(),
/*compositor_thread=*/nullptr, &test_task_graph_runner_,
&fake_renderer_scheduler_);
- compositor_->Initialize(settings,
- std::make_unique<cc::TestUkmRecorderFactory>());
- return compositor_.get();
+ layer_tree_view_->Initialize(settings,
+ std::make_unique<cc::TestUkmRecorderFactory>());
+ return layer_tree_view_.get();
}
WebLayerTreeView* TestWebWidgetClient::InitializeLayerTreeView() {
- return compositor_factory_.Initialize();
+ return layer_tree_view_factory_.Initialize();
}
WebLayerTreeView* TestWebViewClient::InitializeLayerTreeView() {
- compositor_ = compositor_factory_.Initialize();
- return compositor_;
+ layer_tree_view_ = layer_tree_view_factory_.Initialize();
+ return layer_tree_view_;
}
} // namespace FrameTestHelpers
diff --git a/third_party/blink/renderer/core/frame/frame_test_helpers.h b/third_party/blink/renderer/core/frame/frame_test_helpers.h
index a9ff5d0..a08c35f 100644
--- a/third_party/blink/renderer/core/frame/frame_test_helpers.h
+++ b/third_party/blink/renderer/core/frame/frame_test_helpers.h
@@ -38,8 +38,8 @@
#include "base/macros.h"
#include "cc/test/test_task_graph_runner.h"
-#include "content/renderer/gpu/render_widget_compositor.h"
-#include "content/test/stub_render_widget_compositor_delegate.h"
+#include "content/renderer/gpu/layer_tree_view.h"
+#include "content/test/stub_layer_tree_view_delegate.h"
#include "services/service_manager/public/cpp/interface_provider.h"
#include "third_party/blink/public/platform/modules/fetch/fetch_api_request.mojom-shared.h"
#include "third_party/blink/public/platform/platform.h"
@@ -162,21 +162,20 @@
scoped_refptr<SecurityOrigin> = nullptr,
TestWebRemoteFrameClient* = nullptr);
-// A class that constructs and owns a content::RenderWidgetCompositor for blink
+// A class that constructs and owns a LayerTreeView for blink
// unit tests.
-class RenderWidgetCompositorFactory {
+class LayerTreeViewFactory {
public:
- // Use this to make a RenderWidgetCompositor with a stub delegate.
- content::RenderWidgetCompositor* Initialize();
+ // Use this to make a LayerTreeView with a stub delegate.
+ content::LayerTreeView* Initialize();
// Use this to specify a delegate instead of using a stub.
- content::RenderWidgetCompositor* Initialize(
- content::RenderWidgetCompositorDelegate*);
+ content::LayerTreeView* Initialize(content::LayerTreeViewDelegate*);
private:
- content::StubRenderWidgetCompositorDelegate delegate_;
+ content::StubLayerTreeViewDelegate delegate_;
cc::TestTaskGraphRunner test_task_graph_runner_;
blink::scheduler::FakeRendererScheduler fake_renderer_scheduler_;
- std::unique_ptr<content::RenderWidgetCompositor> compositor_;
+ std::unique_ptr<content::LayerTreeView> layer_tree_view_;
};
class TestWebWidgetClient : public WebWidgetClient {
@@ -187,14 +186,14 @@
WebLayerTreeView* InitializeLayerTreeView() override;
private:
- RenderWidgetCompositorFactory compositor_factory_;
+ LayerTreeViewFactory layer_tree_view_factory_;
};
class TestWebViewClient : public WebViewClient {
public:
~TestWebViewClient() override = default;
- content::RenderWidgetCompositor* compositor() { return compositor_; }
+ content::LayerTreeView* layer_tree_view() { return layer_tree_view_; }
// WebViewClient:
WebLayerTreeView* InitializeLayerTreeView() override;
@@ -205,8 +204,8 @@
bool CanUpdateLayout() override { return true; }
private:
- content::RenderWidgetCompositor* compositor_ = nullptr;
- RenderWidgetCompositorFactory compositor_factory_;
+ content::LayerTreeView* layer_tree_view_ = nullptr;
+ LayerTreeViewFactory layer_tree_view_factory_;
bool animation_scheduled_ = false;
};
diff --git a/third_party/blink/renderer/core/testing/DEPS b/third_party/blink/renderer/core/testing/DEPS
index 846ae8f6f..1cd6cec 100644
--- a/third_party/blink/renderer/core/testing/DEPS
+++ b/third_party/blink/renderer/core/testing/DEPS
@@ -1,6 +1,6 @@
include_rules = [
"+cc",
- # TODO(crbug.com/838693): Test harnesses use RenderWidgetCompositor
+ # TODO(crbug.com/838693): Test harnesses use LayerTreeView
# from content instead of a fake WebLayerTreeView implementation, so
# that the Web abstraction can go away.
"+content/renderer/gpu",
diff --git a/third_party/blink/renderer/core/testing/sim/sim_compositor.cc b/third_party/blink/renderer/core/testing/sim/sim_compositor.cc
index 12f31344..b4851956 100644
--- a/third_party/blink/renderer/core/testing/sim/sim_compositor.cc
+++ b/third_party/blink/renderer/core/testing/sim/sim_compositor.cc
@@ -24,14 +24,14 @@
SimCompositor::SimCompositor() {
LocalFrameView::SetInitialTracksPaintInvalidationsForTesting(true);
- // SimCompositor overrides the RenderWidgetCompositorDelegate to respond to
+ // SimCompositor overrides the LayerTreeViewDelegate to respond to
// BeginMainFrame(), which will update and paint the WebViewImpl given to
// SetWebView().
- compositor_ = compositor_factory_.Initialize(this);
+ layer_tree_view_ = layer_tree_view_factory_.Initialize(this);
// SimCompositor starts with defer commits enabled, but uses synchronous
// compositing which does not use defer commits anyhow, it only uses it for
// reading defered state in tests.
- compositor_->SetDeferCommits(true);
+ layer_tree_view_->SetDeferCommits(true);
}
SimCompositor::~SimCompositor() {
@@ -44,8 +44,8 @@
SimCanvas::Commands SimCompositor::BeginFrame(double time_delta_in_seconds) {
DCHECK(web_view_);
- DCHECK(!compositor_->layer_tree_host()->defer_commits());
- DCHECK(compositor_->layer_tree_host()->RequestedMainFramePending());
+ DCHECK(!layer_tree_view_->layer_tree_host()->defer_commits());
+ DCHECK(layer_tree_view_->layer_tree_host()->RequestedMainFramePending());
DCHECK_GT(time_delta_in_seconds, 0);
last_frame_time_ += base::TimeDelta::FromSecondsD(time_delta_in_seconds);
@@ -53,7 +53,8 @@
SimCanvas::Commands commands;
paint_commands_ = &commands;
- compositor_->layer_tree_host()->Composite(last_frame_time_, /*raster=*/false);
+ layer_tree_view_->layer_tree_host()->Composite(last_frame_time_,
+ /*raster=*/false);
paint_commands_ = nullptr;
return commands;
@@ -76,10 +77,10 @@
}
void SimCompositor::RequestNewLayerTreeFrameSink(
- const content::LayerTreeFrameSinkCallback& callback) {
+ LayerTreeFrameSinkCallback callback) {
// Make a valid LayerTreeFrameSink so the compositor will generate begin main
// frames.
- callback.Run(cc::FakeLayerTreeFrameSink::Create3d());
+ std::move(callback).Run(cc::FakeLayerTreeFrameSink::Create3d());
}
void SimCompositor::BeginMainFrame(base::TimeTicks frame_time) {
diff --git a/third_party/blink/renderer/core/testing/sim/sim_compositor.h b/third_party/blink/renderer/core/testing/sim/sim_compositor.h
index 74331ce8..1a5a93a 100644
--- a/third_party/blink/renderer/core/testing/sim/sim_compositor.h
+++ b/third_party/blink/renderer/core/testing/sim/sim_compositor.h
@@ -7,8 +7,8 @@
#include "base/time/time.h"
#include "cc/trees/layer_tree_host.h"
-#include "content/renderer/gpu/render_widget_compositor.h"
-#include "content/test/stub_render_widget_compositor_delegate.h"
+#include "content/renderer/gpu/layer_tree_view.h"
+#include "content/test/stub_layer_tree_view_delegate.h"
#include "third_party/blink/renderer/core/frame/frame_test_helpers.h"
#include "third_party/blink/renderer/core/testing/sim/sim_canvas.h"
@@ -25,13 +25,13 @@
// only part of the layer was invalid.
//
// Note: This also does not support compositor driven animations.
-class SimCompositor final : public content::StubRenderWidgetCompositorDelegate {
+class SimCompositor final : public content::StubLayerTreeViewDelegate {
public:
explicit SimCompositor();
~SimCompositor() override;
// This compositor should be given to the WebViewImpl passed to SetWebView.
- content::RenderWidgetCompositor& compositor() { return *compositor_; }
+ content::LayerTreeView& layer_tree_view() { return *layer_tree_view_; }
// When the compositor asks for a main frame, this WebViewImpl will have its
// lifecycle updated and be painted. The compositor() should have also been
@@ -57,27 +57,28 @@
// Returns true if a main frame has been requested from blink, until the
// BeginFrame() step occurs.
bool NeedsBeginFrame() const {
- return compositor_->layer_tree_host()->RequestedMainFramePending();
+ return layer_tree_view_->layer_tree_host()->RequestedMainFramePending();
}
// Returns true if commits are deferred in the compositor. Since these tests
// use synchronous compositing through BeginFrame(), the deferred state has no
// real effect.
bool DeferCommits() const {
- return compositor_->layer_tree_host()->defer_commits();
+ return layer_tree_view_->layer_tree_host()->defer_commits();
}
// Returns true if a selection is set on the compositor.
bool HasSelection() const {
- return compositor_->layer_tree_host()->selection() != cc::LayerSelection();
+ return layer_tree_view_->layer_tree_host()->selection() !=
+ cc::LayerSelection();
}
// Returns the background color set on the compositor.
SkColor background_color() {
- return compositor_->layer_tree_host()->background_color();
+ return layer_tree_view_->layer_tree_host()->background_color();
}
private:
- // RenderWidgetCompositorDelegate implementation.
+ // content::LayerTreeViewDelegate implementation.
void RequestNewLayerTreeFrameSink(
- const content::LayerTreeFrameSinkCallback& callback) override;
+ LayerTreeFrameSinkCallback callback) override;
void BeginMainFrame(base::TimeTicks frame_time) override;
WebViewImpl* web_view_ = nullptr;
@@ -87,8 +88,8 @@
// be returned from BeginFrame().
SimCanvas::Commands* paint_commands_;
- content::RenderWidgetCompositor* compositor_ = nullptr;
- FrameTestHelpers::RenderWidgetCompositorFactory compositor_factory_;
+ content::LayerTreeView* layer_tree_view_ = nullptr;
+ FrameTestHelpers::LayerTreeViewFactory layer_tree_view_factory_;
};
} // namespace blink
diff --git a/third_party/blink/renderer/core/testing/sim/sim_test.cc b/third_party/blink/renderer/core/testing/sim/sim_test.cc
index ec2c89aa..ee0b4c3 100644
--- a/third_party/blink/renderer/core/testing/sim/sim_test.cc
+++ b/third_party/blink/renderer/core/testing/sim/sim_test.cc
@@ -17,7 +17,8 @@
namespace blink {
SimTest::SimTest()
- : web_view_client_(compositor_.compositor()), web_frame_client_(*this) {
+ : web_view_client_(compositor_.layer_tree_view()),
+ web_frame_client_(*this) {
Document::SetThreadedParsingEnabledForTesting(false);
// Use the mock theme to get more predictable code paths, this also avoids
// the OS callbacks in ScrollAnimatorMac which can schedule frames
diff --git a/third_party/blink/renderer/core/testing/sim/sim_web_view_client.cc b/third_party/blink/renderer/core/testing/sim/sim_web_view_client.cc
index ceb85294..8194c40 100644
--- a/third_party/blink/renderer/core/testing/sim/sim_web_view_client.cc
+++ b/third_party/blink/renderer/core/testing/sim/sim_web_view_client.cc
@@ -8,11 +8,11 @@
namespace blink {
-SimWebViewClient::SimWebViewClient(content::RenderWidgetCompositor& compositor)
+SimWebViewClient::SimWebViewClient(content::LayerTreeView& layer_tree_view)
: visually_non_empty_layout_count_(0),
finished_parsing_layout_count_(0),
finished_loading_layout_count_(0),
- compositor_(&compositor) {}
+ layer_tree_view_(&layer_tree_view) {}
void SimWebViewClient::DidMeaningfulLayout(
WebMeaningfulLayout meaningful_layout) {
@@ -30,7 +30,7 @@
}
WebLayerTreeView* SimWebViewClient::InitializeLayerTreeView() {
- return compositor_;
+ return layer_tree_view_;
}
WebView* SimWebViewClient::CreateView(WebLocalFrame* opener,
diff --git a/third_party/blink/renderer/core/testing/sim/sim_web_view_client.h b/third_party/blink/renderer/core/testing/sim/sim_web_view_client.h
index 549f246..2fa5646 100644
--- a/third_party/blink/renderer/core/testing/sim/sim_web_view_client.h
+++ b/third_party/blink/renderer/core/testing/sim/sim_web_view_client.h
@@ -8,16 +8,16 @@
#include "third_party/blink/renderer/core/frame/frame_test_helpers.h"
namespace content {
-class RenderWidgetCompositor;
+class LayerTreeView;
}
namespace blink {
class SimWebViewClient final : public FrameTestHelpers::TestWebViewClient {
public:
- // The RenderWidgetCompositor to be returned from InitializeLayerTreeView()
+ // The LayerTreeView to be returned from InitializeLayerTreeView()
// must be constructed before this class, and given to it.
- explicit SimWebViewClient(content::RenderWidgetCompositor&);
+ explicit SimWebViewClient(content::LayerTreeView&);
int VisuallyNonEmptyLayoutCount() const {
return visually_non_empty_layout_count_;
@@ -47,7 +47,7 @@
int finished_parsing_layout_count_;
int finished_loading_layout_count_;
- content::RenderWidgetCompositor* compositor_;
+ content::LayerTreeView* layer_tree_view_;
FrameTestHelpers::WebViewHelper web_view_helper_;
};
diff --git a/third_party/blink/renderer/platform/graphics/DEPS b/third_party/blink/renderer/platform/graphics/DEPS
index daead2c..0ef1e730 100644
--- a/third_party/blink/renderer/platform/graphics/DEPS
+++ b/third_party/blink/renderer/platform/graphics/DEPS
@@ -18,7 +18,6 @@
"+cc",
"+components/viz/client",
"+components/viz/common",
- "+components/viz/test/fake_external_begin_frame_source.h",
"+gpu/config",
"+gpu/command_buffer/client/gles2_interface.h",
"+gpu/command_buffer/client/gpu_memory_buffer_manager.h",
