[cc] Store CCLayerImpls as scoped_ptrs

cc/CCOcclusionTrackerTest.cpp

 // 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 "config.h"
 
 #include "CCOcclusionTracker.h"
 
 #include "CCAnimationTestCommon.h"
 #include "CCGeometryTestUtils.h"
@@ skipping 92 matching lines @@
 private:
     bool m_overrideLayerClipRect;
     IntRect m_layerClipRect;
 };
 
 struct CCOcclusionTrackerTestMainThreadTypes {
     typedef LayerChromium LayerType;
     typedef RenderSurfaceChromium RenderSurfaceType;
     typedef TestContentLayerChromium ContentLayerType;
     typedef scoped_refptr<LayerChromium> LayerPtrType;
-    typedef scoped_refptr<LayerChromium> PassLayerPtrType;
     typedef scoped_refptr<ContentLayerType> ContentLayerPtrType;
-    typedef scoped_refptr<ContentLayerType> PassContentLayerPtrType;
     typedef CCLayerIterator<LayerChromium, std::vector<scoped_refptr<LayerChromium> >, RenderSurfaceChromium, CCLayerIteratorActions::FrontToBack> LayerIterator;
     typedef CCOcclusionTracker OcclusionTrackerType;
 
-    static PassLayerPtrType createLayer()
+    static LayerPtrType createLayer()
     {
         return LayerChromium::create();
     }
-    static PassContentLayerPtrType createContentLayer() { return make_scoped_refptr(new ContentLayerType()); }
+    static ContentLayerPtrType createContentLayer() { return make_scoped_refptr(new ContentLayerType()); }
+
+    static LayerPtrType passLayerPtr(ContentLayerPtrType& layer)
+    {
+        return layer.release();
+    }
+
+    static LayerPtrType passLayerPtr(LayerPtrType& layer)
+    {
+        return layer.release();
+    }
 
     static void destroyLayer(LayerPtrType& layer)
     {
         layer = NULL;
     }
 };
 
 struct CCOcclusionTrackerTestImplThreadTypes {
     typedef CCLayerImpl LayerType;
     typedef CCRenderSurface RenderSurfaceType;
     typedef TestContentLayerImpl ContentLayerType;
-    typedef OwnPtr<CCLayerImpl> LayerPtrType;
-    typedef PassOwnPtr<CCLayerImpl> PassLayerPtrType;
-    typedef OwnPtr<ContentLayerType> ContentLayerPtrType;
-    typedef PassOwnPtr<ContentLayerType> PassContentLayerPtrType;
+    typedef scoped_ptr<CCLayerImpl> LayerPtrType;
+    typedef scoped_ptr<ContentLayerType> ContentLayerPtrType;
     typedef CCLayerIterator<CCLayerImpl, std::vector<CCLayerImpl*>, CCRenderSurface, CCLayerIteratorActions::FrontToBack> LayerIterator;
     typedef CCOcclusionTrackerImpl OcclusionTrackerType;
 
-    static PassLayerPtrType createLayer() { return CCLayerImpl::create(nextCCLayerImplId++); }
-    static PassContentLayerPtrType createContentLayer() { return adoptPtr(new ContentLayerType(nextCCLayerImplId++)); }
+    static LayerPtrType createLayer() { return CCLayerImpl::create(nextCCLayerImplId++); }
+    static ContentLayerPtrType createContentLayer() { return make_scoped_ptr(new ContentLayerType(nextCCLayerImplId++)); }
     static int nextCCLayerImplId;
 
+    static LayerPtrType passLayerPtr(LayerPtrType& layer)
+    {
+        return layer.Pass();
+    }
+
+    static LayerPtrType passLayerPtr(ContentLayerPtrType& layer)
+    {
+        return layer.PassAs<LayerType>();
+    }
+
     static void destroyLayer(LayerPtrType& layer)
     {
-        layer.clear();
+        layer.reset();
     }
 };
 
 int CCOcclusionTrackerTestImplThreadTypes::nextCCLayerImplId = 1;
 
 template<typename Types, bool opaqueLayers>
 class CCOcclusionTrackerTest : public testing::Test {
 protected:
     CCOcclusionTrackerTest()
         : testing::Test()
@@ skipping 11 matching lines @@
         CCLayerTreeHost::setNeedsFilterContext(false);
     }
 
     typename Types::ContentLayerType* createRoot(const WebTransformationMatrix& transform, const FloatPoint& position, const IntSize& bounds)
     {
         typename Types::ContentLayerPtrType layer(Types::createContentLayer());
         typename Types::ContentLayerType* layerPtr = layer.get();
         setProperties(layerPtr, transform, position, bounds);
 
         ASSERT(!m_root);
-        m_root = layer.release();
+        m_root = Types::passLayerPtr(layer);
         return layerPtr;
     }
 
     typename Types::LayerType* createLayer(typename Types::LayerType* parent, const WebTransformationMatrix& transform, const FloatPoint& position, const IntSize& bounds)
     {
         typename Types::LayerPtrType layer(Types::createLayer());
         typename Types::LayerType* layerPtr = layer.get();
         setProperties(layerPtr, transform, position, bounds);
-        parent->addChild(layer.release());
+        parent->addChild(Types::passLayerPtr(layer));
         return layerPtr;
     }
 
     typename Types::LayerType* createSurface(typename Types::LayerType* parent, const WebTransformationMatrix& transform, const FloatPoint& position, const IntSize& 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 WebTransformationMatrix& transform, const FloatPoint& position, const IntSize& bounds, bool opaque)
     {
         typename Types::ContentLayerPtrType layer(Types::createContentLayer());
         typename Types::ContentLayerType* layerPtr = layer.get();
         setProperties(layerPtr, transform, position, bounds);
 
         if (opaqueLayers)
             layerPtr->setContentsOpaque(opaque);
         else {
             layerPtr->setContentsOpaque(false);
             if (opaque)
                 layerPtr->setOpaqueContentsRect(IntRect(IntPoint(), bounds));
             else
                 layerPtr->setOpaqueContentsRect(IntRect());
         }
 
-        parent->addChild(layer.release());
+        parent->addChild(Types::passLayerPtr(layer));
         return layerPtr;
     }
 
     typename Types::LayerType* createReplicaLayer(typename Types::LayerType* owningLayer, const WebTransformationMatrix& transform, const FloatPoint& position, const IntSize& bounds)
     {
         typename Types::ContentLayerPtrType layer(Types::createContentLayer());
         typename Types::ContentLayerType* layerPtr = layer.get();
         setProperties(layerPtr, transform, position, bounds);
-        setReplica(owningLayer, layer.release());
+        setReplica(owningLayer, Types::passLayerPtr(layer));
         return layerPtr;
     }
 
     typename Types::LayerType* createMaskLayer(typename Types::LayerType* owningLayer, const IntSize& bounds)
     {
         typename Types::ContentLayerPtrType layer(Types::createContentLayer());
         typename Types::ContentLayerType* layerPtr = layer.get();
         setProperties(layerPtr, identityMatrix, FloatPoint(), bounds);
-        setMask(owningLayer, layer.release());
+        setMask(owningLayer, Types::passLayerPtr(layer));
         return layerPtr;
     }
 
     typename Types::ContentLayerType* createDrawingSurface(typename Types::LayerType* parent, const WebTransformationMatrix& transform, const FloatPoint& position, const IntSize& bounds, bool opaque)
     {
         typename Types::ContentLayerType* layer = createDrawingLayer(parent, transform, position, bounds, opaque);
         WebFilterOperations filters;
         filters.append(WebFilterOperation::createGrayscaleFilter(0.5));
         layer->setFilters(filters);
         return layer;
@@ skipping 100 matching lines @@
 
         layer->setContentBounds(layer->bounds());
     }
 
     void setReplica(LayerChromium* owningLayer, scoped_refptr<LayerChromium> layer)
     {
         owningLayer->setReplicaLayer(layer.get());
         m_replicaLayers.push_back(layer);
     }
 
