[cc] Make LayerImpls point at LayerTreeImpl instead of LTHI

cc/layer_impl.h

 // 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.
 
 #ifndef CC_LAYER_IMPL_H_
 #define CC_LAYER_IMPL_H_
 
 #include <public/WebFilterOperations.h>
 #include <string>
 
@@ skipping 16 matching lines @@
 #include "ui/gfx/rect_f.h"
 #include "ui/gfx/transform.h"
 
 namespace base {
 class DictionaryValue;
 }
 
 namespace cc {
 
 class LayerTreeHostImpl;
+class LayerTreeImpl;
 class QuadSink;
 class Renderer;
 class ScrollbarAnimationController;
 class ScrollbarLayerImpl;
 class Layer;
 
 struct AppendQuadsData;
 
 class CC_EXPORT LayerImpl : public LayerAnimationControllerClient {
 public:
     typedef ScopedPtrVector<LayerImpl> LayerList;
 
-    static scoped_ptr<LayerImpl> create(LayerTreeHostImpl* hostImpl, int id)
+    static scoped_ptr<LayerImpl> create(LayerTreeImpl* treeImpl, int id)
     {
-        return make_scoped_ptr(new LayerImpl(hostImpl, id));
+        return make_scoped_ptr(new LayerImpl(treeImpl, id));
     }
 
     virtual ~LayerImpl();
 
     // LayerAnimationControllerClient implementation.
     virtual int id() const OVERRIDE;
     virtual void setOpacityFromAnimation(float) OVERRIDE;
     virtual float opacity() const OVERRIDE;
     virtual void setTransformFromAnimation(const gfx::Transform&) OVERRIDE;
     virtual const gfx::Transform& transform() const OVERRIDE;
@@ skipping 11 matching lines @@
     const LayerImpl* maskLayer() const { return m_maskLayer.get(); }
 
     void setReplicaLayer(scoped_ptr<LayerImpl>);
     LayerImpl* replicaLayer() { return m_replicaLayer.get(); }
     const LayerImpl* replicaLayer() const { return m_replicaLayer.get(); }
 
     bool hasMask() const { return m_maskLayer; }
     bool hasReplica() const { return m_replicaLayer; }
     bool replicaHasMask() const { return m_replicaLayer && (m_maskLayer || m_replicaLayer->m_maskLayer); }
 
-    LayerTreeHostImpl* layerTreeHostImpl() const { return m_layerTreeHostImpl; }
+    LayerTreeImpl* layerTreeImpl() const { return m_layerTreeImpl; }
+    LayerTreeHostImpl* layerTreeHostImpl() const;
 
     scoped_ptr<SharedQuadState> createSharedQuadState() const;
     // willDraw must be called before appendQuads. If willDraw is called,
     // didDraw is guaranteed to be called before another willDraw or before
     // the layer is destroyed. To enforce this, any class that overrides
     // willDraw/didDraw must call the base class version.
     virtual void willDraw(ResourceProvider*);
     virtual void appendQuads(QuadSink&, AppendQuadsData&) { }
     virtual void didDraw(ResourceProvider*);
 
@@ skipping 185 matching lines @@
     ScrollbarLayerImpl* horizontalScrollbarLayer();
     const ScrollbarLayerImpl* horizontalScrollbarLayer() const;
 
     void setVerticalScrollbarLayer(ScrollbarLayerImpl*);
     ScrollbarLayerImpl* verticalScrollbarLayer();
     const ScrollbarLayerImpl* verticalScrollbarLayer() const;
 
     gfx::Rect layerRectToContentRect(const gfx::RectF& layerRect) const;
 
 protected:
-    LayerImpl(LayerTreeHostImpl* hostImpl, int);
+    LayerImpl(LayerTreeImpl* layerImpl, int);
 
     // Get the color and size of the layer's debug border.
     virtual void getDebugBorderProperties(SkColor*, float* width) const;
 
     void appendDebugBorderQuad(QuadSink&, const SharedQuadState*, AppendQuadsData&) const;
 
     virtual void dumpLayerProperties(std::string*, int indent) const;
     static std::string indentString(int indent);
 
 private:
@@ skipping 14 matching lines @@
 
     // Properties internal to LayerImpl
     LayerImpl* m_parent;
     LayerList m_children;
     // m_maskLayer can be temporarily stolen during tree sync, we need this ID to confirm newly assigned layer is still the previous one
     int m_maskLayerId;
     scoped_ptr<LayerImpl> m_maskLayer;
     int m_replicaLayerId; // ditto
     scoped_ptr<LayerImpl> m_replicaLayer;
     int m_layerId;
-    LayerTreeHostImpl* m_layerTreeHostImpl;
+    LayerTreeImpl* m_layerTreeImpl;
 
     // Properties synchronized from the associated Layer.
     gfx::PointF m_anchorPoint;
     float m_anchorPointZ;
     gfx::Size m_bounds;
     gfx::Size m_contentBounds;
     float m_contentsScaleX;
     float m_contentsScaleY;
     gfx::Vector2d m_scrollOffset;
     bool m_scrollable;
@@ skipping 68 matching lines @@
     // Group of properties that need to be computed based on the layer tree
     // hierarchy before layers can be drawn.
     DrawProperties<LayerImpl, RenderSurfaceImpl> m_drawProperties;
 
     DISALLOW_COPY_AND_ASSIGN(LayerImpl);
 };
 
 }
 
 #endif  // CC_LAYER_IMPL_H_