[cc] Route LayerImpl::layerTreeHostImpl() calls through LayerTreeImpl

cc/layer_impl.cc

 // Copyright 2011 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/layer_impl.h"
 
 #include "base/debug/trace_event.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "cc/debug_border_draw_quad.h"
 #include "cc/debug_colors.h"
-#include "cc/layer_tree_host_impl.h"
+#include "cc/layer_tree_debug_state.h"
 #include "cc/layer_tree_impl.h"
+#include "cc/layer_tree_settings.h"
 #include "cc/math_util.h"
 #include "cc/proxy.h"
 #include "cc/quad_sink.h"
 #include "cc/scrollbar_animation_controller.h"
 #include "ui/gfx/point_conversions.h"
 #include "ui/gfx/rect_conversions.h"
 
 namespace cc {
 
 LayerImpl::LayerImpl(LayerTreeImpl* treeImpl, int id)
@@ skipping 37 matching lines @@
 LayerImpl::~LayerImpl()
 {
 #ifndef NDEBUG
     DCHECK(!m_betweenWillDrawAndDidDraw);
 #endif
 }
 
 void LayerImpl::addChild(scoped_ptr<LayerImpl> child)
 {
     child->setParent(this);
-    DCHECK_EQ(layerTreeHostImpl(), child->layerTreeHostImpl());
+    DCHECK_EQ(layerTreeImpl(), child->layerTreeImpl());
     m_children.append(child.Pass());
-    layerTreeHostImpl()->setNeedsUpdateDrawProperties();
+    layerTreeImpl()->SetNeedsUpdateDrawProperties();
 }
 
 scoped_ptr<LayerImpl> LayerImpl::removeChild(LayerImpl* child)
 {
     for (size_t i = 0; i < m_children.size(); ++i) {
         if (m_children[i] == child) {
             scoped_ptr<LayerImpl> ret = m_children.take(i);
             m_children.remove(i);
-            layerTreeHostImpl()->setNeedsUpdateDrawProperties();
+            layerTreeImpl()->SetNeedsUpdateDrawProperties();
             return ret.Pass();
         }
     }
     return scoped_ptr<LayerImpl>();
 }
 
 void LayerImpl::removeAllChildren()
 {
     m_children.clear();
-    layerTreeHostImpl()->setNeedsUpdateDrawProperties();
+    layerTreeImpl()->SetNeedsUpdateDrawProperties();
 }
 
 void LayerImpl::clearChildList()
 {
     if (m_children.isEmpty())
         return;
 
     m_children.clear();
-    layerTreeHostImpl()->setNeedsUpdateDrawProperties();
+    layerTreeImpl()->SetNeedsUpdateDrawProperties();
 }
 
 void LayerImpl::createRenderSurface()
 {
     DCHECK(!m_drawProperties.render_surface);
     m_drawProperties.render_surface = make_scoped_ptr(new RenderSurfaceImpl(this));
     m_drawProperties.render_target = this;
 }
 
 int LayerImpl::descendantsDrawContent()
 {
     int result = 0;
     for (size_t i = 0; i < m_children.size(); ++i) {
         if (m_children[i]->drawsContent())
             ++result;
         result += m_children[i]->descendantsDrawContent();
         if (result > 1)
             return result;
     }
     return result;
 }
 
-LayerTreeHostImpl* LayerImpl::layerTreeHostImpl() const {
-    return m_layerTreeImpl->layer_tree_host_impl();
-}
-
 scoped_ptr<SharedQuadState> LayerImpl::createSharedQuadState() const
 {
   scoped_ptr<SharedQuadState> state = SharedQuadState::Create();
   state->SetAll(m_drawProperties.target_space_transform,
                 m_drawProperties.visible_content_rect,
                 m_drawProperties.drawable_content_rect,
                 m_drawProperties.clip_rect,
                 m_drawProperties.is_clipped,
                 m_drawProperties.opacity);
   return state.Pass();
@@ skipping 11 matching lines @@
 void LayerImpl::didDraw(ResourceProvider*)
 {
 #ifndef NDEBUG
     DCHECK(m_betweenWillDrawAndDidDraw);
     m_betweenWillDrawAndDidDraw = false;
 #endif
 }
 
 bool LayerImpl::showDebugBorders() const
 {
-    return layerTreeHostImpl()->debugState().showDebugBorders;
+    return layerTreeImpl()->debug_state().showDebugBorders;
 }
 
 void LayerImpl::getDebugBorderProperties(SkColor* color, float* width) const
 {
     if (m_drawsContent) {
         *color = DebugColors::ContentLayerBorderColor();
-        *width = DebugColors::ContentLayerBorderWidth(layerTreeHostImpl());
+        *width = DebugColors::ContentLayerBorderWidth(layerTreeImpl());
         return;
     }
 
     if (m_masksToBounds) {
         *color = DebugColors::MaskingLayerBorderColor();
-        *width = DebugColors::MaskingLayerBorderWidth(layerTreeHostImpl());
+        *width = DebugColors::MaskingLayerBorderWidth(layerTreeImpl());
         return;
     }
 
     *color = DebugColors::ContainerLayerBorderColor();
-    *width = DebugColors::ContainerLayerBorderWidth(layerTreeHostImpl());
+    *width = DebugColors::ContainerLayerBorderWidth(layerTreeImpl());
 }
 
 void LayerImpl::appendDebugBorderQuad(QuadSink& quadList, const SharedQuadState* sharedQuadState, AppendQuadsData& appendQuadsData) const
 {
     if (!showDebugBorders())
         return;
 
     SkColor color;
     float width;
     getDebugBorderProperties(&color, &width);
@@ skipping 76 matching lines @@
     if (!scrollable()) {
         TRACE_EVENT0("cc", "LayerImpl::tryScroll: Ignored not scrollable");
         return InputHandlerClient::ScrollIgnored;
     }
 
     return InputHandlerClient::ScrollStarted;
 }
 
 bool LayerImpl::drawCheckerboardForMissingTiles() const
 {
-    return m_drawCheckerboardForMissingTiles && !layerTreeHostImpl()->settings().backgroundColorInsteadOfCheckerboard;
+    return m_drawCheckerboardForMissingTiles && !layerTreeImpl()->settings().backgroundColorInsteadOfCheckerboard;
 }
 
 gfx::Rect LayerImpl::layerRectToContentRect(const gfx::RectF& layerRect) const
 {
     gfx::RectF contentRect = gfx::ScaleRect(layerRect, contentsScaleX(), contentsScaleY());
     // Intersect with content rect to avoid the extra pixel because for some
     // values x and y, ceil((x / y) * y) may be x + 1.
     contentRect.Intersect(gfx::Rect(gfx::Point(), contentBounds()));
     return gfx::ToEnclosingRect(contentRect);
 }
@@ skipping 122 matching lines @@
             return true;
         current = current->m_parent;
     }
 
     return false;
 }
 
 void LayerImpl::noteLayerSurfacePropertyChanged()
 {
     m_layerSurfacePropertyChanged = true;
-    layerTreeHostImpl()->setNeedsUpdateDrawProperties();
+    layerTreeImpl()->SetNeedsUpdateDrawProperties();
 }
 
 void LayerImpl::noteLayerPropertyChanged()
 {
     m_layerPropertyChanged = true;
-    layerTreeHostImpl()->setNeedsUpdateDrawProperties();
+    layerTreeImpl()->SetNeedsUpdateDrawProperties();
 }
 
 void LayerImpl::noteLayerPropertyChangedForSubtree()
 {
     noteLayerPropertyChanged();
     noteLayerPropertyChangedForDescendants();
 }
 
 void LayerImpl::noteLayerPropertyChangedForDescendants()
 {
-    layerTreeHostImpl()->setNeedsUpdateDrawProperties();
+    layerTreeImpl()->SetNeedsUpdateDrawProperties();
     for (size_t i = 0; i < m_children.size(); ++i)
         m_children[i]->noteLayerPropertyChangedForSubtree();
 }
 
 const char* LayerImpl::layerTypeAsString() const
 {
     return "Layer";
 }
 
 void LayerImpl::resetAllChangeTrackingForSubtree()