-    void setReplica(CCLayerImpl* owningLayer, PassOwnPtr<CCLayerImpl> layer)
+    void setReplica(CCLayerImpl* owningLayer, scoped_ptr<CCLayerImpl> layer)
     {
-        owningLayer->setReplicaLayer(layer);
+        owningLayer->setReplicaLayer(layer.Pass());
     }
 
     void setMask(LayerChromium* owningLayer, scoped_refptr<LayerChromium> layer)
     {
         owningLayer->setMaskLayer(layer.get());
         m_maskLayers.push_back(layer);
     }
 
-    void setMask(CCLayerImpl* owningLayer, PassOwnPtr<CCLayerImpl> layer)
+    void setMask(CCLayerImpl* owningLayer, scoped_ptr<CCLayerImpl> layer)
     {
-        owningLayer->setMaskLayer(layer);
+        owningLayer->setMaskLayer(layer.Pass());
     }
 
     // These hold ownership of the layers for the duration of the test.
     typename Types::LayerPtrType m_root;
     std::vector<scoped_refptr<LayerChromium> > m_renderSurfaceLayerListChromium;
     std::vector<CCLayerImpl*> m_renderSurfaceLayerListImpl;
     typename Types::LayerIterator m_layerIteratorBegin;
     typename Types::LayerIterator m_layerIterator;
     typename Types::LayerType* m_lastLayerVisited;
     std::vector<scoped_refptr<LayerChromium> > m_replicaLayers;
@@ skipping 2639 matching lines @@
         EXPECT_RECT_EQ(IntRect(IntPoint(), trackingSize), occlusion.occlusionInScreenSpace().bounds());
         EXPECT_EQ(1u, occlusion.occlusionInScreenSpace().rects().size());
         EXPECT_RECT_EQ(IntRect(IntPoint(), trackingSize), occlusion.occlusionInTargetSurface().bounds());
         EXPECT_EQ(1u, occlusion.occlusionInTargetSurface().rects().size());
     }
 };
 
 ALL_CCOCCLUSIONTRACKER_TEST(CCOcclusionTrackerTestMinimumTrackingSize);
 
 } // namespace