[cc] Make LayerImpls point at LayerTreeImpl instead of LTHI

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_impl.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(LayerTreeHostImpl* hostImpl, int id)
+LayerImpl::LayerImpl(LayerTreeImpl* treeImpl, int id)
     : m_parent(0)
     , m_maskLayerId(-1)
     , m_replicaLayerId(-1)
     , m_layerId(id)
-    , m_layerTreeHostImpl(hostImpl)
+    , m_layerTreeImpl(treeImpl)
     , m_anchorPoint(0.5, 0.5)
     , m_anchorPointZ(0)
     , m_contentsScaleX(1.0)
     , m_contentsScaleY(1.0)
     , m_scrollable(false)
     , m_shouldScrollOnMainThread(false)
     , m_haveWheelEventHandlers(false)
     , m_backgroundColor(0)
     , m_doubleSided(true)
     , m_layerPropertyChanged(false)
     , m_layerSurfacePropertyChanged(false)
     , m_masksToBounds(false)
     , m_contentsOpaque(false)
     , m_opacity(1.0)
     , m_preserves3D(false)
     , m_useParentBackfaceVisibility(false)
     , m_drawCheckerboardForMissingTiles(false)
     , m_useLCDText(false)
     , m_drawsContent(false)
     , m_forceRenderSurface(false)
     , m_isContainerForFixedPositionLayers(false)
     , m_fixedToContainerLayer(false)
     , m_drawDepth(0)
 #ifndef NDEBUG
     , m_betweenWillDrawAndDidDraw(false)
 #endif
     , m_layerAnimationController(LayerAnimationController::create(this))
 {
     DCHECK(m_layerId > 0);
-    DCHECK(m_layerTreeHostImpl);
+    DCHECK(m_layerTreeImpl);
 }
 
 LayerImpl::~LayerImpl()
 {
 #ifndef NDEBUG
     DCHECK(!m_betweenWillDrawAndDidDraw);
 #endif
 }
 
 void LayerImpl::addChild(scoped_ptr<LayerImpl> child)
 {
     child->setParent(this);
     DCHECK_EQ(layerTreeHostImpl(), child->layerTreeHostImpl());
     m_children.append(child.Pass());
-    m_layerTreeHostImpl->setNeedsUpdateDrawProperties();
+    layerTreeHostImpl()->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);
-            m_layerTreeHostImpl->setNeedsUpdateDrawProperties();
+            layerTreeHostImpl()->setNeedsUpdateDrawProperties();
             return ret.Pass();
         }
     }
     return scoped_ptr<LayerImpl>();
 }
 
 void LayerImpl::removeAllChildren()
 {
     m_children.clear();
-    m_layerTreeHostImpl->setNeedsUpdateDrawProperties();
+    layerTreeHostImpl()->setNeedsUpdateDrawProperties();
 }
 
 void LayerImpl::clearChildList()
 {
     if (m_children.isEmpty())
         return;
 
     m_children.clear();
-    m_layerTreeHostImpl->setNeedsUpdateDrawProperties();
+    layerTreeHostImpl()->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 m_layerTreeHostImpl->debugState().showDebugBorders;
+    return layerTreeHostImpl()->debugState().showDebugBorders;
 }
 
 void LayerImpl::getDebugBorderProperties(SkColor* color, float* width) const
 {
     if (m_drawsContent) {
         *color = DebugColors::ContentLayerBorderColor();
-        *width = DebugColors::ContentLayerBorderWidth(m_layerTreeHostImpl);
+        *width = DebugColors::ContentLayerBorderWidth(layerTreeHostImpl());
         return;
     }
 
     if (m_masksToBounds) {
         *color = DebugColors::MaskingLayerBorderColor();
-        *width = DebugColors::MaskingLayerBorderWidth(m_layerTreeHostImpl);
+        *width = DebugColors::MaskingLayerBorderWidth(layerTreeHostImpl());
         return;
     }
 
     *color = DebugColors::ContainerLayerBorderColor();
-    *width = DebugColors::ContainerLayerBorderWidth(m_layerTreeHostImpl);
+    *width = DebugColors::ContainerLayerBorderWidth(layerTreeHostImpl());
 }
 
 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 && !m_layerTreeHostImpl->settings().backgroundColorInsteadOfCheckerboard;
+    return m_drawCheckerboardForMissingTiles && !layerTreeHostImpl()->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;
-    m_layerTreeHostImpl->setNeedsUpdateDrawProperties();
+    layerTreeHostImpl()->setNeedsUpdateDrawProperties();
 }
 
 void LayerImpl::noteLayerPropertyChanged()
 {
     m_layerPropertyChanged = true;
-    m_layerTreeHostImpl->setNeedsUpdateDrawProperties();
+    layerTreeHostImpl()->setNeedsUpdateDrawProperties();
 }
 
 void LayerImpl::noteLayerPropertyChangedForSubtree()
 {
     noteLayerPropertyChanged();
     noteLayerPropertyChangedForDescendants();
 }
 
 void LayerImpl::noteLayerPropertyChangedForDescendants()
 {
-    m_layerTreeHostImpl->setNeedsUpdateDrawProperties();
+    layerTreeHostImpl()->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 291 matching lines @@
 void LayerImpl::didLoseOutputSurface()
 {
 }
 
 void LayerImpl::setMaxScrollOffset(gfx::Vector2d maxScrollOffset)
 {
     if (m_maxScrollOffset == maxScrollOffset)
         return;
     m_maxScrollOffset = maxScrollOffset;
 
-    m_layerTreeHostImpl->setNeedsUpdateDrawProperties();
+    layerTreeHostImpl()->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