cc: Pass LayerTreeHostImpl to LayerImpl constructor

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"
 #include "cc/layer_animation_controller.h"
 #include "cc/layer_impl.h"
 #include "cc/layer_tree_host_common.h"
 #include "cc/math_util.h"
 #include "cc/overdraw_metrics.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/test/animation_test_common.h"
+#include "cc/test/fake_impl_proxy.h"
+#include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/occlusion_tracker_test_common.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/transform.h"
 
 using namespace WebKit;
 using namespace WebKitTests;
 
 namespace cc {
@@ skipping 24 matching lines @@
     virtual ~TestContentLayer()
     {
     }
 
     bool m_overrideOpaqueContentsRect;
     gfx::Rect m_opaqueContentsRect;
 };
 
 class TestContentLayerImpl : public LayerImpl {
 public:
-    TestContentLayerImpl(int id)
-        : LayerImpl(id)
+    TestContentLayerImpl(LayerTreeHostImpl* hostImpl, int id)
+        : LayerImpl(hostImpl, id)
         , m_overrideOpaqueContentsRect(false)
     {
         setDrawsContent(true);
     }
 
     virtual Region visibleContentOpaqueRegion() const OVERRIDE
     {
         if (m_overrideOpaqueContentsRect)
             return gfx::IntersectRects(m_opaqueContentsRect, visibleContentRect());
         return LayerImpl::visibleContentOpaqueRegion();
@@ skipping 38 matching lines @@
 protected:
     virtual gfx::Rect layerClipRectInTarget(const LayerType* layer) const { return m_overrideLayerClipRect ? m_layerClipRect : OcclusionTrackerBase<LayerType, RenderSurfaceType>::layerClipRectInTarget(layer); }
 
 private:
     bool m_overrideLayerClipRect;
     gfx::Rect m_layerClipRect;
 };
 
 struct OcclusionTrackerTestMainThreadTypes {
     typedef Layer LayerType;
+    typedef LayerTreeHost HostType;
     typedef RenderSurface RenderSurfaceType;
     typedef TestContentLayer ContentLayerType;
     typedef scoped_refptr<Layer> LayerPtrType;
     typedef scoped_refptr<ContentLayerType> ContentLayerPtrType;
     typedef LayerIterator<Layer, std::vector<scoped_refptr<Layer> >, RenderSurface, LayerIteratorActions::FrontToBack> TestLayerIterator;
     typedef OcclusionTracker OcclusionTrackerType;
 
-    static LayerPtrType createLayer()
+    static LayerPtrType createLayer(HostType*)
     {
         return Layer::create();
     }
-    static ContentLayerPtrType createContentLayer() { return make_scoped_refptr(new ContentLayerType()); }
+    static ContentLayerPtrType createContentLayer(HostType*) { return make_scoped_refptr(new ContentLayerType()); }
 
     static LayerPtrType passLayerPtr(ContentLayerPtrType& layer)
     {
         LayerPtrType ref(layer);
         layer = NULL;
         return ref;
     }
 
     static LayerPtrType passLayerPtr(LayerPtrType& layer)
     {
         LayerPtrType ref(layer);
         layer = NULL;
         return ref;
     }
 
     static void destroyLayer(LayerPtrType& layer)
     {
         layer = NULL;
     }
 };
 
 struct OcclusionTrackerTestImplThreadTypes {
     typedef LayerImpl LayerType;
+    typedef LayerTreeHostImpl 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() { return LayerImpl::create(nextLayerImplId++); }
-    static ContentLayerPtrType createContentLayer() { return make_scoped_ptr(new ContentLayerType(nextLayerImplId++)); }
+    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;
 
     static LayerPtrType passLayerPtr(LayerPtrType& layer)
     {
         return layer.Pass();
     }
 
     static LayerPtrType passLayerPtr(ContentLayerPtrType& layer)
     {
         return layer.PassAs<LayerType>();
     }
 
     static void destroyLayer(LayerPtrType& layer)
     {
         layer.reset();
     }
 };
 
 int OcclusionTrackerTestImplThreadTypes::nextLayerImplId = 1;
 
 template<typename Types>
 class OcclusionTrackerTest : public testing::Test {
 protected:
     OcclusionTrackerTest(bool opaqueLayers)
-        : m_opaqueLayers(opaqueLayers)
-    { }
+        : m_hostImpl(&m_proxy)
+        , m_opaqueLayers(opaqueLayers)
+    {
+    }
 
     virtual void runMyTest() = 0;
 
     virtual void TearDown()
     {
         Types::destroyLayer(m_root);
         m_renderSurfaceLayerList.clear();
         m_renderSurfaceLayerListImpl.clear();
         m_replicaLayers.clear();
         m_maskLayers.clear();
         LayerTreeHost::setNeedsFilterContext(false);
     }
 
+    typename Types::HostType* getHost();
+
     typename Types::ContentLayerType* createRoot(const gfx::Transform& transform, const gfx::PointF& position, const gfx::Size& bounds)
     {
-        typename Types::ContentLayerPtrType layer(Types::createContentLayer());
+        typename Types::ContentLayerPtrType layer(Types::createContentLayer(getHost()));
         typename Types::ContentLayerType* layerPtr = layer.get();
         setProperties(layerPtr, transform, position, bounds);
 
         DCHECK(!m_root);
         m_root = Types::passLayerPtr(layer);
         return layerPtr;
     }
 
     typename Types::LayerType* createLayer(typename Types::LayerType* parent, const gfx::Transform& transform, const gfx::PointF& position, const gfx::Size& bounds)
     {
-        typename Types::LayerPtrType layer(Types::createLayer());
+        typename Types::LayerPtrType layer(Types::createLayer(getHost()));
         typename Types::LayerType* layerPtr = layer.get();
         setProperties(layerPtr, transform, position, bounds);
         parent->addChild(Types::passLayerPtr(layer));
         return layerPtr;
     }
 
     typename Types::LayerType* createSurface(typename Types::LayerType* parent, const gfx::Transform& transform, const gfx::PointF& position, const gfx::Size& bounds)
     {
         typename Types::LayerType* layer = createLayer(parent, transform, position, bounds);
         WebFilterOperations filters;
         filters.append(WebFilterOperation::createGrayscaleFilter(0.5));
         layer->setFilters(filters);
         return layer;
     }
 
     typename Types::ContentLayerType* createDrawingLayer(typename Types::LayerType* parent, const gfx::Transform& transform, const gfx::PointF& position, const gfx::Size& bounds, bool opaque)
     {
-        typename Types::ContentLayerPtrType layer(Types::createContentLayer());
+        typename Types::ContentLayerPtrType layer(Types::createContentLayer(getHost()));
         typename Types::ContentLayerType* layerPtr = layer.get();
         setProperties(layerPtr, transform, position, bounds);
 
         if (m_opaqueLayers)
             layerPtr->setContentsOpaque(opaque);
         else {
             layerPtr->setContentsOpaque(false);
             if (opaque)
                 layerPtr->setOpaqueContentsRect(gfx::Rect(gfx::Point(), bounds));
             else
                 layerPtr->setOpaqueContentsRect(gfx::Rect());
         }
 
         parent->addChild(Types::passLayerPtr(layer));
         return layerPtr;
     }
 
     typename Types::LayerType* createReplicaLayer(typename Types::LayerType* owningLayer, const gfx::Transform& transform, const gfx::PointF& position, const gfx::Size& bounds)
     {
-        typename Types::ContentLayerPtrType layer(Types::createContentLayer());
+        typename Types::ContentLayerPtrType layer(Types::createContentLayer(getHost()));
         typename Types::ContentLayerType* layerPtr = layer.get();
         setProperties(layerPtr, transform, position, bounds);
         setReplica(owningLayer, Types::passLayerPtr(layer));
         return layerPtr;
     }
 
     typename Types::LayerType* createMaskLayer(typename Types::LayerType* owningLayer, const gfx::Size& bounds)
     {
-        typename Types::ContentLayerPtrType layer(Types::createContentLayer());
+        typename Types::ContentLayerPtrType layer(Types::createContentLayer(getHost()));
         typename Types::ContentLayerType* layerPtr = layer.get();
         setProperties(layerPtr, identityMatrix, gfx::PointF(), bounds);
         setMask(owningLayer, Types::passLayerPtr(layer));
         return layerPtr;
     }
 
     typename Types::ContentLayerType* createDrawingSurface(typename Types::LayerType* parent, const gfx::Transform& transform, const gfx::PointF& position, const gfx::Size& bounds, bool opaque)
     {
         typename Types::ContentLayerType* layer = createDrawingLayer(parent, transform, position, bounds, opaque);
         WebFilterOperations filters;
@@ skipping 116 matching lines @@
     {
         owningLayer->setMaskLayer(layer.get());
         m_maskLayers.push_back(layer);
     }
 
     void setMask(LayerImpl* owningLayer, scoped_ptr<LayerImpl> layer)
     {
         owningLayer->setMaskLayer(layer.Pass());
     }
 
+    FakeImplProxy m_proxy;
+    FakeLayerTreeHostImpl m_hostImpl;
     bool m_opaqueLayers;
     // These hold ownership of the layers for the duration of the test.
     typename Types::LayerPtrType m_root;
     std::vector<scoped_refptr<Layer> > m_renderSurfaceLayerList;
     std::vector<LayerImpl*> m_renderSurfaceLayerListImpl;
     typename Types::TestLayerIterator m_layerIteratorBegin;
     typename Types::TestLayerIterator m_layerIterator;
     typename Types::LayerType* m_lastLayerVisited;
     std::vector<scoped_refptr<Layer> > m_replicaLayers;
     std::vector<scoped_refptr<Layer> > m_maskLayers;
 };
 
+template<>
+LayerTreeHost* OcclusionTrackerTest<OcclusionTrackerTestMainThreadTypes>::getHost()
+{
+    return 0;
+}
+
+template<>
+LayerTreeHostImpl* OcclusionTrackerTest<OcclusionTrackerTestImplThreadTypes>::getHost()
+{
+    return &m_hostImpl;
+}
+
 #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> { \
     public: \
         ClassName##MainThreadOpaquePaints() : ClassName<OcclusionTrackerTestMainThreadTypes>(false) { } \
@@ skipping 2652 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