Fix remaining cc files to compile with Clang

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 32 matching lines @@
 
 // Base class for composited layers. Special layer types are derived from
 // this class.
 class LayerChromium : public RefCounted<LayerChromium>, public CCLayerAnimationControllerClient {
 public:
     static PassRefPtr<LayerChromium> create();
 
     virtual ~LayerChromium();
 
     // CCLayerAnimationControllerClient implementation
-    virtual int id() const OVERRIDE { return m_layerId; }
+    virtual int id() const OVERRIDE;
     virtual void setOpacityFromAnimation(float) OVERRIDE;
-    virtual float opacity() const OVERRIDE { return m_opacity; }
+    virtual float opacity() const OVERRIDE;
     virtual void setTransformFromAnimation(const WebKit::WebTransformationMatrix&) OVERRIDE;
     // A layer's transform operates layer space. That is, entirely in logical,
     // non-page-scaled pixels (that is, they have page zoom baked in, but not page scale).
     // The root layer is a special case -- it operates in physical pixels.
-    virtual const WebKit::WebTransformationMatrix& transform() const OVERRIDE { return m_transform; }
+    virtual const WebKit::WebTransformationMatrix& transform() const OVERRIDE;
 
     LayerChromium* rootLayer();
     LayerChromium* parent() const;
     void addChild(PassRefPtr<LayerChromium>);
     void insertChild(PassRefPtr<LayerChromium>, size_t index);
     void replaceChild(LayerChromium* reference, PassRefPtr<LayerChromium> newLayer);
     void removeFromParent();
     void removeAllChildren();
     void setChildren(const Vector<RefPtr<LayerChromium> >&);
     const Vector<RefPtr<LayerChromium> >& children() const { return m_children; }
 
     void setAnchorPoint(const FloatPoint&);
     FloatPoint anchorPoint() const { return m_anchorPoint; }
 
     void setAnchorPointZ(float);
     float anchorPointZ() const { return m_anchorPointZ; }
 
     void setBackgroundColor(SkColor);
     SkColor backgroundColor() const { return m_backgroundColor; }
 
     // A layer's bounds are in logical, non-page-scaled pixels (however, the
     // root layer's bounds are in physical pixels).
     void setBounds(const IntSize&);
     const IntSize& bounds() const { return m_bounds; }
-    virtual IntSize contentBounds() const { return bounds(); }
+    virtual IntSize contentBounds() const;
 
     void setMasksToBounds(bool);
     bool masksToBounds() const { return m_masksToBounds; }
 
     void setMaskLayer(LayerChromium*);
     LayerChromium* maskLayer() const { return m_maskLayer.get(); }
 
     virtual void setNeedsDisplayRect(const FloatRect& dirtyRect);
     void setNeedsDisplay() { setNeedsDisplayRect(FloatRect(FloatPoint(), bounds())); }
-    virtual bool needsDisplay() const { return m_needsDisplay; }
+    virtual bool needsDisplay() const;
 
     void setOpacity(float);
     bool opacityIsAnimating() const;
 
     void setFilters(const WebKit::WebFilterOperations&);
     const WebKit::WebFilterOperations& filters() const { return m_filters; }
 
     // Background filters are filters applied to what is behind this layer, when they are viewed through non-opaque
     // regions in this layer. They are used through the WebLayer interface, and are not exposed to HTML.
     void setBackgroundFilters(const WebKit::WebFilterOperations&);
@@ skipping 68 matching lines @@
     void setIsDrawable(bool);
 
     void setReplicaLayer(LayerChromium*);
     LayerChromium* 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); }
 
     // These methods typically need to be overwritten by derived classes.
-    virtual bool drawsContent() const { return m_isDrawable; }
+    virtual bool drawsContent() const;
     virtual void update(CCTextureUpdateQueue&, const CCOcclusionTracker*, CCRenderingStats&) { }
-    virtual bool needMoreUpdates() { return false; }
+    virtual bool needMoreUpdates();
     virtual void setIsMask(bool) { }
     virtual void bindContentsTexture() { }
-    virtual bool needsContentsScale() const { return false; }
+    virtual bool needsContentsScale() const;
 
     void setDebugBorderColor(SkColor);
     void setDebugBorderWidth(float);
     void setDebugName(const std::string&);
 
     virtual void pushPropertiesTo(CCLayerImpl*);
 
     void clearRenderSurface() { m_renderSurface.clear(); }
     RenderSurfaceChromium* renderSurface() const { return m_renderSurface.get(); }
     void createRenderSurface();
@@ skipping 53 matching lines @@
 
     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;
 
-    virtual ScrollbarLayerChromium* toScrollbarLayerChromium() { return 0; }
+    virtual ScrollbarLayerChromium* toScrollbarLayerChromium();
 
 protected:
     friend class CCLayerImpl;
     friend class TreeSynchronizer;
 
     LayerChromium();
 
     void setNeedsCommit();
 
     // This flag is set when layer need repainting/updating.
@@ skipping 98 matching lines @@
     WebKit::WebAnimationDelegate* m_layerAnimationDelegate;
     WebKit::WebLayerScrollClient* m_layerScrollClient;
 };
 
 void sortLayers(Vector<RefPtr<LayerChromium> >::iterator, Vector<RefPtr<LayerChromium> >::iterator, void*);
 
 }
 #endif // USE(ACCELERATED_COMPOSITING)
 
 #endif