Enforce marking "override" for functions overriding Blink in cc/.

BUG=535367
TEST=it all stays working
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1360283003

Cr-Commit-Position: refs/heads/master@{#350566}

17 files changed, 283 insertions, 282 deletions

diff --git a/cc/blink/web_animation_impl.h b/cc/blink/web_animation_impl.h
index 585df6a..c1bdb0e 100644
--- a/cc/blink/web_animation_impl.h
+++ b/cc/blink/web_animation_impl.h
@@ -26,26 +26,26 @@ class WebCompositorAnimationImpl : public blink::WebCompositorAnimation {
       TargetProperty target,
       int animation_id,
       int group_id);
-  virtual ~WebCompositorAnimationImpl();
+  ~WebCompositorAnimationImpl() override;
 
   // blink::WebCompositorAnimation implementation
-  virtual int id();
-  virtual int group();
-  virtual TargetProperty targetProperty() const;
-  virtual double iterations() const;
-  virtual void setIterations(double iterations);
-  virtual double iterationStart() const;
-  virtual void setIterationStart(double iteration_start);
-  virtual double startTime() const;
-  virtual void setStartTime(double monotonic_time);
-  virtual double timeOffset() const;
-  virtual void setTimeOffset(double monotonic_time);
-  virtual Direction direction() const;
-  virtual void setDirection(Direction);
-  virtual double playbackRate() const;
-  virtual void setPlaybackRate(double playback_rate);
-  virtual FillMode fillMode() const;
-  virtual void setFillMode(blink::WebCompositorAnimation::FillMode fill_mode);
+  int id() override;
+  int group() override;
+  TargetProperty targetProperty() const override;
+  double iterations() const override;
+  void setIterations(double iterations) override;
+  double iterationStart() const override;
+  void setIterationStart(double iteration_start) override;
+  double startTime() const override;
+  void setStartTime(double monotonic_time) override;
+  double timeOffset() const override;
+  void setTimeOffset(double monotonic_time) override;
+  Direction direction() const override;
+  void setDirection(Direction) override;
+  double playbackRate() const override;
+  void setPlaybackRate(double playback_rate) override;
+  FillMode fillMode() const override;
+  void setFillMode(blink::WebCompositorAnimation::FillMode fill_mode) override;
   scoped_ptr<cc::Animation> PassAnimation();
 
  private:
diff --git a/cc/blink/web_compositor_animation_player_impl.h b/cc/blink/web_compositor_animation_player_impl.h
index 9b5ea44..1d4879b 100644
--- a/cc/blink/web_compositor_animation_player_impl.h
+++ b/cc/blink/web_compositor_animation_player_impl.h
@@ -22,19 +22,19 @@ class WebCompositorAnimationPlayerImpl
     : public blink::WebCompositorAnimationPlayer {
  public:
   CC_BLINK_EXPORT WebCompositorAnimationPlayerImpl();
-  virtual ~WebCompositorAnimationPlayerImpl();
+  ~WebCompositorAnimationPlayerImpl() override;
 
   CC_BLINK_EXPORT cc::AnimationPlayer* animation_player() const;
 
   // blink::WebCompositorAnimationPlayer implementation
-  virtual void setAnimationDelegate(
-      blink::WebCompositorAnimationDelegate* delegate);
-  virtual void attachLayer(blink::WebLayer* web_layer);
-  virtual void detachLayer();
-  virtual bool isLayerAttached() const;
-  virtual void addAnimation(blink::WebCompositorAnimation* animation);
-  virtual void removeAnimation(int animation_id);
-  virtual void pauseAnimation(int animation_id, double time_offset);
+  void setAnimationDelegate(
+      blink::WebCompositorAnimationDelegate* delegate) override;
+  void attachLayer(blink::WebLayer* web_layer) override;
+  void detachLayer() override;
+  bool isLayerAttached() const override;
+  void addAnimation(blink::WebCompositorAnimation* animation) override;
+  void removeAnimation(int animation_id) override;
+  void pauseAnimation(int animation_id, double time_offset) override;
 
  private:
   scoped_refptr<cc::AnimationPlayer> animation_player_;
diff --git a/cc/blink/web_compositor_animation_timeline_impl.h b/cc/blink/web_compositor_animation_timeline_impl.h
index 65d05d8..624d29f 100644
--- a/cc/blink/web_compositor_animation_timeline_impl.h
+++ b/cc/blink/web_compositor_animation_timeline_impl.h
@@ -24,15 +24,15 @@ class WebCompositorAnimationTimelineImpl
     : public blink::WebCompositorAnimationTimeline {
  public:
   CC_BLINK_EXPORT explicit WebCompositorAnimationTimelineImpl();
-  virtual ~WebCompositorAnimationTimelineImpl();
+  ~WebCompositorAnimationTimelineImpl() override;
 
   CC_BLINK_EXPORT cc::AnimationTimeline* animation_timeline() const;
 
   // blink::WebCompositorAnimationTimeline implementation
-  virtual void playerAttached(
-      const blink::WebCompositorAnimationPlayerClient& client);
-  virtual void playerDestroyed(
-      const blink::WebCompositorAnimationPlayerClient& client);
+  void playerAttached(
+      const blink::WebCompositorAnimationPlayerClient& client) override;
+  void playerDestroyed(
+      const blink::WebCompositorAnimationPlayerClient& client) override;
 
  private:
   scoped_refptr<cc::AnimationTimeline> animation_timeline_;
diff --git a/cc/blink/web_compositor_support_impl.h b/cc/blink/web_compositor_support_impl.h
index d5ad630..0547a14 100644
--- a/cc/blink/web_compositor_support_impl.h
+++ b/cc/blink/web_compositor_support_impl.h
@@ -23,41 +23,40 @@ class CC_BLINK_EXPORT WebCompositorSupportImpl
     : public NON_EXPORTED_BASE(blink::WebCompositorSupport) {
  public:
   WebCompositorSupportImpl();
-  virtual ~WebCompositorSupportImpl();
+  ~WebCompositorSupportImpl() override;
 
-  virtual blink::WebLayer* createLayer();
-  virtual blink::WebContentLayer* createContentLayer(
-      blink::WebContentLayerClient* client);
-  virtual blink::WebExternalTextureLayer* createExternalTextureLayer(
-      blink::WebExternalTextureLayerClient* client);
-  virtual blink::WebImageLayer* createImageLayer();
-  virtual blink::WebScrollbarLayer* createScrollbarLayer(
+  blink::WebLayer* createLayer() override;
+  blink::WebContentLayer* createContentLayer(
+      blink::WebContentLayerClient* client) override;
+  blink::WebExternalTextureLayer* createExternalTextureLayer(
+      blink::WebExternalTextureLayerClient* client) override;
+  blink::WebImageLayer* createImageLayer() override;
+  blink::WebScrollbarLayer* createScrollbarLayer(
       blink::WebScrollbar* scrollbar,
       blink::WebScrollbarThemePainter painter,
-      blink::WebScrollbarThemeGeometry*);
-  virtual blink::WebScrollbarLayer* createSolidColorScrollbarLayer(
+      blink::WebScrollbarThemeGeometry*) override;
+  blink::WebScrollbarLayer* createSolidColorScrollbarLayer(
       blink::WebScrollbar::Orientation orientation,
       int thumb_thickness,
       int track_start,
-      bool is_left_side_vertical_scrollbar);
-  virtual blink::WebCompositorAnimation* createAnimation(
+      bool is_left_side_vertical_scrollbar) override;
+  blink::WebCompositorAnimation* createAnimation(
       const blink::WebCompositorAnimationCurve& curve,
       blink::WebCompositorAnimation::TargetProperty target,
       int group_id,
-      int animation_id);
-  virtual blink::WebFilterAnimationCurve* createFilterAnimationCurve();
-  virtual blink::WebFloatAnimationCurve* createFloatAnimationCurve();
-  virtual blink::WebScrollOffsetAnimationCurve*
-      createScrollOffsetAnimationCurve(
-          blink::WebFloatPoint target_value,
-          blink::WebCompositorAnimationCurve::TimingFunctionType
-              timing_function);
-  virtual blink::WebTransformAnimationCurve* createTransformAnimationCurve();
-  virtual blink::WebTransformOperations* createTransformOperations();
-  virtual blink::WebFilterOperations* createFilterOperations();
+      int animation_id) override;
+  blink::WebFilterAnimationCurve* createFilterAnimationCurve() override;
+  blink::WebFloatAnimationCurve* createFloatAnimationCurve() override;
+  blink::WebScrollOffsetAnimationCurve* createScrollOffsetAnimationCurve(
+      blink::WebFloatPoint target_value,
+      blink::WebCompositorAnimationCurve::TimingFunctionType timing_function)
+      override;
+  blink::WebTransformAnimationCurve* createTransformAnimationCurve() override;
+  blink::WebTransformOperations* createTransformOperations() override;
+  blink::WebFilterOperations* createFilterOperations() override;
 
-  virtual blink::WebCompositorAnimationPlayer* createAnimationPlayer();
-  virtual blink::WebCompositorAnimationTimeline* createAnimationTimeline();
+  blink::WebCompositorAnimationPlayer* createAnimationPlayer() override;
+  blink::WebCompositorAnimationTimeline* createAnimationTimeline() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WebCompositorSupportImpl);
diff --git a/cc/blink/web_content_layer_impl.h b/cc/blink/web_content_layer_impl.h
index 6d118d5..fb0fcb7 100644
--- a/cc/blink/web_content_layer_impl.h
+++ b/cc/blink/web_content_layer_impl.h
@@ -28,11 +28,11 @@ class WebContentLayerImpl : public blink::WebContentLayer,
   CC_BLINK_EXPORT explicit WebContentLayerImpl(blink::WebContentLayerClient*);
 
   // WebContentLayer implementation.
-  virtual blink::WebLayer* layer();
-  virtual void setDoubleSided(bool double_sided);
+  blink::WebLayer* layer() override;
+  void setDoubleSided(bool double_sided) override;
 
  protected:
-  virtual ~WebContentLayerImpl();
+  ~WebContentLayerImpl() override;
 
   // ContentLayerClient implementation.
   void PaintContents(SkCanvas* canvas,
diff --git a/cc/blink/web_display_item_list_impl.h b/cc/blink/web_display_item_list_impl.h
index d45d7d3..438bee0 100644
--- a/cc/blink/web_display_item_list_impl.h
+++ b/cc/blink/web_display_item_list_impl.h
@@ -38,33 +38,33 @@ class WebDisplayItemListImpl : public blink::WebDisplayItemList {
   CC_BLINK_EXPORT WebDisplayItemListImpl();
   CC_BLINK_EXPORT explicit WebDisplayItemListImpl(
       cc::DisplayItemList* display_list);
-  virtual ~WebDisplayItemListImpl();
+  ~WebDisplayItemListImpl() override;
 
   // blink::WebDisplayItemList implementation.
-  virtual void appendDrawingItem(const SkPicture*);
-  virtual void appendClipItem(
+  void appendDrawingItem(const SkPicture*) override;
+  void appendClipItem(
       const blink::WebRect& clip_rect,
-      const blink::WebVector<SkRRect>& rounded_clip_rects);
-  virtual void appendEndClipItem();
-  virtual void appendClipPathItem(const SkPath& clip_path,
-                                  SkRegion::Op clip_op,
-                                  bool antialias);
-  virtual void appendEndClipPathItem();
-  virtual void appendFloatClipItem(const blink::WebFloatRect& clip_rect);
-  virtual void appendEndFloatClipItem();
-  virtual void appendTransformItem(const SkMatrix44& matrix);
-  virtual void appendEndTransformItem();
-  virtual void appendCompositingItem(float opacity,
-                                     SkXfermode::Mode,
-                                     SkRect* bounds,
-                                     SkColorFilter*);
-  virtual void appendEndCompositingItem();
-  virtual void appendFilterItem(const blink::WebFilterOperations& filters,
-                                const blink::WebFloatRect& bounds);
-  virtual void appendEndFilterItem();
-  virtual void appendScrollItem(const blink::WebSize& scrollOffset,
-                                ScrollContainerId);
-  virtual void appendEndScrollItem();
+      const blink::WebVector<SkRRect>& rounded_clip_rects) override;
+  void appendEndClipItem() override;
+  void appendClipPathItem(const SkPath& clip_path,
+                          SkRegion::Op clip_op,
+                          bool antialias) override;
+  void appendEndClipPathItem() override;
+  void appendFloatClipItem(const blink::WebFloatRect& clip_rect) override;
+  void appendEndFloatClipItem() override;
+  void appendTransformItem(const SkMatrix44& matrix) override;
+  void appendEndTransformItem() override;
+  void appendCompositingItem(float opacity,
+                             SkXfermode::Mode,
+                             SkRect* bounds,
+                             SkColorFilter*) override;
+  void appendEndCompositingItem() override;
+  void appendFilterItem(const blink::WebFilterOperations& filters,
+                        const blink::WebFloatRect& bounds) override;
+  void appendEndFilterItem() override;
+  void appendScrollItem(const blink::WebSize& scrollOffset,
+                        ScrollContainerId) override;
+  void appendEndScrollItem() override;
 
  private:
   scoped_refptr<cc::DisplayItemList> display_item_list_;
diff --git a/cc/blink/web_external_texture_layer_impl.h b/cc/blink/web_external_texture_layer_impl.h
index fc14429..5425ae5 100644
--- a/cc/blink/web_external_texture_layer_impl.h
+++ b/cc/blink/web_external_texture_layer_impl.h
@@ -35,15 +35,15 @@ class WebExternalTextureLayerImpl
  public:
   CC_BLINK_EXPORT explicit WebExternalTextureLayerImpl(
       blink::WebExternalTextureLayerClient*);
-  virtual ~WebExternalTextureLayerImpl();
+  ~WebExternalTextureLayerImpl() override;
 
   // blink::WebExternalTextureLayer implementation.
-  virtual blink::WebLayer* layer();
-  virtual void clearTexture();
-  virtual void setOpaque(bool opaque);
-  virtual void setPremultipliedAlpha(bool premultiplied);
-  virtual void setBlendBackgroundColor(bool blend);
-  virtual void setNearestNeighbor(bool nearest_neighbor);
+  blink::WebLayer* layer() override;
+  void clearTexture() override;
+  void setOpaque(bool opaque) override;
+  void setPremultipliedAlpha(bool premultiplied) override;
+  void setBlendBackgroundColor(bool blend) override;
+  void setNearestNeighbor(bool nearest_neighbor) override;
 
   // TextureLayerClient implementation.
   bool PrepareTextureMailbox(
diff --git a/cc/blink/web_filter_animation_curve_impl.h b/cc/blink/web_filter_animation_curve_impl.h
index 93dae4e..e922ccb 100644
--- a/cc/blink/web_filter_animation_curve_impl.h
+++ b/cc/blink/web_filter_animation_curve_impl.h
@@ -23,30 +23,30 @@ namespace cc_blink {
 class WebFilterAnimationCurveImpl : public blink::WebFilterAnimationCurve {
  public:
   CC_BLINK_EXPORT WebFilterAnimationCurveImpl();
-  virtual ~WebFilterAnimationCurveImpl();
+  ~WebFilterAnimationCurveImpl() override;
 
   // blink::WebCompositorAnimationCurve implementation.
-  virtual AnimationCurveType type() const;
+  AnimationCurveType type() const override;
 
   // blink::WebFilterAnimationCurve implementation.
-  virtual void add(const blink::WebFilterKeyframe& keyframe,
-                   TimingFunctionType type);
-  virtual void add(const blink::WebFilterKeyframe& keyframe,
-                   double x1,
-                   double y1,
-                   double x2,
-                   double y2);
-  virtual void add(const blink::WebFilterKeyframe& keyframe,
-                   int steps,
-                   float steps_start_offset);
-  virtual void setLinearTimingFunction();
-  virtual void setCubicBezierTimingFunction(TimingFunctionType);
-  virtual void setCubicBezierTimingFunction(double x1,
-                                            double y1,
-                                            double x2,
-                                            double y2);
-  virtual void setStepsTimingFunction(int number_of_steps,
-                                      float steps_start_offset);
+  void add(const blink::WebFilterKeyframe& keyframe,
+           TimingFunctionType type) override;
+  void add(const blink::WebFilterKeyframe& keyframe,
+           double x1,
+           double y1,
+           double x2,
+           double y2) override;
+  void add(const blink::WebFilterKeyframe& keyframe,
+           int steps,
+           float steps_start_offset) override;
+  void setLinearTimingFunction() override;
+  void setCubicBezierTimingFunction(TimingFunctionType) override;
+  void setCubicBezierTimingFunction(double x1,
+                                    double y1,
+                                    double x2,
+                                    double y2) override;
+  void setStepsTimingFunction(int number_of_steps,
+                              float steps_start_offset) override;
 
   scoped_ptr<cc::AnimationCurve> CloneToAnimationCurve() const;
 
diff --git a/cc/blink/web_filter_operations_impl.h b/cc/blink/web_filter_operations_impl.h
index 36c3b45..d1746ce 100644
--- a/cc/blink/web_filter_operations_impl.h
+++ b/cc/blink/web_filter_operations_impl.h
@@ -14,30 +14,30 @@ namespace cc_blink {
 class WebFilterOperationsImpl : public blink::WebFilterOperations {
  public:
   CC_BLINK_EXPORT WebFilterOperationsImpl();
-  virtual ~WebFilterOperationsImpl();
+  ~WebFilterOperationsImpl() override;
 
   const cc::FilterOperations& AsFilterOperations() const;
 
   // Implementation of blink::WebFilterOperations methods
-  virtual void appendGrayscaleFilter(float amount);
-  virtual void appendSepiaFilter(float amount);
-  virtual void appendSaturateFilter(float amount);
-  virtual void appendHueRotateFilter(float amount);
-  virtual void appendInvertFilter(float amount);
-  virtual void appendBrightnessFilter(float amount);
-  virtual void appendContrastFilter(float amount);
-  virtual void appendOpacityFilter(float amount);
-  virtual void appendBlurFilter(float amount);
-  virtual void appendDropShadowFilter(blink::WebPoint offset,
-                                      float std_deviation,
-                                      blink::WebColor color);
-  virtual void appendColorMatrixFilter(SkScalar matrix[20]);
-  virtual void appendZoomFilter(float amount, int inset);
-  virtual void appendSaturatingBrightnessFilter(float amount);
-  virtual void appendReferenceFilter(SkImageFilter* image_filter);
-
-  virtual void clear();
-  virtual bool isEmpty() const;
+  void appendGrayscaleFilter(float amount) override;
+  void appendSepiaFilter(float amount) override;
+  void appendSaturateFilter(float amount) override;
+  void appendHueRotateFilter(float amount) override;
+  void appendInvertFilter(float amount) override;
+  void appendBrightnessFilter(float amount) override;
+  void appendContrastFilter(float amount) override;
+  void appendOpacityFilter(float amount) override;
+  void appendBlurFilter(float amount) override;
+  void appendDropShadowFilter(blink::WebPoint offset,
+                              float std_deviation,
+                              blink::WebColor color) override;
+  void appendColorMatrixFilter(SkScalar matrix[20]) override;
+  void appendZoomFilter(float amount, int inset) override;
+  void appendSaturatingBrightnessFilter(float amount) override;
+  void appendReferenceFilter(SkImageFilter* image_filter) override;
+
+  void clear() override;
+  bool isEmpty() const override;
 
  private:
   cc::FilterOperations filter_operations_;
diff --git a/cc/blink/web_float_animation_curve_impl.h b/cc/blink/web_float_animation_curve_impl.h
index b5a97aa..42bab59 100644
--- a/cc/blink/web_float_animation_curve_impl.h
+++ b/cc/blink/web_float_animation_curve_impl.h
@@ -23,33 +23,33 @@ namespace cc_blink {
 class WebFloatAnimationCurveImpl : public blink::WebFloatAnimationCurve {
  public:
   CC_BLINK_EXPORT WebFloatAnimationCurveImpl();
-  virtual ~WebFloatAnimationCurveImpl();
+  ~WebFloatAnimationCurveImpl() override;
 
   // WebCompositorAnimationCurve implementation.
-  virtual AnimationCurveType type() const;
+  AnimationCurveType type() const override;
 
   // WebFloatAnimationCurve implementation.
-  virtual void add(const blink::WebFloatKeyframe& keyframe);
-  virtual void add(const blink::WebFloatKeyframe& keyframe,
-                   TimingFunctionType type);
-  virtual void add(const blink::WebFloatKeyframe& keyframe,
-                   double x1,
-                   double y1,
-                   double x2,
-                   double y2);
-  virtual void add(const blink::WebFloatKeyframe& keyframe,
-                   int steps,
-                   float steps_start_offset);
-  virtual void setLinearTimingFunction();
-  virtual void setCubicBezierTimingFunction(TimingFunctionType);
-  virtual void setCubicBezierTimingFunction(double x1,
-                                            double y1,
-                                            double x2,
-                                            double y2);
-  virtual void setStepsTimingFunction(int number_of_steps,
-                                      float steps_start_offset);
+  void add(const blink::WebFloatKeyframe& keyframe) override;
+  void add(const blink::WebFloatKeyframe& keyframe,
+           TimingFunctionType type) override;
+  void add(const blink::WebFloatKeyframe& keyframe,
+           double x1,
+           double y1,
+           double x2,
+           double y2) override;
+  void add(const blink::WebFloatKeyframe& keyframe,
+           int steps,
+           float steps_start_offset) override;
+  void setLinearTimingFunction() override;
+  void setCubicBezierTimingFunction(TimingFunctionType) override;
+  void setCubicBezierTimingFunction(double x1,
+                                    double y1,
+                                    double x2,
+                                    double y2) override;
+  void setStepsTimingFunction(int number_of_steps,
+                              float steps_start_offset) override;
 
-  virtual float getValue(double time) const;
+  float getValue(double time) const override;
 
   scoped_ptr<cc::AnimationCurve> CloneToAnimationCurve() const;
 
diff --git a/cc/blink/web_image_layer_impl.h b/cc/blink/web_image_layer_impl.h
index 5e3749f..74a8e76 100644
--- a/cc/blink/web_image_layer_impl.h
+++ b/cc/blink/web_image_layer_impl.h
@@ -16,12 +16,12 @@ class WebLayerImpl;
 class WebImageLayerImpl : public blink::WebImageLayer {
  public:
   CC_BLINK_EXPORT WebImageLayerImpl();
-  virtual ~WebImageLayerImpl();
+  ~WebImageLayerImpl() override;
 
   // blink::WebImageLayer implementation.
-  virtual blink::WebLayer* layer();
-  virtual void setImage(const SkImage* image);
-  virtual void setNearestNeighbor(bool nearest_neighbor);
+  blink::WebLayer* layer() override;
+  void setImage(const SkImage* image) override;
+  void setNearestNeighbor(bool nearest_neighbor) override;
 
  private:
   scoped_ptr<WebLayerImpl> layer_;
diff --git a/cc/blink/web_layer_impl.h b/cc/blink/web_layer_impl.h
index ea87fec..44ef02e 100644
--- a/cc/blink/web_layer_impl.h
+++ b/cc/blink/web_layer_impl.h
@@ -50,7 +50,7 @@ class WebLayerImpl : public blink::WebLayer, public cc::LayerClient {
  public:
   CC_BLINK_EXPORT WebLayerImpl();
   CC_BLINK_EXPORT explicit WebLayerImpl(scoped_refptr<cc::Layer>);
-  virtual ~WebLayerImpl();
+  ~WebLayerImpl() override;
 
   CC_BLINK_EXPORT static void SetLayerSettings(
       const cc::LayerSettings& settings);
@@ -64,94 +64,95 @@ class WebLayerImpl : public blink::WebLayer, public cc::LayerClient {
   CC_BLINK_EXPORT void SetContentsOpaqueIsFixed(bool fixed);
 
   // WebLayer implementation.
-  virtual int id() const;
-  virtual void invalidateRect(const blink::WebRect&);
-  virtual void invalidate();
-  virtual void addChild(blink::WebLayer* child);
-  virtual void insertChild(blink::WebLayer* child, size_t index);
-  virtual void replaceChild(blink::WebLayer* reference,
-                            blink::WebLayer* new_layer);
-  virtual void removeFromParent();
-  virtual void removeAllChildren();
-  virtual void setBounds(const blink::WebSize& bounds);
-  virtual blink::WebSize bounds() const;
-  virtual void setMasksToBounds(bool masks_to_bounds);
-  virtual bool masksToBounds() const;
-  virtual void setMaskLayer(blink::WebLayer* mask);
-  virtual void setReplicaLayer(blink::WebLayer* replica);
-  virtual void setOpacity(float opacity);
-  virtual float opacity() const;
-  virtual void setBlendMode(blink::WebBlendMode blend_mode);
-  virtual blink::WebBlendMode blendMode() const;
-  virtual void setIsRootForIsolatedGroup(bool root);
-  virtual bool isRootForIsolatedGroup();
-  virtual void setOpaque(bool opaque);
-  virtual bool opaque() const;
-  virtual void setPosition(const blink::WebFloatPoint& position);
-  virtual blink::WebFloatPoint position() const;
-  virtual void setTransform(const SkMatrix44& transform);
-  virtual void setTransformOrigin(const blink::WebFloatPoint3D& point);
-  virtual blink::WebFloatPoint3D transformOrigin() const;
-  virtual SkMatrix44 transform() const;
-  virtual void setDrawsContent(bool draws_content);
-  virtual bool drawsContent() const;
-  virtual void setShouldFlattenTransform(bool flatten);
-  virtual void setRenderingContext(int context);
-  virtual void setUseParentBackfaceVisibility(bool visible);
-  virtual void setBackgroundColor(blink::WebColor color);
-  virtual blink::WebColor backgroundColor() const;
-  virtual void setFilters(const blink::WebFilterOperations& filters);
-  virtual void setBackgroundFilters(const blink::WebFilterOperations& filters);
-  virtual void setAnimationDelegate(
-      blink::WebCompositorAnimationDelegate* delegate);
-  virtual bool addAnimation(blink::WebCompositorAnimation* animation);
-  virtual void removeAnimation(int animation_id);
-  virtual void removeAnimation(int animation_id,
-                               blink::WebCompositorAnimation::TargetProperty);
-  virtual void pauseAnimation(int animation_id, double time_offset);
-  virtual bool hasActiveAnimation();
-  virtual void setForceRenderSurface(bool force);
-  virtual void setScrollPositionDouble(blink::WebDoublePoint position);
-  virtual blink::WebDoublePoint scrollPositionDouble() const;
-  virtual void setScrollCompensationAdjustment(blink::WebDoublePoint position);
-  virtual void setScrollClipLayer(blink::WebLayer* clip_layer);
-  virtual bool scrollable() const;
-  virtual void setUserScrollable(bool horizontal, bool vertical);
-  virtual bool userScrollableHorizontal() const;
-  virtual bool userScrollableVertical() const;
-  virtual void setHaveWheelEventHandlers(bool have_wheel_event_handlers);
-  virtual bool haveWheelEventHandlers() const;
-  virtual void setHaveScrollEventHandlers(bool have_scroll_event_handlers);
-  virtual bool haveScrollEventHandlers() const;
-  virtual void setShouldScrollOnMainThread(bool scroll_on_main);
-  virtual bool shouldScrollOnMainThread() const;
-  virtual void setNonFastScrollableRegion(
-      const blink::WebVector<blink::WebRect>& region);
-  virtual blink::WebVector<blink::WebRect> nonFastScrollableRegion() const;
-  virtual void setTouchEventHandlerRegion(
-      const blink::WebVector<blink::WebRect>& region);
-  virtual blink::WebVector<blink::WebRect> touchEventHandlerRegion() const;
-  virtual void setScrollBlocksOn(blink::WebScrollBlocksOn);
-  virtual blink::WebScrollBlocksOn scrollBlocksOn() const;
-  virtual void setFrameTimingRequests(
-      const blink::WebVector<std::pair<int64_t, blink::WebRect>>& requests);
-  virtual blink::WebVector<std::pair<int64_t, blink::WebRect>>
-  frameTimingRequests() const;
-  virtual void setIsContainerForFixedPositionLayers(bool is_container);
-  virtual bool isContainerForFixedPositionLayers() const;
-  virtual void setPositionConstraint(
-      const blink::WebLayerPositionConstraint& constraint);
-  virtual blink::WebLayerPositionConstraint positionConstraint() const;
-  virtual void setScrollClient(blink::WebLayerScrollClient* client);
-  virtual bool isOrphan() const;
-  virtual void setWebLayerClient(blink::WebLayerClient* client);
+  int id() const override;
+  void invalidateRect(const blink::WebRect&) override;
+  void invalidate() override;
+  void addChild(blink::WebLayer* child) override;
+  void insertChild(blink::WebLayer* child, size_t index) override;
+  void replaceChild(blink::WebLayer* reference,
+                    blink::WebLayer* new_layer) override;
+  void removeFromParent() override;
+  void removeAllChildren() override;
+  void setBounds(const blink::WebSize& bounds) override;
+  blink::WebSize bounds() const override;
+  void setMasksToBounds(bool masks_to_bounds) override;
+  bool masksToBounds() const override;
+  void setMaskLayer(blink::WebLayer* mask) override;
+  void setReplicaLayer(blink::WebLayer* replica) override;
+  void setOpacity(float opacity) override;
+  float opacity() const override;
+  void setBlendMode(blink::WebBlendMode blend_mode) override;
+  blink::WebBlendMode blendMode() const override;
+  void setIsRootForIsolatedGroup(bool root) override;
+  bool isRootForIsolatedGroup() override;
+  void setOpaque(bool opaque) override;
+  bool opaque() const override;
+  void setPosition(const blink::WebFloatPoint& position) override;
+  blink::WebFloatPoint position() const override;
+  void setTransform(const SkMatrix44& transform) override;
+  void setTransformOrigin(const blink::WebFloatPoint3D& point) override;
+  blink::WebFloatPoint3D transformOrigin() const override;
+  SkMatrix44 transform() const override;
+  void setDrawsContent(bool draws_content) override;
+  bool drawsContent() const override;
+  void setShouldFlattenTransform(bool flatten) override;
+  void setRenderingContext(int context) override;
+  void setUseParentBackfaceVisibility(bool visible) override;
+  void setBackgroundColor(blink::WebColor color) override;
+  blink::WebColor backgroundColor() const override;
+  void setFilters(const blink::WebFilterOperations& filters) override;
+  void setBackgroundFilters(const blink::WebFilterOperations& filters) override;
+  void setAnimationDelegate(
+      blink::WebCompositorAnimationDelegate* delegate) override;
+  bool addAnimation(blink::WebCompositorAnimation* animation) override;
+  void removeAnimation(int animation_id) override;
+  void removeAnimation(int animation_id,
+                       blink::WebCompositorAnimation::TargetProperty) override;
+  void pauseAnimation(int animation_id, double time_offset) override;
+  bool hasActiveAnimation() override;
+  void setForceRenderSurface(bool force) override;
+  void setScrollPositionDouble(blink::WebDoublePoint position) override;
+  blink::WebDoublePoint scrollPositionDouble() const override;
+  void setScrollCompensationAdjustment(blink::WebDoublePoint position) override;
+  void setScrollClipLayer(blink::WebLayer* clip_layer) override;
+  bool scrollable() const override;
+  void setUserScrollable(bool horizontal, bool vertical) override;
+  bool userScrollableHorizontal() const override;
+  bool userScrollableVertical() const override;
+  void setHaveWheelEventHandlers(bool have_wheel_event_handlers) override;
+  bool haveWheelEventHandlers() const override;
+  void setHaveScrollEventHandlers(bool have_scroll_event_handlers) override;
+  bool haveScrollEventHandlers() const override;
+  void setShouldScrollOnMainThread(bool scroll_on_main) override;
+  bool shouldScrollOnMainThread() const override;
+  void setNonFastScrollableRegion(
+      const blink::WebVector<blink::WebRect>& region) override;
+  blink::WebVector<blink::WebRect> nonFastScrollableRegion() const override;
+  void setTouchEventHandlerRegion(
+      const blink::WebVector<blink::WebRect>& region) override;
+  blink::WebVector<blink::WebRect> touchEventHandlerRegion() const override;
+  void setScrollBlocksOn(blink::WebScrollBlocksOn) override;
+  blink::WebScrollBlocksOn scrollBlocksOn() const override;
+  void setFrameTimingRequests(
+      const blink::WebVector<std::pair<int64_t, blink::WebRect>>& requests)
+      override;
+  blink::WebVector<std::pair<int64_t, blink::WebRect>> frameTimingRequests()
+      const override;
+  void setIsContainerForFixedPositionLayers(bool is_container) override;
+  bool isContainerForFixedPositionLayers() const override;
+  void setPositionConstraint(
+      const blink::WebLayerPositionConstraint& constraint) override;
+  blink::WebLayerPositionConstraint positionConstraint() const override;
+  void setScrollClient(blink::WebLayerScrollClient* client) override;
+  bool isOrphan() const override;
+  void setWebLayerClient(blink::WebLayerClient* client) override;
 
   // LayerClient implementation.
   scoped_refptr<base::trace_event::ConvertableToTraceFormat> TakeDebugInfo()
       override;
 
-  virtual void setScrollParent(blink::WebLayer* parent);
-  virtual void setClipParent(blink::WebLayer* parent);
+  void setScrollParent(blink::WebLayer* parent) override;
+  void setClipParent(blink::WebLayer* parent) override;
 
  protected:
   scoped_refptr<cc::Layer> layer_;
diff --git a/cc/blink/web_layer_impl_fixed_bounds.h b/cc/blink/web_layer_impl_fixed_bounds.h
index edfd4bb..3289245 100644
--- a/cc/blink/web_layer_impl_fixed_bounds.h
+++ b/cc/blink/web_layer_impl_fixed_bounds.h
@@ -21,7 +21,7 @@ class WebLayerImplFixedBounds : public WebLayerImpl {
   CC_BLINK_EXPORT WebLayerImplFixedBounds();
   CC_BLINK_EXPORT explicit WebLayerImplFixedBounds(
       scoped_refptr<cc::Layer> layer);
-  virtual ~WebLayerImplFixedBounds();
+  ~WebLayerImplFixedBounds() override;
 
   // WebLayerImpl overrides.
   void invalidateRect(const blink::WebRect& rect) override;
diff --git a/cc/blink/web_scroll_offset_animation_curve_impl.h b/cc/blink/web_scroll_offset_animation_curve_impl.h
index 5f914b9..11a1635 100644
--- a/cc/blink/web_scroll_offset_animation_curve_impl.h
+++ b/cc/blink/web_scroll_offset_animation_curve_impl.h
@@ -22,15 +22,16 @@ class WebScrollOffsetAnimationCurveImpl
   CC_BLINK_EXPORT WebScrollOffsetAnimationCurveImpl(
       blink::WebFloatPoint target_value,
       TimingFunctionType timing_function);
-  virtual ~WebScrollOffsetAnimationCurveImpl();
+  ~WebScrollOffsetAnimationCurveImpl() override;
 
   // blink::WebCompositorAnimationCurve implementation.
-  virtual AnimationCurveType type() const;
+  AnimationCurveType type() const override;
 
   // blink::WebScrollOffsetAnimationCurve implementation.
-  virtual void setInitialValue(blink::WebFloatPoint initial_value);
-  virtual blink::WebFloatPoint getValue(double time) const;
-  virtual double duration() const;
+  void setInitialValue(blink::WebFloatPoint initial_value) override;
+  blink::WebFloatPoint getValue(double time) const override;
+  double duration() const override;
+
   virtual blink::WebFloatPoint targetValue() const;
   virtual void updateTarget(double time, blink::WebFloatPoint new_target);
 
diff --git a/cc/blink/web_scrollbar_layer_impl.h b/cc/blink/web_scrollbar_layer_impl.h
index 14ed66e..d4963d9 100644
--- a/cc/blink/web_scrollbar_layer_impl.h
+++ b/cc/blink/web_scrollbar_layer_impl.h
@@ -30,12 +30,12 @@ class WebScrollbarLayerImpl : public blink::WebScrollbarLayer {
       int thumb_thickness,
       int track_start,
       bool is_left_side_vertical_scrollbar);
-  virtual ~WebScrollbarLayerImpl();
+  ~WebScrollbarLayerImpl() override;
 
   // blink::WebScrollbarLayer implementation.
-  virtual blink::WebLayer* layer();
-  virtual void setScrollLayer(blink::WebLayer* layer);
-  virtual void setClipLayer(blink::WebLayer* layer);
+  blink::WebLayer* layer() override;
+  void setScrollLayer(blink::WebLayer* layer) override;
+  void setClipLayer(blink::WebLayer* layer) override;
 
  private:
   scoped_ptr<WebLayerImpl> layer_;
diff --git a/cc/blink/web_transform_animation_curve_impl.h b/cc/blink/web_transform_animation_curve_impl.h
index 81ed607..9143d3c 100644
--- a/cc/blink/web_transform_animation_curve_impl.h
+++ b/cc/blink/web_transform_animation_curve_impl.h
@@ -24,31 +24,31 @@ class WebTransformAnimationCurveImpl
     : public blink::WebTransformAnimationCurve {
  public:
   CC_BLINK_EXPORT WebTransformAnimationCurveImpl();
-  virtual ~WebTransformAnimationCurveImpl();
+  ~WebTransformAnimationCurveImpl() override;
 
   // blink::WebCompositorAnimationCurve implementation.
-  virtual AnimationCurveType type() const;
+  AnimationCurveType type() const override;
 
   // blink::WebTransformAnimationCurve implementation.
-  virtual void add(const blink::WebTransformKeyframe& keyframe);
-  virtual void add(const blink::WebTransformKeyframe& keyframe,
-                   TimingFunctionType type);
-  virtual void add(const blink::WebTransformKeyframe& keyframe,
-                   double x1,
-                   double y1,
-                   double x2,
-                   double y2);
-  virtual void add(const blink::WebTransformKeyframe& keyframe,
-                   int steps,
-                   float stepsStartOffset);
-  virtual void setLinearTimingFunction();
-  virtual void setCubicBezierTimingFunction(TimingFunctionType);
-  virtual void setCubicBezierTimingFunction(double x1,
-                                            double y1,
-                                            double x2,
-                                            double y2);
-  virtual void setStepsTimingFunction(int number_of_steps,
-                                      float steps_start_offset);
+  void add(const blink::WebTransformKeyframe& keyframe) override;
+  void add(const blink::WebTransformKeyframe& keyframe,
+           TimingFunctionType type) override;
+  void add(const blink::WebTransformKeyframe& keyframe,
+           double x1,
+           double y1,
+           double x2,
+           double y2) override;
+  void add(const blink::WebTransformKeyframe& keyframe,
+           int steps,
+           float stepsStartOffset) override;
+  void setLinearTimingFunction() override;
+  void setCubicBezierTimingFunction(TimingFunctionType) override;
+  void setCubicBezierTimingFunction(double x1,
+                                    double y1,
+                                    double x2,
+                                    double y2) override;
+  void setStepsTimingFunction(int number_of_steps,
+                              float steps_start_offset) override;
 
   scoped_ptr<cc::AnimationCurve> CloneToAnimationCurve() const;
 
diff --git a/cc/blink/web_transform_operations_impl.h b/cc/blink/web_transform_operations_impl.h
index 0c91e06..f8fe22b 100644
--- a/cc/blink/web_transform_operations_impl.h
+++ b/cc/blink/web_transform_operations_impl.h
@@ -15,20 +15,20 @@ namespace cc_blink {
 class WebTransformOperationsImpl : public blink::WebTransformOperations {
  public:
   CC_BLINK_EXPORT WebTransformOperationsImpl();
-  virtual ~WebTransformOperationsImpl();
+  ~WebTransformOperationsImpl() override;
 
   const cc::TransformOperations& AsTransformOperations() const;
 
   // Implementation of blink::WebTransformOperations methods
-  virtual bool canBlendWith(const blink::WebTransformOperations& other) const;
-  virtual void appendTranslate(double x, double y, double z);
-  virtual void appendRotate(double x, double y, double z, double degrees);
-  virtual void appendScale(double x, double y, double z);
-  virtual void appendSkew(double x, double y);
-  virtual void appendPerspective(double depth);
-  virtual void appendMatrix(const SkMatrix44&);
-  virtual void appendIdentity();
-  virtual bool isIdentity() const;
+  bool canBlendWith(const blink::WebTransformOperations& other) const override;
+  void appendTranslate(double x, double y, double z) override;
+  void appendRotate(double x, double y, double z, double degrees) override;
+  void appendScale(double x, double y, double z) override;
+  void appendSkew(double x, double y) override;
+  void appendPerspective(double depth) override;
+  void appendMatrix(const SkMatrix44&) override;
+  void appendIdentity() override;
+  bool isIdentity() const override;
 
  private:
   cc::TransformOperations transform_operations_;