cc: Abstract the LayerTreeHost.

cc/layers/layer.cc

 // Copyright 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/layers/layer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 1114 matching lines @@
                                                base::Passed(&result)));
 }
 
 void Layer::PushPropertiesTo(LayerImpl* layer) {
   TRACE_EVENT0("cc", "Layer::PushPropertiesTo");
   DCHECK(layer_tree_host_);
 
   // If we did not SavePaintProperties() for the layer this frame, then push the
   // real property values, not the paint property values.
   bool use_paint_properties = paint_properties_.source_frame_number ==
-                              layer_tree_host_->source_frame_number();
+                              layer_tree_host_->SourceFrameNumber();
 
   layer->SetBackgroundColor(inputs_.background_color);
   layer->SetSafeOpaqueBackgroundColor(safe_opaque_background_color_);
   layer->SetBounds(use_paint_properties ? paint_properties_.bounds
                                         : inputs_.bounds);
 
 #if defined(NDEBUG)
   if (frame_viewer_instrumentation::IsTracingLayerTreeSnapshots())
     layer->SetDebugInfo(TakeDebugInfo());
 #else
@@ skipping 56 matching lines @@
   layer_property_changed_ = false;
   inputs_.update_rect = gfx::Rect();
 
   layer_tree_->RemoveLayerShouldPushProperties(this);
 }
 
 void Layer::TakeCopyRequests(
     std::vector<std::unique_ptr<CopyOutputRequest>>* requests) {
   for (auto& it : inputs_.copy_requests) {
     scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner =
-        layer_tree_host()->task_runner_provider()->MainThreadTaskRunner();
+        layer_tree_host()->GetTaskRunnerProvider()->MainThreadTaskRunner();
     std::unique_ptr<CopyOutputRequest> original_request = std::move(it);
     const CopyOutputRequest& original_request_ref = *original_request;
     std::unique_ptr<CopyOutputRequest> main_thread_request =
         CopyOutputRequest::CreateRelayRequest(
             original_request_ref,
             base::Bind(&PostCopyCallbackToMainThread, main_thread_task_runner,
                        base::Passed(&original_request)));
     if (main_thread_request->has_area()) {
       main_thread_request->set_area(gfx::IntersectRects(
           main_thread_request->area(), gfx::Rect(bounds())));
@@ skipping 115 matching lines @@
   DCHECK(proto.has_id());
   DCHECK_EQ(inputs_.layer_id, proto.id());
   FromLayerSpecificPropertiesProto(proto);
 }
 
 void Layer::LayerSpecificPropertiesToProto(proto::LayerProperties* proto) {
   proto::BaseLayerProperties* base = proto->mutable_base();
 
   bool use_paint_properties = layer_tree_host_ &&
                               paint_properties_.source_frame_number ==
-                                  layer_tree_host_->source_frame_number();
+                                  layer_tree_host_->SourceFrameNumber();
 
   Point3FToProto(inputs_.transform_origin, base->mutable_transform_origin());
   base->set_background_color(inputs_.background_color);
   base->set_safe_opaque_background_color(safe_opaque_background_color_);
   SizeToProto(use_paint_properties ? paint_properties_.bounds : inputs_.bounds,
               base->mutable_bounds());
 
   // TODO(nyquist): Figure out what to do with debug info. See crbug.com/570372.
 
   base->set_transform_free_index(transform_tree_index_);
@@ skipping 201 matching lines @@
 int Layer::NumDescendantsThatDrawContent() const {
   return num_descendants_that_draw_content_;
 }
 
 void Layer::SavePaintProperties() {
   DCHECK(layer_tree_host_);
 
   // TODO(reveman): Save all layer properties that we depend on not
   // changing until PushProperties() has been called. crbug.com/231016
   paint_properties_.bounds = inputs_.bounds;
-  paint_properties_.source_frame_number =
-      layer_tree_host_->source_frame_number();
+  paint_properties_.source_frame_number = layer_tree_host_->SourceFrameNumber();
 }
 
 bool Layer::Update() {
   DCHECK(layer_tree_host_);
-  DCHECK_EQ(layer_tree_host_->source_frame_number(),
-            paint_properties_.source_frame_number) <<
-      "SavePaintProperties must be called for any layer that is painted.";
+  DCHECK_EQ(layer_tree_host_->SourceFrameNumber(),
+            paint_properties_.source_frame_number)
+      << "SavePaintProperties must be called for any layer that is painted.";
   return false;
 }
 
 bool Layer::IsSuitableForGpuRasterization() const {
   return true;
 }
 
 std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
 Layer::TakeDebugInfo() {
   if (inputs_.client)
@@ skipping 293 matching lines @@
   DCHECK_NE(transform_tree_index_, TransformTree::kInvalidNodeId);
   return draw_property_utils::ScreenSpaceTransform(
       this, layer_tree_->property_trees()->transform_tree);
 }
 
 LayerTree* Layer::GetLayerTree() const {
   return layer_tree_;
 }
 
 }  // namespace cc