cc: Abstract the LayerTreeHost.

content/renderer/gpu/render_widget_compositor.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/gpu/render_widget_compositor.h"
 
 #include <stddef.h>
 #include <limits>
 #include <string>
 #include <utility>
@@ skipping 571 matching lines @@
   // Ignore what the system said and give all clients the same maximum
   // allocation on desktop platforms.
   actual.bytes_limit_when_visible = 512 * 1024 * 1024;
   actual.priority_cutoff_when_visible =
       gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE;
 #endif
   return actual;
 }
 
 void RenderWidgetCompositor::SetNeverVisible() {
-  DCHECK(!layer_tree_host_->visible());
+  DCHECK(!layer_tree_host_->IsVisible());
   never_visible_ = true;
 }
 
 const base::WeakPtr<cc::InputHandler>&
 RenderWidgetCompositor::GetInputHandler() {
   return layer_tree_host_->GetInputHandler();
 }
 
 bool RenderWidgetCompositor::BeginMainFrameRequested() const {
   return layer_tree_host_->BeginMainFrameRequested();
 }
 
 void RenderWidgetCompositor::SetNeedsDisplayOnAllLayers() {
   layer_tree_host_->GetLayerTree()->SetNeedsDisplayOnAllLayers();
 }
 
 void RenderWidgetCompositor::SetRasterizeOnlyVisibleContent() {
-  cc::LayerTreeDebugState current = layer_tree_host_->debug_state();
+  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) {
   layer_tree_host_->SetNeedsRedrawRect(damage_rect);
 }
 
 void RenderWidgetCompositor::SetNeedsForcedRedraw() {
   layer_tree_host_->SetNextCommitForcesRedraw();
   setNeedsAnimate();
 }
 
 std::unique_ptr<cc::SwapPromiseMonitor>
 RenderWidgetCompositor::CreateLatencyInfoSwapPromiseMonitor(
     ui::LatencyInfo* latency) {
   return std::unique_ptr<cc::SwapPromiseMonitor>(
       new cc::LatencyInfoSwapPromiseMonitor(latency, layer_tree_host_.get(),
                                             NULL));
 }
 
 void RenderWidgetCompositor::QueueSwapPromise(
     std::unique_ptr<cc::SwapPromise> swap_promise) {
   layer_tree_host_->QueueSwapPromise(std::move(swap_promise));
 }
 
 int RenderWidgetCompositor::GetSourceFrameNumber() const {
-  return layer_tree_host_->source_frame_number();
+  return layer_tree_host_->SourceFrameNumber();
 }
 
 void RenderWidgetCompositor::SetNeedsUpdateLayers() {
   layer_tree_host_->SetNeedsUpdateLayers();
 }
 
 void RenderWidgetCompositor::SetNeedsCommit() {
   layer_tree_host_->SetNeedsCommit();
 }
 
