[cc] Use base ptr types for cc's CSS animation classes

cc/LayerChromium.h

 // Copyright 2010 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 LayerChromium_h
 #define LayerChromium_h
 
 #if USE(ACCELERATED_COMPOSITING)
 
@@ skipping 179 matching lines @@
     virtual void setIsMask(bool) { }
     virtual void bindContentsTexture() { }
     virtual bool needsContentsScale() const;
 
     void setDebugBorderColor(SkColor);
     void setDebugBorderWidth(float);
     void setDebugName(const std::string&);
 
     virtual void pushPropertiesTo(CCLayerImpl*);
 
-    void clearRenderSurface() { m_renderSurface.clear(); }
+    void clearRenderSurface() { m_renderSurface.reset(); }
     RenderSurfaceChromium* renderSurface() const { return m_renderSurface.get(); }
     void createRenderSurface();
 
     float drawOpacity() const { return m_drawOpacity; }
     void setDrawOpacity(float opacity) { m_drawOpacity = opacity; }
 
     bool drawOpacityIsAnimating() const { return m_drawOpacityIsAnimating; }
     void setDrawOpacityIsAnimating(bool drawOpacityIsAnimating) { m_drawOpacityIsAnimating = drawOpacityIsAnimating; }
 
     LayerChromium* renderTarget() const { ASSERT(!m_renderTarget || m_renderTarget->renderSurface()); return m_renderTarget; }
@@ skipping 26 matching lines @@
     bool boundsContainPageScale() const { return m_boundsContainPageScale; }
 
     // Returns true if any of the layer's descendants has content to draw.
     bool descendantDrawsContent();
 
     CCLayerTreeHost* layerTreeHost() const { return m_layerTreeHost; }
 
     // Set the priority of all desired textures in this layer.
     virtual void setTexturePriorities(const CCPriorityCalculator&) { }
 
-    bool addAnimation(PassOwnPtr<CCActiveAnimation>);
+    bool addAnimation(scoped_ptr<CCActiveAnimation>);
     void pauseAnimation(int animationId, double timeOffset);
     void removeAnimation(int animationId);
 
     void suspendAnimations(double monotonicTime);
     void resumeAnimations(double monotonicTime);
 
     CCLayerAnimationController* layerAnimationController() { return m_layerAnimationController.get(); }
-    void setLayerAnimationController(PassOwnPtr<CCLayerAnimationController>);
-    PassOwnPtr<CCLayerAnimationController> releaseLayerAnimationController();
+    void setLayerAnimationController(scoped_ptr<CCLayerAnimationController>);
+    scoped_ptr<CCLayerAnimationController> releaseLayerAnimationController();
 
     void setLayerAnimationDelegate(WebKit::WebAnimationDelegate* layerAnimationDelegate) { m_layerAnimationDelegate = layerAnimationDelegate; }
 
     bool hasActiveAnimation() const;
 
     virtual void notifyAnimationStarted(const CCAnimationEvent&, double wallClockTime);
     virtual void notifyAnimationFinished(double wallClockTime);
 
     virtual Region visibleContentOpaqueRegion() const;
 
@@ skipping 44 matching lines @@
     void removeChild(LayerChromium*);
 
     LayerList m_children;
     LayerChromium* m_parent;
 
     // LayerChromium instances have a weak pointer to their CCLayerTreeHost.
     // This pointer value is nil when a LayerChromium is not in a tree and is
     // updated via setLayerTreeHost() if a layer moves between trees.
     CCLayerTreeHost* m_layerTreeHost;
 
-    OwnPtr<CCLayerAnimationController> m_layerAnimationController;
+    scoped_ptr<CCLayerAnimationController> m_layerAnimationController;
 
     // Layer properties.
     IntSize m_bounds;
 
     // Uses layer's content space.
     IntRect m_visibleContentRect;
 
     IntPoint m_scrollPosition;
     IntSize m_maxScrollPosition;
     bool m_scrollable;
@@ skipping 23 matching lines @@
     bool m_drawCheckerboardForMissingTiles;
     bool m_forceRenderSurface;
 
     WebKit::WebTransformationMatrix m_transform;
     WebKit::WebTransformationMatrix m_sublayerTransform;
 
     // Replica layer used for reflections.
     scoped_refptr<LayerChromium> m_replicaLayer;
 
     // Transient properties.
-    OwnPtr<RenderSurfaceChromium> m_renderSurface;
+    scoped_ptr<RenderSurfaceChromium> m_renderSurface;
     float m_drawOpacity;
     bool m_drawOpacityIsAnimating;
 
     LayerChromium* m_renderTarget;
 
     WebKit::WebTransformationMatrix m_drawTransform;
     WebKit::WebTransformationMatrix m_screenSpaceTransform;
     bool m_drawTransformIsAnimating;
     bool m_screenSpaceTransformIsAnimating;
 
     // Uses target surface space.
     IntRect m_drawableContentRect;
     float m_contentsScale;
     bool m_boundsContainPageScale;
 
     WebKit::WebTransformationMatrix m_implTransform;
 
     WebKit::WebAnimationDelegate* m_layerAnimationDelegate;
     WebKit::WebLayerScrollClient* m_layerScrollClient;
 };
 
 void sortLayers(std::vector<scoped_refptr<LayerChromium> >::iterator, std::vector<scoped_refptr<LayerChromium> >::iterator, void*);
 
 }
 #endif // USE(ACCELERATED_COMPOSITING)
 
 #endif