[cc] Make LayerImpls point at LayerTreeImpl instead of LTHI

cc/occlusion_tracker_unittest.cc

 // Copyright 2012 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/occlusion_tracker.h"
 
 #include <public/WebFilterOperation.h>
 #include <public/WebFilterOperations.h>
 
 #include "cc/layer.h"
@@ skipping 43 matching lines @@
     virtual ~TestContentLayer()
     {
     }
 
     bool m_overrideOpaqueContentsRect;
     gfx::Rect m_opaqueContentsRect;
 };
 
 class TestContentLayerImpl : public LayerImpl {
 public:
-    TestContentLayerImpl(LayerTreeHostImpl* hostImpl, int id)
-        : LayerImpl(hostImpl, id)
+    TestContentLayerImpl(LayerTreeImpl* treeImpl, int id)
+        : LayerImpl(treeImpl, id)
         , m_overrideOpaqueContentsRect(false)
     {
         setDrawsContent(true);
     }
 
     virtual Region visibleContentOpaqueRegion() const OVERRIDE
     {
         if (m_overrideOpaqueContentsRect)
             return gfx::IntersectRects(m_opaqueContentsRect, visibleContentRect());
         return LayerImpl::visibleContentOpaqueRegion();
@@ skipping 74 matching lines @@
     }
 
     static void destroyLayer(LayerPtrType& layer)
     {
         layer = NULL;
     }
 };
 
 struct OcclusionTrackerTestImplThreadTypes {
     typedef LayerImpl LayerType;
-    typedef LayerTreeHostImpl HostType;
+    typedef LayerTreeImpl HostType;
     typedef RenderSurfaceImpl RenderSurfaceType;
     typedef TestContentLayerImpl ContentLayerType;
     typedef scoped_ptr<LayerImpl> LayerPtrType;
     typedef scoped_ptr<ContentLayerType> ContentLayerPtrType;
     typedef LayerIterator<LayerImpl, std::vector<LayerImpl*>, RenderSurfaceImpl, LayerIteratorActions::FrontToBack> TestLayerIterator;
     typedef OcclusionTrackerImpl OcclusionTrackerType;
 
     static LayerPtrType createLayer(HostType* host) { return LayerImpl::create(host, nextLayerImplId++); }
     static ContentLayerPtrType createContentLayer(HostType* host) { return make_scoped_ptr(new ContentLayerType(host, nextLayerImplId++)); }
     static int nextLayerImplId;
@@ skipping 250 matching lines @@
     std::vector<scoped_refptr<Layer> > m_maskLayers;
 };
 
 template<>
 LayerTreeHost* OcclusionTrackerTest<OcclusionTrackerTestMainThreadTypes>::getHost()
 {
     return 0;
 }
 
 template<>
-LayerTreeHostImpl* OcclusionTrackerTest<OcclusionTrackerTestImplThreadTypes>::getHost()
+LayerTreeImpl* OcclusionTrackerTest<OcclusionTrackerTestImplThreadTypes>::getHost()
 {
-    return &m_hostImpl;
+  return m_hostImpl.activeTree();
 }
 
 #define RUN_TEST_MAIN_THREAD_OPAQUE_LAYERS(ClassName) \
     class ClassName##MainThreadOpaqueLayers : public ClassName<OcclusionTrackerTestMainThreadTypes> { \
     public: \
         ClassName##MainThreadOpaqueLayers() : ClassName<OcclusionTrackerTestMainThreadTypes>(true) { } \
     }; \
     TEST_F(ClassName##MainThreadOpaqueLayers, runTest) { runMyTest(); }
 #define RUN_TEST_MAIN_THREAD_OPAQUE_PAINTS(ClassName) \
     class ClassName##MainThreadOpaquePaints : public ClassName<OcclusionTrackerTestMainThreadTypes> { \
@@ skipping 2654 matching lines @@
 
         EXPECT_EQ(gfx::Rect(gfx::Point(), trackingSize).ToString(), occlusion.occlusionInScreenSpace().ToString());
         EXPECT_EQ(gfx::Rect(gfx::Point(), trackingSize).ToString(), occlusion.occlusionInTargetSurface().ToString());
     }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestMinimumTrackingSize);
 
 }  // namespace
 }  // namespace cc