@@ skipping 226 matching lines @@
   if (result->HasBitmap()) {
     std::unique_ptr<SkBitmap> result_bitmap = result->TakeBitmap();
     callback->didCompositeAndReadback(*result_bitmap);
   } else {
     callback->didCompositeAndReadback(SkBitmap());
   }
 }
 
 bool RenderWidgetCompositor::CompositeIsSynchronous() const {
   if (!threaded_) {
-    DCHECK(!layer_tree_host_->settings().single_thread_proxy_scheduler);
+    DCHECK(!layer_tree_host_->GetSettings().single_thread_proxy_scheduler);
     return true;
   }
   return false;
 }
 
 void RenderWidgetCompositor::layoutAndPaintAsync(
     blink::WebLayoutAndPaintAsyncCallback* callback) {
   DCHECK(!layout_and_paint_async_callback_);
   layout_and_paint_async_callback_ = callback;
 
@@ skipping 16 matching lines @@
   if (!layout_and_paint_async_callback_)
     return;
   layout_and_paint_async_callback_->didLayoutAndPaint();
   layout_and_paint_async_callback_ = nullptr;
 }
 
 void RenderWidgetCompositor::compositeAndReadbackAsync(
     blink::WebCompositeAndReadbackAsyncCallback* callback) {
   DCHECK(!layout_and_paint_async_callback_);
   scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner =
-      layer_tree_host_->task_runner_provider()->MainThreadTaskRunner();
+      layer_tree_host_->GetTaskRunnerProvider()->MainThreadTaskRunner();
   std::unique_ptr<cc::CopyOutputRequest> request =
       cc::CopyOutputRequest::CreateBitmapRequest(base::Bind(
           [](blink::WebCompositeAndReadbackAsyncCallback* callback,
              scoped_refptr<base::SingleThreadTaskRunner> task_runner,
              std::unique_ptr<cc::CopyOutputResult> result) {
             task_runner->PostTask(FROM_HERE,
                                   base::Bind(&CompositeAndReadbackAsyncCallback,
                                              callback, base::Passed(&result)));
           },
           callback, base::Passed(&main_thread_task_runner)));
@@ skipping 15 matching lines @@
 void RenderWidgetCompositor::SynchronouslyComposite() {
   DCHECK(CompositeIsSynchronous());
   layer_tree_host_->Composite(base::TimeTicks::Now());
 }
 
 void RenderWidgetCompositor::setDeferCommits(bool defer_commits) {
   layer_tree_host_->SetDeferCommits(defer_commits);
 }
 
 int RenderWidgetCompositor::layerTreeId() const {
-  return layer_tree_host_->id();
+  return layer_tree_host_->GetId();
 }
 
 void RenderWidgetCompositor::setShowFPSCounter(bool show) {
-  cc::LayerTreeDebugState debug_state = layer_tree_host_->debug_state();
+  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) {
-  cc::LayerTreeDebugState debug_state = layer_tree_host_->debug_state();
+  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) {
-  cc::LayerTreeDebugState debug_state = layer_tree_host_->debug_state();
+  cc::LayerTreeDebugState debug_state = layer_tree_host_->GetDebugState();
   debug_state.show_debug_borders = show;
   layer_tree_host_->SetDebugState(debug_state);
 }
 
 void RenderWidgetCompositor::setShowScrollBottleneckRects(bool show) {
-  cc::LayerTreeDebugState debug_state = layer_tree_host_->debug_state();
+  cc::LayerTreeDebugState debug_state = layer_tree_host_->GetDebugState();
   debug_state.show_touch_event_handler_rects = show;
   debug_state.show_wheel_event_handler_rects = show;
   debug_state.show_non_fast_scrollable_rects = show;
   layer_tree_host_->SetDebugState(debug_state);
 }
 
 void RenderWidgetCompositor::updateTopControlsState(
     WebTopControlsState constraints,
     WebTopControlsState current,
     bool animate) {
@@ skipping 126 matching lines @@
 void RenderWidgetCompositor::SendCompositorProto(
     const cc::proto::CompositorMessage& proto) {
   int signed_size = proto.ByteSize();
   size_t unsigned_size = base::checked_cast<size_t>(signed_size);
   std::vector<uint8_t> serialized(unsigned_size);
   proto.SerializeToArray(serialized.data(), signed_size);
   delegate_->ForwardCompositorProto(serialized);
 }
 
 void RenderWidgetCompositor::SetSurfaceClientId(uint32_t surface_client_id) {
-  layer_tree_host_->set_surface_client_id(surface_client_id);
+  layer_tree_host_->SetSurfaceClientId(surface_client_id);
 }
 
 void RenderWidgetCompositor::OnHandleCompositorProto(
     const std::vector<uint8_t>& proto) {
   DCHECK(remote_proto_channel_receiver_);
 
   std::unique_ptr<cc::proto::CompositorMessage> deserialized(
       new cc::proto::CompositorMessage);
   int signed_size = base::checked_cast<int>(proto.size());
   if (!deserialized->ParseFromArray(proto.data(), signed_size)) {
     LOG(ERROR) << "Unable to parse compositor proto.";
     return;
   }
 
   remote_proto_channel_receiver_->OnProtoReceived(std::move(deserialized));
 }
 
 void RenderWidgetCompositor::SetPaintedDeviceScaleFactor(
     float device_scale) {
   layer_tree_host_->GetLayerTree()->SetPaintedDeviceScaleFactor(device_scale);
 }
 
 }  // namespace content