Revert 160631 - [cc] Store CCLayerImpls as scoped_ptrs

cc/CCLayerImpl.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 CCLayerImpl_h
 #define CCLayerImpl_h
 
-#include "base/memory/scoped_ptr.h"
 #include "CCInputHandler.h"
 #include "CCLayerAnimationController.h"
 #include "CCRenderPass.h"
 #include "CCRenderSurface.h"
 #include "CCResourceProvider.h"
 #include "CCSharedQuadState.h"
 #include "FloatRect.h"
 #include "IntRect.h"
 #include "Region.h"
 #include "SkColor.h"
-#include "cc/scoped_ptr_vector.h"
+#include "cc/own_ptr_vector.h"
 #include <public/WebFilterOperations.h>
 #include <public/WebTransformationMatrix.h>
 #include <string>
 #include <wtf/OwnPtr.h>
+#include <wtf/PassRefPtr.h>
+#include <wtf/RefCounted.h>
 
 namespace cc {
 
 class CCLayerSorter;
 class CCLayerTreeHostImpl;
 class CCQuadSink;
 class CCRenderer;
 class CCScrollbarAnimationController;
 class CCScrollbarLayerImpl;
 class LayerChromium;
 
 struct CCAppendQuadsData;
 
 class CCLayerImpl : public CCLayerAnimationControllerClient {
 public:
-    static scoped_ptr<CCLayerImpl> create(int id)
+    static PassOwnPtr<CCLayerImpl> create(int id)
     {
-        return make_scoped_ptr(new CCLayerImpl(id));
+        return adoptPtr(new CCLayerImpl(id));
     }
 
     virtual ~CCLayerImpl();
 
     // CCLayerAnimationControllerClient implementation.
     virtual int id() const OVERRIDE;
     virtual void setOpacityFromAnimation(float) OVERRIDE;
     virtual float opacity() const OVERRIDE;
     virtual void setTransformFromAnimation(const WebKit::WebTransformationMatrix&) OVERRIDE;
     virtual const WebKit::WebTransformationMatrix& transform() const OVERRIDE;
 
     // Tree structure.
     CCLayerImpl* parent() const { return m_parent; }
-    const ScopedPtrVector<CCLayerImpl>& children() const { return m_children; }
-    void addChild(scoped_ptr<CCLayerImpl>);
+    const OwnPtrVector<CCLayerImpl>& children() const { return m_children; }
+    void addChild(PassOwnPtr<CCLayerImpl>);
     void removeFromParent();
     void removeAllChildren();
 
-    void setMaskLayer(scoped_ptr<CCLayerImpl>);
+    void setMaskLayer(PassOwnPtr<CCLayerImpl>);
     CCLayerImpl* maskLayer() const { return m_maskLayer.get(); }
 
-    void setReplicaLayer(scoped_ptr<CCLayerImpl>);
+    void setReplicaLayer(PassOwnPtr<CCLayerImpl>);
     CCLayerImpl* 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); }
 
     CCLayerTreeHostImpl* layerTreeHostImpl() const { return m_layerTreeHostImpl; }
     void setLayerTreeHostImpl(CCLayerTreeHostImpl* hostImpl) { m_layerTreeHostImpl = hostImpl; }
 
     scoped_ptr<CCSharedQuadState> createSharedQuadState() const;
@@ skipping 201 matching lines @@
 
     // Note carefully this does not affect the current layer.
     void noteLayerPropertyChangedForDescendants();
 
     virtual const char* layerTypeAsString() const;
 
     void dumpLayer(std::string*, int indent) const;
 
     // Properties internal to CCLayerImpl
     CCLayerImpl* m_parent;
-    ScopedPtrVector<CCLayerImpl> m_children;
+    OwnPtrVector<CCLayerImpl> 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<CCLayerImpl> m_maskLayer;
+    OwnPtr<CCLayerImpl> m_maskLayer;
     int m_replicaLayerId; // ditto
-    scoped_ptr<CCLayerImpl> m_replicaLayer;
+    OwnPtr<CCLayerImpl> m_replicaLayer;
     int m_layerId;
     CCLayerTreeHostImpl* m_layerTreeHostImpl;
 
     // Properties synchronized from the associated LayerChromium.
     FloatPoint m_anchorPoint;
     float m_anchorPointZ;
     IntSize m_bounds;
     IntSize m_contentBounds;
     IntPoint m_scrollPosition;
     bool m_scrollable;
@@ skipping 88 matching lines @@
 
     // Manages scrollbars for this layer
     OwnPtr<CCScrollbarAnimationController> m_scrollbarAnimationController;
 };
 
 void sortLayers(std::vector<CCLayerImpl*>::iterator first, std::vector<CCLayerImpl*>::iterator end, CCLayerSorter*);
 
 }
 
 #endif // CCLayerImpl_h