@@ skipping 55 matching lines @@
 
     if (masksToBounds())
         noteLayerPropertyChangedForSubtree();
     else
         noteLayerPropertyChanged();
 }
 
 void LayerImpl::setMaskLayer(scoped_ptr<LayerImpl> maskLayer)
 {
     if (maskLayer)
-        DCHECK_EQ(layerTreeHostImpl(), maskLayer->layerTreeHostImpl());
+        DCHECK_EQ(layerTreeImpl(), maskLayer->layerTreeImpl());
     m_maskLayer = maskLayer.Pass();
 
     int newLayerId = m_maskLayer ? m_maskLayer->id() : -1;
     if (newLayerId == m_maskLayerId)
         return;
 
     m_maskLayerId = newLayerId;
     noteLayerPropertyChangedForSubtree();
 }
 
 void LayerImpl::setReplicaLayer(scoped_ptr<LayerImpl> replicaLayer)
 {
     if (replicaLayer)
-        DCHECK_EQ(layerTreeHostImpl(), replicaLayer->layerTreeHostImpl());
+        DCHECK_EQ(layerTreeImpl(), replicaLayer->layerTreeImpl());
     m_replicaLayer = replicaLayer.Pass();
 
     int newLayerId = m_replicaLayer ? m_replicaLayer->id() : -1;
     if (newLayerId == m_replicaLayerId)
         return;
 
     m_replicaLayerId = newLayerId;
     noteLayerPropertyChangedForSubtree();
 }
 
@@ skipping 201 matching lines @@
 void LayerImpl::didLoseOutputSurface()
 {
 }
 
 void LayerImpl::setMaxScrollOffset(gfx::Vector2d maxScrollOffset)
 {
     if (m_maxScrollOffset == maxScrollOffset)
         return;
     m_maxScrollOffset = maxScrollOffset;
 
-    layerTreeHostImpl()->setNeedsUpdateDrawProperties();
+    layerTreeImpl()->SetNeedsUpdateDrawProperties();
 
     if (!m_scrollbarAnimationController)
         return;
     m_scrollbarAnimationController->updateScrollOffset(this);
 }
 
 ScrollbarLayerImpl* LayerImpl::horizontalScrollbarLayer()
 {
     return m_scrollbarAnimationController ? m_scrollbarAnimationController->horizontalScrollbarLayer() : 0;
 }
@@ skipping 23 matching lines @@
 
 void LayerImpl::setVerticalScrollbarLayer(ScrollbarLayerImpl* scrollbarLayer)
 {
     if (!m_scrollbarAnimationController)
         m_scrollbarAnimationController = ScrollbarAnimationController::create(this);
     m_scrollbarAnimationController->setVerticalScrollbarLayer(scrollbarLayer);
     m_scrollbarAnimationController->updateScrollOffset(this);
 }
 
 }  // namespace cc