replace OVERRIDE and FINAL with override and final in cc/

BUG=417463

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

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

219 files changed, 2270 insertions, 2233 deletions

diff --git a/cc/PRESUBMIT.py b/cc/PRESUBMIT.py
index f381684..d749aac 100644
--- a/cc/PRESUBMIT.py
+++ b/cc/PRESUBMIT.py
@@ -313,6 +313,42 @@ def CheckForUseOfWrongClock(input_api,
   else:
     return []
 
+def CheckOverrideFinal(input_api, output_api,
+                       whitelist=CC_SOURCE_FILES, blacklist=None):
+  """Make sure new lines of code don't use the OVERRIDE or FINAL macros."""
+
+  # TODO(mostynb): remove this check once the macros are removed
+  # from base/compiler_specific.h.
+
+  errors = []
+
+  source_file_filter = lambda x: input_api.FilterSourceFile(
+    x, white_list=CC_SOURCE_FILES, black_list=None)
+
+  override_files = []
+  final_files = []
+
+  for f in input_api.AffectedSourceFiles(source_file_filter):
+    contents = input_api.ReadFile(f, 'rb')
+
+    # "override" and "final" should be used instead of OVERRIDE/FINAL now.
+    if re.search(r"\bOVERRIDE\b", contents):
+      override_files.append(f.LocalPath())
+
+    if re.search(r"\bFINAL\b", contents):
+      final_files.append(f.LocalPath())
+
+  if override_files:
+    return [output_api.PresubmitError(
+      'These files use OVERRIDE instead of using override:',
+      items=override_files)]
+  if final_files:
+    return [output_api.PresubmitError(
+      'These files use FINAL instead of using final:',
+      items=final_files)]
+
+  return []
+
 def CheckChangeOnUpload(input_api, output_api):
   results = []
   results += CheckAsserts(input_api, output_api)
@@ -324,6 +360,7 @@ def CheckChangeOnUpload(input_api, output_api):
   results += CheckNamespace(input_api, output_api)
   results += CheckForUseOfWrongClock(input_api, output_api)
   results += FindUselessIfdefs(input_api, output_api)
+  results += CheckOverrideFinal(input_api, output_api)
   results += input_api.canned_checks.CheckPatchFormatted(input_api, output_api)
   return results
 
diff --git a/cc/animation/animation_curve.h b/cc/animation/animation_curve.h
index 72aadef..ca53e44 100644
--- a/cc/animation/animation_curve.h
+++ b/cc/animation/animation_curve.h
@@ -50,7 +50,7 @@ class CC_EXPORT ColorAnimationCurve : public AnimationCurve {
   virtual SkColor GetValue(double t) const = 0;
 
   // Partial Animation implementation.
-  virtual CurveType Type() const OVERRIDE;
+  virtual CurveType Type() const override;
 };
 
 class CC_EXPORT FloatAnimationCurve : public AnimationCurve {
@@ -60,7 +60,7 @@ class CC_EXPORT FloatAnimationCurve : public AnimationCurve {
   virtual float GetValue(double t) const = 0;
 
   // Partial Animation implementation.
-  virtual CurveType Type() const OVERRIDE;
+  virtual CurveType Type() const override;
 };
 
 class CC_EXPORT TransformAnimationCurve : public AnimationCurve {
@@ -86,7 +86,7 @@ class CC_EXPORT TransformAnimationCurve : public AnimationCurve {
   virtual bool MaximumScale(float* max_scale) const = 0;
 
   // Partial Animation implementation.
-  virtual CurveType Type() const OVERRIDE;
+  virtual CurveType Type() const override;
 };
 
 class CC_EXPORT FilterAnimationCurve : public AnimationCurve {
@@ -97,7 +97,7 @@ class CC_EXPORT FilterAnimationCurve : public AnimationCurve {
   virtual bool HasFilterThatMovesPixels() const = 0;
 
   // Partial Animation implementation.
-  virtual CurveType Type() const OVERRIDE;
+  virtual CurveType Type() const override;
 };
 
 }  // namespace cc
diff --git a/cc/animation/keyframed_animation_curve.h b/cc/animation/keyframed_animation_curve.h
index 2fb1888..d596256 100644
--- a/cc/animation/keyframed_animation_curve.h
+++ b/cc/animation/keyframed_animation_curve.h
@@ -126,11 +126,11 @@ class CC_EXPORT KeyframedColorAnimationCurve : public ColorAnimationCurve {
   }
 
   // AnimationCurve implementation
-  virtual double Duration() const OVERRIDE;
-  virtual scoped_ptr<AnimationCurve> Clone() const OVERRIDE;
+  virtual double Duration() const override;
+  virtual scoped_ptr<AnimationCurve> Clone() const override;
 
   // BackgrounColorAnimationCurve implementation
-  virtual SkColor GetValue(double t) const OVERRIDE;
+  virtual SkColor GetValue(double t) const override;
 
  private:
   KeyframedColorAnimationCurve();
@@ -156,11 +156,11 @@ class CC_EXPORT KeyframedFloatAnimationCurve : public FloatAnimationCurve {
   }
 
   // AnimationCurve implementation
-  virtual double Duration() const OVERRIDE;
-  virtual scoped_ptr<AnimationCurve> Clone() const OVERRIDE;
+  virtual double Duration() const override;
+  virtual scoped_ptr<AnimationCurve> Clone() const override;
 
   // FloatAnimationCurve implementation
-  virtual float GetValue(double t) const OVERRIDE;
+  virtual float GetValue(double t) const override;
 
  private:
   KeyframedFloatAnimationCurve();
@@ -187,16 +187,16 @@ class CC_EXPORT KeyframedTransformAnimationCurve
   }
 
   // AnimationCurve implementation
-  virtual double Duration() const OVERRIDE;
-  virtual scoped_ptr<AnimationCurve> Clone() const OVERRIDE;
+  virtual double Duration() const override;
+  virtual scoped_ptr<AnimationCurve> Clone() const override;
 
   // TransformAnimationCurve implementation
-  virtual gfx::Transform GetValue(double t) const OVERRIDE;
+  virtual gfx::Transform GetValue(double t) const override;
   virtual bool AnimatedBoundsForBox(const gfx::BoxF& box,
-                                    gfx::BoxF* bounds) const OVERRIDE;
-  virtual bool AffectsScale() const OVERRIDE;
-  virtual bool IsTranslation() const OVERRIDE;
-  virtual bool MaximumScale(float* max_scale) const OVERRIDE;
+                                    gfx::BoxF* bounds) const override;
+  virtual bool AffectsScale() const override;
+  virtual bool IsTranslation() const override;
+  virtual bool MaximumScale(float* max_scale) const override;
 
  private:
   KeyframedTransformAnimationCurve();
@@ -223,12 +223,12 @@ class CC_EXPORT KeyframedFilterAnimationCurve
   }
 
   // AnimationCurve implementation
-  virtual double Duration() const OVERRIDE;
-  virtual scoped_ptr<AnimationCurve> Clone() const OVERRIDE;
+  virtual double Duration() const override;
+  virtual scoped_ptr<AnimationCurve> Clone() const override;
 
   // FilterAnimationCurve implementation
-  virtual FilterOperations GetValue(double t) const OVERRIDE;
-  virtual bool HasFilterThatMovesPixels() const OVERRIDE;
+  virtual FilterOperations GetValue(double t) const override;
+  virtual bool HasFilterThatMovesPixels() const override;
 
  private:
   KeyframedFilterAnimationCurve();
diff --git a/cc/animation/layer_animation_controller_unittest.cc b/cc/animation/layer_animation_controller_unittest.cc
index d32751b..de21762 100644
--- a/cc/animation/layer_animation_controller_unittest.cc
+++ b/cc/animation/layer_animation_controller_unittest.cc
@@ -867,13 +867,13 @@ class FakeAnimationDelegate : public AnimationDelegate {
 
   virtual void NotifyAnimationStarted(
       TimeTicks monotonic_time,
-      Animation::TargetProperty target_property) OVERRIDE {
+      Animation::TargetProperty target_property) override {
     started_ = true;
   }
 
   virtual void NotifyAnimationFinished(
       TimeTicks monotonic_time,
-      Animation::TargetProperty target_property) OVERRIDE {
+      Animation::TargetProperty target_property) override {
     finished_ = true;
   }
 
diff --git a/cc/animation/scroll_offset_animation_curve.h b/cc/animation/scroll_offset_animation_curve.h
index 452da27..197a431 100644
--- a/cc/animation/scroll_offset_animation_curve.h
+++ b/cc/animation/scroll_offset_animation_curve.h
@@ -29,9 +29,9 @@ class CC_EXPORT ScrollOffsetAnimationCurve : public AnimationCurve {
   void UpdateTarget(double t, const gfx::ScrollOffset& new_target);
 
   // AnimationCurve implementation
-  virtual double Duration() const OVERRIDE;
-  virtual CurveType Type() const OVERRIDE;
-  virtual scoped_ptr<AnimationCurve> Clone() const OVERRIDE;
+  virtual double Duration() const override;
+  virtual CurveType Type() const override;
+  virtual scoped_ptr<AnimationCurve> Clone() const override;
 
  private:
   ScrollOffsetAnimationCurve(const gfx::ScrollOffset& target_value,
diff --git a/cc/animation/scrollbar_animation_controller_linear_fade.h b/cc/animation/scrollbar_animation_controller_linear_fade.h
index 1070049..4d86933 100644
--- a/cc/animation/scrollbar_animation_controller_linear_fade.h
+++ b/cc/animation/scrollbar_animation_controller_linear_fade.h
@@ -23,7 +23,7 @@ class CC_EXPORT ScrollbarAnimationControllerLinearFade
 
   virtual ~ScrollbarAnimationControllerLinearFade();
 
-  virtual void DidScrollUpdate() OVERRIDE;
+  virtual void DidScrollUpdate() override;
 
  protected:
   ScrollbarAnimationControllerLinearFade(
@@ -32,7 +32,7 @@ class CC_EXPORT ScrollbarAnimationControllerLinearFade
       base::TimeDelta delay_before_starting,
       base::TimeDelta duration);
 
-  virtual void RunAnimationFrame(float progress) OVERRIDE;
+  virtual void RunAnimationFrame(float progress) override;
 
  private:
   float OpacityAtTime(base::TimeTicks now) const;
diff --git a/cc/animation/scrollbar_animation_controller_linear_fade_unittest.cc b/cc/animation/scrollbar_animation_controller_linear_fade_unittest.cc
index e5801d6..64db0d2 100644
--- a/cc/animation/scrollbar_animation_controller_linear_fade_unittest.cc
+++ b/cc/animation/scrollbar_animation_controller_linear_fade_unittest.cc
@@ -21,10 +21,10 @@ class ScrollbarAnimationControllerLinearFadeTest
       : host_impl_(&proxy_, &shared_bitmap_manager_), needs_frame_count_(0) {}
 
   virtual void PostDelayedScrollbarFade(const base::Closure& start_fade,
-                                        base::TimeDelta delay) OVERRIDE {
+                                        base::TimeDelta delay) override {
     start_fade_ = start_fade;
   }
-  virtual void SetNeedsScrollbarAnimationFrame() OVERRIDE {
+  virtual void SetNeedsScrollbarAnimationFrame() override {
     needs_frame_count_++;
   }
 
diff --git a/cc/animation/scrollbar_animation_controller_thinning.h b/cc/animation/scrollbar_animation_controller_thinning.h
index c0c7a83..233b350 100644
--- a/cc/animation/scrollbar_animation_controller_thinning.h
+++ b/cc/animation/scrollbar_animation_controller_thinning.h
@@ -31,9 +31,9 @@ class CC_EXPORT ScrollbarAnimationControllerThinning
   bool mouse_is_over_scrollbar() const { return mouse_is_over_scrollbar_; }
   bool mouse_is_near_scrollbar() const { return mouse_is_near_scrollbar_; }
 
-  virtual void DidScrollUpdate() OVERRIDE;
-  virtual void DidMouseMoveOffScrollbar() OVERRIDE;
-  virtual void DidMouseMoveNear(float distance) OVERRIDE;
+  virtual void DidScrollUpdate() override;
+  virtual void DidMouseMoveOffScrollbar() override;
+  virtual void DidMouseMoveNear(float distance) override;
 
  protected:
   ScrollbarAnimationControllerThinning(
@@ -42,7 +42,7 @@ class CC_EXPORT ScrollbarAnimationControllerThinning
       base::TimeDelta delay_before_starting,
       base::TimeDelta duration);
 
-  virtual void RunAnimationFrame(float progress) OVERRIDE;
+  virtual void RunAnimationFrame(float progress) override;
 
  private:
   // Describes whether the current animation should INCREASE (darken / thicken)
diff --git a/cc/animation/scrollbar_animation_controller_thinning_unittest.cc b/cc/animation/scrollbar_animation_controller_thinning_unittest.cc
index 6dad5b0..2b53fdc 100644
--- a/cc/animation/scrollbar_animation_controller_thinning_unittest.cc
+++ b/cc/animation/scrollbar_animation_controller_thinning_unittest.cc
@@ -21,10 +21,10 @@ class ScrollbarAnimationControllerThinningTest
       : host_impl_(&proxy_, &shared_bitmap_manager_) {}
 
   virtual void PostDelayedScrollbarFade(const base::Closure& start_fade,
-                                        base::TimeDelta delay) OVERRIDE {
+                                        base::TimeDelta delay) override {
     start_fade_ = start_fade;
   }
-  virtual void SetNeedsScrollbarAnimationFrame() OVERRIDE {}
+  virtual void SetNeedsScrollbarAnimationFrame() override {}
 
  protected:
   virtual void SetUp() {
diff --git a/cc/animation/timing_function.h b/cc/animation/timing_function.h
index a6d1aac..9974865 100644
--- a/cc/animation/timing_function.h
+++ b/cc/animation/timing_function.h
@@ -35,10 +35,10 @@ class CC_EXPORT CubicBezierTimingFunction : public TimingFunction {
   virtual ~CubicBezierTimingFunction();
 
   // TimingFunction implementation.
-  virtual float GetValue(double time) const OVERRIDE;
-  virtual float Velocity(double time) const OVERRIDE;
-  virtual void Range(float* min, float* max) const OVERRIDE;
-  virtual scoped_ptr<TimingFunction> Clone() const OVERRIDE;
+  virtual float GetValue(double time) const override;
+  virtual float Velocity(double time) const override;
+  virtual void Range(float* min, float* max) const override;
+  virtual scoped_ptr<TimingFunction> Clone() const override;
 
  protected:
   CubicBezierTimingFunction(double x1, double y1, double x2, double y2);
diff --git a/cc/base/delayed_unique_notifier_unittest.cc b/cc/base/delayed_unique_notifier_unittest.cc
index 6c7ae6e..090da33 100644
--- a/cc/base/delayed_unique_notifier_unittest.cc
+++ b/cc/base/delayed_unique_notifier_unittest.cc
@@ -23,7 +23,7 @@ class TestNotifier : public DelayedUniqueNotifier {
   virtual ~TestNotifier() {}
 
   // Overridden from DelayedUniqueNotifier:
-  virtual base::TimeTicks Now() const OVERRIDE { return now_; }
+  virtual base::TimeTicks Now() const override { return now_; }
 
   void SetNow(base::TimeTicks now) { now_ = now; }
 
@@ -35,7 +35,7 @@ class DelayedUniqueNotifierTest : public testing::Test {
  public:
   DelayedUniqueNotifierTest() : notification_count_(0) {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     notification_count_ = 0;
     task_runner_ = make_scoped_refptr(new base::TestSimpleTaskRunner);
   }
diff --git a/cc/base/latency_info_swap_promise.h b/cc/base/latency_info_swap_promise.h
index a210a3f..b912f24 100644
--- a/cc/base/latency_info_swap_promise.h
+++ b/cc/base/latency_info_swap_promise.h
@@ -16,10 +16,10 @@ class CC_EXPORT LatencyInfoSwapPromise : public SwapPromise {
   explicit LatencyInfoSwapPromise(const ui::LatencyInfo& latency_info);
   virtual ~LatencyInfoSwapPromise();
 
-  virtual void DidSwap(CompositorFrameMetadata* metadata) OVERRIDE;
-  virtual void DidNotSwap(DidNotSwapReason reason) OVERRIDE;
+  virtual void DidSwap(CompositorFrameMetadata* metadata) override;
+  virtual void DidNotSwap(DidNotSwapReason reason) override;
 
-  virtual int64 TraceId() const OVERRIDE;
+  virtual int64 TraceId() const override;
 
  private:
   ui::LatencyInfo latency_;
diff --git a/cc/base/latency_info_swap_promise_monitor.h b/cc/base/latency_info_swap_promise_monitor.h
index 1a114fb..cf1dc1d 100644
--- a/cc/base/latency_info_swap_promise_monitor.h
+++ b/cc/base/latency_info_swap_promise_monitor.h
@@ -24,9 +24,9 @@ class CC_EXPORT LatencyInfoSwapPromiseMonitor : public SwapPromiseMonitor {
                                 LayerTreeHostImpl* layer_tree_host_impl);
   virtual ~LatencyInfoSwapPromiseMonitor();
 
-  virtual void OnSetNeedsCommitOnMain() OVERRIDE;
-  virtual void OnSetNeedsRedrawOnImpl() OVERRIDE;
-  virtual void OnForwardScrollUpdateToMainThreadOnImpl() OVERRIDE;
+  virtual void OnSetNeedsCommitOnMain() override;
+  virtual void OnSetNeedsRedrawOnImpl() override;
+  virtual void OnForwardScrollUpdateToMainThreadOnImpl() override;
 
  private:
   ui::LatencyInfo* latency_;
diff --git a/cc/base/unique_notifier_unittest.cc b/cc/base/unique_notifier_unittest.cc
index ec1b83c..0ba9892 100644
--- a/cc/base/unique_notifier_unittest.cc
+++ b/cc/base/unique_notifier_unittest.cc
@@ -17,7 +17,7 @@ class UniqueNotifierTest : public testing::Test {
  public:
   UniqueNotifierTest() : notification_count_(0) {}
 
-  virtual void SetUp() OVERRIDE { ResetNotificationCount(); }
+  virtual void SetUp() override { ResetNotificationCount(); }
 
   void Notify() { ++notification_count_; }
 
diff --git a/cc/blink/scrollbar_impl.h b/cc/blink/scrollbar_impl.h
index fe7bf59..5f0572c 100644
--- a/cc/blink/scrollbar_impl.h
+++ b/cc/blink/scrollbar_impl.h
@@ -25,17 +25,17 @@ class ScrollbarImpl : public cc::Scrollbar {
   virtual ~ScrollbarImpl();
 
   // cc::Scrollbar implementation.
-  virtual cc::ScrollbarOrientation Orientation() const OVERRIDE;
-  virtual bool IsLeftSideVerticalScrollbar() const OVERRIDE;
-  virtual bool HasThumb() const OVERRIDE;
-  virtual bool IsOverlay() const OVERRIDE;
-  virtual gfx::Point Location() const OVERRIDE;
-  virtual int ThumbThickness() const OVERRIDE;
-  virtual int ThumbLength() const OVERRIDE;
-  virtual gfx::Rect TrackRect() const OVERRIDE;
+  virtual cc::ScrollbarOrientation Orientation() const override;
+  virtual bool IsLeftSideVerticalScrollbar() const override;
+  virtual bool HasThumb() const override;
+  virtual bool IsOverlay() const override;
+  virtual gfx::Point Location() const override;
+  virtual int ThumbThickness() const override;
+  virtual int ThumbLength() const override;
+  virtual gfx::Rect TrackRect() const override;
   virtual void PaintPart(SkCanvas* canvas,
                          cc::ScrollbarPart part,
-                         const gfx::Rect& content_rect) OVERRIDE;
+                         const gfx::Rect& content_rect) override;
 
  private:
   scoped_ptr<blink::WebScrollbar> scrollbar_;
diff --git a/cc/blink/web_content_layer_impl.h b/cc/blink/web_content_layer_impl.h
index bc23aa0..9dab02d 100644
--- a/cc/blink/web_content_layer_impl.h
+++ b/cc/blink/web_content_layer_impl.h
@@ -39,9 +39,9 @@ class WebContentLayerImpl : public blink::WebContentLayer,
   virtual void PaintContents(SkCanvas* canvas,
                              const gfx::Rect& clip,
                              ContentLayerClient::GraphicsContextStatus
-                                 graphics_context_status) OVERRIDE;
-  virtual void DidChangeLayerCanUseLCDText() OVERRIDE;
-  virtual bool FillsBoundsCompletely() const OVERRIDE;
+                                 graphics_context_status) override;
+  virtual void DidChangeLayerCanUseLCDText() override;
+  virtual bool FillsBoundsCompletely() const override;
 
   scoped_ptr<WebLayerImpl> layer_;
   blink::WebContentLayerClient* client_;
diff --git a/cc/blink/web_external_bitmap_impl.h b/cc/blink/web_external_bitmap_impl.h
index 905c098..7dbfab3 100644
--- a/cc/blink/web_external_bitmap_impl.h
+++ b/cc/blink/web_external_bitmap_impl.h
@@ -28,9 +28,9 @@ class WebExternalBitmapImpl : public blink::WebExternalBitmap {
   virtual ~WebExternalBitmapImpl();
 
   // blink::WebExternalBitmap implementation.
-  virtual blink::WebSize size() OVERRIDE;
-  virtual void setSize(blink::WebSize size) OVERRIDE;
-  virtual uint8* pixels() OVERRIDE;
+  virtual blink::WebSize size() override;
+  virtual void setSize(blink::WebSize size) override;
+  virtual uint8* pixels() override;
 
   base::SharedMemory* shared_memory() { return shared_memory_.get(); }
 
diff --git a/cc/blink/web_external_texture_layer_impl.h b/cc/blink/web_external_texture_layer_impl.h
index 044be1a..a657e62 100644
--- a/cc/blink/web_external_texture_layer_impl.h
+++ b/cc/blink/web_external_texture_layer_impl.h
@@ -48,7 +48,7 @@ class WebExternalTextureLayerImpl
   virtual bool PrepareTextureMailbox(
       cc::TextureMailbox* mailbox,
       scoped_ptr<cc::SingleReleaseCallback>* release_callback,
-      bool use_shared_memory) OVERRIDE;
+      bool use_shared_memory) override;
 
  private:
   static void DidReleaseMailbox(
diff --git a/cc/blink/web_layer_impl.cc b/cc/blink/web_layer_impl.cc
index 36304a1..dadfd6d 100644
--- a/cc/blink/web_layer_impl.cc
+++ b/cc/blink/web_layer_impl.cc
@@ -443,7 +443,7 @@ class TracedDebugInfo : public base::debug::ConvertableToTraceFormat {
   // This object takes ownership of the debug_info object.
   explicit TracedDebugInfo(blink::WebGraphicsLayerDebugInfo* debug_info)
       : debug_info_(debug_info) {}
-  virtual void AppendAsTraceFormat(std::string* out) const OVERRIDE {
+  virtual void AppendAsTraceFormat(std::string* out) const override {
     DCHECK(thread_checker_.CalledOnValidThread());
     blink::WebString web_string;
     debug_info_->appendAsTraceFormat(&web_string);
diff --git a/cc/blink/web_layer_impl.h b/cc/blink/web_layer_impl.h
index 0e3de76..75f8a55 100644
--- a/cc/blink/web_layer_impl.h
+++ b/cc/blink/web_layer_impl.h
@@ -137,7 +137,7 @@ class WebLayerImpl : public blink::WebLayer, public cc::LayerClient {
 
   // LayerClient implementation.
   virtual scoped_refptr<base::debug::ConvertableToTraceFormat> TakeDebugInfo()
-      OVERRIDE;
+      override;
 
   virtual void setScrollParent(blink::WebLayer* parent);
   virtual void setClipParent(blink::WebLayer* parent);
diff --git a/cc/blink/web_to_cc_animation_delegate_adapter.h b/cc/blink/web_to_cc_animation_delegate_adapter.h
index 2f7897b6..c7e7c56 100644
--- a/cc/blink/web_to_cc_animation_delegate_adapter.h
+++ b/cc/blink/web_to_cc_animation_delegate_adapter.h
@@ -23,10 +23,10 @@ class WebToCCAnimationDelegateAdapter : public cc::AnimationDelegate {
  private:
   virtual void NotifyAnimationStarted(
       base::TimeTicks monotonic_time,
-      cc::Animation::TargetProperty target_property) OVERRIDE;
+      cc::Animation::TargetProperty target_property) override;
   virtual void NotifyAnimationFinished(
       base::TimeTicks monotonic_time,
-      cc::Animation::TargetProperty target_property) OVERRIDE;
+      cc::Animation::TargetProperty target_property) override;
 
   blink::WebCompositorAnimationDelegate* delegate_;
 
diff --git a/cc/debug/invalidation_benchmark.h b/cc/debug/invalidation_benchmark.h
index 00481ae..a727104 100644
--- a/cc/debug/invalidation_benchmark.h
+++ b/cc/debug/invalidation_benchmark.h
@@ -24,9 +24,9 @@ class CC_EXPORT InvalidationBenchmark : public MicroBenchmark {
   virtual ~InvalidationBenchmark();
 
   // Implements MicroBenchmark interface.
-  virtual void DidUpdateLayers(LayerTreeHost* host) OVERRIDE;
-  virtual void RunOnLayer(PictureLayer* layer) OVERRIDE;
-  virtual bool ProcessMessage(scoped_ptr<base::Value> value) OVERRIDE;
+  virtual void DidUpdateLayers(LayerTreeHost* host) override;
+  virtual void RunOnLayer(PictureLayer* layer) override;
+  virtual bool ProcessMessage(scoped_ptr<base::Value> value) override;
 
  private:
   enum Mode { FIXED_SIZE, LAYER, VIEWPORT, RANDOM };
diff --git a/cc/debug/micro_benchmark_controller_unittest.cc b/cc/debug/micro_benchmark_controller_unittest.cc
index 1f2bfd8..527e850 100644
--- a/cc/debug/micro_benchmark_controller_unittest.cc
+++ b/cc/debug/micro_benchmark_controller_unittest.cc
@@ -21,7 +21,7 @@ class MicroBenchmarkControllerTest : public testing::Test {
   MicroBenchmarkControllerTest()
       : layer_tree_host_client_(FakeLayerTreeHostClient::DIRECT_3D) {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     impl_proxy_ = make_scoped_ptr(new FakeImplProxy);
     shared_bitmap_manager_.reset(new TestSharedBitmapManager());
     layer_tree_host_impl_ = make_scoped_ptr(new FakeLayerTreeHostImpl(
@@ -32,7 +32,7 @@ class MicroBenchmarkControllerTest : public testing::Test {
     layer_tree_host_->InitializeForTesting(scoped_ptr<Proxy>(new FakeProxy));
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     layer_tree_host_impl_ = nullptr;
     layer_tree_host_ = nullptr;
     impl_proxy_ = nullptr;
diff --git a/cc/debug/picture_record_benchmark.h b/cc/debug/picture_record_benchmark.h
index 89f2bc0..42404b1 100644
--- a/cc/debug/picture_record_benchmark.h
+++ b/cc/debug/picture_record_benchmark.h
@@ -23,8 +23,8 @@ class CC_EXPORT PictureRecordBenchmark : public MicroBenchmark {
   virtual ~PictureRecordBenchmark();
 
   // Implements MicroBenchmark interface.
-  virtual void DidUpdateLayers(LayerTreeHost* host) OVERRIDE;
-  virtual void RunOnLayer(PictureLayer* layer) OVERRIDE;
+  virtual void DidUpdateLayers(LayerTreeHost* host) override;
+  virtual void RunOnLayer(PictureLayer* layer) override;
 
  private:
   void Run(Layer* layer);
diff --git a/cc/debug/rasterize_and_record_benchmark.h b/cc/debug/rasterize_and_record_benchmark.h
index e2942d4..921a7e9 100644
--- a/cc/debug/rasterize_and_record_benchmark.h
+++ b/cc/debug/rasterize_and_record_benchmark.h
@@ -30,11 +30,11 @@ class RasterizeAndRecordBenchmark : public MicroBenchmark {
   virtual ~RasterizeAndRecordBenchmark();
 
   // Implements MicroBenchmark interface.
-  virtual void DidUpdateLayers(LayerTreeHost* host) OVERRIDE;
-  virtual void RunOnLayer(PictureLayer* layer) OVERRIDE;
+  virtual void DidUpdateLayers(LayerTreeHost* host) override;
+  virtual void RunOnLayer(PictureLayer* layer) override;
 
   virtual scoped_ptr<MicroBenchmarkImpl> CreateBenchmarkImpl(
-      scoped_refptr<base::MessageLoopProxy> origin_loop) OVERRIDE;
+      scoped_refptr<base::MessageLoopProxy> origin_loop) override;
 
  private:
   void Run(Layer* layer);
diff --git a/cc/debug/rasterize_and_record_benchmark_impl.cc b/cc/debug/rasterize_and_record_benchmark_impl.cc
index dbf74a42..48bdf8a 100644
--- a/cc/debug/rasterize_and_record_benchmark_impl.cc
+++ b/cc/debug/rasterize_and_record_benchmark_impl.cc
@@ -37,7 +37,7 @@ class BenchmarkRasterTask : public Task {
         best_time_(base::TimeDelta::Max()) {}
 
   // Overridden from Task:
-  virtual void RunOnWorkerThread() OVERRIDE {
+  virtual void RunOnWorkerThread() override {
     // Parameters for LapTimer.
     const int kTimeLimitMillis = 1;
     const int kWarmupRuns = 0;
@@ -96,46 +96,46 @@ class FixedInvalidationPictureLayerTilingClient
 
   virtual scoped_refptr<Tile> CreateTile(
       PictureLayerTiling* tiling,
-      const gfx::Rect& content_rect) OVERRIDE {
+      const gfx::Rect& content_rect) override {
     return base_client_->CreateTile(tiling, content_rect);
   }
 
-  virtual PicturePileImpl* GetPile() OVERRIDE {
+  virtual PicturePileImpl* GetPile() override {
     return base_client_->GetPile();
   }
 
   virtual gfx::Size CalculateTileSize(
-      const gfx::Size& content_bounds) const OVERRIDE {
+      const gfx::Size& content_bounds) const override {
     return base_client_->CalculateTileSize(content_bounds);
   }
 
   // This is the only function that returns something different from the base
   // client.
-  virtual const Region* GetInvalidation() OVERRIDE { return &invalidation_; }
+  virtual const Region* GetInvalidation() override { return &invalidation_; }
 
   virtual const PictureLayerTiling* GetTwinTiling(
-      const PictureLayerTiling* tiling) const OVERRIDE {
+      const PictureLayerTiling* tiling) const override {
     return base_client_->GetTwinTiling(tiling);
   }
 
   virtual PictureLayerTiling* GetRecycledTwinTiling(
-      const PictureLayerTiling* tiling) OVERRIDE {
+      const PictureLayerTiling* tiling) override {
     return base_client_->GetRecycledTwinTiling(tiling);
   }
 
-  virtual size_t GetMaxTilesForInterestArea() const OVERRIDE {
+  virtual size_t GetMaxTilesForInterestArea() const override {
     return base_client_->GetMaxTilesForInterestArea();
   }
 
-  virtual float GetSkewportTargetTimeInSeconds() const OVERRIDE {
+  virtual float GetSkewportTargetTimeInSeconds() const override {
     return base_client_->GetSkewportTargetTimeInSeconds();
   }
 
-  virtual int GetSkewportExtrapolationLimitInContentPixels() const OVERRIDE {
+  virtual int GetSkewportExtrapolationLimitInContentPixels() const override {
     return base_client_->GetSkewportExtrapolationLimitInContentPixels();
   }
 
-  virtual WhichTree GetTree() const OVERRIDE { return base_client_->GetTree(); }
+  virtual WhichTree GetTree() const override { return base_client_->GetTree(); }
 
  private:
   PictureLayerTilingClient* base_client_;
diff --git a/cc/debug/rasterize_and_record_benchmark_impl.h b/cc/debug/rasterize_and_record_benchmark_impl.h
index cceef05..4508d5e 100644
--- a/cc/debug/rasterize_and_record_benchmark_impl.h
+++ b/cc/debug/rasterize_and_record_benchmark_impl.h
@@ -27,8 +27,8 @@ class RasterizeAndRecordBenchmarkImpl : public MicroBenchmarkImpl {
   virtual ~RasterizeAndRecordBenchmarkImpl();
 
   // Implements MicroBenchmark interface.
-  virtual void DidCompleteCommit(LayerTreeHostImpl* host) OVERRIDE;
-  virtual void RunOnLayer(PictureLayerImpl* layer) OVERRIDE;
+  virtual void DidCompleteCommit(LayerTreeHostImpl* host) override;
+  virtual void RunOnLayer(PictureLayerImpl* layer) override;
 
  private:
   void Run(LayerImpl* layer);
diff --git a/cc/debug/traced_picture.h b/cc/debug/traced_picture.h
index 638f00b..1d31694a 100644
--- a/cc/debug/traced_picture.h
+++ b/cc/debug/traced_picture.h
@@ -23,7 +23,7 @@ class TracedPicture : public base::debug::ConvertableToTraceFormat {
   static scoped_refptr<base::debug::ConvertableToTraceFormat>
       AsTraceablePictureAlias(const Picture* original);
 
-  virtual void AppendAsTraceFormat(std::string* out) const OVERRIDE;
+  virtual void AppendAsTraceFormat(std::string* out) const override;
 
  private:
   virtual ~TracedPicture();
diff --git a/cc/debug/unittest_only_benchmark.h b/cc/debug/unittest_only_benchmark.h
index 8b2c815..277d85f 100644
--- a/cc/debug/unittest_only_benchmark.h
+++ b/cc/debug/unittest_only_benchmark.h
@@ -16,12 +16,12 @@ class CC_EXPORT UnittestOnlyBenchmark : public MicroBenchmark {
                         const DoneCallback& callback);
   virtual ~UnittestOnlyBenchmark();
 
-  virtual void DidUpdateLayers(LayerTreeHost* host) OVERRIDE;
-  virtual bool ProcessMessage(scoped_ptr<base::Value> value) OVERRIDE;
+  virtual void DidUpdateLayers(LayerTreeHost* host) override;
+  virtual bool ProcessMessage(scoped_ptr<base::Value> value) override;
 
  protected:
   virtual scoped_ptr<MicroBenchmarkImpl> CreateBenchmarkImpl(
-      scoped_refptr<base::MessageLoopProxy> origin_loop) OVERRIDE;
+      scoped_refptr<base::MessageLoopProxy> origin_loop) override;
 
  private:
   void RecordImplResults(scoped_ptr<base::Value> results);
diff --git a/cc/debug/unittest_only_benchmark_impl.h b/cc/debug/unittest_only_benchmark_impl.h
index b9e9bc9..48953de 100644
--- a/cc/debug/unittest_only_benchmark_impl.h
+++ b/cc/debug/unittest_only_benchmark_impl.h
@@ -23,7 +23,7 @@ class CC_EXPORT UnittestOnlyBenchmarkImpl : public MicroBenchmarkImpl {
                             const DoneCallback& callback);
   virtual ~UnittestOnlyBenchmarkImpl();
 
-  virtual void DidCompleteCommit(LayerTreeHostImpl* host) OVERRIDE;
+  virtual void DidCompleteCommit(LayerTreeHostImpl* host) override;
 };
 
 }  // namespace cc
diff --git a/cc/input/top_controls_manager_unittest.cc b/cc/input/top_controls_manager_unittest.cc
index 91577c8..177904c 100644
--- a/cc/input/top_controls_manager_unittest.cc
+++ b/cc/input/top_controls_manager_unittest.cc
@@ -37,20 +37,20 @@ class MockTopControlsManagerClient : public TopControlsManagerClient {
 
   virtual ~MockTopControlsManagerClient() {}
 
-  virtual void DidChangeTopControlsPosition() OVERRIDE {
+  virtual void DidChangeTopControlsPosition() override {
     redraw_needed_ = true;
     update_draw_properties_needed_ = true;
   }
 
-  virtual bool HaveRootScrollLayer() const OVERRIDE {
+  virtual bool HaveRootScrollLayer() const override {
     return true;
   }
 
-  virtual void SetControlsTopOffset(float offset) OVERRIDE {
+  virtual void SetControlsTopOffset(float offset) override {
     top_controls_top_offset_ = offset;
   }
 
-  virtual float ControlsTopOffset() const OVERRIDE {
+  virtual float ControlsTopOffset() const override {
     return top_controls_top_offset_;
   }
 
diff --git a/cc/layers/content_layer.h b/cc/layers/content_layer.h
index 4bc414c..4b8c346 100644
--- a/cc/layers/content_layer.h
+++ b/cc/layers/content_layer.h
@@ -21,7 +21,7 @@ class CC_EXPORT ContentLayerPainter : public LayerPainter {
  public:
   static scoped_ptr<ContentLayerPainter> Create(ContentLayerClient* client);
 
-  virtual void Paint(SkCanvas* canvas, const gfx::Rect& content_rect) OVERRIDE;
+  virtual void Paint(SkCanvas* canvas, const gfx::Rect& content_rect) override;
 
  private:
   explicit ContentLayerPainter(ContentLayerClient* client);
@@ -38,33 +38,33 @@ class CC_EXPORT ContentLayer : public TiledLayer {
 
   void ClearClient();
 
-  virtual void SetLayerTreeHost(LayerTreeHost* layer_tree_host) OVERRIDE;
+  virtual void SetLayerTreeHost(LayerTreeHost* layer_tree_host) override;
   virtual void SetTexturePriorities(const PriorityCalculator& priority_calc)
-      OVERRIDE;
+      override;
   virtual bool Update(ResourceUpdateQueue* queue,
-                      const OcclusionTracker<Layer>* occlusion) OVERRIDE;
-  virtual bool NeedMoreUpdates() OVERRIDE;
+                      const OcclusionTracker<Layer>* occlusion) override;
+  virtual bool NeedMoreUpdates() override;
 
-  virtual void SetContentsOpaque(bool contents_opaque) OVERRIDE;
+  virtual void SetContentsOpaque(bool contents_opaque) override;
 
-  virtual bool SupportsLCDText() const OVERRIDE;
+  virtual bool SupportsLCDText() const override;
 
-  virtual skia::RefPtr<SkPicture> GetPicture() const OVERRIDE;
+  virtual skia::RefPtr<SkPicture> GetPicture() const override;
 
-  virtual void OnOutputSurfaceCreated() OVERRIDE;
+  virtual void OnOutputSurfaceCreated() override;
 
  protected:
   explicit ContentLayer(ContentLayerClient* client);
   virtual ~ContentLayer();
 
-  virtual bool HasDrawableContent() const OVERRIDE;
+  virtual bool HasDrawableContent() const override;
 
   // TiledLayer implementation.
-  virtual LayerUpdater* Updater() const OVERRIDE;
+  virtual LayerUpdater* Updater() const override;
 
  private:
   // TiledLayer implementation.
-  virtual void CreateUpdaterIfNeeded() OVERRIDE;
+  virtual void CreateUpdaterIfNeeded() override;
 
   void UpdateCanUseLCDText();
 
diff --git a/cc/layers/contents_scaling_layer.h b/cc/layers/contents_scaling_layer.h
index 84780d2..3b1f828 100644
--- a/cc/layers/contents_scaling_layer.h
+++ b/cc/layers/contents_scaling_layer.h
@@ -17,10 +17,10 @@ class CC_EXPORT ContentsScalingLayer : public Layer {
   virtual void CalculateContentsScale(float ideal_contents_scale,
                                       float* contents_scale_x,
                                       float* contents_scale_y,
-                                      gfx::Size* content_bounds) OVERRIDE;
+                                      gfx::Size* content_bounds) override;
 
   virtual bool Update(ResourceUpdateQueue* queue,
-                      const OcclusionTracker<Layer>* occlusion) OVERRIDE;
+                      const OcclusionTracker<Layer>* occlusion) override;
 
  protected:
   ContentsScalingLayer();
diff --git a/cc/layers/contents_scaling_layer_unittest.cc b/cc/layers/contents_scaling_layer_unittest.cc
index 70f66f5..8cbd517 100644
--- a/cc/layers/contents_scaling_layer_unittest.cc
+++ b/cc/layers/contents_scaling_layer_unittest.cc
@@ -18,7 +18,7 @@ class MockContentsScalingLayer : public ContentsScalingLayer {
   MockContentsScalingLayer()
       : ContentsScalingLayer() {}
 
-  virtual void SetNeedsDisplayRect(const gfx::RectF& dirty_rect) OVERRIDE {
+  virtual void SetNeedsDisplayRect(const gfx::RectF& dirty_rect) override {
     last_needs_display_rect_ = dirty_rect;
     ContentsScalingLayer::SetNeedsDisplayRect(dirty_rect);
   }
diff --git a/cc/layers/delegated_frame_provider_unittest.cc b/cc/layers/delegated_frame_provider_unittest.cc
index 8462595..4a3f77e 100644
--- a/cc/layers/delegated_frame_provider_unittest.cc
+++ b/cc/layers/delegated_frame_provider_unittest.cc
@@ -62,14 +62,14 @@ class DelegatedFrameProviderTest
                  false);
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     resource_collection_ = new DelegatedFrameResourceCollection;
     resource_collection_->SetClient(this);
   }
 
-  virtual void TearDown() OVERRIDE { resource_collection_->SetClient(NULL); }
+  virtual void TearDown() override { resource_collection_->SetClient(NULL); }
 
-  virtual void UnusedResourcesAreAvailable() OVERRIDE {
+  virtual void UnusedResourcesAreAvailable() override {
     resources_available_ = true;
     resource_collection_->TakeUnusedResourcesForChildCompositor(&resources_);
   }
diff --git a/cc/layers/delegated_frame_resource_collection_unittest.cc b/cc/layers/delegated_frame_resource_collection_unittest.cc
index 9bfd59c..99c181e 100644
--- a/cc/layers/delegated_frame_resource_collection_unittest.cc
+++ b/cc/layers/delegated_frame_resource_collection_unittest.cc
@@ -21,9 +21,9 @@ class DelegatedFrameResourceCollectionTest
  protected:
   DelegatedFrameResourceCollectionTest() : resources_available_(false) {}
 
-  virtual void SetUp() OVERRIDE { CreateResourceCollection(); }
+  virtual void SetUp() override { CreateResourceCollection(); }
 
-  virtual void TearDown() OVERRIDE { DestroyResourceCollection(); }
+  virtual void TearDown() override { DestroyResourceCollection(); }
 
   void CreateResourceCollection() {
     DCHECK(!resource_collection_.get());
@@ -46,7 +46,7 @@ class DelegatedFrameResourceCollectionTest
     return resources;
   }
 
-  virtual void UnusedResourcesAreAvailable() OVERRIDE {
+  virtual void UnusedResourcesAreAvailable() override {
     resources_available_ = true;
     resource_collection_->TakeUnusedResourcesForChildCompositor(
         &returned_resources_);
diff --git a/cc/layers/delegated_renderer_layer.h b/cc/layers/delegated_renderer_layer.h
index 49b41d9..8f31b17 100644
--- a/cc/layers/delegated_renderer_layer.h
+++ b/cc/layers/delegated_renderer_layer.h
@@ -22,16 +22,16 @@ class CC_EXPORT DelegatedRendererLayer : public Layer {
       const scoped_refptr<DelegatedFrameProvider>& frame_provider);
 
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
-  virtual void SetLayerTreeHost(LayerTreeHost* host) OVERRIDE;
+      override;
+  virtual void SetLayerTreeHost(LayerTreeHost* host) override;
   virtual bool Update(ResourceUpdateQueue* queue,
-                      const OcclusionTracker<Layer>* occlusion) OVERRIDE;
-  virtual void PushPropertiesTo(LayerImpl* impl) OVERRIDE;
+                      const OcclusionTracker<Layer>* occlusion) override;
+  virtual void PushPropertiesTo(LayerImpl* impl) override;
 
   // Called by the DelegatedFrameProvider when a new frame is available to be
   // picked up.
   void ProviderHasNewFrame();
-  virtual bool HasDelegatedContent() const OVERRIDE;
+  virtual bool HasDelegatedContent() const override;
 
  protected:
   DelegatedRendererLayer(
diff --git a/cc/layers/delegated_renderer_layer_impl.h b/cc/layers/delegated_renderer_layer_impl.h
index 1f3c881..db63928 100644
--- a/cc/layers/delegated_renderer_layer_impl.h
+++ b/cc/layers/delegated_renderer_layer_impl.h
@@ -25,19 +25,19 @@ class CC_EXPORT DelegatedRendererLayerImpl : public LayerImpl {
 
   // LayerImpl overrides.
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
-  virtual bool HasDelegatedContent() const OVERRIDE;
-  virtual bool HasContributingDelegatedRenderPasses() const OVERRIDE;
-  virtual RenderPassId FirstContributingRenderPassId() const OVERRIDE;
+      override;
+  virtual bool HasDelegatedContent() const override;
+  virtual bool HasContributingDelegatedRenderPasses() const override;
+  virtual RenderPassId FirstContributingRenderPassId() const override;
   virtual RenderPassId NextContributingRenderPassId(
-      RenderPassId previous) const OVERRIDE;
-  virtual void ReleaseResources() OVERRIDE;
+      RenderPassId previous) const override;
+  virtual void ReleaseResources() override;
   virtual bool WillDraw(DrawMode draw_mode,
-                        ResourceProvider* resource_provider) OVERRIDE;
+                        ResourceProvider* resource_provider) override;
   virtual void AppendQuads(RenderPass* render_pass,
                            const OcclusionTracker<LayerImpl>& occlusion_tracker,
-                           AppendQuadsData* append_quads_data) OVERRIDE;
-  virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE;
+                           AppendQuadsData* append_quads_data) override;
+  virtual void PushPropertiesTo(LayerImpl* layer) override;
 
   void AppendContributingRenderPasses(RenderPassSink* render_pass_sink);
 
@@ -86,7 +86,7 @@ class CC_EXPORT DelegatedRendererLayerImpl : public LayerImpl {
       const gfx::Size& frame_size) const;
 
   // LayerImpl overrides.
-  virtual const char* LayerTypeAsString() const OVERRIDE;
+  virtual const char* LayerTypeAsString() const override;
 
   bool have_render_passes_to_push_;
   float inverse_device_scale_factor_;
diff --git a/cc/layers/heads_up_display_layer.h b/cc/layers/heads_up_display_layer.h
index 12d6aef..22dcec8 100644
--- a/cc/layers/heads_up_display_layer.h
+++ b/cc/layers/heads_up_display_layer.h
@@ -22,11 +22,11 @@ class CC_EXPORT HeadsUpDisplayLayer : public ContentsScalingLayer {
 
 
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
+      override;
 
  protected:
   HeadsUpDisplayLayer();
-  virtual bool HasDrawableContent() const OVERRIDE;
+  virtual bool HasDrawableContent() const override;
 
  private:
   virtual ~HeadsUpDisplayLayer();
diff --git a/cc/layers/heads_up_display_layer_impl.h b/cc/layers/heads_up_display_layer_impl.h
index 3cba4f5..fc5fbe7 100644
--- a/cc/layers/heads_up_display_layer_impl.h
+++ b/cc/layers/heads_up_display_layer_impl.h
@@ -35,17 +35,17 @@ class CC_EXPORT HeadsUpDisplayLayerImpl : public LayerImpl {
   virtual ~HeadsUpDisplayLayerImpl();
 
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
+      override;
 
   virtual bool WillDraw(DrawMode draw_mode,
-                        ResourceProvider* resource_provider) OVERRIDE;
+                        ResourceProvider* resource_provider) override;
   virtual void AppendQuads(RenderPass* render_pass,
                            const OcclusionTracker<LayerImpl>& occlusion_tracker,
-                           AppendQuadsData* append_quads_data) OVERRIDE;
+                           AppendQuadsData* append_quads_data) override;
   void UpdateHudTexture(DrawMode draw_mode,
                         ResourceProvider* resource_provider);
 
-  virtual void ReleaseResources() OVERRIDE;
+  virtual void ReleaseResources() override;
 
   bool IsAnimatingHUDContents() const { return fade_step_ > 0; }
 
@@ -70,9 +70,9 @@ class CC_EXPORT HeadsUpDisplayLayerImpl : public LayerImpl {
 
   HeadsUpDisplayLayerImpl(LayerTreeImpl* tree_impl, int id);
 
-  virtual const char* LayerTypeAsString() const OVERRIDE;
+  virtual const char* LayerTypeAsString() const override;
 
-  virtual void AsValueInto(base::debug::TracedValue* dict) const OVERRIDE;
+  virtual void AsValueInto(base::debug::TracedValue* dict) const override;
 
   void UpdateHudContents();
   void DrawHudContents(SkCanvas* canvas);
diff --git a/cc/layers/heads_up_display_unittest.cc b/cc/layers/heads_up_display_unittest.cc
index b9bd5db..686338e 100644
--- a/cc/layers/heads_up_display_unittest.cc
+++ b/cc/layers/heads_up_display_unittest.cc
@@ -12,7 +12,7 @@ namespace {
 
 class HeadsUpDisplayTest : public LayerTreeTest {
  protected:
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     // Enable the HUD without requiring text.
     settings->initial_debug_state.show_property_changed_rects = true;
   }
@@ -23,7 +23,7 @@ class DrawsContentLayer : public Layer {
   static scoped_refptr<DrawsContentLayer> Create() {
     return make_scoped_refptr(new DrawsContentLayer());
   }
-  virtual bool DrawsContent() const OVERRIDE { return true; }
+  virtual bool DrawsContent() const override { return true; }
 
  private:
   DrawsContentLayer() : Layer() {}
@@ -37,14 +37,14 @@ class HudWithRootLayerChange : public HeadsUpDisplayTest {
         root_layer2_(DrawsContentLayer::Create()),
         num_commits_(0) {}
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     root_layer1_->SetBounds(gfx::Size(30, 30));
     root_layer2_->SetBounds(gfx::Size(30, 30));
 
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     ++num_commits_;
 
     ASSERT_TRUE(layer_tree_host()->hud_layer());
@@ -86,7 +86,7 @@ class HudWithRootLayerChange : public HeadsUpDisplayTest {
     }
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   scoped_refptr<DrawsContentLayer> root_layer1_;
diff --git a/cc/layers/image_layer.h b/cc/layers/image_layer.h
index 63d467a..53d1f69 100644
--- a/cc/layers/image_layer.h
+++ b/cc/layers/image_layer.h
@@ -20,27 +20,27 @@ class CC_EXPORT ImageLayer : public TiledLayer {
 
   // Layer implementation.
   virtual void SetTexturePriorities(const PriorityCalculator& priority_calc)
-      OVERRIDE;
+      override;
   virtual bool Update(ResourceUpdateQueue* queue,
-                      const OcclusionTracker<Layer>* occlusion) OVERRIDE;
+                      const OcclusionTracker<Layer>* occlusion) override;
   virtual void CalculateContentsScale(float ideal_contents_scale,
                                       float* contents_scale_x,
                                       float* contents_scale_y,
-                                      gfx::Size* content_bounds) OVERRIDE;
-  virtual void OnOutputSurfaceCreated() OVERRIDE;
+                                      gfx::Size* content_bounds) override;
+  virtual void OnOutputSurfaceCreated() override;
 
   void SetBitmap(const SkBitmap& image);
 
  protected:
-  virtual bool HasDrawableContent() const OVERRIDE;
+  virtual bool HasDrawableContent() const override;
 
  private:
   ImageLayer();
   virtual ~ImageLayer();
 
   // TiledLayer Implementation.
-  virtual LayerUpdater* Updater() const OVERRIDE;
-  virtual void CreateUpdaterIfNeeded() OVERRIDE;
+  virtual LayerUpdater* Updater() const override;
+  virtual void CreateUpdaterIfNeeded() override;
 
   float ImageContentsScaleX() const;
   float ImageContentsScaleY() const;
diff --git a/cc/layers/io_surface_layer.h b/cc/layers/io_surface_layer.h
index ad06e7f..681f1a1 100644
--- a/cc/layers/io_surface_layer.h
+++ b/cc/layers/io_surface_layer.h
@@ -17,13 +17,13 @@ class CC_EXPORT IOSurfaceLayer : public Layer {
   void SetIOSurfaceProperties(uint32_t io_surface_id, const gfx::Size& size);
 
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
-  virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE;
+      override;
+  virtual void PushPropertiesTo(LayerImpl* layer) override;
   virtual bool Update(ResourceUpdateQueue* queue,
-                      const OcclusionTracker<Layer>* occlusion) OVERRIDE;
+                      const OcclusionTracker<Layer>* occlusion) override;
 
  protected:
-  virtual bool HasDrawableContent() const OVERRIDE;
+  virtual bool HasDrawableContent() const override;
   IOSurfaceLayer();
 
  private:
diff --git a/cc/layers/io_surface_layer_impl.h b/cc/layers/io_surface_layer_impl.h
index ac8142d..15fa5bd 100644
--- a/cc/layers/io_surface_layer_impl.h
+++ b/cc/layers/io_surface_layer_impl.h
@@ -24,23 +24,23 @@ class CC_EXPORT IOSurfaceLayerImpl : public LayerImpl {
   void SetIOSurfaceProperties(unsigned io_surface_id, const gfx::Size& size);
 
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
-  virtual void PushPropertiesTo(LayerImpl* layer_tree_impl) OVERRIDE;
+      override;
+  virtual void PushPropertiesTo(LayerImpl* layer_tree_impl) override;
 
   virtual void AppendQuads(RenderPass* render_pass,
                            const OcclusionTracker<LayerImpl>& occlusion_tracker,
-                           AppendQuadsData* append_quads_data) OVERRIDE;
+                           AppendQuadsData* append_quads_data) override;
 
   virtual bool WillDraw(DrawMode draw_mode,
-                        ResourceProvider* resource_provider) OVERRIDE;
-  virtual void ReleaseResources() OVERRIDE;
+                        ResourceProvider* resource_provider) override;
+  virtual void ReleaseResources() override;
 
  private:
   IOSurfaceLayerImpl(LayerTreeImpl* tree_impl, int id);
 
   void DestroyResource();
 
-  virtual const char* LayerTypeAsString() const OVERRIDE;
+  virtual const char* LayerTypeAsString() const override;
 
   unsigned io_surface_id_;
   gfx::Size io_surface_size_;
diff --git a/cc/layers/layer.h b/cc/layers/layer.h
index a627140..3e83e8f 100644
--- a/cc/layers/layer.h
+++ b/cc/layers/layer.h
@@ -552,16 +552,16 @@ class CC_EXPORT Layer : public base::RefCounted<Layer>,
   void RemoveChildOrDependent(Layer* child);
 
   // LayerAnimationValueProvider implementation.
-  virtual gfx::ScrollOffset ScrollOffsetForAnimation() const OVERRIDE;
+  virtual gfx::ScrollOffset ScrollOffsetForAnimation() const override;
 
   // LayerAnimationValueObserver implementation.
-  virtual void OnFilterAnimated(const FilterOperations& filters) OVERRIDE;
-  virtual void OnOpacityAnimated(float opacity) OVERRIDE;
-  virtual void OnTransformAnimated(const gfx::Transform& transform) OVERRIDE;
+  virtual void OnFilterAnimated(const FilterOperations& filters) override;
+  virtual void OnOpacityAnimated(float opacity) override;
+  virtual void OnTransformAnimated(const gfx::Transform& transform) override;
   virtual void OnScrollOffsetAnimated(
-      const gfx::ScrollOffset& scroll_offset) OVERRIDE;
-  virtual void OnAnimationWaitingForDeletion() OVERRIDE;
-  virtual bool IsActive() const OVERRIDE;
+      const gfx::ScrollOffset& scroll_offset) override;
+  virtual void OnAnimationWaitingForDeletion() override;
+  virtual bool IsActive() const override;
 
   // If this layer has a scroll parent, it removes |this| from its list of
   // scroll children.
diff --git a/cc/layers/layer_impl.h b/cc/layers/layer_impl.h
index fc7f1c6..0af74b7 100644
--- a/cc/layers/layer_impl.h
+++ b/cc/layers/layer_impl.h
@@ -98,24 +98,24 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
   int id() const { return layer_id_; }
 
   // LayerAnimationValueProvider implementation.
-  virtual gfx::ScrollOffset ScrollOffsetForAnimation() const OVERRIDE;
+  virtual gfx::ScrollOffset ScrollOffsetForAnimation() const override;
 
   // LayerAnimationValueObserver implementation.
-  virtual void OnFilterAnimated(const FilterOperations& filters) OVERRIDE;
-  virtual void OnOpacityAnimated(float opacity) OVERRIDE;
-  virtual void OnTransformAnimated(const gfx::Transform& transform) OVERRIDE;
+  virtual void OnFilterAnimated(const FilterOperations& filters) override;
+  virtual void OnOpacityAnimated(float opacity) override;
+  virtual void OnTransformAnimated(const gfx::Transform& transform) override;
   virtual void OnScrollOffsetAnimated(
-      const gfx::ScrollOffset& scroll_offset) OVERRIDE;
-  virtual void OnAnimationWaitingForDeletion() OVERRIDE;
-  virtual bool IsActive() const OVERRIDE;
+      const gfx::ScrollOffset& scroll_offset) override;
+  virtual void OnAnimationWaitingForDeletion() override;
+  virtual bool IsActive() const override;
 
   // AnimationDelegate implementation.
   virtual void NotifyAnimationStarted(
       base::TimeTicks monotonic_time,
-      Animation::TargetProperty target_property) OVERRIDE{};
+      Animation::TargetProperty target_property) override{};
   virtual void NotifyAnimationFinished(
       base::TimeTicks monotonic_time,
-      Animation::TargetProperty target_property) OVERRIDE;
+      Animation::TargetProperty target_property) override;
 
   // Tree structure.
   LayerImpl* parent() { return parent_; }
diff --git a/cc/layers/layer_impl_unittest.cc b/cc/layers/layer_impl_unittest.cc
index dc046a0..1d8289f 100644
--- a/cc/layers/layer_impl_unittest.cc
+++ b/cc/layers/layer_impl_unittest.cc
@@ -492,11 +492,11 @@ TEST_F(LayerImplScrollTest, ScrollByWithNonZeroOffset) {
 class ScrollDelegateIgnore : public LayerImpl::ScrollOffsetDelegate {
  public:
   virtual void SetTotalScrollOffset(
-      const gfx::ScrollOffset& new_value) OVERRIDE {}
-  virtual gfx::ScrollOffset GetTotalScrollOffset() OVERRIDE {
+      const gfx::ScrollOffset& new_value) override {}
+  virtual gfx::ScrollOffset GetTotalScrollOffset() override {
     return gfx::ScrollOffset(fixed_offset_);
   }
-  virtual bool IsExternalFlingActive() const OVERRIDE { return false; }
+  virtual bool IsExternalFlingActive() const override { return false; }
 
   void set_fixed_offset(const gfx::Vector2dF& fixed_offset) {
     fixed_offset_ = fixed_offset;
@@ -542,13 +542,13 @@ TEST_F(LayerImplScrollTest, ScrollByWithIgnoringDelegate) {
 class ScrollDelegateAccept : public LayerImpl::ScrollOffsetDelegate {
  public:
   virtual void SetTotalScrollOffset(
-      const gfx::ScrollOffset& new_value) OVERRIDE {
+      const gfx::ScrollOffset& new_value) override {
     current_offset_ = new_value;
   }
-  virtual gfx::ScrollOffset GetTotalScrollOffset() OVERRIDE {
+  virtual gfx::ScrollOffset GetTotalScrollOffset() override {
     return current_offset_;
   }
-  virtual bool IsExternalFlingActive() const OVERRIDE { return false; }
+  virtual bool IsExternalFlingActive() const override { return false; }
 
  private:
   gfx::ScrollOffset current_offset_;
diff --git a/cc/layers/layer_iterator_unittest.cc b/cc/layers/layer_iterator_unittest.cc
index 1daa923..3aa98d22 100644
--- a/cc/layers/layer_iterator_unittest.cc
+++ b/cc/layers/layer_iterator_unittest.cc
@@ -31,7 +31,7 @@ class TestLayer : public Layer {
   int count_representing_contributing_surface_;
   int count_representing_itself_;
 
-  virtual bool DrawsContent() const OVERRIDE { return draws_content_; }
+  virtual bool DrawsContent() const override { return draws_content_; }
   void set_draws_content(bool draws_content) { draws_content_ = draws_content; }
 
  private:
diff --git a/cc/layers/layer_perftest.cc b/cc/layers/layer_perftest.cc
index 18b4355..14afcbf 100644
--- a/cc/layers/layer_perftest.cc
+++ b/cc/layers/layer_perftest.cc
@@ -23,7 +23,7 @@ static const int kTimeCheckInterval = 10;
 
 class MockLayerPainter : public LayerPainter {
  public:
-  virtual void Paint(SkCanvas* canvas, const gfx::Rect& content_rect) OVERRIDE {
+  virtual void Paint(SkCanvas* canvas, const gfx::Rect& content_rect) override {
   }
 };
 
@@ -38,13 +38,13 @@ class LayerPerfTest : public testing::Test {
                kTimeCheckInterval) {}
 
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     layer_tree_host_ = FakeLayerTreeHost::Create(&fake_client_);
     layer_tree_host_->InitializeSingleThreaded(
         &fake_client_, base::MessageLoopProxy::current());
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     layer_tree_host_->SetRootLayer(NULL);
     layer_tree_host_ = nullptr;
   }
diff --git a/cc/layers/layer_unittest.cc b/cc/layers/layer_unittest.cc
index 0ea8f3d..32b4b4c 100644
--- a/cc/layers/layer_unittest.cc
+++ b/cc/layers/layer_unittest.cc
@@ -51,7 +51,7 @@ class MockLayerTreeHost : public LayerTreeHost {
 
 class MockLayerPainter : public LayerPainter {
  public:
-  virtual void Paint(SkCanvas* canvas, const gfx::Rect& content_rect) OVERRIDE {
+  virtual void Paint(SkCanvas* canvas, const gfx::Rect& content_rect) override {
   }
 };
 
@@ -62,11 +62,11 @@ class LayerTest : public testing::Test {
         fake_client_(FakeLayerTreeHostClient::DIRECT_3D) {}
 
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     layer_tree_host_.reset(new StrictMock<MockLayerTreeHost>(&fake_client_));
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     Mock::VerifyAndClearExpectations(layer_tree_host_.get());
     EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(AnyNumber());
     parent_ = NULL;
@@ -1211,12 +1211,12 @@ class DrawsContentChangeLayer : public Layer {
     return make_scoped_refptr(new DrawsContentChangeLayer());
   }
 
-  virtual void SetLayerTreeHost(LayerTreeHost* host) OVERRIDE {
+  virtual void SetLayerTreeHost(LayerTreeHost* host) override {
     Layer::SetLayerTreeHost(host);
     SetFakeDrawsContent(!fake_draws_content_);
   }
 
-  virtual bool HasDrawableContent() const OVERRIDE {
+  virtual bool HasDrawableContent() const override {
     return fake_draws_content_ && Layer::HasDrawableContent();
   }
 
@@ -1227,7 +1227,7 @@ class DrawsContentChangeLayer : public Layer {
 
  private:
   DrawsContentChangeLayer() : Layer(), fake_draws_content_(false) {}
-  virtual ~DrawsContentChangeLayer() OVERRIDE {}
+  virtual ~DrawsContentChangeLayer() override {}
 
   bool fake_draws_content_;
 };
diff --git a/cc/layers/nine_patch_layer.h b/cc/layers/nine_patch_layer.h
index 61d3e01..c1891bc 100644
--- a/cc/layers/nine_patch_layer.h
+++ b/cc/layers/nine_patch_layer.h
@@ -21,7 +21,7 @@ class CC_EXPORT NinePatchLayer : public UIResourceLayer {
  public:
   static scoped_refptr<NinePatchLayer> Create();
 
-  virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE;
+  virtual void PushPropertiesTo(LayerImpl* layer) override;
 
   // |border| is the space around the center rectangular region in layer space
   // (known as aperture in image space).  |border.x()| and |border.y()| are the
@@ -43,7 +43,7 @@ class CC_EXPORT NinePatchLayer : public UIResourceLayer {
   NinePatchLayer();
   virtual ~NinePatchLayer();
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
+      override;
 
   gfx::Rect border_;
   bool fill_center_;
diff --git a/cc/layers/nine_patch_layer_impl.h b/cc/layers/nine_patch_layer_impl.h
index 235b182..15a9e54 100644
--- a/cc/layers/nine_patch_layer_impl.h
+++ b/cc/layers/nine_patch_layer_impl.h
@@ -58,20 +58,20 @@ class CC_EXPORT NinePatchLayerImpl : public UIResourceLayerImpl {
                  bool fill_center);
 
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
-  virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE;
+      override;
+  virtual void PushPropertiesTo(LayerImpl* layer) override;
 
   virtual void AppendQuads(RenderPass* render_pass,
                            const OcclusionTracker<LayerImpl>& occlusion_tracker,
-                           AppendQuadsData* append_quads_data) OVERRIDE;
+                           AppendQuadsData* append_quads_data) override;
 
-  virtual base::DictionaryValue* LayerTreeAsJson() const OVERRIDE;
+  virtual base::DictionaryValue* LayerTreeAsJson() const override;
 
  protected:
   NinePatchLayerImpl(LayerTreeImpl* tree_impl, int id);
 
  private:
-  virtual const char* LayerTypeAsString() const OVERRIDE;
+  virtual const char* LayerTypeAsString() const override;
 
   void CheckGeometryLimitations();
 
diff --git a/cc/layers/painted_scrollbar_layer.h b/cc/layers/painted_scrollbar_layer.h
index cd6a046..8a621e3 100644
--- a/cc/layers/painted_scrollbar_layer.h
+++ b/cc/layers/painted_scrollbar_layer.h
@@ -20,32 +20,32 @@ class CC_EXPORT PaintedScrollbarLayer : public ScrollbarLayerInterface,
                                         public ContentsScalingLayer {
  public:
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
+      override;
 
   static scoped_refptr<PaintedScrollbarLayer> Create(
       scoped_ptr<Scrollbar> scrollbar,
       int scroll_layer_id);
 
-  virtual bool OpacityCanAnimateOnImplThread() const OVERRIDE;
-  virtual ScrollbarLayerInterface* ToScrollbarLayer() OVERRIDE;
+  virtual bool OpacityCanAnimateOnImplThread() const override;
+  virtual ScrollbarLayerInterface* ToScrollbarLayer() override;
 
   // ScrollbarLayerInterface
-  virtual int ScrollLayerId() const OVERRIDE;
-  virtual void SetScrollLayer(int layer_id) OVERRIDE;
-  virtual void SetClipLayer(int layer_id) OVERRIDE;
+  virtual int ScrollLayerId() const override;
+  virtual void SetScrollLayer(int layer_id) override;
+  virtual void SetClipLayer(int layer_id) override;
 
-  virtual ScrollbarOrientation orientation() const OVERRIDE;
+  virtual ScrollbarOrientation orientation() const override;
 
   // Layer interface
   virtual bool Update(ResourceUpdateQueue* queue,
-                      const OcclusionTracker<Layer>* occlusion) OVERRIDE;
-  virtual void SetLayerTreeHost(LayerTreeHost* host) OVERRIDE;
-  virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE;
-  virtual void PushScrollClipPropertiesTo(LayerImpl* layer) OVERRIDE;
+                      const OcclusionTracker<Layer>* occlusion) override;
+  virtual void SetLayerTreeHost(LayerTreeHost* host) override;
+  virtual void PushPropertiesTo(LayerImpl* layer) override;
+  virtual void PushScrollClipPropertiesTo(LayerImpl* layer) override;
   virtual void CalculateContentsScale(float ideal_contents_scale,
                                       float* contents_scale_x,
                                       float* contents_scale_y,
-                                      gfx::Size* content_bounds) OVERRIDE;
+                                      gfx::Size* content_bounds) override;
 
  protected:
   PaintedScrollbarLayer(scoped_ptr<Scrollbar> scrollbar, int scroll_layer_id);
diff --git a/cc/layers/painted_scrollbar_layer_impl.h b/cc/layers/painted_scrollbar_layer_impl.h
index 4ebefb6..d835223 100644
--- a/cc/layers/painted_scrollbar_layer_impl.h
+++ b/cc/layers/painted_scrollbar_layer_impl.h
@@ -25,14 +25,14 @@ class CC_EXPORT PaintedScrollbarLayerImpl : public ScrollbarLayerImplBase {
 
   // LayerImpl implementation.
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
-  virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE;
+      override;
+  virtual void PushPropertiesTo(LayerImpl* layer) override;
 
   virtual bool WillDraw(DrawMode draw_mode,
-                        ResourceProvider* resource_provider) OVERRIDE;
+                        ResourceProvider* resource_provider) override;
   virtual void AppendQuads(RenderPass* render_pass,
                            const OcclusionTracker<LayerImpl>& occlusion_tracker,
-                           AppendQuadsData* append_quads_data) OVERRIDE;
+                           AppendQuadsData* append_quads_data) override;
 
   void SetThumbThickness(int thumb_thickness);
   void SetThumbLength(int thumb_length);
@@ -52,14 +52,14 @@ class CC_EXPORT PaintedScrollbarLayerImpl : public ScrollbarLayerImplBase {
                             ScrollbarOrientation orientation);
 
   // ScrollbarLayerImplBase implementation.
-  virtual int ThumbThickness() const OVERRIDE;
-  virtual int ThumbLength() const OVERRIDE;
-  virtual float TrackLength() const OVERRIDE;
-  virtual int TrackStart() const OVERRIDE;
-  virtual bool IsThumbResizable() const OVERRIDE;
+  virtual int ThumbThickness() const override;
+  virtual int ThumbLength() const override;
+  virtual float TrackLength() const override;
+  virtual int TrackStart() const override;
+  virtual bool IsThumbResizable() const override;
 
  private:
-  virtual const char* LayerTypeAsString() const OVERRIDE;
+  virtual const char* LayerTypeAsString() const override;
 
   UIResourceId track_ui_resource_id_;
   UIResourceId thumb_ui_resource_id_;
diff --git a/cc/layers/picture_image_layer.h b/cc/layers/picture_image_layer.h
index c0c0c84..6f73b42 100644
--- a/cc/layers/picture_image_layer.h
+++ b/cc/layers/picture_image_layer.h
@@ -21,18 +21,18 @@ class CC_EXPORT PictureImageLayer : public PictureLayer, ContentLayerClient {
 
   // Layer implementation.
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(
-      LayerTreeImpl* tree_impl) OVERRIDE;
+      LayerTreeImpl* tree_impl) override;
 
   // ContentLayerClient implementation.
   virtual void PaintContents(
       SkCanvas* canvas,
       const gfx::Rect& clip,
-      ContentLayerClient::GraphicsContextStatus gc_status) OVERRIDE;
-  virtual void DidChangeLayerCanUseLCDText() OVERRIDE {}
-  virtual bool FillsBoundsCompletely() const OVERRIDE;
+      ContentLayerClient::GraphicsContextStatus gc_status) override;
+  virtual void DidChangeLayerCanUseLCDText() override {}
+  virtual bool FillsBoundsCompletely() const override;
 
  protected:
-  virtual bool HasDrawableContent() const OVERRIDE;
+  virtual bool HasDrawableContent() const override;
 
  private:
   PictureImageLayer();
diff --git a/cc/layers/picture_image_layer_impl.h b/cc/layers/picture_image_layer_impl.h
index cb48cf5..db36a13 100644
--- a/cc/layers/picture_image_layer_impl.h
+++ b/cc/layers/picture_image_layer_impl.h
@@ -18,19 +18,19 @@ class CC_EXPORT PictureImageLayerImpl : public PictureLayerImpl {
   virtual ~PictureImageLayerImpl();
 
   // LayerImpl overrides.
-  virtual const char* LayerTypeAsString() const OVERRIDE;
+  virtual const char* LayerTypeAsString() const override;
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(
-      LayerTreeImpl* tree_impl) OVERRIDE;
+      LayerTreeImpl* tree_impl) override;
 
  protected:
   PictureImageLayerImpl(LayerTreeImpl* tree_impl, int id);
 
-  virtual bool ShouldAdjustRasterScale() const OVERRIDE;
-  virtual void RecalculateRasterScales() OVERRIDE;
+  virtual bool ShouldAdjustRasterScale() const override;
+  virtual void RecalculateRasterScales() override;
   virtual void GetDebugBorderProperties(
-      SkColor* color, float* width) const OVERRIDE;
+      SkColor* color, float* width) const override;
 
-  virtual void UpdateIdealScales() OVERRIDE;
+  virtual void UpdateIdealScales() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PictureImageLayerImpl);
diff --git a/cc/layers/picture_layer.h b/cc/layers/picture_layer.h
index 80bb4d8..978ec40 100644
--- a/cc/layers/picture_layer.h
+++ b/cc/layers/picture_layer.h
@@ -25,18 +25,18 @@ class CC_EXPORT PictureLayer : public Layer {
 
   // Layer interface.
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(
-      LayerTreeImpl* tree_impl) OVERRIDE;
-  virtual void SetLayerTreeHost(LayerTreeHost* host) OVERRIDE;
-  virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE;
-  virtual void SetNeedsDisplayRect(const gfx::RectF& layer_rect) OVERRIDE;
+      LayerTreeImpl* tree_impl) override;
+  virtual void SetLayerTreeHost(LayerTreeHost* host) override;
+  virtual void PushPropertiesTo(LayerImpl* layer) override;
+  virtual void SetNeedsDisplayRect(const gfx::RectF& layer_rect) override;
   virtual bool Update(ResourceUpdateQueue* queue,
-                      const OcclusionTracker<Layer>* occlusion) OVERRIDE;
-  virtual void SetIsMask(bool is_mask) OVERRIDE;
-  virtual bool SupportsLCDText() const OVERRIDE;
-  virtual skia::RefPtr<SkPicture> GetPicture() const OVERRIDE;
-  virtual bool IsSuitableForGpuRasterization() const OVERRIDE;
+                      const OcclusionTracker<Layer>* occlusion) override;
+  virtual void SetIsMask(bool is_mask) override;
+  virtual bool SupportsLCDText() const override;
+  virtual skia::RefPtr<SkPicture> GetPicture() const override;
+  virtual bool IsSuitableForGpuRasterization() const override;
 
-  virtual void RunMicroBenchmark(MicroBenchmark* benchmark) OVERRIDE;
+  virtual void RunMicroBenchmark(MicroBenchmark* benchmark) override;
 
   ContentLayerClient* client() { return client_; }
 
@@ -48,7 +48,7 @@ class CC_EXPORT PictureLayer : public Layer {
   explicit PictureLayer(ContentLayerClient* client);
   virtual ~PictureLayer();
 
-  virtual bool HasDrawableContent() const OVERRIDE;
+  virtual bool HasDrawableContent() const override;
   void UpdateCanUseLCDText();
 
  private:
diff --git a/cc/layers/picture_layer_impl.h b/cc/layers/picture_layer_impl.h
index a0cc434..9f9a939 100644
--- a/cc/layers/picture_layer_impl.h
+++ b/cc/layers/picture_layer_impl.h
@@ -102,47 +102,47 @@ class CC_EXPORT PictureLayerImpl
   virtual ~PictureLayerImpl();
 
   // LayerImpl overrides.
-  virtual const char* LayerTypeAsString() const OVERRIDE;
+  virtual const char* LayerTypeAsString() const override;
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
-  virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE;
+      override;
+  virtual void PushPropertiesTo(LayerImpl* layer) override;
   virtual void AppendQuads(RenderPass* render_pass,
                            const OcclusionTracker<LayerImpl>& occlusion_tracker,
-                           AppendQuadsData* append_quads_data) OVERRIDE;
+                           AppendQuadsData* append_quads_data) override;
   virtual void UpdateTiles(const Occlusion& occlusion_in_content_space,
-                           bool resourceless_software_draw) OVERRIDE;
-  virtual void NotifyTileStateChanged(const Tile* tile) OVERRIDE;
-  virtual void DidBecomeActive() OVERRIDE;
-  virtual void DidBeginTracing() OVERRIDE;
-  virtual void ReleaseResources() OVERRIDE;
-  virtual skia::RefPtr<SkPicture> GetPicture() OVERRIDE;
+                           bool resourceless_software_draw) override;
+  virtual void NotifyTileStateChanged(const Tile* tile) override;
+  virtual void DidBecomeActive() override;
+  virtual void DidBeginTracing() override;
+  virtual void ReleaseResources() override;
+  virtual skia::RefPtr<SkPicture> GetPicture() override;
 
   // PictureLayerTilingClient overrides.
   virtual scoped_refptr<Tile> CreateTile(
     PictureLayerTiling* tiling,
-    const gfx::Rect& content_rect) OVERRIDE;
-  virtual PicturePileImpl* GetPile() OVERRIDE;
+    const gfx::Rect& content_rect) override;
+  virtual PicturePileImpl* GetPile() override;
   virtual gfx::Size CalculateTileSize(
-      const gfx::Size& content_bounds) const OVERRIDE;
-  virtual const Region* GetInvalidation() OVERRIDE;
+      const gfx::Size& content_bounds) const override;
+  virtual const Region* GetInvalidation() override;
   virtual const PictureLayerTiling* GetTwinTiling(
-      const PictureLayerTiling* tiling) const OVERRIDE;
+      const PictureLayerTiling* tiling) const override;
   virtual PictureLayerTiling* GetRecycledTwinTiling(
-      const PictureLayerTiling* tiling) OVERRIDE;
-  virtual size_t GetMaxTilesForInterestArea() const OVERRIDE;
-  virtual float GetSkewportTargetTimeInSeconds() const OVERRIDE;
-  virtual int GetSkewportExtrapolationLimitInContentPixels() const OVERRIDE;
-  virtual WhichTree GetTree() const OVERRIDE;
+      const PictureLayerTiling* tiling) override;
+  virtual size_t GetMaxTilesForInterestArea() const override;
+  virtual float GetSkewportTargetTimeInSeconds() const override;
+  virtual int GetSkewportExtrapolationLimitInContentPixels() const override;
+  virtual WhichTree GetTree() const override;
 
   // PushPropertiesTo active tree => pending tree.
   void SyncTiling(const PictureLayerTiling* tiling);
 
   // Mask-related functions.
-  virtual ResourceProvider::ResourceId ContentsResourceId() const OVERRIDE;
+  virtual ResourceProvider::ResourceId ContentsResourceId() const override;
 
-  virtual size_t GPUMemoryUsageInBytes() const OVERRIDE;
+  virtual size_t GPUMemoryUsageInBytes() const override;
 
-  virtual void RunMicroBenchmark(MicroBenchmarkImpl* benchmark) OVERRIDE;
+  virtual void RunMicroBenchmark(MicroBenchmarkImpl* benchmark) override;
 
   // Functions used by tile manager.
   PictureLayerImpl* GetTwinLayer() { return twin_layer_; }
@@ -190,10 +190,10 @@ class CC_EXPORT PictureLayerImpl
   bool ShouldAdjustRasterScaleDuringScaleAnimations() const;
 
   virtual void GetDebugBorderProperties(
-      SkColor* color, float* width) const OVERRIDE;
+      SkColor* color, float* width) const override;
   virtual void GetAllTilesForTracing(
-      std::set<const Tile*>* tiles) const OVERRIDE;
-  virtual void AsValueInto(base::debug::TracedValue* dict) const OVERRIDE;
+      std::set<const Tile*>* tiles) const override;
+  virtual void AsValueInto(base::debug::TracedValue* dict) const override;
 
   virtual void UpdateIdealScales();
   float MaximumTilingContentsScale() const;
diff --git a/cc/layers/picture_layer_impl_perftest.cc b/cc/layers/picture_layer_impl_perftest.cc
index c26b07d..7d87424 100644
--- a/cc/layers/picture_layer_impl_perftest.cc
+++ b/cc/layers/picture_layer_impl_perftest.cc
@@ -45,7 +45,7 @@ class PictureLayerImplPerfTest : public testing::Test {
                base::TimeDelta::FromMilliseconds(kTimeLimitMillis),
                kTimeCheckInterval) {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     host_impl_.InitializeRenderer(FakeOutputSurface::Create3d());
   }
 
diff --git a/cc/layers/picture_layer_impl_unittest.cc b/cc/layers/picture_layer_impl_unittest.cc
index 20e61dc..c1809d8 100644
--- a/cc/layers/picture_layer_impl_unittest.cc
+++ b/cc/layers/picture_layer_impl_unittest.cc
@@ -38,7 +38,7 @@ class MockCanvas : public SkCanvas {
  public:
   explicit MockCanvas(int w, int h) : SkCanvas(w, h) {}
 
-  virtual void drawRect(const SkRect& rect, const SkPaint& paint) OVERRIDE {
+  virtual void drawRect(const SkRect& rect, const SkPaint& paint) override {
     // Capture calls before SkCanvas quickReject() kicks in.
     rects_.push_back(rect);
   }
@@ -71,7 +71,7 @@ class PictureLayerImplTest : public testing::Test {
   virtual ~PictureLayerImplTest() {
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     InitializeRenderer();
   }
 
@@ -2237,14 +2237,14 @@ TEST_F(PictureLayerImplTest, PinchingTooSmall) {
 
 class DeferredInitPictureLayerImplTest : public PictureLayerImplTest {
  public:
-  virtual void InitializeRenderer() OVERRIDE {
+  virtual void InitializeRenderer() override {
     bool delegated_rendering = false;
     host_impl_.InitializeRenderer(FakeOutputSurface::CreateDeferredGL(
         scoped_ptr<SoftwareOutputDevice>(new SoftwareOutputDevice),
         delegated_rendering));
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     PictureLayerImplTest::SetUp();
 
     // Create some default active and pending trees.
@@ -3564,7 +3564,7 @@ class PictureLayerImplTestWithDelegatingRenderer : public PictureLayerImplTest {
  public:
   PictureLayerImplTestWithDelegatingRenderer() : PictureLayerImplTest() {}
 
-  virtual void InitializeRenderer() OVERRIDE {
+  virtual void InitializeRenderer() override {
     host_impl_.InitializeRenderer(FakeOutputSurface::CreateDelegating3d());
   }
 };
diff --git a/cc/layers/picture_layer_unittest.cc b/cc/layers/picture_layer_unittest.cc
index 331193f..0e3d8fa 100644
--- a/cc/layers/picture_layer_unittest.cc
+++ b/cc/layers/picture_layer_unittest.cc
@@ -23,9 +23,9 @@ class MockContentLayerClient : public ContentLayerClient {
   virtual void PaintContents(
       SkCanvas* canvas,
       const gfx::Rect& clip,
-      ContentLayerClient::GraphicsContextStatus gc_status) OVERRIDE {}
-  virtual void DidChangeLayerCanUseLCDText() OVERRIDE {}
-  virtual bool FillsBoundsCompletely() const OVERRIDE {
+      ContentLayerClient::GraphicsContextStatus gc_status) override {}
+  virtual void DidChangeLayerCanUseLCDText() override {}
+  virtual bool FillsBoundsCompletely() const override {
     return false;
   };
 };
diff --git a/cc/layers/render_surface_unittest.cc b/cc/layers/render_surface_unittest.cc
index f9ac05b..b57152a 100644
--- a/cc/layers/render_surface_unittest.cc
+++ b/cc/layers/render_surface_unittest.cc
@@ -135,7 +135,7 @@ TEST(RenderSurfaceTest, SanityCheckSurfaceCreatesCorrectSharedQuadState) {
 
 class TestRenderPassSink : public RenderPassSink {
  public:
-  virtual void AppendRenderPass(scoped_ptr<RenderPass> render_pass) OVERRIDE {
+  virtual void AppendRenderPass(scoped_ptr<RenderPass> render_pass) override {
     render_passes_.push_back(render_pass.Pass());
   }
 
diff --git a/cc/layers/scrollbar_layer_impl_base.h b/cc/layers/scrollbar_layer_impl_base.h
index 7017ba2..014282e 100644
--- a/cc/layers/scrollbar_layer_impl_base.h
+++ b/cc/layers/scrollbar_layer_impl_base.h
@@ -44,8 +44,8 @@ class CC_EXPORT ScrollbarLayerImplBase : public LayerImpl {
     return is_left_side_vertical_scrollbar_;
   }
 
-  virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE;
-  virtual ScrollbarLayerImplBase* ToScrollbarLayer() OVERRIDE;
+  virtual void PushPropertiesTo(LayerImpl* layer) override;
+  virtual ScrollbarLayerImplBase* ToScrollbarLayer() override;
   void PushScrollClipPropertiesTo(LayerImpl* layer);
 
   bool SetVisibleToTotalLengthRatio(float ratio);
diff --git a/cc/layers/scrollbar_layer_unittest.cc b/cc/layers/scrollbar_layer_unittest.cc
index 44158d5..c83da7f 100644
--- a/cc/layers/scrollbar_layer_unittest.cc
+++ b/cc/layers/scrollbar_layer_unittest.cc
@@ -578,7 +578,7 @@ class ScrollbarLayerTestMaxTextureSize : public LayerTreeTest {
 
   void SetScrollbarBounds(const gfx::Size& bounds) { bounds_ = bounds; }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     scroll_layer_ = Layer::Create();
     layer_tree_host()->root_layer()->AddChild(scroll_layer_);
 
@@ -593,7 +593,7 @@ class ScrollbarLayerTestMaxTextureSize : public LayerTreeTest {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     const int kMaxTextureSize =
         layer_tree_host()->GetRendererCapabilities().max_texture_size;
 
@@ -608,7 +608,7 @@ class ScrollbarLayerTestMaxTextureSize : public LayerTreeTest {
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   scoped_refptr<PaintedScrollbarLayer> scrollbar_layer_;
@@ -645,7 +645,7 @@ class FakeLayerTreeHost : public LayerTreeHost {
     InitializeSingleThreaded(client, base::MessageLoopProxy::current());
   }
 
-  virtual UIResourceId CreateUIResource(UIResourceClient* content) OVERRIDE {
+  virtual UIResourceId CreateUIResource(UIResourceClient* content) override {
     total_ui_resource_created_++;
     UIResourceId nid = next_id_++;
     ui_resource_bitmap_map_.insert(
@@ -654,7 +654,7 @@ class FakeLayerTreeHost : public LayerTreeHost {
   }
 
   // Deletes a UI resource.  May safely be called more than once.
-  virtual void DeleteUIResource(UIResourceId id) OVERRIDE {
+  virtual void DeleteUIResource(UIResourceId id) override {
     UIResourceBitmapMap::iterator iter = ui_resource_bitmap_map_.find(id);
     if (iter != ui_resource_bitmap_map_.end()) {
       ui_resource_bitmap_map_.erase(iter);
diff --git a/cc/layers/solid_color_layer.h b/cc/layers/solid_color_layer.h
index d391070..987c005 100644
--- a/cc/layers/solid_color_layer.h
+++ b/cc/layers/solid_color_layer.h
@@ -18,9 +18,9 @@ class CC_EXPORT SolidColorLayer : public Layer {
   static scoped_refptr<SolidColorLayer> Create();
 
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
+      override;
 
-  virtual void SetBackgroundColor(SkColor color) OVERRIDE;
+  virtual void SetBackgroundColor(SkColor color) override;
 
  protected:
   SolidColorLayer();
diff --git a/cc/layers/solid_color_layer_impl.h b/cc/layers/solid_color_layer_impl.h
index e59db0f..b9ab1cf 100644
--- a/cc/layers/solid_color_layer_impl.h
+++ b/cc/layers/solid_color_layer_impl.h
@@ -31,16 +31,16 @@ class CC_EXPORT SolidColorLayerImpl : public LayerImpl {
 
   // LayerImpl overrides.
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
+      override;
   virtual void AppendQuads(RenderPass* render_pass,
                            const OcclusionTracker<LayerImpl>& occlusion_tracker,
-                           AppendQuadsData* append_quads_data) OVERRIDE;
+                           AppendQuadsData* append_quads_data) override;
 
  protected:
   SolidColorLayerImpl(LayerTreeImpl* tree_impl, int id);
 
  private:
-  virtual const char* LayerTypeAsString() const OVERRIDE;
+  virtual const char* LayerTypeAsString() const override;
 
   DISALLOW_COPY_AND_ASSIGN(SolidColorLayerImpl);
 };
diff --git a/cc/layers/solid_color_scrollbar_layer.h b/cc/layers/solid_color_scrollbar_layer.h
index 654a6a6..de46c54 100644
--- a/cc/layers/solid_color_scrollbar_layer.h
+++ b/cc/layers/solid_color_scrollbar_layer.h
@@ -15,7 +15,7 @@ class CC_EXPORT SolidColorScrollbarLayer : public ScrollbarLayerInterface,
                                            public Layer {
  public:
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
+      override;
 
   static scoped_refptr<SolidColorScrollbarLayer> Create(
       ScrollbarOrientation orientation,
@@ -25,20 +25,20 @@ class CC_EXPORT SolidColorScrollbarLayer : public ScrollbarLayerInterface,
       int scroll_layer_id);
 
   // Layer overrides.
-  virtual bool OpacityCanAnimateOnImplThread() const OVERRIDE;
-  virtual ScrollbarLayerInterface* ToScrollbarLayer() OVERRIDE;
+  virtual bool OpacityCanAnimateOnImplThread() const override;
+  virtual ScrollbarLayerInterface* ToScrollbarLayer() override;
 
-  virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE;
-  virtual void PushScrollClipPropertiesTo(LayerImpl* layer) OVERRIDE;
+  virtual void PushPropertiesTo(LayerImpl* layer) override;
+  virtual void PushScrollClipPropertiesTo(LayerImpl* layer) override;
 
-  virtual void SetNeedsDisplayRect(const gfx::RectF&) OVERRIDE;
+  virtual void SetNeedsDisplayRect(const gfx::RectF&) override;
 
   // ScrollbarLayerInterface
-  virtual int ScrollLayerId() const OVERRIDE;
-  virtual void SetScrollLayer(int layer_id) OVERRIDE;
-  virtual void SetClipLayer(int layer_id) OVERRIDE;
+  virtual int ScrollLayerId() const override;
+  virtual void SetScrollLayer(int layer_id) override;
+  virtual void SetClipLayer(int layer_id) override;
 
-  virtual ScrollbarOrientation orientation() const OVERRIDE;
+  virtual ScrollbarOrientation orientation() const override;
 
  protected:
   SolidColorScrollbarLayer(ScrollbarOrientation orientation,
diff --git a/cc/layers/solid_color_scrollbar_layer_impl.h b/cc/layers/solid_color_scrollbar_layer_impl.h
index 91f1ac3..93f1561 100644
--- a/cc/layers/solid_color_scrollbar_layer_impl.h
+++ b/cc/layers/solid_color_scrollbar_layer_impl.h
@@ -24,12 +24,12 @@ class CC_EXPORT SolidColorScrollbarLayerImpl : public ScrollbarLayerImplBase {
 
   // LayerImpl overrides.
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
-  virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE;
+      override;
+  virtual void PushPropertiesTo(LayerImpl* layer) override;
 
   virtual void AppendQuads(RenderPass* render_pass,
                            const OcclusionTracker<LayerImpl>& occlusion_tracker,
-                           AppendQuadsData* append_quads_data) OVERRIDE;
+                           AppendQuadsData* append_quads_data) override;
 
  protected:
   SolidColorScrollbarLayerImpl(LayerTreeImpl* tree_impl,
@@ -41,11 +41,11 @@ class CC_EXPORT SolidColorScrollbarLayerImpl : public ScrollbarLayerImplBase {
                                bool is_overlay);
 
   // ScrollbarLayerImplBase implementation.
-  virtual int ThumbThickness() const OVERRIDE;
-  virtual int ThumbLength() const OVERRIDE;
-  virtual float TrackLength() const OVERRIDE;
-  virtual int TrackStart() const OVERRIDE;
-  virtual bool IsThumbResizable() const OVERRIDE;
+  virtual int ThumbThickness() const override;
+  virtual int ThumbLength() const override;
+  virtual float TrackLength() const override;
+  virtual int TrackStart() const override;
+  virtual bool IsThumbResizable() const override;
 
  private:
   int thumb_thickness_;
diff --git a/cc/layers/surface_layer.h b/cc/layers/surface_layer.h
index d58d47d..eace365 100644
--- a/cc/layers/surface_layer.h
+++ b/cc/layers/surface_layer.h
@@ -21,12 +21,12 @@ class CC_EXPORT SurfaceLayer : public Layer {
 
   // Layer overrides.
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
-  virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE;
+      override;
+  virtual void PushPropertiesTo(LayerImpl* layer) override;
 
  protected:
   SurfaceLayer();
-  virtual bool HasDrawableContent() const OVERRIDE;
+  virtual bool HasDrawableContent() const override;
 
  private:
   virtual ~SurfaceLayer();
diff --git a/cc/layers/surface_layer_impl.h b/cc/layers/surface_layer_impl.h
index 712ea14..d791340 100644
--- a/cc/layers/surface_layer_impl.h
+++ b/cc/layers/surface_layer_impl.h
@@ -23,20 +23,20 @@ class CC_EXPORT SurfaceLayerImpl : public LayerImpl {
 
   // LayerImpl overrides.
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
-  virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE;
+      override;
+  virtual void PushPropertiesTo(LayerImpl* layer) override;
   virtual void AppendQuads(RenderPass* render_pass,
                            const OcclusionTracker<LayerImpl>& occlusion_tracker,
-                           AppendQuadsData* append_quads_data) OVERRIDE;
+                           AppendQuadsData* append_quads_data) override;
 
  protected:
   SurfaceLayerImpl(LayerTreeImpl* tree_impl, int id);
 
  private:
   virtual void GetDebugBorderProperties(SkColor* color,
-                                        float* width) const OVERRIDE;
-  virtual void AsValueInto(base::debug::TracedValue* dict) const OVERRIDE;
-  virtual const char* LayerTypeAsString() const OVERRIDE;
+                                        float* width) const override;
+  virtual void AsValueInto(base::debug::TracedValue* dict) const override;
+  virtual const char* LayerTypeAsString() const override;
 
   SurfaceId surface_id_;
 
diff --git a/cc/layers/texture_layer.h b/cc/layers/texture_layer.h
index 22dcb4d..735fed9 100644
--- a/cc/layers/texture_layer.h
+++ b/cc/layers/texture_layer.h
@@ -95,7 +95,7 @@ class CC_EXPORT TextureLayer : public Layer {
   void ClearTexture();
 
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
+      override;
 
   // Sets whether this texture should be Y-flipped at draw time. Defaults to
   // true.
@@ -134,18 +134,18 @@ class CC_EXPORT TextureLayer : public Layer {
   // TODO(danakj): Remove this when pepper doesn't need it. crbug.com/350204
   void SetTextureMailboxWithoutReleaseCallback(const TextureMailbox& mailbox);
 
-  virtual void SetNeedsDisplayRect(const gfx::RectF& dirty_rect) OVERRIDE;
+  virtual void SetNeedsDisplayRect(const gfx::RectF& dirty_rect) override;
 
-  virtual void SetLayerTreeHost(LayerTreeHost* layer_tree_host) OVERRIDE;
+  virtual void SetLayerTreeHost(LayerTreeHost* layer_tree_host) override;
   virtual bool Update(ResourceUpdateQueue* queue,
-                      const OcclusionTracker<Layer>* occlusion) OVERRIDE;
-  virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE;
-  virtual SimpleEnclosedRegion VisibleContentOpaqueRegion() const OVERRIDE;
+                      const OcclusionTracker<Layer>* occlusion) override;
+  virtual void PushPropertiesTo(LayerImpl* layer) override;
+  virtual SimpleEnclosedRegion VisibleContentOpaqueRegion() const override;
 
  protected:
   explicit TextureLayer(TextureLayerClient* client);
   virtual ~TextureLayer();
-  virtual bool HasDrawableContent() const OVERRIDE;
+  virtual bool HasDrawableContent() const override;
 
  private:
   void SetTextureMailboxInternal(
diff --git a/cc/layers/texture_layer_impl.h b/cc/layers/texture_layer_impl.h
index 9edf099..8fe7f0c 100644
--- a/cc/layers/texture_layer_impl.h
+++ b/cc/layers/texture_layer_impl.h
@@ -23,16 +23,16 @@ class CC_EXPORT TextureLayerImpl : public LayerImpl {
   virtual ~TextureLayerImpl();
 
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* layer_tree_impl)
-      OVERRIDE;
-  virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE;
+      override;
+  virtual void PushPropertiesTo(LayerImpl* layer) override;
 
   virtual bool WillDraw(DrawMode draw_mode,
-                        ResourceProvider* resource_provider) OVERRIDE;
+                        ResourceProvider* resource_provider) override;
   virtual void AppendQuads(RenderPass* render_pass,
                            const OcclusionTracker<LayerImpl>& occlusion_tracker,
-                           AppendQuadsData* append_quads_data) OVERRIDE;
-  virtual SimpleEnclosedRegion VisibleContentOpaqueRegion() const OVERRIDE;
-  virtual void ReleaseResources() OVERRIDE;
+                           AppendQuadsData* append_quads_data) override;
+  virtual SimpleEnclosedRegion VisibleContentOpaqueRegion() const override;
+  virtual void ReleaseResources() override;
 
   // These setter methods don't cause any implicit damage, so the texture client
   // must explicitly invalidate if they intend to cause a visible change in the
@@ -56,7 +56,7 @@ class CC_EXPORT TextureLayerImpl : public LayerImpl {
  private:
   TextureLayerImpl(LayerTreeImpl* tree_impl, int id);
 
-  virtual const char* LayerTypeAsString() const OVERRIDE;
+  virtual const char* LayerTypeAsString() const override;
   void FreeTextureMailbox();
 
   ResourceProvider::ResourceId external_texture_resource_;
diff --git a/cc/layers/texture_layer_unittest.cc b/cc/layers/texture_layer_unittest.cc
index b3c48fb..8846152 100644
--- a/cc/layers/texture_layer_unittest.cc
+++ b/cc/layers/texture_layer_unittest.cc
@@ -68,7 +68,7 @@ class FakeTextureLayerClient : public TextureLayerClient {
   virtual bool PrepareTextureMailbox(
       TextureMailbox* mailbox,
       scoped_ptr<SingleReleaseCallback>* release_callback,
-      bool use_shared_memory) OVERRIDE {
+      bool use_shared_memory) override {
     if (!mailbox_changed_)
       return false;
 
@@ -721,7 +721,7 @@ class TextureLayerImplWithMailboxThreadedCallback : public LayerTreeTest {
         callback.Pass());
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
 
     gfx::Size bounds(100, 100);
@@ -745,7 +745,7 @@ class TextureLayerImplWithMailboxThreadedCallback : public LayerTreeTest {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     ++commit_count_;
     switch (commit_count_) {
       case 1:
@@ -817,7 +817,7 @@ class TextureLayerImplWithMailboxThreadedCallback : public LayerTreeTest {
     }
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   base::ThreadChecker main_thread_;
@@ -846,7 +846,7 @@ class TextureLayerMailboxIsActivatedDuringCommit : public LayerTreeTest {
         callback.Pass());
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     gfx::Size bounds(100, 100);
     root_ = Layer::Create();
     root_->SetBounds(bounds);
@@ -863,11 +863,11 @@ class TextureLayerMailboxIsActivatedDuringCommit : public LayerTreeTest {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void WillActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void WillActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     ++activate_count_;
   }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // The first mailbox has been activated. Set a new mailbox, and
@@ -886,7 +886,7 @@ class TextureLayerMailboxIsActivatedDuringCommit : public LayerTreeTest {
     }
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     switch (host_impl->active_tree()->source_frame_number()) {
       case 0: {
         // The activate for the 1st mailbox should have happened before now.
@@ -911,7 +911,7 @@ class TextureLayerMailboxIsActivatedDuringCommit : public LayerTreeTest {
   }
 
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   int activate_count_;
   scoped_refptr<Layer> root_;
@@ -1133,7 +1133,7 @@ class TextureLayerNoExtraCommitForMailboxTest
   virtual bool PrepareTextureMailbox(
       TextureMailbox* texture_mailbox,
       scoped_ptr<SingleReleaseCallback>* release_callback,
-      bool use_shared_memory) OVERRIDE {
+      bool use_shared_memory) override {
     if (layer_tree_host()->source_frame_number() == 1) {
       // Once this has been committed, the mailbox will be released.
       *texture_mailbox = TextureMailbox();
@@ -1154,7 +1154,7 @@ class TextureLayerNoExtraCommitForMailboxTest
     EndTest();
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(gfx::Size(10, 10));
     root->SetIsDrawable(true);
@@ -1168,11 +1168,11 @@ class TextureLayerNoExtraCommitForMailboxTest
     LayerTreeTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         EXPECT_FALSE(proxy()->MainFrameWillHappenForTesting());
@@ -1189,7 +1189,7 @@ class TextureLayerNoExtraCommitForMailboxTest
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
-                                   bool result) OVERRIDE {
+                                   bool result) override {
     ASSERT_TRUE(result);
     DelegatedFrameData* delegated_frame_data =
         output_surface()->last_sent_frame().delegated_frame_data.get();
@@ -1206,7 +1206,7 @@ class TextureLayerNoExtraCommitForMailboxTest
     host_impl->ReclaimResources(&ack);
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   scoped_refptr<TextureLayer> texture_layer_;
@@ -1233,7 +1233,7 @@ class TextureLayerChangeInvisibleMailboxTest
   virtual bool PrepareTextureMailbox(
       TextureMailbox* mailbox,
       scoped_ptr<SingleReleaseCallback>* release_callback,
-      bool use_shared_memory) OVERRIDE {
+      bool use_shared_memory) override {
     ++prepare_called_;
     if (!mailbox_changed_)
       return false;
@@ -1252,7 +1252,7 @@ class TextureLayerChangeInvisibleMailboxTest
     ++mailbox_returned_;
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(gfx::Size(10, 10));
     root->SetIsDrawable(true);
@@ -1277,11 +1277,11 @@ class TextureLayerChangeInvisibleMailboxTest
     LayerTreeTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     ++commit_count_;
     switch (commit_count_) {
       case 1:
@@ -1326,7 +1326,7 @@ class TextureLayerChangeInvisibleMailboxTest
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
-                                   bool result) OVERRIDE {
+                                   bool result) override {
     ASSERT_TRUE(result);
     DelegatedFrameData* delegated_frame_data =
         output_surface()->last_sent_frame().delegated_frame_data.get();
@@ -1343,7 +1343,7 @@ class TextureLayerChangeInvisibleMailboxTest
     host_impl->ReclaimResources(&ack);
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   scoped_refptr<SolidColorLayer> solid_layer_;
@@ -1370,7 +1370,7 @@ class TextureLayerReleaseResourcesBase
   virtual bool PrepareTextureMailbox(
       TextureMailbox* mailbox,
       scoped_ptr<SingleReleaseCallback>* release_callback,
-      bool use_shared_memory) OVERRIDE {
+      bool use_shared_memory) override {
     *mailbox = TextureMailbox(MailboxFromChar('1'), GL_TEXTURE_2D, 0);
     *release_callback = SingleReleaseCallback::Create(
         base::Bind(&TextureLayerReleaseResourcesBase::MailboxReleased,
@@ -1382,7 +1382,7 @@ class TextureLayerReleaseResourcesBase
     mailbox_released_ = true;
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     LayerTreeTest::SetupTree();
 
     scoped_refptr<TextureLayer> texture_layer =
@@ -1393,16 +1393,16 @@ class TextureLayerReleaseResourcesBase
     layer_tree_host()->root_layer()->AddChild(texture_layer);
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     mailbox_released_ = false;
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     EXPECT_TRUE(mailbox_released_);
   }
 
@@ -1413,7 +1413,7 @@ class TextureLayerReleaseResourcesBase
 class TextureLayerReleaseResourcesAfterCommit
     : public TextureLayerReleaseResourcesBase {
  public:
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     LayerTreeImpl* tree = NULL;
     if (host_impl->settings().impl_side_painting)
       tree = host_impl->pending_tree();
@@ -1428,7 +1428,7 @@ SINGLE_AND_MULTI_THREAD_TEST_F(TextureLayerReleaseResourcesAfterCommit);
 class TextureLayerReleaseResourcesAfterActivate
     : public TextureLayerReleaseResourcesBase {
  public:
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     host_impl->active_tree()->root_layer()->children()[0]->ReleaseResources();
   }
 };
@@ -1455,7 +1455,7 @@ class TextureLayerWithMailboxMainThreadDeleted : public LayerTreeTest {
         callback.Pass());
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     gfx::Size bounds(100, 100);
     root_ = Layer::Create();
     root_->SetBounds(bounds);
@@ -1469,7 +1469,7 @@ class TextureLayerWithMailboxMainThreadDeleted : public LayerTreeTest {
     layer_tree_host()->SetViewportSize(bounds);
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
 
     callback_count_ = 0;
@@ -1481,7 +1481,7 @@ class TextureLayerWithMailboxMainThreadDeleted : public LayerTreeTest {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // Delete the TextureLayer on the main thread while the mailbox is in
@@ -1492,7 +1492,7 @@ class TextureLayerWithMailboxMainThreadDeleted : public LayerTreeTest {
     }
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     EXPECT_EQ(1, callback_count_);
   }
 
@@ -1526,7 +1526,7 @@ class TextureLayerWithMailboxImplThreadDeleted : public LayerTreeTest {
         callback.Pass());
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     gfx::Size bounds(100, 100);
     root_ = Layer::Create();
     root_->SetBounds(bounds);
@@ -1540,7 +1540,7 @@ class TextureLayerWithMailboxImplThreadDeleted : public LayerTreeTest {
     layer_tree_host()->SetViewportSize(bounds);
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
 
     callback_count_ = 0;
@@ -1552,7 +1552,7 @@ class TextureLayerWithMailboxImplThreadDeleted : public LayerTreeTest {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // Remove the TextureLayer on the main thread while the mailbox is in
@@ -1566,7 +1566,7 @@ class TextureLayerWithMailboxImplThreadDeleted : public LayerTreeTest {
     }
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     EXPECT_EQ(1, callback_count_);
   }
 
diff --git a/cc/layers/tiled_layer.h b/cc/layers/tiled_layer.h
index 9f482c8..e8ac89b 100644
--- a/cc/layers/tiled_layer.h
+++ b/cc/layers/tiled_layer.h
@@ -25,17 +25,17 @@ class CC_EXPORT TiledLayer : public ContentsScalingLayer {
   };
 
   // Layer implementation.
-  virtual void SetIsMask(bool is_mask) OVERRIDE;
-  virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE;
-  virtual void ReduceMemoryUsage() OVERRIDE;
-  virtual void SetNeedsDisplayRect(const gfx::RectF& dirty_rect) OVERRIDE;
-  virtual void SetLayerTreeHost(LayerTreeHost* layer_tree_host) OVERRIDE;
+  virtual void SetIsMask(bool is_mask) override;
+  virtual void PushPropertiesTo(LayerImpl* layer) override;
+  virtual void ReduceMemoryUsage() override;
+  virtual void SetNeedsDisplayRect(const gfx::RectF& dirty_rect) override;
+  virtual void SetLayerTreeHost(LayerTreeHost* layer_tree_host) override;
   virtual void SetTexturePriorities(const PriorityCalculator& priority_calc)
-      OVERRIDE;
-  virtual SimpleEnclosedRegion VisibleContentOpaqueRegion() const OVERRIDE;
+      override;
+  virtual SimpleEnclosedRegion VisibleContentOpaqueRegion() const override;
   virtual bool Update(ResourceUpdateQueue* queue,
-                      const OcclusionTracker<Layer>* occlusion) OVERRIDE;
-  virtual void OnOutputSurfaceCreated() OVERRIDE;
+                      const OcclusionTracker<Layer>* occlusion) override;
+  virtual void OnOutputSurfaceCreated() override;
 
  protected:
   TiledLayer();
@@ -67,7 +67,7 @@ class CC_EXPORT TiledLayer : public ContentsScalingLayer {
 
   bool SkipsDraw() const { return skips_draw_; }
 
-  virtual bool HasDrawableContent() const OVERRIDE;
+  virtual bool HasDrawableContent() const override;
 
   // Virtual for testing
   virtual PrioritizedResourceManager* ResourceManager();
@@ -76,7 +76,7 @@ class CC_EXPORT TiledLayer : public ContentsScalingLayer {
 
  private:
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
+      override;
 
   void CreateTilerIfNeeded();
   void set_tiling_option(TilingOption tiling_option) {
diff --git a/cc/layers/tiled_layer_impl.h b/cc/layers/tiled_layer_impl.h
index 4c1459e..0cd0741 100644
--- a/cc/layers/tiled_layer_impl.h
+++ b/cc/layers/tiled_layer_impl.h
@@ -23,16 +23,16 @@ class CC_EXPORT TiledLayerImpl : public LayerImpl {
   virtual ~TiledLayerImpl();
 
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
-  virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE;
+      override;
+  virtual void PushPropertiesTo(LayerImpl* layer) override;
 
   virtual bool WillDraw(DrawMode draw_mode,
-                        ResourceProvider* resource_provider) OVERRIDE;
+                        ResourceProvider* resource_provider) override;
   virtual void AppendQuads(RenderPass* render_pass,
                            const OcclusionTracker<LayerImpl>& occlusion_tracker,
-                           AppendQuadsData* append_quads_data) OVERRIDE;
+                           AppendQuadsData* append_quads_data) override;
 
-  virtual ResourceProvider::ResourceId ContentsResourceId() const OVERRIDE;
+  virtual ResourceProvider::ResourceId ContentsResourceId() const override;
 
   void set_skips_draw(bool skips_draw) { skips_draw_ = skips_draw; }
   void SetTilingData(const LayerTilingData& tiler);
@@ -42,12 +42,12 @@ class CC_EXPORT TiledLayerImpl : public LayerImpl {
                           bool contents_swizzled);
   void PushInvalidTile(int i, int j);
 
-  virtual SimpleEnclosedRegion VisibleContentOpaqueRegion() const OVERRIDE;
-  virtual void ReleaseResources() OVERRIDE;
+  virtual SimpleEnclosedRegion VisibleContentOpaqueRegion() const override;
+  virtual void ReleaseResources() override;
 
   const LayerTilingData* TilingForTesting() const { return tiler_.get(); }
 
-  virtual size_t GPUMemoryUsageInBytes() const OVERRIDE;
+  virtual size_t GPUMemoryUsageInBytes() const override;
 
  protected:
   TiledLayerImpl(LayerTreeImpl* tree_impl, int id);
@@ -56,11 +56,11 @@ class CC_EXPORT TiledLayerImpl : public LayerImpl {
   bool HasResourceIdForTileAt(int i, int j) const;
 
   virtual void GetDebugBorderProperties(SkColor* color, float* width) const
-      OVERRIDE;
-  virtual void AsValueInto(base::debug::TracedValue* dict) const OVERRIDE;
+      override;
+  virtual void AsValueInto(base::debug::TracedValue* dict) const override;
 
  private:
-  virtual const char* LayerTypeAsString() const OVERRIDE;
+  virtual const char* LayerTypeAsString() const override;
 
   DrawableTile* TileAt(int i, int j) const;
   DrawableTile* CreateTile(int i, int j);
diff --git a/cc/layers/tiled_layer_unittest.cc b/cc/layers/tiled_layer_unittest.cc
index d2bc0a9..3af0e3f 100644
--- a/cc/layers/tiled_layer_unittest.cc
+++ b/cc/layers/tiled_layer_unittest.cc
@@ -69,7 +69,7 @@ class SynchronousOutputSurfaceLayerTreeHost : public LayerTreeHost {
   }
 
   virtual void OnCreateAndInitializeOutputSurfaceAttempted(
-      bool success) OVERRIDE {
+      bool success) override {
     LayerTreeHost::OnCreateAndInitializeOutputSurfaceAttempted(success);
     output_surface_created_ = success;
     run_loop_.Quit();
@@ -1648,7 +1648,7 @@ class TrackingLayerPainter : public LayerPainter {
     return make_scoped_ptr(new TrackingLayerPainter());
   }
 
-  virtual void Paint(SkCanvas* canvas, const gfx::Rect& content_rect) OVERRIDE {
+  virtual void Paint(SkCanvas* canvas, const gfx::Rect& content_rect) override {
     painted_rect_ = content_rect;
   }
 
@@ -1674,7 +1674,7 @@ class UpdateTrackingTiledLayer : public FakeTiledLayer {
   }
 
  private:
-  virtual LayerUpdater* Updater() const OVERRIDE {
+  virtual LayerUpdater* Updater() const override {
     return layer_updater_.get();
   }
   virtual ~UpdateTrackingTiledLayer() {}
diff --git a/cc/layers/ui_resource_layer.cc b/cc/layers/ui_resource_layer.cc
index 498ba33..4293b09 100644
--- a/cc/layers/ui_resource_layer.cc
+++ b/cc/layers/ui_resource_layer.cc
@@ -23,7 +23,7 @@ class ScopedUIResourceHolder : public UIResourceLayer::UIResourceHolder {
                                             const SkBitmap& skbitmap) {
     return make_scoped_ptr(new ScopedUIResourceHolder(host, skbitmap));
   }
-  virtual UIResourceId id() OVERRIDE { return resource_->id(); }
+  virtual UIResourceId id() override { return resource_->id(); }
 
  private:
   ScopedUIResourceHolder(LayerTreeHost* host, const SkBitmap& skbitmap) {
@@ -39,7 +39,7 @@ class SharedUIResourceHolder : public UIResourceLayer::UIResourceHolder {
     return make_scoped_ptr(new SharedUIResourceHolder(id));
   }
 
-  virtual UIResourceId id() OVERRIDE { return id_; }
+  virtual UIResourceId id() override { return id_; }
 
  private:
   explicit SharedUIResourceHolder(UIResourceId id) : id_(id) {}
diff --git a/cc/layers/ui_resource_layer.h b/cc/layers/ui_resource_layer.h
index 8e278a9..f79389b 100644
--- a/cc/layers/ui_resource_layer.h
+++ b/cc/layers/ui_resource_layer.h
@@ -20,9 +20,9 @@ class CC_EXPORT UIResourceLayer : public Layer {
  public:
   static scoped_refptr<UIResourceLayer> Create();
 
-  virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE;
+  virtual void PushPropertiesTo(LayerImpl* layer) override;
 
-  virtual void SetLayerTreeHost(LayerTreeHost* host) OVERRIDE;
+  virtual void SetLayerTreeHost(LayerTreeHost* host) override;
 
   void SetBitmap(const SkBitmap& skbitmap);
 
@@ -49,7 +49,7 @@ class CC_EXPORT UIResourceLayer : public Layer {
   UIResourceLayer();
   virtual ~UIResourceLayer();
 
-  virtual bool HasDrawableContent() const OVERRIDE;
+  virtual bool HasDrawableContent() const override;
 
   scoped_ptr<UIResourceHolder> ui_resource_holder_;
   SkBitmap bitmap_;
@@ -60,7 +60,7 @@ class CC_EXPORT UIResourceLayer : public Layer {
 
  private:
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
+      override;
   void RecreateUIResourceHolder();
 
 
diff --git a/cc/layers/ui_resource_layer_impl.h b/cc/layers/ui_resource_layer_impl.h
index 2bdf818..f214546 100644
--- a/cc/layers/ui_resource_layer_impl.h
+++ b/cc/layers/ui_resource_layer_impl.h
@@ -40,16 +40,16 @@ class CC_EXPORT UIResourceLayerImpl : public LayerImpl {
   void SetVertexOpacity(const float vertex_opacity[4]);
 
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
-  virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE;
+      override;
+  virtual void PushPropertiesTo(LayerImpl* layer) override;
 
   virtual bool WillDraw(DrawMode draw_mode,
-                        ResourceProvider* resource_provider) OVERRIDE;
+                        ResourceProvider* resource_provider) override;
   virtual void AppendQuads(RenderPass* render_pass,
                            const OcclusionTracker<LayerImpl>& occlusion_tracker,
-                           AppendQuadsData* append_quads_data) OVERRIDE;
+                           AppendQuadsData* append_quads_data) override;
 
-  virtual base::DictionaryValue* LayerTreeAsJson() const OVERRIDE;
+  virtual base::DictionaryValue* LayerTreeAsJson() const override;
 
  protected:
   UIResourceLayerImpl(LayerTreeImpl* tree_impl, int id);
@@ -64,7 +64,7 @@ class CC_EXPORT UIResourceLayerImpl : public LayerImpl {
   float vertex_opacity_[4];
 
  private:
-  virtual const char* LayerTypeAsString() const OVERRIDE;
+  virtual const char* LayerTypeAsString() const override;
 
   DISALLOW_COPY_AND_ASSIGN(UIResourceLayerImpl);
 };
diff --git a/cc/layers/video_frame_provider_client_impl.h b/cc/layers/video_frame_provider_client_impl.h
index e676d0b..c2d6599 100644
--- a/cc/layers/video_frame_provider_client_impl.h
+++ b/cc/layers/video_frame_provider_client_impl.h
@@ -39,9 +39,9 @@ class VideoFrameProviderClientImpl
 
   // VideoFrameProvider::Client implementation. These methods are all callable
   // on any thread.
-  virtual void StopUsingProvider() OVERRIDE;
-  virtual void DidReceiveFrame() OVERRIDE;
-  virtual void DidUpdateMatrix(const float* matrix) OVERRIDE;
+  virtual void StopUsingProvider() override;
+  virtual void DidReceiveFrame() override;
+  virtual void DidUpdateMatrix(const float* matrix) override;
 
  private:
   explicit VideoFrameProviderClientImpl(VideoFrameProvider* provider);
diff --git a/cc/layers/video_layer.h b/cc/layers/video_layer.h
index 361007d..c7ca647 100644
--- a/cc/layers/video_layer.h
+++ b/cc/layers/video_layer.h
@@ -24,10 +24,10 @@ class CC_EXPORT VideoLayer : public Layer {
                                           media::VideoRotation video_rotation);
 
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
+      override;
 
   virtual bool Update(ResourceUpdateQueue* queue,
-                      const OcclusionTracker<Layer>* occlusion) OVERRIDE;
+                      const OcclusionTracker<Layer>* occlusion) override;
 
  private:
   VideoLayer(VideoFrameProvider* provider, media::VideoRotation video_rotation);
diff --git a/cc/layers/video_layer_impl.h b/cc/layers/video_layer_impl.h
index 34f013a..47d14e2 100644
--- a/cc/layers/video_layer_impl.h
+++ b/cc/layers/video_layer_impl.h
@@ -31,16 +31,16 @@ class CC_EXPORT VideoLayerImpl : public LayerImpl {
 
   // LayerImpl implementation.
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
-  virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE;
+      override;
+  virtual void PushPropertiesTo(LayerImpl* layer) override;
   virtual bool WillDraw(DrawMode draw_mode,
-                        ResourceProvider* resource_provider) OVERRIDE;
+                        ResourceProvider* resource_provider) override;
   virtual void AppendQuads(RenderPass* render_pass,
                            const OcclusionTracker<LayerImpl>& occlusion_tracker,
-                           AppendQuadsData* append_quads_data) OVERRIDE;
-  virtual void DidDraw(ResourceProvider* resource_provider) OVERRIDE;
-  virtual void DidBecomeActive() OVERRIDE;
-  virtual void ReleaseResources() OVERRIDE;
+                           AppendQuadsData* append_quads_data) override;
+  virtual void DidDraw(ResourceProvider* resource_provider) override;
+  virtual void DidBecomeActive() override;
+  virtual void ReleaseResources() override;
 
   void SetNeedsRedraw();
 
@@ -54,7 +54,7 @@ class CC_EXPORT VideoLayerImpl : public LayerImpl {
                  int id,
                  media::VideoRotation video_rotation);
 
-  virtual const char* LayerTypeAsString() const OVERRIDE;
+  virtual const char* LayerTypeAsString() const override;
 
   scoped_refptr<VideoFrameProviderClientImpl> provider_client_impl_;
 
diff --git a/cc/output/bsp_walk_action.h b/cc/output/bsp_walk_action.h
index bb31865..342e635 100644
--- a/cc/output/bsp_walk_action.h
+++ b/cc/output/bsp_walk_action.h
@@ -23,7 +23,7 @@ class CC_EXPORT BspWalkAction {
 class CC_EXPORT BspWalkActionToVector : public BspWalkAction {
  public:
   explicit BspWalkActionToVector(std::vector<DrawPolygon*>* in_list);
-  virtual void operator()(DrawPolygon* item) OVERRIDE;
+  virtual void operator()(DrawPolygon* item) override;
 
  private:
   std::vector<DrawPolygon*>* list_;
diff --git a/cc/output/delegating_renderer.h b/cc/output/delegating_renderer.h
index 52dbe01..1acebc5 100644
--- a/cc/output/delegating_renderer.h
+++ b/cc/output/delegating_renderer.h
@@ -24,18 +24,18 @@ class CC_EXPORT DelegatingRenderer : public Renderer {
       ResourceProvider* resource_provider);
   virtual ~DelegatingRenderer();
 
-  virtual const RendererCapabilitiesImpl& Capabilities() const OVERRIDE;
+  virtual const RendererCapabilitiesImpl& Capabilities() const override;
 
   virtual void DrawFrame(RenderPassList* render_passes_in_draw_order,
                          float device_scale_factor,
                          const gfx::Rect& device_viewport_rect,
                          const gfx::Rect& device_clip_rect,
-                         bool disable_picture_quad_image_filtering) OVERRIDE;
+                         bool disable_picture_quad_image_filtering) override;
 
-  virtual void Finish() OVERRIDE {}
+  virtual void Finish() override {}
 
-  virtual void SwapBuffers(const CompositorFrameMetadata& metadata) OVERRIDE;
-  virtual void ReceiveSwapBuffersAck(const CompositorFrameAck&) OVERRIDE;
+  virtual void SwapBuffers(const CompositorFrameMetadata& metadata) override;
+  virtual void ReceiveSwapBuffersAck(const CompositorFrameAck&) override;
 
  private:
   DelegatingRenderer(RendererClient* client,
@@ -43,7 +43,7 @@ class CC_EXPORT DelegatingRenderer : public Renderer {
                      OutputSurface* output_surface,
                      ResourceProvider* resource_provider);
 
-  virtual void DidChangeVisibility() OVERRIDE;
+  virtual void DidChangeVisibility() override;
 
   OutputSurface* output_surface_;
   ResourceProvider* resource_provider_;
diff --git a/cc/output/delegating_renderer_unittest.cc b/cc/output/delegating_renderer_unittest.cc
index 48bacd5..4c9deb2 100644
--- a/cc/output/delegating_renderer_unittest.cc
+++ b/cc/output/delegating_renderer_unittest.cc
@@ -18,7 +18,7 @@ class DelegatingRendererTest : public LayerTreeTest {
   virtual ~DelegatingRendererTest() {}
 
   virtual scoped_ptr<OutputSurface> CreateOutputSurface(bool fallback)
-      OVERRIDE {
+      override {
     scoped_ptr<FakeOutputSurface> output_surface =
         FakeOutputSurface::CreateDelegating3d();
     output_surface_ = output_surface.get();
@@ -32,17 +32,17 @@ class DelegatingRendererTest : public LayerTreeTest {
 
 class DelegatingRendererTestDraw : public DelegatingRendererTest {
  public:
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.5f, 4.f);
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   virtual DrawResult PrepareToDrawOnThread(
       LayerTreeHostImpl* host_impl,
       LayerTreeHostImpl::FrameData* frame,
-      DrawResult draw_result) OVERRIDE {
+      DrawResult draw_result) override {
     EXPECT_EQ(0u, output_surface_->num_sent_frames());
 
     const CompositorFrame& last_frame = output_surface_->last_sent_frame();
@@ -53,12 +53,12 @@ class DelegatingRendererTestDraw : public DelegatingRendererTest {
     return DRAW_SUCCESS;
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     EXPECT_EQ(0u, output_surface_->num_sent_frames());
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
-                                   bool result) OVERRIDE {
+                                   bool result) override {
     EXPECT_TRUE(result);
     EXPECT_EQ(1u, output_surface_->num_sent_frames());
 
@@ -83,15 +83,15 @@ SINGLE_AND_MULTI_THREAD_DELEGATING_RENDERER_TEST_F(DelegatingRendererTestDraw);
 
 class DelegatingRendererTestResources : public DelegatingRendererTest {
  public:
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   virtual DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                            LayerTreeHostImpl::FrameData* frame,
-                                           DrawResult draw_result) OVERRIDE {
+                                           DrawResult draw_result) override {
     frame->render_passes.clear();
     frame->render_passes_by_id.clear();
 
@@ -111,12 +111,12 @@ class DelegatingRendererTestResources : public DelegatingRendererTest {
     return draw_result;
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     EXPECT_EQ(0u, output_surface_->num_sent_frames());
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
-                                   bool result) OVERRIDE {
+                                   bool result) override {
     EXPECT_TRUE(result);
     EXPECT_EQ(1u, output_surface_->num_sent_frames());
 
diff --git a/cc/output/direct_renderer.h b/cc/output/direct_renderer.h
index f13ed37..d4c4ba6 100644
--- a/cc/output/direct_renderer.h
+++ b/cc/output/direct_renderer.h
@@ -26,13 +26,13 @@ class CC_EXPORT DirectRenderer : public Renderer {
   virtual ~DirectRenderer();
 
   virtual void DecideRenderPassAllocationsForFrame(
-      const RenderPassList& render_passes_in_draw_order) OVERRIDE;
-  virtual bool HasAllocatedResourcesForTesting(RenderPassId id) const OVERRIDE;
+      const RenderPassList& render_passes_in_draw_order) override;
+  virtual bool HasAllocatedResourcesForTesting(RenderPassId id) const override;
   virtual void DrawFrame(RenderPassList* render_passes_in_draw_order,
                          float device_scale_factor,
                          const gfx::Rect& device_viewport_rect,
                          const gfx::Rect& device_clip_rect,
-                         bool disable_picture_quad_image_filtering) OVERRIDE;
+                         bool disable_picture_quad_image_filtering) override;
 
   struct CC_EXPORT DrawingFrame {
     DrawingFrame();
diff --git a/cc/output/gl_renderer.cc b/cc/output/gl_renderer.cc
index 0a897f3..6d5bc44 100644
--- a/cc/output/gl_renderer.cc
+++ b/cc/output/gl_renderer.cc
@@ -56,8 +56,8 @@ class FallbackFence : public ResourceProvider::Fence {
       : gl_(gl), has_passed_(true) {}
 
   // Overridden from ResourceProvider::Fence:
-  virtual void Set() OVERRIDE { has_passed_ = false; }
-  virtual bool HasPassed() OVERRIDE {
+  virtual void Set() override { has_passed_ = false; }
+  virtual bool HasPassed() override {
     if (!has_passed_) {
       has_passed_ = true;
       Synchronize();
@@ -251,11 +251,11 @@ class GLRenderer::SyncQuery {
         : query_(query) {}
 
     // Overridden from ResourceProvider::Fence:
-    virtual void Set() OVERRIDE {
+    virtual void Set() override {
       DCHECK(query_);
       query_->Set();
     }
-    virtual bool HasPassed() OVERRIDE {
+    virtual bool HasPassed() override {
       return !query_ || !query_->IsPending();
     }
 
diff --git a/cc/output/gl_renderer.h b/cc/output/gl_renderer.h
index 87739da..72f51b5 100644
--- a/cc/output/gl_renderer.h
+++ b/cc/output/gl_renderer.h
@@ -57,13 +57,13 @@ class CC_EXPORT GLRenderer : public DirectRenderer {
 
   virtual ~GLRenderer();
 
-  virtual const RendererCapabilitiesImpl& Capabilities() const OVERRIDE;
+  virtual const RendererCapabilitiesImpl& Capabilities() const override;
 
   // Waits for rendering to finish.
-  virtual void Finish() OVERRIDE;
+  virtual void Finish() override;
 
-  virtual void DoNoOp() OVERRIDE;
-  virtual void SwapBuffers(const CompositorFrameMetadata& metadata) OVERRIDE;
+  virtual void DoNoOp() override;
+  virtual void SwapBuffers(const CompositorFrameMetadata& metadata) override;
 
   virtual bool IsContextLost();
 
@@ -80,7 +80,7 @@ class CC_EXPORT GLRenderer : public DirectRenderer {
              TextureMailboxDeleter* texture_mailbox_deleter,
              int highp_threshold_min);
 
-  virtual void DidChangeVisibility() OVERRIDE;
+  virtual void DidChangeVisibility() override;
 
   bool IsBackbufferDiscarded() const { return is_backbuffer_discarded_; }
 
@@ -101,26 +101,26 @@ class CC_EXPORT GLRenderer : public DirectRenderer {
   void SetBlendEnabled(bool enabled);
   bool blend_enabled() const { return blend_shadow_; }
 
-  virtual void BindFramebufferToOutputSurface(DrawingFrame* frame) OVERRIDE;
+  virtual void BindFramebufferToOutputSurface(DrawingFrame* frame) override;
   virtual bool BindFramebufferToTexture(DrawingFrame* frame,
                                         const ScopedResource* resource,
-                                        const gfx::Rect& target_rect) OVERRIDE;
-  virtual void SetDrawViewport(const gfx::Rect& window_space_viewport) OVERRIDE;
-  virtual void SetScissorTestRect(const gfx::Rect& scissor_rect) OVERRIDE;
+                                        const gfx::Rect& target_rect) override;
+  virtual void SetDrawViewport(const gfx::Rect& window_space_viewport) override;
+  virtual void SetScissorTestRect(const gfx::Rect& scissor_rect) override;
   virtual void DiscardPixels(bool has_external_stencil_test,
-                             bool draw_rect_covers_full_surface) OVERRIDE;
+                             bool draw_rect_covers_full_surface) override;
   virtual void ClearFramebuffer(DrawingFrame* frame,
-                                bool has_external_stencil_test) OVERRIDE;
-  virtual void DoDrawQuad(DrawingFrame* frame, const class DrawQuad*) OVERRIDE;
-  virtual void BeginDrawingFrame(DrawingFrame* frame) OVERRIDE;
-  virtual void FinishDrawingFrame(DrawingFrame* frame) OVERRIDE;
-  virtual bool FlippedFramebuffer() const OVERRIDE;
-  virtual void EnsureScissorTestEnabled() OVERRIDE;
-  virtual void EnsureScissorTestDisabled() OVERRIDE;
+                                bool has_external_stencil_test) override;
+  virtual void DoDrawQuad(DrawingFrame* frame, const class DrawQuad*) override;
+  virtual void BeginDrawingFrame(DrawingFrame* frame) override;
+  virtual void FinishDrawingFrame(DrawingFrame* frame) override;
+  virtual bool FlippedFramebuffer() const override;
+  virtual void EnsureScissorTestEnabled() override;
+  virtual void EnsureScissorTestDisabled() override;
   virtual void CopyCurrentRenderPassToBitmap(
       DrawingFrame* frame,
-      scoped_ptr<CopyOutputRequest> request) OVERRIDE;
-  virtual void FinishDrawingQuadList() OVERRIDE;
+      scoped_ptr<CopyOutputRequest> request) override;
+  virtual void FinishDrawingQuadList() override;
 
   // Check if quad needs antialiasing and if so, inflate the quad and
   // fill edge array for fragment shader.  local_quad is set to
@@ -205,8 +205,8 @@ class CC_EXPORT GLRenderer : public DirectRenderer {
   void RestoreGLState();
   void RestoreFramebuffer(DrawingFrame* frame);
 
-  virtual void DiscardBackbuffer() OVERRIDE;
-  virtual void EnsureBackbuffer() OVERRIDE;
+  virtual void DiscardBackbuffer() override;
+  virtual void EnsureBackbuffer() override;
   void EnforceMemoryPolicy();
 
   void ScheduleOverlays(DrawingFrame* frame);
diff --git a/cc/output/gl_renderer_unittest.cc b/cc/output/gl_renderer_unittest.cc
index c98652c..45b6d2a 100644
--- a/cc/output/gl_renderer_unittest.cc
+++ b/cc/output/gl_renderer_unittest.cc
@@ -363,35 +363,35 @@ class ForbidSynchronousCallContext : public TestWebGraphicsContext3D {
   virtual void getAttachedShaders(GLuint program,
                                   GLsizei max_count,
                                   GLsizei* count,
-                                  GLuint* shaders) OVERRIDE {
+                                  GLuint* shaders) override {
     ADD_FAILURE();
   }
-  virtual GLint getAttribLocation(GLuint program, const GLchar* name) OVERRIDE {
+  virtual GLint getAttribLocation(GLuint program, const GLchar* name) override {
     ADD_FAILURE();
     return 0;
   }
-  virtual void getBooleanv(GLenum pname, GLboolean* value) OVERRIDE {
+  virtual void getBooleanv(GLenum pname, GLboolean* value) override {
     ADD_FAILURE();
   }
   virtual void getBufferParameteriv(GLenum target,
                                     GLenum pname,
-                                    GLint* value) OVERRIDE {
+                                    GLint* value) override {
     ADD_FAILURE();
   }
-  virtual GLenum getError() OVERRIDE {
+  virtual GLenum getError() override {
     ADD_FAILURE();
     return GL_NO_ERROR;
   }
-  virtual void getFloatv(GLenum pname, GLfloat* value) OVERRIDE {
+  virtual void getFloatv(GLenum pname, GLfloat* value) override {
     ADD_FAILURE();
   }
   virtual void getFramebufferAttachmentParameteriv(GLenum target,
                                                    GLenum attachment,
                                                    GLenum pname,
-                                                   GLint* value) OVERRIDE {
+                                                   GLint* value) override {
     ADD_FAILURE();
   }
-  virtual void getIntegerv(GLenum pname, GLint* value) OVERRIDE {
+  virtual void getIntegerv(GLenum pname, GLint* value) override {
     if (pname == GL_MAX_TEXTURE_SIZE) {
       // MAX_TEXTURE_SIZE is cached client side, so it's OK to query.
       *value = 1024;
@@ -404,7 +404,7 @@ class ForbidSynchronousCallContext : public TestWebGraphicsContext3D {
   // mode, but not release.
   virtual void getProgramiv(GLuint program,
                             GLenum pname,
-                            GLint* value) OVERRIDE {
+                            GLint* value) override {
 #ifndef NDEBUG
     *value = 1;
 #else
@@ -412,7 +412,7 @@ class ForbidSynchronousCallContext : public TestWebGraphicsContext3D {
 #endif
   }
 
-  virtual void getShaderiv(GLuint shader, GLenum pname, GLint* value) OVERRIDE {
+  virtual void getShaderiv(GLuint shader, GLenum pname, GLint* value) override {
 #ifndef NDEBUG
     *value = 1;
 #else
@@ -422,53 +422,53 @@ class ForbidSynchronousCallContext : public TestWebGraphicsContext3D {
 
   virtual void getRenderbufferParameteriv(GLenum target,
                                           GLenum pname,
-                                          GLint* value) OVERRIDE {
+                                          GLint* value) override {
     ADD_FAILURE();
   }
 
   virtual void getShaderPrecisionFormat(GLenum shadertype,
                                         GLenum precisiontype,
                                         GLint* range,
-                                        GLint* precision) OVERRIDE {
+                                        GLint* precision) override {
     ADD_FAILURE();
   }
   virtual void getTexParameterfv(GLenum target,
                                  GLenum pname,
-                                 GLfloat* value) OVERRIDE {
+                                 GLfloat* value) override {
     ADD_FAILURE();
   }
   virtual void getTexParameteriv(GLenum target,
                                  GLenum pname,
-                                 GLint* value) OVERRIDE {
+                                 GLint* value) override {
     ADD_FAILURE();
   }
   virtual void getUniformfv(GLuint program,
                             GLint location,
-                            GLfloat* value) OVERRIDE {
+                            GLfloat* value) override {
     ADD_FAILURE();
   }
   virtual void getUniformiv(GLuint program,
                             GLint location,
-                            GLint* value) OVERRIDE {
+                            GLint* value) override {
     ADD_FAILURE();
   }
   virtual GLint getUniformLocation(GLuint program,
-                                   const GLchar* name) OVERRIDE {
+                                   const GLchar* name) override {
     ADD_FAILURE();
     return 0;
   }
   virtual void getVertexAttribfv(GLuint index,
                                  GLenum pname,
-                                 GLfloat* value) OVERRIDE {
+                                 GLfloat* value) override {
     ADD_FAILURE();
   }
   virtual void getVertexAttribiv(GLuint index,
                                  GLenum pname,
-                                 GLint* value) OVERRIDE {
+                                 GLint* value) override {
     ADD_FAILURE();
   }
   virtual GLsizeiptr getVertexAttribOffset(GLuint index,
-                                           GLenum pname) OVERRIDE {
+                                           GLenum pname) override {
     ADD_FAILURE();
     return 0;
   }
@@ -504,12 +504,12 @@ class LoseContextOnFirstGetContext : public TestWebGraphicsContext3D {
 
   virtual void getProgramiv(GLuint program,
                             GLenum pname,
-                            GLint* value) OVERRIDE {
+                            GLint* value) override {
     context_lost_ = true;
     *value = 0;
   }
 
-  virtual void getShaderiv(GLuint shader, GLenum pname, GLint* value) OVERRIDE {
+  virtual void getShaderiv(GLuint shader, GLenum pname, GLint* value) override {
     context_lost_ = true;
     *value = 0;
   }
@@ -700,17 +700,17 @@ class VisibilityChangeIsLastCallTrackingContext
       : last_call_was_set_visibility_(false) {}
 
   // TestWebGraphicsContext3D methods.
-  virtual void flush() OVERRIDE { last_call_was_set_visibility_ = false; }
-  virtual void deleteTexture(GLuint) OVERRIDE {
+  virtual void flush() override { last_call_was_set_visibility_ = false; }
+  virtual void deleteTexture(GLuint) override {
     last_call_was_set_visibility_ = false;
   }
-  virtual void deleteFramebuffer(GLuint) OVERRIDE {
+  virtual void deleteFramebuffer(GLuint) override {
     last_call_was_set_visibility_ = false;
   }
-  virtual void deleteQueryEXT(GLuint) OVERRIDE {
+  virtual void deleteQueryEXT(GLuint) override {
     last_call_was_set_visibility_ = false;
   }
-  virtual void deleteRenderbuffer(GLuint) OVERRIDE {
+  virtual void deleteRenderbuffer(GLuint) override {
     last_call_was_set_visibility_ = false;
   }
 
@@ -979,14 +979,14 @@ class ScissorTestOnClearCheckingContext : public TestWebGraphicsContext3D {
  public:
   ScissorTestOnClearCheckingContext() : scissor_enabled_(false) {}
 
-  virtual void clear(GLbitfield) OVERRIDE { EXPECT_FALSE(scissor_enabled_); }
+  virtual void clear(GLbitfield) override { EXPECT_FALSE(scissor_enabled_); }
 
-  virtual void enable(GLenum cap) OVERRIDE {
+  virtual void enable(GLenum cap) override {
     if (cap == GL_SCISSOR_TEST)
       scissor_enabled_ = true;
   }
 
-  virtual void disable(GLenum cap) OVERRIDE {
+  virtual void disable(GLenum cap) override {
     if (cap == GL_SCISSOR_TEST)
       scissor_enabled_ = false;
   }
@@ -1069,7 +1069,7 @@ class DiscardCheckingContext : public TestWebGraphicsContext3D {
 
   virtual void discardFramebufferEXT(GLenum target,
                                      GLsizei numAttachments,
-                                     const GLenum* attachments) OVERRIDE {
+                                     const GLenum* attachments) override {
     ++discarded_;
   }
 
@@ -1088,7 +1088,7 @@ class NonReshapableOutputSurface : public FakeOutputSurface {
                           false) {
     surface_size_ = gfx::Size(500, 500);
   }
-  virtual void Reshape(const gfx::Size& size, float scale_factor) OVERRIDE {}
+  virtual void Reshape(const gfx::Size& size, float scale_factor) override {}
   void set_fixed_size(const gfx::Size& size) { surface_size_ = size; }
 };
 
@@ -1258,7 +1258,7 @@ class FlippedScissorAndViewportContext : public TestWebGraphicsContext3D {
   }
 
   virtual void viewport(GLint x, GLint y, GLsizei width, GLsizei height)
-      OVERRIDE {
+      override {
     EXPECT_EQ(10, x);
     EXPECT_EQ(390, y);
     EXPECT_EQ(100, width);
@@ -1267,7 +1267,7 @@ class FlippedScissorAndViewportContext : public TestWebGraphicsContext3D {
   }
 
   virtual void scissor(GLint x, GLint y, GLsizei width, GLsizei height)
-      OVERRIDE {
+      override {
     EXPECT_EQ(30, x);
     EXPECT_EQ(450, y);
     EXPECT_EQ(20, width);
diff --git a/cc/output/output_surface_unittest.cc b/cc/output/output_surface_unittest.cc
index 4c51e1a..aca1d27 100644
--- a/cc/output/output_surface_unittest.cc
+++ b/cc/output/output_surface_unittest.cc
@@ -61,8 +61,8 @@ class TestSoftwareOutputDevice : public SoftwareOutputDevice {
   virtual ~TestSoftwareOutputDevice();
 
   // Overriden from cc:SoftwareOutputDevice
-  virtual void DiscardBackbuffer() OVERRIDE;
-  virtual void EnsureBackbuffer() OVERRIDE;
+  virtual void DiscardBackbuffer() override;
+  virtual void EnsureBackbuffer() override;
 
   int discard_backbuffer_count() { return discard_backbuffer_count_; }
   int ensure_backbuffer_count() { return ensure_backbuffer_count_; }
diff --git a/cc/output/overlay_strategy_single_on_top.h b/cc/output/overlay_strategy_single_on_top.h
index d984d3d..1bf6bd8 100644
--- a/cc/output/overlay_strategy_single_on_top.h
+++ b/cc/output/overlay_strategy_single_on_top.h
@@ -20,7 +20,7 @@ class CC_EXPORT OverlayStrategySingleOnTop : public OverlayProcessor::Strategy {
   OverlayStrategySingleOnTop(OverlayCandidateValidator* capability_checker,
                              ResourceProvider* resource_provider);
   virtual bool Attempt(RenderPassList* render_passes_in_draw_order,
-                       OverlayCandidateList* candidate_list) OVERRIDE;
+                       OverlayCandidateList* candidate_list) override;
 
  private:
   OverlayCandidateValidator* capability_checker_;
diff --git a/cc/output/overlay_unittest.cc b/cc/output/overlay_unittest.cc
index 71f1ddc..64e0951 100644
--- a/cc/output/overlay_unittest.cc
+++ b/cc/output/overlay_unittest.cc
@@ -40,7 +40,7 @@ void MailboxReleased(unsigned sync_point,
 
 class SingleOverlayValidator : public OverlayCandidateValidator {
  public:
-  virtual void CheckOverlaySupport(OverlayCandidateList* surfaces) OVERRIDE;
+  virtual void CheckOverlaySupport(OverlayCandidateList* surfaces) override;
 };
 
 void SingleOverlayValidator::CheckOverlaySupport(
@@ -62,7 +62,7 @@ class SingleOverlayProcessor : public OverlayProcessor {
   SingleOverlayProcessor(OutputSurface* surface,
                          ResourceProvider* resource_provider);
   // Virtual to allow testing different strategies.
-  virtual void Initialize() OVERRIDE;
+  virtual void Initialize() override;
 };
 
 SingleOverlayProcessor::SingleOverlayProcessor(
@@ -529,7 +529,7 @@ class OverlayInfoRendererGL : public GLRenderer {
 
   MOCK_METHOD2(DoDrawQuad, void(DrawingFrame* frame, const DrawQuad* quad));
 
-  virtual void FinishDrawingFrame(DrawingFrame* frame) OVERRIDE {
+  virtual void FinishDrawingFrame(DrawingFrame* frame) override {
     GLRenderer::FinishDrawingFrame(frame);
 
     if (!expect_overlays_) {
@@ -552,7 +552,7 @@ class OverlayInfoRendererGL : public GLRenderer {
 class FakeRendererClient : public RendererClient {
  public:
   // RendererClient methods.
-  virtual void SetFullRootLayerDamage() OVERRIDE {}
+  virtual void SetFullRootLayerDamage() override {}
 };
 
 class MockOverlayScheduler {
diff --git a/cc/output/renderer_pixeltest.cc b/cc/output/renderer_pixeltest.cc
index 892adbd..00c9100 100644
--- a/cc/output/renderer_pixeltest.cc
+++ b/cc/output/renderer_pixeltest.cc
@@ -525,7 +525,7 @@ class VideoGLRendererPixelTest : public GLRendererPixelTest {
                      color_space);
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     GLRendererPixelTest::SetUp();
     video_resource_updater_.reset(new VideoResourceUpdater(
         output_surface_->context_provider(), resource_provider_.get()));
diff --git a/cc/output/software_renderer.h b/cc/output/software_renderer.h
index 5c9fef0..deac838 100644
--- a/cc/output/software_renderer.h
+++ b/cc/output/software_renderer.h
@@ -34,42 +34,42 @@ class CC_EXPORT SoftwareRenderer : public DirectRenderer {
       ResourceProvider* resource_provider);
 
   virtual ~SoftwareRenderer();
-  virtual const RendererCapabilitiesImpl& Capabilities() const OVERRIDE;
-  virtual void Finish() OVERRIDE;
-  virtual void SwapBuffers(const CompositorFrameMetadata& metadata) OVERRIDE;
+  virtual const RendererCapabilitiesImpl& Capabilities() const override;
+  virtual void Finish() override;
+  virtual void SwapBuffers(const CompositorFrameMetadata& metadata) override;
   virtual void ReceiveSwapBuffersAck(
-      const CompositorFrameAck& ack) OVERRIDE;
-  virtual void DiscardBackbuffer() OVERRIDE;
-  virtual void EnsureBackbuffer() OVERRIDE;
+      const CompositorFrameAck& ack) override;
+  virtual void DiscardBackbuffer() override;
+  virtual void EnsureBackbuffer() override;
 
  protected:
-  virtual void BindFramebufferToOutputSurface(DrawingFrame* frame) OVERRIDE;
+  virtual void BindFramebufferToOutputSurface(DrawingFrame* frame) override;
   virtual bool BindFramebufferToTexture(
       DrawingFrame* frame,
       const ScopedResource* texture,
-      const gfx::Rect& target_rect) OVERRIDE;
-  virtual void SetDrawViewport(const gfx::Rect& window_space_viewport) OVERRIDE;
-  virtual void SetScissorTestRect(const gfx::Rect& scissor_rect) OVERRIDE;
+      const gfx::Rect& target_rect) override;
+  virtual void SetDrawViewport(const gfx::Rect& window_space_viewport) override;
+  virtual void SetScissorTestRect(const gfx::Rect& scissor_rect) override;
   virtual void DiscardPixels(bool has_external_stencil_test,
-                             bool draw_rect_covers_full_surface) OVERRIDE;
+                             bool draw_rect_covers_full_surface) override;
   virtual void ClearFramebuffer(DrawingFrame* frame,
-                                bool has_external_stencil_test) OVERRIDE;
-  virtual void DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) OVERRIDE;
-  virtual void BeginDrawingFrame(DrawingFrame* frame) OVERRIDE;
-  virtual void FinishDrawingFrame(DrawingFrame* frame) OVERRIDE;
-  virtual bool FlippedFramebuffer() const OVERRIDE;
-  virtual void EnsureScissorTestEnabled() OVERRIDE;
-  virtual void EnsureScissorTestDisabled() OVERRIDE;
+                                bool has_external_stencil_test) override;
+  virtual void DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) override;
+  virtual void BeginDrawingFrame(DrawingFrame* frame) override;
+  virtual void FinishDrawingFrame(DrawingFrame* frame) override;
+  virtual bool FlippedFramebuffer() const override;
+  virtual void EnsureScissorTestEnabled() override;
+  virtual void EnsureScissorTestDisabled() override;
   virtual void CopyCurrentRenderPassToBitmap(
       DrawingFrame* frame,
-      scoped_ptr<CopyOutputRequest> request) OVERRIDE;
+      scoped_ptr<CopyOutputRequest> request) override;
 
   SoftwareRenderer(RendererClient* client,
                    const LayerTreeSettings* settings,
                    OutputSurface* output_surface,
                    ResourceProvider* resource_provider);
 
-  virtual void DidChangeVisibility() OVERRIDE;
+  virtual void DidChangeVisibility() override;
 
  private:
   void ClearCanvas(SkColor color);
diff --git a/cc/output/software_renderer_unittest.cc b/cc/output/software_renderer_unittest.cc
index 2818ab6..5dfc158 100644
--- a/cc/output/software_renderer_unittest.cc
+++ b/cc/output/software_renderer_unittest.cc
@@ -54,7 +54,7 @@ class SoftwareRendererTest : public testing::Test, public RendererClient {
   SoftwareRenderer* renderer() const { return renderer_.get(); }
 
   // RendererClient implementation.
-  virtual void SetFullRootLayerDamage() OVERRIDE {}
+  virtual void SetFullRootLayerDamage() override {}
 
   scoped_ptr<SkBitmap> DrawAndCopyOutput(RenderPassList* list,
                                          float device_scale_factor,
diff --git a/cc/quads/checkerboard_draw_quad.h b/cc/quads/checkerboard_draw_quad.h
index f99531d..71253e3 100644
--- a/cc/quads/checkerboard_draw_quad.h
+++ b/cc/quads/checkerboard_draw_quad.h
@@ -31,12 +31,12 @@ class CC_EXPORT CheckerboardDrawQuad : public DrawQuad {
   SkColor color;
 
   virtual void IterateResources(const ResourceIteratorCallback& callback)
-    OVERRIDE;
+    override;
 
   static const CheckerboardDrawQuad* MaterialCast(const DrawQuad*);
 
  private:
-  virtual void ExtendValue(base::debug::TracedValue* value) const OVERRIDE;
+  virtual void ExtendValue(base::debug::TracedValue* value) const override;
 };
 
 }  // namespace cc
diff --git a/cc/quads/content_draw_quad_base.h b/cc/quads/content_draw_quad_base.h
index 5173d6c..d6b1995 100644
--- a/cc/quads/content_draw_quad_base.h
+++ b/cc/quads/content_draw_quad_base.h
@@ -42,7 +42,7 @@ class CC_EXPORT ContentDrawQuadBase : public DrawQuad {
  protected:
   ContentDrawQuadBase();
   virtual ~ContentDrawQuadBase();
-  virtual void ExtendValue(base::debug::TracedValue* value) const OVERRIDE;
+  virtual void ExtendValue(base::debug::TracedValue* value) const override;
 };
 
 }  // namespace cc
diff --git a/cc/quads/debug_border_draw_quad.h b/cc/quads/debug_border_draw_quad.h
index 828d4e0..e2b6f70 100644
--- a/cc/quads/debug_border_draw_quad.h
+++ b/cc/quads/debug_border_draw_quad.h
@@ -34,12 +34,12 @@ class CC_EXPORT DebugBorderDrawQuad : public DrawQuad {
   int width;
 
   virtual void IterateResources(const ResourceIteratorCallback& callback)
-      OVERRIDE;
+      override;
 
   static const DebugBorderDrawQuad* MaterialCast(const DrawQuad*);
 
  private:
-  virtual void ExtendValue(base::debug::TracedValue* value) const OVERRIDE;
+  virtual void ExtendValue(base::debug::TracedValue* value) const override;
 };
 
 }  // namespace cc
diff --git a/cc/quads/io_surface_draw_quad.h b/cc/quads/io_surface_draw_quad.h
index 86b4d52..3829156 100644
--- a/cc/quads/io_surface_draw_quad.h
+++ b/cc/quads/io_surface_draw_quad.h
@@ -44,12 +44,12 @@ class CC_EXPORT IOSurfaceDrawQuad : public DrawQuad {
   Orientation orientation;
 
   virtual void IterateResources(const ResourceIteratorCallback& callback)
-      OVERRIDE;
+      override;
 
   static const IOSurfaceDrawQuad* MaterialCast(const DrawQuad*);
 
  private:
-  virtual void ExtendValue(base::debug::TracedValue* value) const OVERRIDE;
+  virtual void ExtendValue(base::debug::TracedValue* value) const override;
 };
 
 }  // namespace cc
diff --git a/cc/quads/list_container_unittest.cc b/cc/quads/list_container_unittest.cc
index cb79f7a..8b68852 100644
--- a/cc/quads/list_container_unittest.cc
+++ b/cc/quads/list_container_unittest.cc
@@ -31,11 +31,11 @@ class SimpleDrawQuad : public DrawQuad {
  public:
   virtual ~SimpleDrawQuad() {}
   virtual void IterateResources(
-      const ResourceIteratorCallback& callback) OVERRIDE {}
+      const ResourceIteratorCallback& callback) override {}
 
   void set_value(int val) { value = val; }
   int get_value() { return value; }
-  virtual void ExtendValue(base::debug::TracedValue* value) const OVERRIDE {}
+  virtual void ExtendValue(base::debug::TracedValue* value) const override {}
 
  private:
   int value;
@@ -59,8 +59,8 @@ class MockDrawQuad : public DrawQuad {
  public:
   virtual ~MockDrawQuad() { Destruct(); }
   virtual void IterateResources(
-      const ResourceIteratorCallback& callback) OVERRIDE {}
-  virtual void ExtendValue(base::debug::TracedValue* value) const OVERRIDE {}
+      const ResourceIteratorCallback& callback) override {}
+  virtual void ExtendValue(base::debug::TracedValue* value) const override {}
   MOCK_METHOD0(Destruct, void());
 };
 
diff --git a/cc/quads/picture_draw_quad.h b/cc/quads/picture_draw_quad.h
index 4fb6b4b..5d75e05 100644
--- a/cc/quads/picture_draw_quad.h
+++ b/cc/quads/picture_draw_quad.h
@@ -51,12 +51,12 @@ class CC_EXPORT PictureDrawQuad : public ContentDrawQuadBase {
   ResourceFormat texture_format;
 
   virtual void IterateResources(const ResourceIteratorCallback& callback)
-      OVERRIDE;
+      override;
 
   static const PictureDrawQuad* MaterialCast(const DrawQuad* quad);
 
  private:
-  virtual void ExtendValue(base::debug::TracedValue* value) const OVERRIDE;
+  virtual void ExtendValue(base::debug::TracedValue* value) const override;
 };
 
 }  // namespace cc
diff --git a/cc/quads/render_pass_draw_quad.h b/cc/quads/render_pass_draw_quad.h
index 40540d2..587c7ec 100644
--- a/cc/quads/render_pass_draw_quad.h
+++ b/cc/quads/render_pass_draw_quad.h
@@ -60,12 +60,12 @@ class CC_EXPORT RenderPassDrawQuad : public DrawQuad {
   FilterOperations background_filters;
 
   virtual void IterateResources(const ResourceIteratorCallback& callback)
-      OVERRIDE;
+      override;
 
   static const RenderPassDrawQuad* MaterialCast(const DrawQuad*);
 
  private:
-  virtual void ExtendValue(base::debug::TracedValue* value) const OVERRIDE;
+  virtual void ExtendValue(base::debug::TracedValue* value) const override;
 };
 
 }  // namespace cc
diff --git a/cc/quads/solid_color_draw_quad.h b/cc/quads/solid_color_draw_quad.h
index bfb6022..256cc526 100644
--- a/cc/quads/solid_color_draw_quad.h
+++ b/cc/quads/solid_color_draw_quad.h
@@ -34,12 +34,12 @@ class CC_EXPORT SolidColorDrawQuad : public DrawQuad {
   bool force_anti_aliasing_off;
 
   virtual void IterateResources(const ResourceIteratorCallback& callback)
-      OVERRIDE;
+      override;
 
   static const SolidColorDrawQuad* MaterialCast(const DrawQuad*);
 
  private:
-  virtual void ExtendValue(base::debug::TracedValue* value) const OVERRIDE;
+  virtual void ExtendValue(base::debug::TracedValue* value) const override;
 };
 
 }  // namespace cc
diff --git a/cc/quads/stream_video_draw_quad.h b/cc/quads/stream_video_draw_quad.h
index 5db7c3b..f4cb0f5 100644
--- a/cc/quads/stream_video_draw_quad.h
+++ b/cc/quads/stream_video_draw_quad.h
@@ -35,12 +35,12 @@ class CC_EXPORT StreamVideoDrawQuad : public DrawQuad {
   gfx::Transform matrix;
 
   virtual void IterateResources(const ResourceIteratorCallback& callback)
-      OVERRIDE;
+      override;
 
   static const StreamVideoDrawQuad* MaterialCast(const DrawQuad*);
 
  private:
-  virtual void ExtendValue(base::debug::TracedValue* value) const OVERRIDE;
+  virtual void ExtendValue(base::debug::TracedValue* value) const override;
 };
 
 }  // namespace cc
diff --git a/cc/quads/surface_draw_quad.h b/cc/quads/surface_draw_quad.h
index 91e5668..2fa35f1 100644
--- a/cc/quads/surface_draw_quad.h
+++ b/cc/quads/surface_draw_quad.h
@@ -31,12 +31,12 @@ class CC_EXPORT SurfaceDrawQuad : public DrawQuad {
   SurfaceId surface_id;
 
   virtual void IterateResources(const ResourceIteratorCallback& callback)
-      OVERRIDE;
+      override;
 
   static const SurfaceDrawQuad* MaterialCast(const DrawQuad* quad);
 
  private:
-  virtual void ExtendValue(base::debug::TracedValue* value) const OVERRIDE;
+  virtual void ExtendValue(base::debug::TracedValue* value) const override;
 };
 
 }  // namespace cc
diff --git a/cc/quads/texture_draw_quad.h b/cc/quads/texture_draw_quad.h
index ef8090c..3a3bb54 100644
--- a/cc/quads/texture_draw_quad.h
+++ b/cc/quads/texture_draw_quad.h
@@ -50,12 +50,12 @@ class CC_EXPORT TextureDrawQuad : public DrawQuad {
   bool flipped;
 
   virtual void IterateResources(const ResourceIteratorCallback& callback)
-      OVERRIDE;
+      override;
 
   static const TextureDrawQuad* MaterialCast(const DrawQuad*);
 
  private:
-  virtual void ExtendValue(base::debug::TracedValue* value) const OVERRIDE;
+  virtual void ExtendValue(base::debug::TracedValue* value) const override;
 };
 
 }  // namespace cc
diff --git a/cc/quads/tile_draw_quad.h b/cc/quads/tile_draw_quad.h
index 72e6bba..e8941d5 100644
--- a/cc/quads/tile_draw_quad.h
+++ b/cc/quads/tile_draw_quad.h
@@ -36,12 +36,12 @@ class CC_EXPORT TileDrawQuad : public ContentDrawQuadBase {
   unsigned resource_id;
 
   virtual void IterateResources(const ResourceIteratorCallback& callback)
-      OVERRIDE;
+      override;
 
   static const TileDrawQuad* MaterialCast(const DrawQuad*);
 
  private:
-  virtual void ExtendValue(base::debug::TracedValue* value) const OVERRIDE;
+  virtual void ExtendValue(base::debug::TracedValue* value) const override;
 };
 
 }  // namespace cc
diff --git a/cc/quads/yuv_video_draw_quad.h b/cc/quads/yuv_video_draw_quad.h
index 930c821..e0fc758 100644
--- a/cc/quads/yuv_video_draw_quad.h
+++ b/cc/quads/yuv_video_draw_quad.h
@@ -56,12 +56,12 @@ class CC_EXPORT YUVVideoDrawQuad : public DrawQuad {
   ColorSpace color_space;
 
   virtual void IterateResources(const ResourceIteratorCallback& callback)
-      OVERRIDE;
+      override;
 
   static const YUVVideoDrawQuad* MaterialCast(const DrawQuad*);
 
  private:
-  virtual void ExtendValue(base::debug::TracedValue* value) const OVERRIDE;
+  virtual void ExtendValue(base::debug::TracedValue* value) const override;
 };
 
 }  // namespace cc
diff --git a/cc/resources/bitmap_content_layer_updater.h b/cc/resources/bitmap_content_layer_updater.h
index ca3f445..0010c41 100644
--- a/cc/resources/bitmap_content_layer_updater.h
+++ b/cc/resources/bitmap_content_layer_updater.h
@@ -32,7 +32,7 @@ class CC_EXPORT BitmapContentLayerUpdater : public ContentLayerUpdater {
     virtual void Update(ResourceUpdateQueue* queue,
                         const gfx::Rect& source_rect,
                         const gfx::Vector2d& dest_offset,
-                        bool partial_update) OVERRIDE;
+                        bool partial_update) override;
 
    private:
     BitmapContentLayerUpdater* updater_;
@@ -46,19 +46,19 @@ class CC_EXPORT BitmapContentLayerUpdater : public ContentLayerUpdater {
       int layer_id);
 
   virtual scoped_ptr<LayerUpdater::Resource> CreateResource(
-      PrioritizedResourceManager* manager) OVERRIDE;
+      PrioritizedResourceManager* manager) override;
   virtual void PrepareToUpdate(const gfx::Size& content_size,
                                const gfx::Rect& paint_rect,
                                const gfx::Size& tile_size,
                                float contents_width_scale,
-                               float contents_height_scale) OVERRIDE;
+                               float contents_height_scale) override;
   void UpdateTexture(ResourceUpdateQueue* queue,
                      PrioritizedResource* resource,
                      const gfx::Rect& source_rect,
                      const gfx::Vector2d& dest_offset,
                      bool partial_update);
-  virtual void SetOpaque(bool opaque) OVERRIDE;
-  virtual void ReduceMemoryUsage() OVERRIDE;
+  virtual void SetOpaque(bool opaque) override;
+  virtual void ReduceMemoryUsage() override;
 
  protected:
   BitmapContentLayerUpdater(
diff --git a/cc/resources/bitmap_raster_worker_pool.cc b/cc/resources/bitmap_raster_worker_pool.cc
index 959a0f3..404f67f 100644
--- a/cc/resources/bitmap_raster_worker_pool.cc
+++ b/cc/resources/bitmap_raster_worker_pool.cc
@@ -23,10 +23,10 @@ class RasterBufferImpl : public RasterBuffer {
       : lock_(resource_provider, resource->id()) {}
 
   // Overridden from RasterBuffer:
-  virtual skia::RefPtr<SkCanvas> AcquireSkCanvas() OVERRIDE {
+  virtual skia::RefPtr<SkCanvas> AcquireSkCanvas() override {
     return skia::SharePtr(lock_.sk_canvas());
   }
-  virtual void ReleaseSkCanvas(const skia::RefPtr<SkCanvas>& canvas) OVERRIDE {}
+  virtual void ReleaseSkCanvas(const skia::RefPtr<SkCanvas>& canvas) override {}
 
  private:
   ResourceProvider::ScopedWriteLockSoftware lock_;
diff --git a/cc/resources/bitmap_raster_worker_pool.h b/cc/resources/bitmap_raster_worker_pool.h
index 39c4237..876bf36 100644
--- a/cc/resources/bitmap_raster_worker_pool.h
+++ b/cc/resources/bitmap_raster_worker_pool.h
@@ -31,18 +31,18 @@ class CC_EXPORT BitmapRasterWorkerPool : public RasterWorkerPool,
       ResourceProvider* resource_provider);
 
   // Overridden from RasterWorkerPool:
-  virtual Rasterizer* AsRasterizer() OVERRIDE;
+  virtual Rasterizer* AsRasterizer() override;
 
   // Overridden from Rasterizer:
-  virtual void SetClient(RasterizerClient* client) OVERRIDE;
-  virtual void Shutdown() OVERRIDE;
-  virtual void ScheduleTasks(RasterTaskQueue* queue) OVERRIDE;
-  virtual void CheckForCompletedTasks() OVERRIDE;
+  virtual void SetClient(RasterizerClient* client) override;
+  virtual void Shutdown() override;
+  virtual void ScheduleTasks(RasterTaskQueue* queue) override;
+  virtual void CheckForCompletedTasks() override;
 
   // Overridden from RasterizerTaskClient:
   virtual scoped_ptr<RasterBuffer> AcquireBufferForRaster(
-      const Resource* resource) OVERRIDE;
-  virtual void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) OVERRIDE;
+      const Resource* resource) override;
+  virtual void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) override;
 
  protected:
   BitmapRasterWorkerPool(base::SequencedTaskRunner* task_runner,
diff --git a/cc/resources/bitmap_skpicture_content_layer_updater.h b/cc/resources/bitmap_skpicture_content_layer_updater.h
index e20e3c3..030db6e 100644
--- a/cc/resources/bitmap_skpicture_content_layer_updater.h
+++ b/cc/resources/bitmap_skpicture_content_layer_updater.h
@@ -23,7 +23,7 @@ class BitmapSkPictureContentLayerUpdater : public SkPictureContentLayerUpdater {
     virtual void Update(ResourceUpdateQueue* queue,
                         const gfx::Rect& source_rect,
                         const gfx::Vector2d& dest_offset,
-                        bool partial_update) OVERRIDE;
+                        bool partial_update) override;
 
    private:
     SkBitmap bitmap_;
@@ -38,7 +38,7 @@ class BitmapSkPictureContentLayerUpdater : public SkPictureContentLayerUpdater {
       int layer_id);
 
   virtual scoped_ptr<LayerUpdater::Resource> CreateResource(
-      PrioritizedResourceManager* manager) OVERRIDE;
+      PrioritizedResourceManager* manager) override;
   void PaintContentsRect(SkCanvas* canvas,
                          const gfx::Rect& source_rect);
 
diff --git a/cc/resources/content_layer_updater.h b/cc/resources/content_layer_updater.h
index b11281e..33d3ee52 100644
--- a/cc/resources/content_layer_updater.h
+++ b/cc/resources/content_layer_updater.h
@@ -22,9 +22,9 @@ class RenderingStatsInstrumentation;
 class CC_EXPORT ContentLayerUpdater : public LayerUpdater {
  public:
   void set_rendering_stats_instrumentation(RenderingStatsInstrumentation* rsi);
-  virtual void SetOpaque(bool opaque) OVERRIDE;
-  virtual void SetFillsBoundsCompletely(bool fills_bounds) OVERRIDE;
-  virtual void SetBackgroundColor(SkColor background_color) OVERRIDE;
+  virtual void SetOpaque(bool opaque) override;
+  virtual void SetFillsBoundsCompletely(bool fills_bounds) override;
+  virtual void SetBackgroundColor(SkColor background_color) override;
 
  protected:
   ContentLayerUpdater(scoped_ptr<LayerPainter> painter,
diff --git a/cc/resources/gpu_raster_worker_pool.cc b/cc/resources/gpu_raster_worker_pool.cc
index cee01fe..0463cff 100644
--- a/cc/resources/gpu_raster_worker_pool.cc
+++ b/cc/resources/gpu_raster_worker_pool.cc
@@ -36,7 +36,7 @@ class RasterBufferImpl : public RasterBuffer {
   }
 
   // Overridden from RasterBuffer:
-  virtual skia::RefPtr<SkCanvas> AcquireSkCanvas() OVERRIDE {
+  virtual skia::RefPtr<SkCanvas> AcquireSkCanvas() override {
     if (!surface_)
       return skia::AdoptRef(SkCreateNullCanvas());
 
@@ -48,7 +48,7 @@ class RasterBufferImpl : public RasterBuffer {
     canvas->save();
     return canvas;
   }
-  virtual void ReleaseSkCanvas(const skia::RefPtr<SkCanvas>& canvas) OVERRIDE {
+  virtual void ReleaseSkCanvas(const skia::RefPtr<SkCanvas>& canvas) override {
     if (!surface_)
       return;
 
diff --git a/cc/resources/gpu_raster_worker_pool.h b/cc/resources/gpu_raster_worker_pool.h
index 2149400..48c17b1 100644
--- a/cc/resources/gpu_raster_worker_pool.h
+++ b/cc/resources/gpu_raster_worker_pool.h
@@ -26,18 +26,18 @@ class CC_EXPORT GpuRasterWorkerPool : public RasterWorkerPool,
       ResourceProvider* resource_provider);
 
   // Overridden from RasterWorkerPool:
-  virtual Rasterizer* AsRasterizer() OVERRIDE;
+  virtual Rasterizer* AsRasterizer() override;
 
   // Overridden from Rasterizer:
-  virtual void SetClient(RasterizerClient* client) OVERRIDE;
-  virtual void Shutdown() OVERRIDE;
-  virtual void ScheduleTasks(RasterTaskQueue* queue) OVERRIDE;
-  virtual void CheckForCompletedTasks() OVERRIDE;
+  virtual void SetClient(RasterizerClient* client) override;
+  virtual void Shutdown() override;
+  virtual void ScheduleTasks(RasterTaskQueue* queue) override;
+  virtual void CheckForCompletedTasks() override;
 
   // Overridden from RasterizerTaskClient:
   virtual scoped_ptr<RasterBuffer> AcquireBufferForRaster(
-      const Resource* resource) OVERRIDE;
-  virtual void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) OVERRIDE;
+      const Resource* resource) override;
+  virtual void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) override;
 
  private:
   GpuRasterWorkerPool(base::SequencedTaskRunner* task_runner,
diff --git a/cc/resources/image_layer_updater.h b/cc/resources/image_layer_updater.h
index b2235b1..55fdfe5 100644
--- a/cc/resources/image_layer_updater.h
+++ b/cc/resources/image_layer_updater.h
@@ -24,7 +24,7 @@ class CC_EXPORT ImageLayerUpdater : public LayerUpdater {
     virtual void Update(ResourceUpdateQueue* queue,
                         const gfx::Rect& source_rect,
                         const gfx::Vector2d& dest_offset,
-                        bool partial_update) OVERRIDE;
+                        bool partial_update) override;
 
    private:
     ImageLayerUpdater* updater_;
@@ -35,7 +35,7 @@ class CC_EXPORT ImageLayerUpdater : public LayerUpdater {
   static scoped_refptr<ImageLayerUpdater> Create();
 
   virtual scoped_ptr<LayerUpdater::Resource> CreateResource(
-      PrioritizedResourceManager*) OVERRIDE;
+      PrioritizedResourceManager*) override;
 
   void UpdateTexture(ResourceUpdateQueue* queue,
                      PrioritizedResource* texture,
diff --git a/cc/resources/one_copy_raster_worker_pool.cc b/cc/resources/one_copy_raster_worker_pool.cc
index a86d498..f447df5 100644
--- a/cc/resources/one_copy_raster_worker_pool.cc
+++ b/cc/resources/one_copy_raster_worker_pool.cc
@@ -53,7 +53,7 @@ class RasterBufferImpl : public RasterBuffer {
   }
 
   // Overridden from RasterBuffer:
-  virtual skia::RefPtr<SkCanvas> AcquireSkCanvas() OVERRIDE {
+  virtual skia::RefPtr<SkCanvas> AcquireSkCanvas() override {
     if (!buffer_)
       return skia::AdoptRef(SkCreateNullCanvas());
 
@@ -61,7 +61,7 @@ class RasterBufferImpl : public RasterBuffer {
         &bitmap_, buffer_, resource_->format(), resource_->size(), stride_);
     return skia::AdoptRef(new SkCanvas(bitmap_));
   }
-  virtual void ReleaseSkCanvas(const skia::RefPtr<SkCanvas>& canvas) OVERRIDE {
+  virtual void ReleaseSkCanvas(const skia::RefPtr<SkCanvas>& canvas) override {
     if (!buffer_)
       return;
 
diff --git a/cc/resources/one_copy_raster_worker_pool.h b/cc/resources/one_copy_raster_worker_pool.h
index 1943868..c240999 100644
--- a/cc/resources/one_copy_raster_worker_pool.h
+++ b/cc/resources/one_copy_raster_worker_pool.h
@@ -37,18 +37,18 @@ class CC_EXPORT OneCopyRasterWorkerPool : public RasterWorkerPool,
       ResourcePool* resource_pool);
 
   // Overridden from RasterWorkerPool:
-  virtual Rasterizer* AsRasterizer() OVERRIDE;
+  virtual Rasterizer* AsRasterizer() override;
 
   // Overridden from Rasterizer:
-  virtual void SetClient(RasterizerClient* client) OVERRIDE;
-  virtual void Shutdown() OVERRIDE;
-  virtual void ScheduleTasks(RasterTaskQueue* queue) OVERRIDE;
-  virtual void CheckForCompletedTasks() OVERRIDE;
+  virtual void SetClient(RasterizerClient* client) override;
+  virtual void Shutdown() override;
+  virtual void ScheduleTasks(RasterTaskQueue* queue) override;
+  virtual void CheckForCompletedTasks() override;
 
   // Overridden from RasterizerTaskClient:
   virtual scoped_ptr<RasterBuffer> AcquireBufferForRaster(
-      const Resource* resource) OVERRIDE;
-  virtual void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) OVERRIDE;
+      const Resource* resource) override;
+  virtual void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) override;
 
  protected:
   OneCopyRasterWorkerPool(base::SequencedTaskRunner* task_runner,
diff --git a/cc/resources/picture_layer_tiling_perftest.cc b/cc/resources/picture_layer_tiling_perftest.cc
index 78a6a08..32cc9bb 100644
--- a/cc/resources/picture_layer_tiling_perftest.cc
+++ b/cc/resources/picture_layer_tiling_perftest.cc
@@ -43,7 +43,7 @@ class PictureLayerTilingPerfTest : public testing::Test {
                                                   false).Pass();
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     picture_layer_tiling_client_.SetTileSize(gfx::Size(256, 256));
     picture_layer_tiling_client_.set_max_tiles_for_interest_area(250);
     picture_layer_tiling_client_.set_tree(PENDING_TREE);
@@ -52,7 +52,7 @@ class PictureLayerTilingPerfTest : public testing::Test {
     picture_layer_tiling_->CreateAllTilesForTesting();
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     picture_layer_tiling_.reset(NULL);
   }
 
diff --git a/cc/resources/picture_pile_unittest.cc b/cc/resources/picture_pile_unittest.cc
index 87938fa..15cb3d3 100644
--- a/cc/resources/picture_pile_unittest.cc
+++ b/cc/resources/picture_pile_unittest.cc
@@ -96,7 +96,7 @@ class PicturePileTestBase {
 
 class PicturePileTest : public PicturePileTestBase, public testing::Test {
  public:
-  virtual void SetUp() OVERRIDE { InitializeData(); }
+  virtual void SetUp() override { InitializeData(); }
 };
 
 TEST_F(PicturePileTest, SmallInvalidateInflated) {
@@ -402,7 +402,7 @@ enum Corner {
 class PicturePileResizeCornerTest : public PicturePileTestBase,
                                     public testing::TestWithParam<Corner> {
  protected:
-  virtual void SetUp() OVERRIDE { InitializeData(); }
+  virtual void SetUp() override { InitializeData(); }
 
   static gfx::Rect CornerSinglePixelRect(Corner corner, const gfx::Size& s) {
     switch (corner) {
diff --git a/cc/resources/pixel_buffer_raster_worker_pool.cc b/cc/resources/pixel_buffer_raster_worker_pool.cc
index b1011fc..87c4a79 100644
--- a/cc/resources/pixel_buffer_raster_worker_pool.cc
+++ b/cc/resources/pixel_buffer_raster_worker_pool.cc
@@ -36,7 +36,7 @@ class RasterBufferImpl : public RasterBuffer {
   }
 
   // Overridden from RasterBuffer:
-  virtual skia::RefPtr<SkCanvas> AcquireSkCanvas() OVERRIDE {
+  virtual skia::RefPtr<SkCanvas> AcquireSkCanvas() override {
     if (!buffer_)
       return skia::AdoptRef(SkCreateNullCanvas());
 
@@ -44,7 +44,7 @@ class RasterBufferImpl : public RasterBuffer {
         &bitmap_, buffer_, resource_->format(), resource_->size(), stride_);
     return skia::AdoptRef(new SkCanvas(bitmap_));
   }
-  virtual void ReleaseSkCanvas(const skia::RefPtr<SkCanvas>& canvas) OVERRIDE {
+  virtual void ReleaseSkCanvas(const skia::RefPtr<SkCanvas>& canvas) override {
     if (!buffer_)
       return;
 
diff --git a/cc/resources/pixel_buffer_raster_worker_pool.h b/cc/resources/pixel_buffer_raster_worker_pool.h
index a2bed33..65fcdad 100644
--- a/cc/resources/pixel_buffer_raster_worker_pool.h
+++ b/cc/resources/pixel_buffer_raster_worker_pool.h
@@ -39,18 +39,18 @@ class CC_EXPORT PixelBufferRasterWorkerPool : public RasterWorkerPool,
       size_t max_transfer_buffer_usage_bytes);
 
   // Overridden from RasterWorkerPool:
-  virtual Rasterizer* AsRasterizer() OVERRIDE;
+  virtual Rasterizer* AsRasterizer() override;
 
   // Overridden from Rasterizer:
-  virtual void SetClient(RasterizerClient* client) OVERRIDE;
-  virtual void Shutdown() OVERRIDE;
-  virtual void ScheduleTasks(RasterTaskQueue* queue) OVERRIDE;
-  virtual void CheckForCompletedTasks() OVERRIDE;
+  virtual void SetClient(RasterizerClient* client) override;
+  virtual void Shutdown() override;
+  virtual void ScheduleTasks(RasterTaskQueue* queue) override;
+  virtual void CheckForCompletedTasks() override;
 
   // Overridden from RasterizerTaskClient:
   virtual scoped_ptr<RasterBuffer> AcquireBufferForRaster(
-      const Resource* resource) OVERRIDE;
-  virtual void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) OVERRIDE;
+      const Resource* resource) override;
+  virtual void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) override;
 
  private:
   struct RasterTaskState {
diff --git a/cc/resources/raster_worker_pool.cc b/cc/resources/raster_worker_pool.cc
index a720543..80477c1 100644
--- a/cc/resources/raster_worker_pool.cc
+++ b/cc/resources/raster_worker_pool.cc
@@ -39,7 +39,7 @@ class RasterTaskGraphRunner : public TaskGraphRunner,
 
  private:
   // Overridden from base::DelegateSimpleThread::Delegate:
-  virtual void Run() OVERRIDE {
+  virtual void Run() override {
     TaskGraphRunner::Run();
   }
 
@@ -62,15 +62,15 @@ class RasterFinishedTaskImpl : public RasterizerTask {
         on_raster_finished_callback_(on_raster_finished_callback) {}
 
   // Overridden from Task:
-  virtual void RunOnWorkerThread() OVERRIDE {
+  virtual void RunOnWorkerThread() override {
     TRACE_EVENT0("cc", "RasterFinishedTaskImpl::RunOnWorkerThread");
     RasterFinished();
   }
 
   // Overridden from RasterizerTask:
-  virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) OVERRIDE {}
-  virtual void CompleteOnOriginThread(RasterizerTaskClient* client) OVERRIDE {}
-  virtual void RunReplyOnOriginThread() OVERRIDE {}
+  virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) override {}
+  virtual void CompleteOnOriginThread(RasterizerTaskClient* client) override {}
+  virtual void RunReplyOnOriginThread() override {}
 
  protected:
   virtual ~RasterFinishedTaskImpl() {}
diff --git a/cc/resources/raster_worker_pool_perftest.cc b/cc/resources/raster_worker_pool_perftest.cc
index 3ae1c20..e84e8af 100644
--- a/cc/resources/raster_worker_pool_perftest.cc
+++ b/cc/resources/raster_worker_pool_perftest.cc
@@ -35,28 +35,28 @@ class PerfGLES2Interface : public gpu::gles2::GLES2InterfaceStub {
   virtual GLuint CreateImageCHROMIUM(GLsizei width,
                                      GLsizei height,
                                      GLenum internalformat,
-                                     GLenum usage) OVERRIDE {
+                                     GLenum usage) override {
     return 1u;
   }
-  virtual void GenBuffers(GLsizei n, GLuint* buffers) OVERRIDE {
+  virtual void GenBuffers(GLsizei n, GLuint* buffers) override {
     for (GLsizei i = 0; i < n; ++i)
       buffers[i] = 1u;
   }
-  virtual void GenTextures(GLsizei n, GLuint* textures) OVERRIDE {
+  virtual void GenTextures(GLsizei n, GLuint* textures) override {
     for (GLsizei i = 0; i < n; ++i)
       textures[i] = 1u;
   }
-  virtual void GetIntegerv(GLenum pname, GLint* params) OVERRIDE {
+  virtual void GetIntegerv(GLenum pname, GLint* params) override {
     if (pname == GL_MAX_TEXTURE_SIZE)
       *params = INT_MAX;
   }
-  virtual void GenQueriesEXT(GLsizei n, GLuint* queries) OVERRIDE {
+  virtual void GenQueriesEXT(GLsizei n, GLuint* queries) override {
     for (GLsizei i = 0; i < n; ++i)
       queries[i] = 1u;
   }
   virtual void GetQueryObjectuivEXT(GLuint query,
                                     GLenum pname,
-                                    GLuint* params) OVERRIDE {
+                                    GLuint* params) override {
     if (pname == GL_QUERY_RESULT_AVAILABLE_EXT)
       *params = 1;
   }
@@ -66,25 +66,25 @@ class PerfContextProvider : public ContextProvider {
  public:
   PerfContextProvider() : context_gl_(new PerfGLES2Interface) {}
 
-  virtual bool BindToCurrentThread() OVERRIDE { return true; }
-  virtual Capabilities ContextCapabilities() OVERRIDE {
+  virtual bool BindToCurrentThread() override { return true; }
+  virtual Capabilities ContextCapabilities() override {
     Capabilities capabilities;
     capabilities.gpu.image = true;
     capabilities.gpu.sync_query = true;
     return capabilities;
   }
-  virtual gpu::gles2::GLES2Interface* ContextGL() OVERRIDE {
+  virtual gpu::gles2::GLES2Interface* ContextGL() override {
     return context_gl_.get();
   }
-  virtual gpu::ContextSupport* ContextSupport() OVERRIDE { return &support_; }
-  virtual class GrContext* GrContext() OVERRIDE { return NULL; }
-  virtual bool IsContextLost() OVERRIDE { return false; }
-  virtual void VerifyContexts() OVERRIDE {}
-  virtual void DeleteCachedResources() OVERRIDE {}
-  virtual bool DestroyedOnMainThread() OVERRIDE { return false; }
-  virtual void SetLostContextCallback(const LostContextCallback& cb) OVERRIDE {}
+  virtual gpu::ContextSupport* ContextSupport() override { return &support_; }
+  virtual class GrContext* GrContext() override { return NULL; }
+  virtual bool IsContextLost() override { return false; }
+  virtual void VerifyContexts() override {}
+  virtual void DeleteCachedResources() override {}
+  virtual bool DestroyedOnMainThread() override { return false; }
+  virtual void SetLostContextCallback(const LostContextCallback& cb) override {}
   virtual void SetMemoryPolicyChangedCallback(
-      const MemoryPolicyChangedCallback& cb) OVERRIDE {}
+      const MemoryPolicyChangedCallback& cb) override {}
 
  private:
   virtual ~PerfContextProvider() {}
@@ -110,12 +110,12 @@ class PerfImageDecodeTaskImpl : public ImageDecodeTask {
   PerfImageDecodeTaskImpl() {}
 
   // Overridden from Task:
-  virtual void RunOnWorkerThread() OVERRIDE {}
+  virtual void RunOnWorkerThread() override {}
 
   // Overridden from RasterizerTask:
-  virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) OVERRIDE {}
-  virtual void CompleteOnOriginThread(RasterizerTaskClient* client) OVERRIDE {}
-  virtual void RunReplyOnOriginThread() OVERRIDE { Reset(); }
+  virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) override {}
+  virtual void CompleteOnOriginThread(RasterizerTaskClient* client) override {}
+  virtual void RunReplyOnOriginThread() override { Reset(); }
 
   void Reset() {
     did_run_ = false;
@@ -136,16 +136,16 @@ class PerfRasterTaskImpl : public RasterTask {
       : RasterTask(resource.get(), dependencies), resource_(resource.Pass()) {}
 
   // Overridden from Task:
-  virtual void RunOnWorkerThread() OVERRIDE {}
+  virtual void RunOnWorkerThread() override {}
 
   // Overridden from RasterizerTask:
-  virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) OVERRIDE {
+  virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) override {
     raster_buffer_ = client->AcquireBufferForRaster(resource());
   }
-  virtual void CompleteOnOriginThread(RasterizerTaskClient* client) OVERRIDE {
+  virtual void CompleteOnOriginThread(RasterizerTaskClient* client) override {
     client->ReleaseBufferForRaster(raster_buffer_.Pass());
   }
-  virtual void RunReplyOnOriginThread() OVERRIDE { Reset(); }
+  virtual void RunReplyOnOriginThread() override { Reset(); }
 
   void Reset() {
     did_run_ = false;
@@ -227,7 +227,7 @@ class RasterWorkerPoolPerfTest
       public RasterizerClient {
  public:
   // Overridden from testing::Test:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     switch (GetParam()) {
       case RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER:
         Create3dOutputSurfaceAndResourceProvider();
@@ -275,16 +275,16 @@ class RasterWorkerPoolPerfTest
     DCHECK(raster_worker_pool_);
     raster_worker_pool_->AsRasterizer()->SetClient(this);
   }
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     raster_worker_pool_->AsRasterizer()->Shutdown();
     raster_worker_pool_->AsRasterizer()->CheckForCompletedTasks();
   }
 
   // Overriden from RasterizerClient:
-  virtual void DidFinishRunningTasks(TaskSet task_set) OVERRIDE {
+  virtual void DidFinishRunningTasks(TaskSet task_set) override {
     raster_worker_pool_->AsRasterizer()->CheckForCompletedTasks();
   }
-  virtual TaskSetCollection TasksThatShouldBeForcedToComplete() const OVERRIDE {
+  virtual TaskSetCollection TasksThatShouldBeForcedToComplete() const override {
     return TaskSetCollection();
   }
 
@@ -478,7 +478,7 @@ class RasterWorkerPoolCommonPerfTest : public RasterWorkerPoolPerfTestBase,
                                        public testing::Test {
  public:
   // Overridden from testing::Test:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     output_surface_ = FakeOutputSurface::Create3d(context_provider_).Pass();
     CHECK(output_surface_->BindToClient(&output_surface_client_));
     resource_provider_ =
diff --git a/cc/resources/raster_worker_pool_unittest.cc b/cc/resources/raster_worker_pool_unittest.cc
index 86755f8..3c39c05 100644
--- a/cc/resources/raster_worker_pool_unittest.cc
+++ b/cc/resources/raster_worker_pool_unittest.cc
@@ -53,7 +53,7 @@ class TestRasterTaskImpl : public RasterTask {
       : RasterTask(resource, dependencies), reply_(reply) {}
 
   // Overridden from Task:
-  virtual void RunOnWorkerThread() OVERRIDE {
+  virtual void RunOnWorkerThread() override {
     skia::RefPtr<SkCanvas> canvas = raster_buffer_->AcquireSkCanvas();
     DCHECK(canvas);
     canvas->drawColor(SK_ColorWHITE);
@@ -61,13 +61,13 @@ class TestRasterTaskImpl : public RasterTask {
   }
 
   // Overridden from RasterizerTask:
-  virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) OVERRIDE {
+  virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) override {
     raster_buffer_ = client->AcquireBufferForRaster(resource());
   }
-  virtual void CompleteOnOriginThread(RasterizerTaskClient* client) OVERRIDE {
+  virtual void CompleteOnOriginThread(RasterizerTaskClient* client) override {
     client->ReleaseBufferForRaster(raster_buffer_.Pass());
   }
-  virtual void RunReplyOnOriginThread() OVERRIDE {
+  virtual void RunReplyOnOriginThread() override {
     reply_.Run(PicturePileImpl::Analysis(), !HasFinishedRunning());
   }
 
@@ -90,13 +90,13 @@ class BlockingTestRasterTaskImpl : public TestRasterTaskImpl {
       : TestRasterTaskImpl(resource, reply, dependencies), lock_(lock) {}
 
   // Overridden from Task:
-  virtual void RunOnWorkerThread() OVERRIDE {
+  virtual void RunOnWorkerThread() override {
     base::AutoLock lock(*lock_);
     TestRasterTaskImpl::RunOnWorkerThread();
   }
 
   // Overridden from RasterizerTask:
-  virtual void RunReplyOnOriginThread() OVERRIDE {}
+  virtual void RunReplyOnOriginThread() override {}
 
  protected:
   virtual ~BlockingTestRasterTaskImpl() {}
@@ -126,7 +126,7 @@ class RasterWorkerPoolTest
         timed_out_(false) {}
 
   // Overridden from testing::Test:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     switch (GetParam()) {
       case RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER:
         Create3dOutputSurfaceAndResourceProvider();
@@ -175,19 +175,19 @@ class RasterWorkerPoolTest
     raster_worker_pool_->AsRasterizer()->SetClient(this);
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     raster_worker_pool_->AsRasterizer()->Shutdown();
     raster_worker_pool_->AsRasterizer()->CheckForCompletedTasks();
   }
 
   // Overriden from RasterWorkerPoolClient:
-  virtual void DidFinishRunningTasks(TaskSet task_set) OVERRIDE {
+  virtual void DidFinishRunningTasks(TaskSet task_set) override {
     if (task_set == ALL) {
       raster_worker_pool_->AsRasterizer()->CheckForCompletedTasks();
       base::MessageLoop::current()->Quit();
     }
   }
-  virtual TaskSetCollection TasksThatShouldBeForcedToComplete() const OVERRIDE {
+  virtual TaskSetCollection TasksThatShouldBeForcedToComplete() const override {
     return TaskSetCollection();
   }
 
diff --git a/cc/resources/rasterizer.h b/cc/resources/rasterizer.h
index 72b50f2..5d2eeee 100644
--- a/cc/resources/rasterizer.h
+++ b/cc/resources/rasterizer.h
@@ -61,7 +61,7 @@ class CC_EXPORT ImageDecodeTask : public RasterizerTask {
   typedef std::vector<scoped_refptr<ImageDecodeTask> > Vector;
 
   // Overridden from RasterizerTask:
-  virtual ImageDecodeTask* AsImageDecodeTask() OVERRIDE;
+  virtual ImageDecodeTask* AsImageDecodeTask() override;
 
  protected:
   ImageDecodeTask();
@@ -73,7 +73,7 @@ class CC_EXPORT RasterTask : public RasterizerTask {
   typedef std::vector<scoped_refptr<RasterTask> > Vector;
 
   // Overridden from RasterizerTask:
-  virtual RasterTask* AsRasterTask() OVERRIDE;
+  virtual RasterTask* AsRasterTask() override;
 
   const Resource* resource() const { return resource_; }
   const ImageDecodeTask::Vector& dependencies() const { return dependencies_; }
diff --git a/cc/resources/resource_provider.cc b/cc/resources/resource_provider.cc
index 0e7c938..94ae1d9 100644
--- a/cc/resources/resource_provider.cc
+++ b/cc/resources/resource_provider.cc
@@ -143,7 +143,7 @@ class TextureIdAllocator : public IdAllocator {
   }
 
   // Overridden from IdAllocator:
-  virtual GLuint NextId() OVERRIDE {
+  virtual GLuint NextId() override {
     if (next_id_index_ == id_allocation_chunk_size_) {
       gl_->GenTextures(id_allocation_chunk_size_, ids_.get());
       next_id_index_ = 0;
@@ -166,7 +166,7 @@ class BufferIdAllocator : public IdAllocator {
   }
 
   // Overridden from IdAllocator:
-  virtual GLuint NextId() OVERRIDE {
+  virtual GLuint NextId() override {
     if (next_id_index_ == id_allocation_chunk_size_) {
       gl_->GenBuffers(id_allocation_chunk_size_, ids_.get());
       next_id_index_ = 0;
@@ -187,8 +187,8 @@ class QueryFence : public ResourceProvider::Fence {
       : gl_(gl), query_id_(query_id) {}
 
   // Overridden from ResourceProvider::Fence:
-  virtual void Set() OVERRIDE {}
-  virtual bool HasPassed() OVERRIDE {
+  virtual void Set() override {}
+  virtual bool HasPassed() override {
     unsigned available = 1;
     gl_->GetQueryObjectuivEXT(
         query_id_, GL_QUERY_RESULT_AVAILABLE_EXT, &available);
diff --git a/cc/resources/resource_provider_unittest.cc b/cc/resources/resource_provider_unittest.cc
index 04d88c6..a7ab3ae 100644
--- a/cc/resources/resource_provider_unittest.cc
+++ b/cc/resources/resource_provider_unittest.cc
@@ -101,11 +101,11 @@ class TextureStateTrackingContext : public TestWebGraphicsContext3D {
 
   // Force all textures to be consecutive numbers starting at "1",
   // so we easily can test for them.
-  virtual GLuint NextTextureId() OVERRIDE {
+  virtual GLuint NextTextureId() override {
     base::AutoLock lock(namespace_->lock);
     return namespace_->next_texture_id++;
   }
-  virtual void RetireTextureId(GLuint) OVERRIDE {}
+  virtual void RetireTextureId(GLuint) override {}
 };
 
 // Shared data between multiple ResourceProviderContext. This contains mailbox
@@ -168,7 +168,7 @@ class ResourceProviderContext : public TestWebGraphicsContext3D {
     return make_scoped_ptr(new ResourceProviderContext(shared_data));
   }
 
-  virtual GLuint insertSyncPoint() OVERRIDE {
+  virtual GLuint insertSyncPoint() override {
     uint32 sync_point = shared_data_->InsertSyncPoint();
     // Commit the produceTextureCHROMIUM calls at this point, so that
     // they're associated with the sync point.
@@ -183,7 +183,7 @@ class ResourceProviderContext : public TestWebGraphicsContext3D {
     return sync_point;
   }
 
-  virtual void waitSyncPoint(GLuint sync_point) OVERRIDE {
+  virtual void waitSyncPoint(GLuint sync_point) override {
     last_waited_sync_point_ = std::max(sync_point, last_waited_sync_point_);
   }
 
@@ -193,7 +193,7 @@ class ResourceProviderContext : public TestWebGraphicsContext3D {
                                GLint levels,
                                GLuint internalformat,
                                GLint width,
-                               GLint height) OVERRIDE {
+                               GLint height) override {
     CheckTextureIsBound(target);
     ASSERT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
     ASSERT_EQ(1, levels);
@@ -218,7 +218,7 @@ class ResourceProviderContext : public TestWebGraphicsContext3D {
                           GLint border,
                           GLenum format,
                           GLenum type,
-                          const void* pixels) OVERRIDE {
+                          const void* pixels) override {
     CheckTextureIsBound(target);
     ASSERT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
     ASSERT_FALSE(level);
@@ -238,7 +238,7 @@ class ResourceProviderContext : public TestWebGraphicsContext3D {
                              GLsizei height,
                              GLenum format,
                              GLenum type,
-                             const void* pixels) OVERRIDE {
+                             const void* pixels) override {
     CheckTextureIsBound(target);
     ASSERT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
     ASSERT_FALSE(level);
@@ -251,12 +251,12 @@ class ResourceProviderContext : public TestWebGraphicsContext3D {
     SetPixels(xoffset, yoffset, width, height, pixels);
   }
 
-  virtual void genMailboxCHROMIUM(GLbyte* mailbox) OVERRIDE {
+  virtual void genMailboxCHROMIUM(GLbyte* mailbox) override {
     return shared_data_->GenMailbox(mailbox);
   }
 
   virtual void produceTextureCHROMIUM(GLenum target,
-                                      const GLbyte* mailbox) OVERRIDE {
+                                      const GLbyte* mailbox) override {
     CheckTextureIsBound(target);
 
     // Delay moving the texture into the mailbox until the next
@@ -270,7 +270,7 @@ class ResourceProviderContext : public TestWebGraphicsContext3D {
   }
 
   virtual void consumeTextureCHROMIUM(GLenum target,
-                                      const GLbyte* mailbox) OVERRIDE {
+                                      const GLbyte* mailbox) override {
     CheckTextureIsBound(target);
     base::AutoLock lock_for_texture_access(namespace_->lock);
     scoped_refptr<TestTexture> texture =
@@ -3615,11 +3615,11 @@ INSTANTIATE_TEST_CASE_P(
 
 class TextureIdAllocationTrackingContext : public TestWebGraphicsContext3D {
  public:
-  virtual GLuint NextTextureId() OVERRIDE {
+  virtual GLuint NextTextureId() override {
     base::AutoLock lock(namespace_->lock);
     return namespace_->next_texture_id++;
   }
-  virtual void RetireTextureId(GLuint) OVERRIDE {}
+  virtual void RetireTextureId(GLuint) override {}
   GLuint PeekTextureId() {
     base::AutoLock lock(namespace_->lock);
     return namespace_->next_texture_id;
diff --git a/cc/resources/resource_update_controller_unittest.cc b/cc/resources/resource_update_controller_unittest.cc
index 58df016..18ad507 100644
--- a/cc/resources/resource_update_controller_unittest.cc
+++ b/cc/resources/resource_update_controller_unittest.cc
@@ -32,8 +32,8 @@ class WebGraphicsContext3DForUploadTest : public TestWebGraphicsContext3D {
   explicit WebGraphicsContext3DForUploadTest(ResourceUpdateControllerTest* test)
       : test_(test) {}
 
-  virtual void flush() OVERRIDE;
-  virtual void shallowFlushCHROMIUM() OVERRIDE;
+  virtual void flush() override;
+  virtual void shallowFlushCHROMIUM() override;
   virtual void texSubImage2D(GLenum target,
                              GLint level,
                              GLint xoffset,
@@ -42,10 +42,10 @@ class WebGraphicsContext3DForUploadTest : public TestWebGraphicsContext3D {
                              GLsizei height,
                              GLenum format,
                              GLenum type,
-                             const void* pixels) OVERRIDE;
+                             const void* pixels) override;
 
   virtual void getQueryObjectuivEXT(GLuint id, GLenum pname, GLuint* value)
-      OVERRIDE;
+      override;
 
  private:
   ResourceUpdateControllerTest* test_;
@@ -328,7 +328,7 @@ class FakeResourceUpdateControllerClient
   void Reset() { ready_to_finalize_called_ = false; }
   bool ReadyToFinalizeCalled() const { return ready_to_finalize_called_; }
 
-  virtual void ReadyToFinalizeTextureUpdates() OVERRIDE {
+  virtual void ReadyToFinalizeTextureUpdates() override {
     ready_to_finalize_called_ = true;
   }
 
@@ -352,7 +352,7 @@ class FakeResourceUpdateController : public ResourceUpdateController {
   void SetUpdateTextureTime(base::TimeDelta time) {
     update_textures_time_ = time;
   }
-  virtual base::TimeTicks UpdateMoreTexturesCompletionTime() OVERRIDE {
+  virtual base::TimeTicks UpdateMoreTexturesCompletionTime() override {
     size_t total_updates =
         resource_provider_->NumBlockingUploads() + update_more_textures_size_;
     return now_ + total_updates * update_textures_time_;
@@ -360,7 +360,7 @@ class FakeResourceUpdateController : public ResourceUpdateController {
   void SetUpdateMoreTexturesSize(size_t size) {
     update_more_textures_size_ = size;
   }
-  virtual size_t UpdateMoreTexturesSize() const OVERRIDE {
+  virtual size_t UpdateMoreTexturesSize() const override {
     return update_more_textures_size_;
   }
 
diff --git a/cc/resources/scoped_ui_resource.h b/cc/resources/scoped_ui_resource.h
index c257e1e..9d4b937 100644
--- a/cc/resources/scoped_ui_resource.h
+++ b/cc/resources/scoped_ui_resource.h
@@ -29,7 +29,7 @@ class CC_EXPORT ScopedUIResource : public UIResourceClient {
 
   // UIResourceClient implementation.
   virtual UIResourceBitmap GetBitmap(UIResourceId uid,
-                                     bool resource_lost) OVERRIDE;
+                                     bool resource_lost) override;
   UIResourceId id() { return id_; }
 
  protected:
diff --git a/cc/resources/skpicture_content_layer_updater.h b/cc/resources/skpicture_content_layer_updater.h
index 9c79c74..55edade 100644
--- a/cc/resources/skpicture_content_layer_updater.h
+++ b/cc/resources/skpicture_content_layer_updater.h
@@ -29,7 +29,7 @@ class SkPictureContentLayerUpdater : public ContentLayerUpdater {
                                const gfx::Rect& paint_rect,
                                const gfx::Size& tile_size,
                                float contents_width_scale,
-                               float contents_height_scale) OVERRIDE;
+                               float contents_height_scale) override;
   void DrawPicture(SkCanvas* canvas);
 
  private:
diff --git a/cc/resources/task_graph_runner_perftest.cc b/cc/resources/task_graph_runner_perftest.cc
index 533ea4b..999043f 100644
--- a/cc/resources/task_graph_runner_perftest.cc
+++ b/cc/resources/task_graph_runner_perftest.cc
@@ -27,7 +27,7 @@ class PerfTaskImpl : public Task {
   PerfTaskImpl() {}
 
   // Overridden from Task:
-  virtual void RunOnWorkerThread() OVERRIDE {}
+  virtual void RunOnWorkerThread() override {}
 
   void Reset() { did_run_ = false; }
 
@@ -45,11 +45,11 @@ class TaskGraphRunnerPerfTest : public testing::Test {
                kTimeCheckInterval) {}
 
   // Overridden from testing::Test:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     task_graph_runner_ = make_scoped_ptr(new TaskGraphRunner);
     namespace_token_ = task_graph_runner_->GetNamespaceToken();
   }
-  virtual void TearDown() OVERRIDE { task_graph_runner_ = nullptr; }
+  virtual void TearDown() override { task_graph_runner_ = nullptr; }
 
   void AfterTest(const std::string& test_name) {
     // Format matches chrome/test/perf/perf_test.h:PrintResult
diff --git a/cc/resources/task_graph_runner_unittest.cc b/cc/resources/task_graph_runner_unittest.cc
index 1a6256c..6e5a785 100644
--- a/cc/resources/task_graph_runner_unittest.cc
+++ b/cc/resources/task_graph_runner_unittest.cc
@@ -118,7 +118,7 @@ class TaskGraphRunnerTestBase {
         : test_(test), namespace_index_(namespace_index), id_(id) {}
 
     // Overridden from Task:
-    virtual void RunOnWorkerThread() OVERRIDE {
+    virtual void RunOnWorkerThread() override {
       test_->RunTaskOnWorkerThread(namespace_index_, id_);
     }
 
@@ -145,7 +145,7 @@ class TaskGraphRunnerTestBase {
         : FakeTaskImpl(test, namespace_index, id) {}
 
     // Overridden from FakeTaskImpl:
-    virtual void CompleteOnOriginThread() OVERRIDE {}
+    virtual void CompleteOnOriginThread() override {}
 
    private:
     virtual ~FakeDependentTaskImpl() {}
@@ -167,7 +167,7 @@ class TaskGraphRunnerTest : public TaskGraphRunnerTestBase,
                             public base::DelegateSimpleThread::Delegate {
  public:
   // Overridden from testing::Test:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     const size_t num_threads = GetParam();
     while (workers_.size() < num_threads) {
       scoped_ptr<base::DelegateSimpleThread> worker =
@@ -179,7 +179,7 @@ class TaskGraphRunnerTest : public TaskGraphRunnerTestBase,
     for (int i = 0; i < kNamespaceCount; ++i)
       namespace_token_[i] = task_graph_runner_->GetNamespaceToken();
   }
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     task_graph_runner_->Shutdown();
     while (workers_.size()) {
       scoped_ptr<base::DelegateSimpleThread> worker = workers_.take_front();
@@ -189,7 +189,7 @@ class TaskGraphRunnerTest : public TaskGraphRunnerTestBase,
 
  private:
   // Overridden from base::DelegateSimpleThread::Delegate:
-  virtual void Run() OVERRIDE { task_graph_runner_->Run(); }
+  virtual void Run() override { task_graph_runner_->Run(); }
 
   ScopedPtrDeque<base::DelegateSimpleThread> workers_;
 };
@@ -285,21 +285,21 @@ class TaskGraphRunnerSingleThreadTest
       public base::DelegateSimpleThread::Delegate {
  public:
   // Overridden from testing::Test:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     worker_.reset(new base::DelegateSimpleThread(this, "TestWorker"));
     worker_->Start();
 
     for (int i = 0; i < kNamespaceCount; ++i)
       namespace_token_[i] = task_graph_runner_->GetNamespaceToken();
   }
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     task_graph_runner_->Shutdown();
     worker_->Join();
   }
 
  private:
   // Overridden from base::DelegateSimpleThread::Delegate:
-  virtual void Run() OVERRIDE { task_graph_runner_->Run(); }
+  virtual void Run() override { task_graph_runner_->Run(); }
 
   scoped_ptr<base::DelegateSimpleThread> worker_;
 };
diff --git a/cc/resources/texture_uploader_unittest.cc b/cc/resources/texture_uploader_unittest.cc
index bf94065..335908d 100644
--- a/cc/resources/texture_uploader_unittest.cc
+++ b/cc/resources/texture_uploader_unittest.cc
@@ -19,7 +19,7 @@ class TextureUploadTestContext : public gpu::gles2::GLES2InterfaceStub {
  public:
   TextureUploadTestContext() : result_available_(0), unpack_alignment_(4) {}
 
-  virtual void PixelStorei(GLenum pname, GLint param) OVERRIDE {
+  virtual void PixelStorei(GLenum pname, GLint param) override {
     switch (pname) {
       case GL_UNPACK_ALIGNMENT:
         // Param should be a power of two <= 8.
@@ -43,7 +43,7 @@ class TextureUploadTestContext : public gpu::gles2::GLES2InterfaceStub {
 
   virtual void GetQueryObjectuivEXT(GLuint,
                                     GLenum type,
-                                    GLuint* value) OVERRIDE {
+                                    GLuint* value) override {
     switch (type) {
       case GL_QUERY_RESULT_AVAILABLE_EXT:
         *value = result_available_;
@@ -62,7 +62,7 @@ class TextureUploadTestContext : public gpu::gles2::GLES2InterfaceStub {
                              GLsizei height,
                              GLenum format,
                              GLenum type,
-                             const void* pixels) OVERRIDE {
+                             const void* pixels) override {
     EXPECT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
     EXPECT_EQ(0, level);
     EXPECT_LE(0, width);
diff --git a/cc/resources/tile_manager.cc b/cc/resources/tile_manager.cc
index 218faca..d121840 100644
--- a/cc/resources/tile_manager.cc
+++ b/cc/resources/tile_manager.cc
@@ -59,7 +59,7 @@ class RasterTaskImpl : public RasterTask {
         reply_(reply) {}
 
   // Overridden from Task:
-  virtual void RunOnWorkerThread() OVERRIDE {
+  virtual void RunOnWorkerThread() override {
     TRACE_EVENT0("cc", "RasterizerTaskImpl::RunOnWorkerThread");
 
     DCHECK(picture_pile_.get());
@@ -75,14 +75,14 @@ class RasterTaskImpl : public RasterTask {
   }
 
   // Overridden from RasterizerTask:
-  virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) OVERRIDE {
+  virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) override {
     DCHECK(!raster_buffer_);
     raster_buffer_ = client->AcquireBufferForRaster(resource());
   }
-  virtual void CompleteOnOriginThread(RasterizerTaskClient* client) OVERRIDE {
+  virtual void CompleteOnOriginThread(RasterizerTaskClient* client) override {
     client->ReleaseBufferForRaster(raster_buffer_.Pass());
   }
-  virtual void RunReplyOnOriginThread() OVERRIDE {
+  virtual void RunReplyOnOriginThread() override {
     DCHECK(!raster_buffer_);
     reply_.Run(analysis_, !HasFinishedRunning());
   }
@@ -172,7 +172,7 @@ class ImageDecodeTaskImpl : public ImageDecodeTask {
         reply_(reply) {}
 
   // Overridden from Task:
-  virtual void RunOnWorkerThread() OVERRIDE {
+  virtual void RunOnWorkerThread() override {
     TRACE_EVENT0("cc", "ImageDecodeTaskImpl::RunOnWorkerThread");
 
     devtools_instrumentation::ScopedImageDecodeTask image_decode_task(
@@ -183,9 +183,9 @@ class ImageDecodeTaskImpl : public ImageDecodeTask {
   }
 
   // Overridden from RasterizerTask:
-  virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) OVERRIDE {}
-  virtual void CompleteOnOriginThread(RasterizerTaskClient* client) OVERRIDE {}
-  virtual void RunReplyOnOriginThread() OVERRIDE {
+  virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) override {}
+  virtual void CompleteOnOriginThread(RasterizerTaskClient* client) override {}
+  virtual void RunReplyOnOriginThread() override {
     reply_.Run(!HasFinishedRunning());
   }
 
diff --git a/cc/resources/tile_manager.h b/cc/resources/tile_manager.h
index a9118a7..d8d219b 100644
--- a/cc/resources/tile_manager.h
+++ b/cc/resources/tile_manager.h
@@ -183,11 +183,11 @@ class CC_EXPORT TileManager : public RasterizerClient,
   void CleanUpReleasedTiles();
 
   // Overriden from RefCountedManager<Tile>:
-  virtual void Release(Tile* tile) OVERRIDE;
+  virtual void Release(Tile* tile) override;
 
   // Overriden from RasterizerClient:
-  virtual void DidFinishRunningTasks(TaskSet task_set) OVERRIDE;
-  virtual TaskSetCollection TasksThatShouldBeForcedToComplete() const OVERRIDE;
+  virtual void DidFinishRunningTasks(TaskSet task_set) override;
+  virtual TaskSetCollection TasksThatShouldBeForcedToComplete() const override;
 
   typedef std::vector<Tile*> TileVector;
   typedef std::set<Tile*> TileSet;
diff --git a/cc/resources/tile_manager_perftest.cc b/cc/resources/tile_manager_perftest.cc
index 5ff4fa2..9766df6 100644
--- a/cc/resources/tile_manager_perftest.cc
+++ b/cc/resources/tile_manager_perftest.cc
@@ -37,9 +37,9 @@ static const int kTimeCheckInterval = 10;
 class FakeRasterizerImpl : public Rasterizer, public RasterizerTaskClient {
  public:
   // Overridden from Rasterizer:
-  virtual void SetClient(RasterizerClient* client) OVERRIDE {}
-  virtual void Shutdown() OVERRIDE {}
-  virtual void ScheduleTasks(RasterTaskQueue* queue) OVERRIDE {
+  virtual void SetClient(RasterizerClient* client) override {}
+  virtual void Shutdown() override {}
+  virtual void ScheduleTasks(RasterTaskQueue* queue) override {
     for (RasterTaskQueue::Item::Vector::const_iterator it =
              queue->items.begin();
          it != queue->items.end();
@@ -53,7 +53,7 @@ class FakeRasterizerImpl : public Rasterizer, public RasterizerTaskClient {
       completed_tasks_.push_back(task);
     }
   }
-  virtual void CheckForCompletedTasks() OVERRIDE {
+  virtual void CheckForCompletedTasks() override {
     for (RasterTask::Vector::iterator it = completed_tasks_.begin();
          it != completed_tasks_.end();
          ++it) {
@@ -70,11 +70,11 @@ class FakeRasterizerImpl : public Rasterizer, public RasterizerTaskClient {
 
   // Overridden from RasterizerTaskClient:
   virtual scoped_ptr<RasterBuffer> AcquireBufferForRaster(
-      const Resource* resource) OVERRIDE {
+      const Resource* resource) override {
     return nullptr;
   }
   virtual void ReleaseBufferForRaster(
-      scoped_ptr<RasterBuffer> buffer) OVERRIDE {}
+      scoped_ptr<RasterBuffer> buffer) override {}
 
  private:
   RasterTask::Vector completed_tasks_;
@@ -112,7 +112,7 @@ class TileManagerPerfTest : public testing::Test {
     host_impl_.tile_manager()->SetGlobalStateForTesting(state);
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     picture_pile_ = FakePicturePileImpl::CreateInfiniteFilledPile();
     InitializeRenderer();
     SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES);
diff --git a/cc/resources/tile_manager_unittest.cc b/cc/resources/tile_manager_unittest.cc
index 3fb5b13..b0d57e6 100644
--- a/cc/resources/tile_manager_unittest.cc
+++ b/cc/resources/tile_manager_unittest.cc
@@ -81,7 +81,7 @@ class TileManagerTest : public testing::TestWithParam<bool>,
     tile_manager_->SetGlobalStateForTesting(state);
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     tile_manager_.reset(NULL);
     picture_pile_ = NULL;
 
@@ -90,15 +90,15 @@ class TileManagerTest : public testing::TestWithParam<bool>,
 
   // TileManagerClient implementation.
   virtual const std::vector<PictureLayerImpl*>& GetPictureLayers()
-      const OVERRIDE {
+      const override {
     return picture_layers_;
   }
-  virtual void NotifyReadyToActivate() OVERRIDE { ready_to_activate_ = true; }
-  virtual void NotifyTileStateChanged(const Tile* tile) OVERRIDE {}
+  virtual void NotifyReadyToActivate() override { ready_to_activate_ = true; }
+  virtual void NotifyTileStateChanged(const Tile* tile) override {}
   virtual void BuildRasterQueue(RasterTilePriorityQueue* queue,
-                                TreePriority priority) OVERRIDE {}
+                                TreePriority priority) override {}
   virtual void BuildEvictionQueue(EvictionTilePriorityQueue* queue,
-                                  TreePriority priority) OVERRIDE {}
+                                  TreePriority priority) override {}
 
   TileVector CreateTilesWithSize(int count,
                                  TilePriority active_priority,
@@ -514,7 +514,7 @@ class TileManagerTilePriorityQueueTest : public testing::Test {
     host_impl_.tile_manager()->SetGlobalStateForTesting(state);
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     InitializeRenderer();
     SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES);
   }
diff --git a/cc/resources/video_resource_updater.cc b/cc/resources/video_resource_updater.cc
index 75edccb..f62b6e6 100644
--- a/cc/resources/video_resource_updater.cc
+++ b/cc/resources/video_resource_updater.cc
@@ -27,10 +27,10 @@ class SyncPointClientImpl : public media::VideoFrame::SyncPointClient {
  public:
   explicit SyncPointClientImpl(gpu::gles2::GLES2Interface* gl) : gl_(gl) {}
   virtual ~SyncPointClientImpl() {}
-  virtual uint32 InsertSyncPoint() OVERRIDE {
+  virtual uint32 InsertSyncPoint() override {
     return GLC(gl_, gl_->InsertSyncPointCHROMIUM());
   }
-  virtual void WaitSyncPoint(uint32 sync_point) OVERRIDE {
+  virtual void WaitSyncPoint(uint32 sync_point) override {
     GLC(gl_, gl_->WaitSyncPointCHROMIUM(sync_point));
   }
 
diff --git a/cc/resources/zero_copy_raster_worker_pool.cc b/cc/resources/zero_copy_raster_worker_pool.cc
index f463406..8d98eaf 100644
--- a/cc/resources/zero_copy_raster_worker_pool.cc
+++ b/cc/resources/zero_copy_raster_worker_pool.cc
@@ -36,7 +36,7 @@ class RasterBufferImpl : public RasterBuffer {
   }
 
   // Overridden from RasterBuffer:
-  virtual skia::RefPtr<SkCanvas> AcquireSkCanvas() OVERRIDE {
+  virtual skia::RefPtr<SkCanvas> AcquireSkCanvas() override {
     if (!buffer_)
       return skia::AdoptRef(SkCreateNullCanvas());
 
@@ -44,7 +44,7 @@ class RasterBufferImpl : public RasterBuffer {
         &bitmap_, buffer_, resource_->format(), resource_->size(), stride_);
     return skia::AdoptRef(new SkCanvas(bitmap_));
   }
-  virtual void ReleaseSkCanvas(const skia::RefPtr<SkCanvas>& canvas) OVERRIDE {
+  virtual void ReleaseSkCanvas(const skia::RefPtr<SkCanvas>& canvas) override {
     if (!buffer_)
       return;
 
diff --git a/cc/resources/zero_copy_raster_worker_pool.h b/cc/resources/zero_copy_raster_worker_pool.h
index 4e4280e..b94713d 100644
--- a/cc/resources/zero_copy_raster_worker_pool.h
+++ b/cc/resources/zero_copy_raster_worker_pool.h
@@ -31,18 +31,18 @@ class CC_EXPORT ZeroCopyRasterWorkerPool : public RasterWorkerPool,
       ResourceProvider* resource_provider);
 
   // Overridden from RasterWorkerPool:
-  virtual Rasterizer* AsRasterizer() OVERRIDE;
+  virtual Rasterizer* AsRasterizer() override;
 
   // Overridden from Rasterizer:
-  virtual void SetClient(RasterizerClient* client) OVERRIDE;
-  virtual void Shutdown() OVERRIDE;
-  virtual void ScheduleTasks(RasterTaskQueue* queue) OVERRIDE;
-  virtual void CheckForCompletedTasks() OVERRIDE;
+  virtual void SetClient(RasterizerClient* client) override;
+  virtual void Shutdown() override;
+  virtual void ScheduleTasks(RasterTaskQueue* queue) override;
+  virtual void CheckForCompletedTasks() override;
 
   // Overridden from RasterizerTaskClient:
   virtual scoped_ptr<RasterBuffer> AcquireBufferForRaster(
-      const Resource* resource) OVERRIDE;
-  virtual void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) OVERRIDE;
+      const Resource* resource) override;
+  virtual void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) override;
 
  protected:
   ZeroCopyRasterWorkerPool(base::SequencedTaskRunner* task_runner,
diff --git a/cc/scheduler/begin_frame_source.h b/cc/scheduler/begin_frame_source.h
index e0c78be..3b8a576 100644
--- a/cc/scheduler/begin_frame_source.h
+++ b/cc/scheduler/begin_frame_source.h
@@ -71,11 +71,11 @@ class CC_EXPORT BeginFrameObserverMixIn : public BeginFrameObserver {
   // Traces |args| and DCHECK |args| satisfies pre-conditions then calls
   // OnBeginFrameMixInDelegate and updates the last_begin_frame_args_ value on
   // true.
-  virtual void OnBeginFrame(const BeginFrameArgs& args) OVERRIDE;
-  virtual const BeginFrameArgs LastUsedBeginFrameArgs() const OVERRIDE;
+  virtual void OnBeginFrame(const BeginFrameArgs& args) override;
+  virtual const BeginFrameArgs LastUsedBeginFrameArgs() const override;
 
   // Outputs last_begin_frame_args_
-  virtual void AsValueInto(base::debug::TracedValue* dict) const OVERRIDE;
+  virtual void AsValueInto(base::debug::TracedValue* dict) const override;
 
  protected:
   // Subclasses should override this method!
@@ -134,15 +134,15 @@ class CC_EXPORT BeginFrameSourceMixIn : public BeginFrameSource {
   virtual ~BeginFrameSourceMixIn() {}
 
   // BeginFrameSource
-  virtual bool NeedsBeginFrames() const OVERRIDE;
-  virtual void SetNeedsBeginFrames(bool needs_begin_frames) OVERRIDE;
-  virtual void DidFinishFrame(size_t remaining_frames) OVERRIDE {}
-  virtual void AddObserver(BeginFrameObserver* obs) OVERRIDE;
-  virtual void RemoveObserver(BeginFrameObserver* obs) OVERRIDE;
+  virtual bool NeedsBeginFrames() const override;
+  virtual void SetNeedsBeginFrames(bool needs_begin_frames) override;
+  virtual void DidFinishFrame(size_t remaining_frames) override {}
+  virtual void AddObserver(BeginFrameObserver* obs) override;
+  virtual void RemoveObserver(BeginFrameObserver* obs) override;
 
   // Tracing support - Recommend (but not required) to call this implementation
   // in any override.
-  virtual void AsValueInto(base::debug::TracedValue* dict) const OVERRIDE;
+  virtual void AsValueInto(base::debug::TracedValue* dict) const override;
 
  protected:
   BeginFrameSourceMixIn();
@@ -171,10 +171,10 @@ class CC_EXPORT BackToBackBeginFrameSource : public BeginFrameSourceMixIn {
   virtual ~BackToBackBeginFrameSource();
 
   // BeginFrameSource
-  virtual void DidFinishFrame(size_t remaining_frames) OVERRIDE;
+  virtual void DidFinishFrame(size_t remaining_frames) override;
 
   // Tracing
-  virtual void AsValueInto(base::debug::TracedValue* dict) const OVERRIDE;
+  virtual void AsValueInto(base::debug::TracedValue* dict) const override;
 
  protected:
   explicit BackToBackBeginFrameSource(
@@ -187,7 +187,7 @@ class CC_EXPORT BackToBackBeginFrameSource : public BeginFrameSourceMixIn {
   bool send_begin_frame_posted_;
 
   // BeginFrameSourceMixIn
-  virtual void OnNeedsBeginFramesChange(bool needs_begin_frames) OVERRIDE;
+  virtual void OnNeedsBeginFramesChange(bool needs_begin_frames) override;
 
   void BeginFrame();
 };
@@ -205,18 +205,18 @@ class CC_EXPORT SyntheticBeginFrameSource : public BeginFrameSourceMixIn,
   virtual ~SyntheticBeginFrameSource();
 
   // BeginFrameSource
-  virtual bool NeedsBeginFrames() const OVERRIDE;
+  virtual bool NeedsBeginFrames() const override;
 
   // Tracing
-  virtual void AsValueInto(base::debug::TracedValue* dict) const OVERRIDE;
+  virtual void AsValueInto(base::debug::TracedValue* dict) const override;
 
   // VSyncParameterObserver
   virtual void OnUpdateVSyncParameters(
       base::TimeTicks new_vsync_timebase,
-      base::TimeDelta new_vsync_interval) OVERRIDE;
+      base::TimeDelta new_vsync_interval) override;
 
   // TimeSourceClient
-  virtual void OnTimerTick() OVERRIDE;
+  virtual void OnTimerTick() override;
 
  protected:
   explicit SyntheticBeginFrameSource(
@@ -226,7 +226,7 @@ class CC_EXPORT SyntheticBeginFrameSource : public BeginFrameSourceMixIn,
                                       BeginFrameArgs::BeginFrameArgsType type);
 
   // BeginFrameSourceMixIn
-  virtual void OnNeedsBeginFramesChange(bool needs_begin_frames) OVERRIDE;
+  virtual void OnNeedsBeginFramesChange(bool needs_begin_frames) override;
 
   scoped_refptr<DelayBasedTimeSource> time_source_;
 };
@@ -251,16 +251,16 @@ class CC_EXPORT BeginFrameSourceMultiplexer : public BeginFrameSourceMixIn,
   // The mux is an BeginFrameObserver as it needs to proxy the OnBeginFrame
   // calls to preserve the monotonicity of the BeginFrameArgs when switching
   // sources.
-  virtual void OnBeginFrame(const BeginFrameArgs& args) OVERRIDE;
-  virtual const BeginFrameArgs LastUsedBeginFrameArgs() const OVERRIDE;
+  virtual void OnBeginFrame(const BeginFrameArgs& args) override;
+  virtual const BeginFrameArgs LastUsedBeginFrameArgs() const override;
 
   // BeginFrameSource
-  virtual bool NeedsBeginFrames() const OVERRIDE;
-  virtual void SetNeedsBeginFrames(bool needs_begin_frames) OVERRIDE;
-  virtual void DidFinishFrame(size_t remaining_frames) OVERRIDE;
+  virtual bool NeedsBeginFrames() const override;
+  virtual void SetNeedsBeginFrames(bool needs_begin_frames) override;
+  virtual void DidFinishFrame(size_t remaining_frames) override;
 
   // Tracing
-  virtual void AsValueInto(base::debug::TracedValue* dict) const OVERRIDE;
+  virtual void AsValueInto(base::debug::TracedValue* dict) const override;
 
  protected:
   BeginFrameSourceMultiplexer();
diff --git a/cc/scheduler/begin_frame_source_unittest.cc b/cc/scheduler/begin_frame_source_unittest.cc
index 20a4878..8abf1a9 100644
--- a/cc/scheduler/begin_frame_source_unittest.cc
+++ b/cc/scheduler/begin_frame_source_unittest.cc
@@ -256,7 +256,7 @@ class LoopingBeginFrameObserver : public BeginFrameObserverMixIn {
  public:
   BeginFrameSource* source_;
 
-  virtual void AsValueInto(base::debug::TracedValue* dict) const OVERRIDE {
+  virtual void AsValueInto(base::debug::TracedValue* dict) const override {
     dict->SetString("type", "LoopingBeginFrameObserver");
     dict->BeginDictionary("source");
     source_->AsValueInto(dict);
@@ -265,7 +265,7 @@ class LoopingBeginFrameObserver : public BeginFrameObserverMixIn {
 
  protected:
   // BeginFrameObserverMixIn
-  virtual bool OnBeginFrameMixInDelegate(const BeginFrameArgs& args) OVERRIDE {
+  virtual bool OnBeginFrameMixInDelegate(const BeginFrameArgs& args) override {
     return true;
   }
 };
@@ -297,7 +297,7 @@ class TestBackToBackBeginFrameSource : public BackToBackBeginFrameSource {
                                  base::SingleThreadTaskRunner* task_runner)
       : BackToBackBeginFrameSource(task_runner), now_src_(now_src) {}
 
-  virtual base::TimeTicks Now() OVERRIDE { return now_src_->Now(); }
+  virtual base::TimeTicks Now() override { return now_src_->Now(); }
 
   scoped_refptr<TestNowSource> now_src_;
 };
@@ -312,7 +312,7 @@ class BackToBackBeginFrameSourceTest : public ::testing::Test {
   scoped_ptr<TestBackToBackBeginFrameSource> source_;
   scoped_ptr<MockBeginFrameObserver> obs_;
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     now_src_ = TestNowSource::Create(1000);
     task_runner_ =
         make_scoped_refptr(new OrderedSimpleTaskRunner(now_src_, false));
@@ -323,7 +323,7 @@ class BackToBackBeginFrameSourceTest : public ::testing::Test {
     source_->AddObserver(obs_.get());
   }
 
-  virtual void TearDown() OVERRIDE { obs_.reset(); }
+  virtual void TearDown() override { obs_.reset(); }
 };
 
 const int64_t BackToBackBeginFrameSourceTest::kDeadline =
@@ -478,7 +478,7 @@ class SyntheticBeginFrameSourceTest : public ::testing::Test {
   scoped_ptr<TestSyntheticBeginFrameSource> source_;
   scoped_ptr<MockBeginFrameObserver> obs_;
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     now_src_ = TestNowSource::Create(1000);
     task_runner_ =
         make_scoped_refptr(new OrderedSimpleTaskRunner(now_src_, false));
@@ -488,7 +488,7 @@ class SyntheticBeginFrameSourceTest : public ::testing::Test {
     source_->AddObserver(obs_.get());
   }
 
-  virtual void TearDown() OVERRIDE { obs_.reset(); }
+  virtual void TearDown() override { obs_.reset(); }
 };
 
 TEST_F(SyntheticBeginFrameSourceTest,
@@ -547,7 +547,7 @@ TEST_F(SyntheticBeginFrameSourceTest, VSyncChanges) {
 // BeginFrameSourceMultiplexer testing -----------------------------------
 class BeginFrameSourceMultiplexerTest : public ::testing::Test {
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     mux_ = BeginFrameSourceMultiplexer::Create();
 
     source1_store_ = make_scoped_ptr(new FakeBeginFrameSource());
@@ -559,7 +559,7 @@ class BeginFrameSourceMultiplexerTest : public ::testing::Test {
     source3_ = source3_store_.get();
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     // Make sure the mux is torn down before the sources.
     mux_.reset();
   }
diff --git a/cc/scheduler/delay_based_time_source.h b/cc/scheduler/delay_based_time_source.h
index c5cc47d..270102b 100644
--- a/cc/scheduler/delay_based_time_source.h
+++ b/cc/scheduler/delay_based_time_source.h
@@ -101,14 +101,14 @@ class DelayBasedTimeSourceHighRes : public DelayBasedTimeSource {
   static scoped_refptr<DelayBasedTimeSourceHighRes> Create(
         base::TimeDelta interval, base::SingleThreadTaskRunner* task_runner);
 
-  virtual base::TimeTicks Now() const OVERRIDE;
+  virtual base::TimeTicks Now() const override;
 
  protected:
   DelayBasedTimeSourceHighRes(base::TimeDelta interval,
                               base::SingleThreadTaskRunner* task_runner);
   virtual ~DelayBasedTimeSourceHighRes();
 
-  virtual std::string TypeString() const OVERRIDE;
+  virtual std::string TypeString() const override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DelayBasedTimeSourceHighRes);
diff --git a/cc/scheduler/scheduler.h b/cc/scheduler/scheduler.h
index 3f00421..2ef10a4 100644
--- a/cc/scheduler/scheduler.h
+++ b/cc/scheduler/scheduler.h
@@ -150,14 +150,14 @@ class CC_EXPORT Scheduler : public BeginFrameObserverMixIn {
   base::TimeTicks LastBeginImplFrameTime();
 
   scoped_refptr<base::debug::ConvertableToTraceFormat> AsValue() const;
-  virtual void AsValueInto(base::debug::TracedValue* value) const OVERRIDE;
+  virtual void AsValueInto(base::debug::TracedValue* value) const override;
 
   void SetContinuousPainting(bool continuous_painting) {
     state_machine_.SetContinuousPainting(continuous_painting);
   }
 
   // BeginFrameObserverMixin
-  virtual bool OnBeginFrameMixInDelegate(const BeginFrameArgs& args) OVERRIDE;
+  virtual bool OnBeginFrameMixInDelegate(const BeginFrameArgs& args) override;
 
  protected:
   Scheduler(SchedulerClient* client,
diff --git a/cc/scheduler/scheduler_unittest.cc b/cc/scheduler/scheduler_unittest.cc
index 514899b..add50ca 100644
--- a/cc/scheduler/scheduler_unittest.cc
+++ b/cc/scheduler/scheduler_unittest.cc
@@ -53,7 +53,7 @@ class FakeSchedulerClient : public SchedulerClient {
         FakeSchedulerClient* client)
         : client_(client) {}
 
-    virtual void OnNeedsBeginFramesChange(bool needs_begin_frames) OVERRIDE {
+    virtual void OnNeedsBeginFramesChange(bool needs_begin_frames) override {
       if (needs_begin_frames) {
         client_->actions_.push_back("SetNeedsBeginFrames(true)");
       } else {
@@ -107,7 +107,7 @@ class FakeSchedulerClient : public SchedulerClient {
     return scheduler_->settings().begin_frame_scheduling_enabled &&
            scheduler_->settings().throttle_frame_production;
   }
-  virtual FakeBeginFrameSource* ExternalBeginFrameSource() OVERRIDE {
+  virtual FakeBeginFrameSource* ExternalBeginFrameSource() override {
     return &fake_frame_source_;
   }
 
@@ -159,19 +159,19 @@ class FakeSchedulerClient : public SchedulerClient {
     redraw_will_happen_if_update_visible_tiles_happens_ = redraw;
   }
   // SchedulerClient implementation.
-  virtual void WillBeginImplFrame(const BeginFrameArgs& args) OVERRIDE {
+  virtual void WillBeginImplFrame(const BeginFrameArgs& args) override {
     actions_.push_back("WillBeginImplFrame");
     states_.push_back(scheduler_->AsValue());
   }
-  virtual void ScheduledActionSendBeginMainFrame() OVERRIDE {
+  virtual void ScheduledActionSendBeginMainFrame() override {
     actions_.push_back("ScheduledActionSendBeginMainFrame");
     states_.push_back(scheduler_->AsValue());
   }
-  virtual void ScheduledActionAnimate() OVERRIDE {
+  virtual void ScheduledActionAnimate() override {
     actions_.push_back("ScheduledActionAnimate");
     states_.push_back(scheduler_->AsValue());
   }
-  virtual DrawResult ScheduledActionDrawAndSwapIfPossible() OVERRIDE {
+  virtual DrawResult ScheduledActionDrawAndSwapIfPossible() override {
     actions_.push_back("ScheduledActionDrawAndSwapIfPossible");
     states_.push_back(scheduler_->AsValue());
     num_draws_++;
@@ -193,48 +193,48 @@ class FakeSchedulerClient : public SchedulerClient {
     }
     return result;
   }
-  virtual DrawResult ScheduledActionDrawAndSwapForced() OVERRIDE {
+  virtual DrawResult ScheduledActionDrawAndSwapForced() override {
     actions_.push_back("ScheduledActionDrawAndSwapForced");
     states_.push_back(scheduler_->AsValue());
     return DRAW_SUCCESS;
   }
-  virtual void ScheduledActionCommit() OVERRIDE {
+  virtual void ScheduledActionCommit() override {
     actions_.push_back("ScheduledActionCommit");
     states_.push_back(scheduler_->AsValue());
   }
-  virtual void ScheduledActionUpdateVisibleTiles() OVERRIDE {
+  virtual void ScheduledActionUpdateVisibleTiles() override {
     actions_.push_back("ScheduledActionUpdateVisibleTiles");
     states_.push_back(scheduler_->AsValue());
     if (redraw_will_happen_if_update_visible_tiles_happens_)
       scheduler_->SetNeedsRedraw();
   }
-  virtual void ScheduledActionActivateSyncTree() OVERRIDE {
+  virtual void ScheduledActionActivateSyncTree() override {
     actions_.push_back("ScheduledActionActivateSyncTree");
     states_.push_back(scheduler_->AsValue());
   }
-  virtual void ScheduledActionBeginOutputSurfaceCreation() OVERRIDE {
+  virtual void ScheduledActionBeginOutputSurfaceCreation() override {
     actions_.push_back("ScheduledActionBeginOutputSurfaceCreation");
     states_.push_back(scheduler_->AsValue());
   }
-  virtual void ScheduledActionManageTiles() OVERRIDE {
+  virtual void ScheduledActionManageTiles() override {
     actions_.push_back("ScheduledActionManageTiles");
     states_.push_back(scheduler_->AsValue());
   }
-  virtual void DidAnticipatedDrawTimeChange(base::TimeTicks) OVERRIDE {
+  virtual void DidAnticipatedDrawTimeChange(base::TimeTicks) override {
     if (log_anticipated_draw_time_change_)
       actions_.push_back("DidAnticipatedDrawTimeChange");
   }
-  virtual base::TimeDelta DrawDurationEstimate() OVERRIDE {
+  virtual base::TimeDelta DrawDurationEstimate() override {
     return base::TimeDelta();
   }
-  virtual base::TimeDelta BeginMainFrameToCommitDurationEstimate() OVERRIDE {
+  virtual base::TimeDelta BeginMainFrameToCommitDurationEstimate() override {
     return base::TimeDelta();
   }
-  virtual base::TimeDelta CommitToActivateDurationEstimate() OVERRIDE {
+  virtual base::TimeDelta CommitToActivateDurationEstimate() override {
     return base::TimeDelta();
   }
 
-  virtual void DidBeginImplFrameDeadline() OVERRIDE {}
+  virtual void DidBeginImplFrameDeadline() override {}
 
   base::Callback<bool(void)> ImplFrameDeadlinePending(bool state) {
     return base::Bind(&FakeSchedulerClient::ImplFrameDeadlinePendingCallback,
@@ -455,23 +455,23 @@ TEST(SchedulerTest, RequestCommitAfterBeginMainFrameSent) {
 
 class SchedulerClientThatsetNeedsDrawInsideDraw : public FakeSchedulerClient {
  public:
-  virtual void ScheduledActionSendBeginMainFrame() OVERRIDE {}
+  virtual void ScheduledActionSendBeginMainFrame() override {}
   virtual DrawResult ScheduledActionDrawAndSwapIfPossible()
-      OVERRIDE {
+      override {
     // Only SetNeedsRedraw the first time this is called
     if (!num_draws_)
       scheduler_->SetNeedsRedraw();
     return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
   }
 
-  virtual DrawResult ScheduledActionDrawAndSwapForced() OVERRIDE {
+  virtual DrawResult ScheduledActionDrawAndSwapForced() override {
     NOTREACHED();
     return DRAW_SUCCESS;
   }
 
-  virtual void ScheduledActionCommit() OVERRIDE {}
-  virtual void ScheduledActionBeginOutputSurfaceCreation() OVERRIDE {}
-  virtual void DidAnticipatedDrawTimeChange(base::TimeTicks) OVERRIDE {}
+  virtual void ScheduledActionCommit() override {}
+  virtual void ScheduledActionBeginOutputSurfaceCreation() override {}
+  virtual void DidAnticipatedDrawTimeChange(base::TimeTicks) override {}
 };
 
 // Tests for two different situations:
@@ -566,9 +566,9 @@ class SchedulerClientThatSetNeedsCommitInsideDraw : public FakeSchedulerClient {
   SchedulerClientThatSetNeedsCommitInsideDraw()
       : set_needs_commit_on_next_draw_(false) {}
 
-  virtual void ScheduledActionSendBeginMainFrame() OVERRIDE {}
+  virtual void ScheduledActionSendBeginMainFrame() override {}
   virtual DrawResult ScheduledActionDrawAndSwapIfPossible()
-      OVERRIDE {
+      override {
     // Only SetNeedsCommit the first time this is called
     if (set_needs_commit_on_next_draw_) {
       scheduler_->SetNeedsCommit();
@@ -577,14 +577,14 @@ class SchedulerClientThatSetNeedsCommitInsideDraw : public FakeSchedulerClient {
     return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
   }
 
-  virtual DrawResult ScheduledActionDrawAndSwapForced() OVERRIDE {
+  virtual DrawResult ScheduledActionDrawAndSwapForced() override {
     NOTREACHED();
     return DRAW_SUCCESS;
   }
 
-  virtual void ScheduledActionCommit() OVERRIDE {}
-  virtual void ScheduledActionBeginOutputSurfaceCreation() OVERRIDE {}
-  virtual void DidAnticipatedDrawTimeChange(base::TimeTicks) OVERRIDE {}
+  virtual void ScheduledActionCommit() override {}
+  virtual void ScheduledActionBeginOutputSurfaceCreation() override {}
+  virtual void DidAnticipatedDrawTimeChange(base::TimeTicks) override {}
 
   void SetNeedsCommitOnNextDraw() { set_needs_commit_on_next_draw_ = true; }
 
@@ -722,7 +722,7 @@ TEST(SchedulerTest, NoSwapWhenDrawFails) {
 class SchedulerClientNeedsManageTilesInDraw : public FakeSchedulerClient {
  public:
   virtual DrawResult ScheduledActionDrawAndSwapIfPossible()
-      OVERRIDE {
+      override {
     scheduler_->SetNeedsManageTiles();
     return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
   }
@@ -1043,13 +1043,13 @@ class SchedulerClientWithFixedEstimates : public FakeSchedulerClient {
             begin_main_frame_to_commit_duration),
         commit_to_activate_duration_(commit_to_activate_duration) {}
 
-  virtual base::TimeDelta DrawDurationEstimate() OVERRIDE {
+  virtual base::TimeDelta DrawDurationEstimate() override {
     return draw_duration_;
   }
-  virtual base::TimeDelta BeginMainFrameToCommitDurationEstimate() OVERRIDE {
+  virtual base::TimeDelta BeginMainFrameToCommitDurationEstimate() override {
     return begin_main_frame_to_commit_duration_;
   }
-  virtual base::TimeDelta CommitToActivateDurationEstimate() OVERRIDE {
+  virtual base::TimeDelta CommitToActivateDurationEstimate() override {
     return commit_to_activate_duration_;
   }
 
diff --git a/cc/surfaces/display.h b/cc/surfaces/display.h
index d12d956..16bdd98 100644
--- a/cc/surfaces/display.h
+++ b/cc/surfaces/display.h
@@ -52,32 +52,32 @@ class CC_SURFACES_EXPORT Display : public OutputSurfaceClient,
   int GetMaxFramesPending();
 
   // OutputSurfaceClient implementation.
-  virtual void DeferredInitialize() OVERRIDE {}
-  virtual void ReleaseGL() OVERRIDE {}
+  virtual void DeferredInitialize() override {}
+  virtual void ReleaseGL() override {}
   virtual void CommitVSyncParameters(base::TimeTicks timebase,
-                                     base::TimeDelta interval) OVERRIDE;
-  virtual void SetNeedsRedrawRect(const gfx::Rect& damage_rect) OVERRIDE {}
-  virtual void BeginFrame(const BeginFrameArgs& args) OVERRIDE {}
-  virtual void DidSwapBuffers() OVERRIDE;
-  virtual void DidSwapBuffersComplete() OVERRIDE;
-  virtual void ReclaimResources(const CompositorFrameAck* ack) OVERRIDE {}
-  virtual void DidLoseOutputSurface() OVERRIDE;
+                                     base::TimeDelta interval) override;
+  virtual void SetNeedsRedrawRect(const gfx::Rect& damage_rect) override {}
+  virtual void BeginFrame(const BeginFrameArgs& args) override {}
+  virtual void DidSwapBuffers() override;
+  virtual void DidSwapBuffersComplete() override;
+  virtual void ReclaimResources(const CompositorFrameAck* ack) override {}
+  virtual void DidLoseOutputSurface() override;
   virtual void SetExternalDrawConstraints(
       const gfx::Transform& transform,
       const gfx::Rect& viewport,
       const gfx::Rect& clip,
       const gfx::Rect& viewport_rect_for_tile_priority,
       const gfx::Transform& transform_for_tile_priority,
-      bool resourceless_software_draw) OVERRIDE {}
-  virtual void SetMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE;
+      bool resourceless_software_draw) override {}
+  virtual void SetMemoryPolicy(const ManagedMemoryPolicy& policy) override;
   virtual void SetTreeActivationCallback(
-      const base::Closure& callback) OVERRIDE {}
+      const base::Closure& callback) override {}
 
   // RendererClient implementation.
-  virtual void SetFullRootLayerDamage() OVERRIDE {}
+  virtual void SetFullRootLayerDamage() override {}
 
   // SurfaceDamageObserver implementation.
-  virtual void OnSurfaceDamaged(SurfaceId surface) OVERRIDE;
+  virtual void OnSurfaceDamaged(SurfaceId surface) override;
 
  private:
   void InitializeRenderer();
diff --git a/cc/surfaces/surface_aggregator_unittest.cc b/cc/surfaces/surface_aggregator_unittest.cc
index cde8b8f..0a8cca2 100644
--- a/cc/surfaces/surface_aggregator_unittest.cc
+++ b/cc/surfaces/surface_aggregator_unittest.cc
@@ -43,7 +43,7 @@ gfx::Size SurfaceSize() {
 class EmptySurfaceFactoryClient : public SurfaceFactoryClient {
  public:
   virtual void ReturnResources(
-      const ReturnedResourceArray& resources) OVERRIDE {}
+      const ReturnedResourceArray& resources) override {}
 };
 
 class SurfaceAggregatorTest : public testing::Test {
@@ -1061,7 +1061,7 @@ class ResourceTrackingSurfaceFactoryClient : public SurfaceFactoryClient {
   virtual ~ResourceTrackingSurfaceFactoryClient() {}
 
   virtual void ReturnResources(
-      const ReturnedResourceArray& resources) OVERRIDE {
+      const ReturnedResourceArray& resources) override {
     returned_resources_ = resources;
   }
 
diff --git a/cc/surfaces/surface_factory_unittest.cc b/cc/surfaces/surface_factory_unittest.cc
index a4aecf8..5cb83fe 100644
--- a/cc/surfaces/surface_factory_unittest.cc
+++ b/cc/surfaces/surface_factory_unittest.cc
@@ -20,7 +20,7 @@ class TestSurfaceFactoryClient : public SurfaceFactoryClient {
   virtual ~TestSurfaceFactoryClient() {}
 
   virtual void ReturnResources(
-      const ReturnedResourceArray& resources) OVERRIDE {
+      const ReturnedResourceArray& resources) override {
     returned_resources_.insert(
         returned_resources_.end(), resources.begin(), resources.end());
   }
diff --git a/cc/surfaces/surfaces_pixeltest.cc b/cc/surfaces/surfaces_pixeltest.cc
index 1e8166f..171d74e 100644
--- a/cc/surfaces/surfaces_pixeltest.cc
+++ b/cc/surfaces/surfaces_pixeltest.cc
@@ -24,7 +24,7 @@ namespace {
 class EmptySurfaceFactoryClient : public SurfaceFactoryClient {
  public:
   virtual void ReturnResources(
-      const ReturnedResourceArray& resources) OVERRIDE {}
+      const ReturnedResourceArray& resources) override {}
 };
 
 class SurfacesPixelTest : public RendererPixelTest<GLRenderer> {
diff --git a/cc/test/animation_test_common.h b/cc/test/animation_test_common.h
index bd680d6..1ee89da 100644
--- a/cc/test/animation_test_common.h
+++ b/cc/test/animation_test_common.h
@@ -26,9 +26,9 @@ class FakeFloatAnimationCurve : public FloatAnimationCurve {
   explicit FakeFloatAnimationCurve(double duration);
   virtual ~FakeFloatAnimationCurve();
 
-  virtual double Duration() const OVERRIDE;
-  virtual float GetValue(double now) const OVERRIDE;
-  virtual scoped_ptr<AnimationCurve> Clone() const OVERRIDE;
+  virtual double Duration() const override;
+  virtual float GetValue(double now) const override;
+  virtual scoped_ptr<AnimationCurve> Clone() const override;
 
  private:
   double duration_;
@@ -39,15 +39,15 @@ class FakeTransformTransition : public TransformAnimationCurve {
   explicit FakeTransformTransition(double duration);
   virtual ~FakeTransformTransition();
 
-  virtual double Duration() const OVERRIDE;
-  virtual gfx::Transform GetValue(double time) const OVERRIDE;
+  virtual double Duration() const override;
+  virtual gfx::Transform GetValue(double time) const override;
   virtual bool AnimatedBoundsForBox(const gfx::BoxF& box,
-                                    gfx::BoxF* bounds) const OVERRIDE;
-  virtual bool AffectsScale() const OVERRIDE;
-  virtual bool IsTranslation() const OVERRIDE;
-  virtual bool MaximumScale(float* max_scale) const OVERRIDE;
+                                    gfx::BoxF* bounds) const override;
+  virtual bool AffectsScale() const override;
+  virtual bool IsTranslation() const override;
+  virtual bool MaximumScale(float* max_scale) const override;
 
-  virtual scoped_ptr<AnimationCurve> Clone() const OVERRIDE;
+  virtual scoped_ptr<AnimationCurve> Clone() const override;
 
  private:
   double duration_;
@@ -58,10 +58,10 @@ class FakeFloatTransition : public FloatAnimationCurve {
   FakeFloatTransition(double duration, float from, float to);
   virtual ~FakeFloatTransition();
 
-  virtual double Duration() const OVERRIDE;
-  virtual float GetValue(double time) const OVERRIDE;
+  virtual double Duration() const override;
+  virtual float GetValue(double time) const override;
 
-  virtual scoped_ptr<AnimationCurve> Clone() const OVERRIDE;
+  virtual scoped_ptr<AnimationCurve> Clone() const override;
 
  private:
   double duration_;
@@ -75,13 +75,13 @@ class FakeLayerAnimationValueObserver : public LayerAnimationValueObserver {
   virtual ~FakeLayerAnimationValueObserver();
 
   // LayerAnimationValueObserver implementation
-  virtual void OnFilterAnimated(const FilterOperations& filters) OVERRIDE;
-  virtual void OnOpacityAnimated(float opacity) OVERRIDE;
-  virtual void OnTransformAnimated(const gfx::Transform& transform) OVERRIDE;
+  virtual void OnFilterAnimated(const FilterOperations& filters) override;
+  virtual void OnOpacityAnimated(float opacity) override;
+  virtual void OnTransformAnimated(const gfx::Transform& transform) override;
   virtual void OnScrollOffsetAnimated(
-      const gfx::ScrollOffset& scroll_offset) OVERRIDE;
-  virtual void OnAnimationWaitingForDeletion() OVERRIDE;
-  virtual bool IsActive() const OVERRIDE;
+      const gfx::ScrollOffset& scroll_offset) override;
+  virtual void OnAnimationWaitingForDeletion() override;
+  virtual bool IsActive() const override;
 
   const FilterOperations& filters() const { return filters_; }
   float opacity() const  { return opacity_; }
@@ -103,12 +103,12 @@ class FakeLayerAnimationValueObserver : public LayerAnimationValueObserver {
 class FakeInactiveLayerAnimationValueObserver
     : public FakeLayerAnimationValueObserver {
  public:
-  virtual bool IsActive() const OVERRIDE;
+  virtual bool IsActive() const override;
 };
 
 class FakeLayerAnimationValueProvider : public LayerAnimationValueProvider {
  public:
-  virtual gfx::ScrollOffset ScrollOffsetForAnimation() const OVERRIDE;
+  virtual gfx::ScrollOffset ScrollOffsetForAnimation() const override;
 
   void set_scroll_offset(const gfx::ScrollOffset& scroll_offset) {
     scroll_offset_ = scroll_offset;
diff --git a/cc/test/cc_test_suite.h b/cc/test/cc_test_suite.h
index 5f749e7..6edcd6a 100644
--- a/cc/test/cc_test_suite.h
+++ b/cc/test/cc_test_suite.h
@@ -22,8 +22,8 @@ class CCTestSuite : public base::TestSuite {
 
  protected:
   // Overridden from base::TestSuite:
-  virtual void Initialize() OVERRIDE;
-  virtual void Shutdown() OVERRIDE;
+  virtual void Initialize() override;
+  virtual void Shutdown() override;
 
  private:
   scoped_ptr<base::MessageLoop> message_loop_;
diff --git a/cc/test/fake_content_layer.h b/cc/test/fake_content_layer.h
index ee6cfb4..1debe85 100644
--- a/cc/test/fake_content_layer.h
+++ b/cc/test/fake_content_layer.h
@@ -17,7 +17,7 @@ class FakeContentLayer : public ContentLayer {
   }
 
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
+      override;
 
   size_t update_count() const { return update_count_; }
   void reset_update_count() { update_count_ = 0; }
@@ -26,7 +26,7 @@ class FakeContentLayer : public ContentLayer {
   void reset_push_properties_count() { push_properties_count_ = 0; }
 
   virtual bool Update(ResourceUpdateQueue* queue,
-                      const OcclusionTracker<Layer>* occlusion) OVERRIDE;
+                      const OcclusionTracker<Layer>* occlusion) override;
 
   gfx::Rect LastPaintRect() const;
 
@@ -34,9 +34,9 @@ class FakeContentLayer : public ContentLayer {
     always_update_resources_ = always_update_resources;
   }
 
-  virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE;
+  virtual void PushPropertiesTo(LayerImpl* layer) override;
 
-  virtual void OnOutputSurfaceCreated() OVERRIDE;
+  virtual void OnOutputSurfaceCreated() override;
   size_t output_surface_created_count() const {
     return output_surface_created_count_;
   }
diff --git a/cc/test/fake_content_layer_client.h b/cc/test/fake_content_layer_client.h
index ae0ebdd..3ae031a 100644
--- a/cc/test/fake_content_layer_client.h
+++ b/cc/test/fake_content_layer_client.h
@@ -30,9 +30,9 @@ class FakeContentLayerClient : public ContentLayerClient {
   virtual void PaintContents(
       SkCanvas* canvas,
       const gfx::Rect& rect,
-      ContentLayerClient::GraphicsContextStatus gc_status) OVERRIDE;
-  virtual void DidChangeLayerCanUseLCDText() OVERRIDE {}
-  virtual bool FillsBoundsCompletely() const OVERRIDE;
+      ContentLayerClient::GraphicsContextStatus gc_status) override;
+  virtual void DidChangeLayerCanUseLCDText() override {}
+  virtual bool FillsBoundsCompletely() const override;
 
   void set_fill_with_nonsolid_color(bool nonsolid) {
     fill_with_nonsolid_color_ = nonsolid;
diff --git a/cc/test/fake_content_layer_impl.h b/cc/test/fake_content_layer_impl.h
index 4313cad3..f4c8f54 100644
--- a/cc/test/fake_content_layer_impl.h
+++ b/cc/test/fake_content_layer_impl.h
@@ -19,7 +19,7 @@ class FakeContentLayerImpl : public TiledLayerImpl {
   virtual ~FakeContentLayerImpl();
 
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
+      override;
 
   bool HaveResourceForTileAt(int i, int j);
 
@@ -28,7 +28,7 @@ class FakeContentLayerImpl : public TiledLayerImpl {
   }
   void reset_lost_output_surface_count() { lost_output_surface_count_ = 0; }
 
-  virtual void ReleaseResources() OVERRIDE;
+  virtual void ReleaseResources() override;
 
  private:
   explicit FakeContentLayerImpl(LayerTreeImpl* tree_impl, int id);
diff --git a/cc/test/fake_delegated_renderer_layer.h b/cc/test/fake_delegated_renderer_layer.h
index f162473..a5fca87 100644
--- a/cc/test/fake_delegated_renderer_layer.h
+++ b/cc/test/fake_delegated_renderer_layer.h
@@ -18,7 +18,7 @@ class FakeDelegatedRendererLayer : public DelegatedRendererLayer {
   }
 
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
+      override;
 
  protected:
   explicit FakeDelegatedRendererLayer(DelegatedFrameProvider* frame_provider);
diff --git a/cc/test/fake_delegated_renderer_layer_impl.h b/cc/test/fake_delegated_renderer_layer_impl.h
index f909d24..dc3fee7 100644
--- a/cc/test/fake_delegated_renderer_layer_impl.h
+++ b/cc/test/fake_delegated_renderer_layer_impl.h
@@ -18,7 +18,7 @@ class FakeDelegatedRendererLayerImpl : public DelegatedRendererLayerImpl {
   virtual ~FakeDelegatedRendererLayerImpl();
 
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
+      override;
 
   int ChildId() const { return ChildIdForTesting(); }
   const RenderPassList& RenderPassesInDrawOrder() const {
diff --git a/cc/test/fake_layer_tree_host.h b/cc/test/fake_layer_tree_host.h
index c99edb3..c288046 100644
--- a/cc/test/fake_layer_tree_host.h
+++ b/cc/test/fake_layer_tree_host.h
@@ -25,8 +25,8 @@ class FakeLayerTreeHost : public LayerTreeHost {
 
   virtual ~FakeLayerTreeHost();
 
-  virtual void SetNeedsCommit() OVERRIDE;
-  virtual void SetNeedsFullTreeSync() OVERRIDE {}
+  virtual void SetNeedsCommit() override;
+  virtual void SetNeedsFullTreeSync() override {}
 
   using LayerTreeHost::SetRootLayer;
   using LayerTreeHost::root_layer;
diff --git a/cc/test/fake_layer_tree_host_client.h b/cc/test/fake_layer_tree_host_client.h
index 6ad53d6..9371e32 100644
--- a/cc/test/fake_layer_tree_host_client.h
+++ b/cc/test/fake_layer_tree_host_client.h
@@ -30,28 +30,28 @@ class FakeLayerTreeHostClient : public LayerTreeHostClient,
   void SetLayerTreeHost(LayerTreeHost* host) { host_ = host; }
 
   // LayerTreeHostClient implementation.
-  virtual void WillBeginMainFrame(int frame_id) OVERRIDE {}
-  virtual void DidBeginMainFrame() OVERRIDE {}
-  virtual void BeginMainFrame(const BeginFrameArgs& args) OVERRIDE {}
-  virtual void Layout() OVERRIDE {}
+  virtual void WillBeginMainFrame(int frame_id) override {}
+  virtual void DidBeginMainFrame() override {}
+  virtual void BeginMainFrame(const BeginFrameArgs& args) override {}
+  virtual void Layout() override {}
   virtual void ApplyViewportDeltas(const gfx::Vector2d& inner_delta,
                                    const gfx::Vector2d& outer_delta,
                                    float page_scale,
-                                   float top_controls_delta) OVERRIDE {}
+                                   float top_controls_delta) override {}
   virtual void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
                                    float page_scale,
-                                   float top_controls_delta) OVERRIDE {}
+                                   float top_controls_delta) override {}
 
-  virtual void RequestNewOutputSurface(bool fallback) OVERRIDE;
-  virtual void DidInitializeOutputSurface() OVERRIDE {}
-  virtual void WillCommit() OVERRIDE {}
-  virtual void DidCommit() OVERRIDE {}
-  virtual void DidCommitAndDrawFrame() OVERRIDE {}
-  virtual void DidCompleteSwapBuffers() OVERRIDE {}
+  virtual void RequestNewOutputSurface(bool fallback) override;
+  virtual void DidInitializeOutputSurface() override {}
+  virtual void WillCommit() override {}
+  virtual void DidCommit() override {}
+  virtual void DidCommitAndDrawFrame() override {}
+  virtual void DidCompleteSwapBuffers() override {}
 
   // LayerTreeHostSingleThreadClient implementation.
-  virtual void DidPostSwapBuffers() OVERRIDE {}
-  virtual void DidAbortSwapBuffers() OVERRIDE {}
+  virtual void DidPostSwapBuffers() override {}
+  virtual void DidAbortSwapBuffers() override {}
 
  private:
   bool use_software_rendering_;
diff --git a/cc/test/fake_layer_tree_host_impl.h b/cc/test/fake_layer_tree_host_impl.h
index 6d31c51..558007e 100644
--- a/cc/test/fake_layer_tree_host_impl.h
+++ b/cc/test/fake_layer_tree_host_impl.h
@@ -26,9 +26,9 @@ class FakeLayerTreeHostImpl : public LayerTreeHostImpl {
     DidDrawAllLayers(frame_data);
   }
 
-  virtual void CreatePendingTree() OVERRIDE;
+  virtual void CreatePendingTree() override;
 
-  virtual BeginFrameArgs CurrentBeginFrameArgs() const OVERRIDE;
+  virtual BeginFrameArgs CurrentBeginFrameArgs() const override;
   void SetCurrentBeginFrameArgs(const BeginFrameArgs& args);
   void UpdateNumChildrenAndDrawPropertiesForActiveTree();
   static void UpdateNumChildrenAndDrawProperties(LayerTreeImpl* layerTree);
diff --git a/cc/test/fake_layer_tree_host_impl_client.h b/cc/test/fake_layer_tree_host_impl_client.h
index ec86f7b..c73e023 100644
--- a/cc/test/fake_layer_tree_host_impl_client.h
+++ b/cc/test/fake_layer_tree_host_impl_client.h
@@ -13,35 +13,35 @@ namespace cc {
 class FakeLayerTreeHostImplClient : public LayerTreeHostImplClient {
  public:
   // LayerTreeHostImplClient implementation.
-  virtual void UpdateRendererCapabilitiesOnImplThread() OVERRIDE {}
-  virtual void DidLoseOutputSurfaceOnImplThread() OVERRIDE {}
+  virtual void UpdateRendererCapabilitiesOnImplThread() override {}
+  virtual void DidLoseOutputSurfaceOnImplThread() override {}
   virtual void CommitVSyncParameters(base::TimeTicks timebase,
-                                     base::TimeDelta interval) OVERRIDE {}
-  virtual void SetEstimatedParentDrawTime(base::TimeDelta draw_time) OVERRIDE {}
-  virtual void SetMaxSwapsPendingOnImplThread(int max) OVERRIDE {}
-  virtual void DidSwapBuffersOnImplThread() OVERRIDE {}
-  virtual void DidSwapBuffersCompleteOnImplThread() OVERRIDE {}
-  virtual void OnCanDrawStateChanged(bool can_draw) OVERRIDE {}
-  virtual void NotifyReadyToActivate() OVERRIDE {}
-  virtual void SetNeedsRedrawOnImplThread() OVERRIDE {}
+                                     base::TimeDelta interval) override {}
+  virtual void SetEstimatedParentDrawTime(base::TimeDelta draw_time) override {}
+  virtual void SetMaxSwapsPendingOnImplThread(int max) override {}
+  virtual void DidSwapBuffersOnImplThread() override {}
+  virtual void DidSwapBuffersCompleteOnImplThread() override {}
+  virtual void OnCanDrawStateChanged(bool can_draw) override {}
+  virtual void NotifyReadyToActivate() override {}
+  virtual void SetNeedsRedrawOnImplThread() override {}
   virtual void SetNeedsRedrawRectOnImplThread(
-    const gfx::Rect& damage_rect) OVERRIDE {}
-  virtual void SetNeedsAnimateOnImplThread() OVERRIDE {}
-  virtual void DidInitializeVisibleTileOnImplThread() OVERRIDE {}
-  virtual void SetNeedsCommitOnImplThread() OVERRIDE {}
-  virtual void SetNeedsManageTilesOnImplThread() OVERRIDE {}
+    const gfx::Rect& damage_rect) override {}
+  virtual void SetNeedsAnimateOnImplThread() override {}
+  virtual void DidInitializeVisibleTileOnImplThread() override {}
+  virtual void SetNeedsCommitOnImplThread() override {}
+  virtual void SetNeedsManageTilesOnImplThread() override {}
   virtual void PostAnimationEventsToMainThreadOnImplThread(
-      scoped_ptr<AnimationEventsVector> events) OVERRIDE {}
+      scoped_ptr<AnimationEventsVector> events) override {}
   virtual bool ReduceContentsTextureMemoryOnImplThread(
       size_t limit_bytes,
-      int priority_cutoff) OVERRIDE;
-  virtual bool IsInsideDraw() OVERRIDE;
-  virtual void RenewTreePriority() OVERRIDE {}
+      int priority_cutoff) override;
+  virtual bool IsInsideDraw() override;
+  virtual void RenewTreePriority() override {}
   virtual void PostDelayedScrollbarFadeOnImplThread(
       const base::Closure& start_fade,
-      base::TimeDelta delay) OVERRIDE {}
-  virtual void DidActivateSyncTree() OVERRIDE {}
-  virtual void DidManageTiles() OVERRIDE {}
+      base::TimeDelta delay) override {}
+  virtual void DidActivateSyncTree() override {}
+  virtual void DidManageTiles() override {}
 };
 
 }  // namespace cc
diff --git a/cc/test/fake_output_surface.h b/cc/test/fake_output_surface.h
index 193d03c..306879b 100644
--- a/cc/test/fake_output_surface.h
+++ b/cc/test/fake_output_surface.h
@@ -92,12 +92,12 @@ class FakeOutputSurface : public OutputSurface {
   CompositorFrame& last_sent_frame() { return last_sent_frame_; }
   size_t num_sent_frames() { return num_sent_frames_; }
 
-  virtual void SwapBuffers(CompositorFrame* frame) OVERRIDE;
+  virtual void SwapBuffers(CompositorFrame* frame) override;
 
-  virtual void SetNeedsBeginFrame(bool enable) OVERRIDE;
+  virtual void SetNeedsBeginFrame(bool enable) override;
   bool needs_begin_frame() const { return needs_begin_frame_; }
 
-  virtual bool BindToClient(OutputSurfaceClient* client) OVERRIDE;
+  virtual bool BindToClient(OutputSurfaceClient* client) override;
 
   using OutputSurface::ReleaseGL;
   using OutputSurface::InitializeAndSetContext3d;
@@ -110,7 +110,7 @@ class FakeOutputSurface : public OutputSurface {
 
   void ReturnResource(unsigned id, CompositorFrameAck* ack);
 
-  virtual bool HasExternalStencilTest() const OVERRIDE;
+  virtual bool HasExternalStencilTest() const override;
 
   void set_has_external_stencil_test(bool has_test) {
     has_external_stencil_test_ = has_test;
diff --git a/cc/test/fake_output_surface_client.h b/cc/test/fake_output_surface_client.h
index 7ecb6cf..258ad87 100644
--- a/cc/test/fake_output_surface_client.h
+++ b/cc/test/fake_output_surface_client.h
@@ -28,25 +28,25 @@ class FakeOutputSurfaceClient : public OutputSurfaceClient {
         did_lose_output_surface_called_(false),
         memory_policy_(0) {}
 
-  virtual void DeferredInitialize() OVERRIDE;
-  virtual void ReleaseGL() OVERRIDE;
+  virtual void DeferredInitialize() override;
+  virtual void ReleaseGL() override;
   virtual void CommitVSyncParameters(base::TimeTicks timebase,
-                                     base::TimeDelta interval) OVERRIDE {}
-  virtual void SetNeedsRedrawRect(const gfx::Rect& damage_rect) OVERRIDE {}
-  virtual void BeginFrame(const BeginFrameArgs& args) OVERRIDE;
-  virtual void DidSwapBuffers() OVERRIDE {}
-  virtual void DidSwapBuffersComplete() OVERRIDE {}
-  virtual void ReclaimResources(const CompositorFrameAck* ack) OVERRIDE {}
-  virtual void DidLoseOutputSurface() OVERRIDE;
+                                     base::TimeDelta interval) override {}
+  virtual void SetNeedsRedrawRect(const gfx::Rect& damage_rect) override {}
+  virtual void BeginFrame(const BeginFrameArgs& args) override;
+  virtual void DidSwapBuffers() override {}
+  virtual void DidSwapBuffersComplete() override {}
+  virtual void ReclaimResources(const CompositorFrameAck* ack) override {}
+  virtual void DidLoseOutputSurface() override;
   virtual void SetExternalDrawConstraints(
       const gfx::Transform& transform,
       const gfx::Rect& viewport,
       const gfx::Rect& clip,
       const gfx::Rect& viewport_rect_for_tile_priority,
       const gfx::Transform& transform_for_tile_priority,
-      bool resourceless_software_draw) OVERRIDE {}
-  virtual void SetMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE;
-  virtual void SetTreeActivationCallback(const base::Closure&) OVERRIDE {}
+      bool resourceless_software_draw) override {}
+  virtual void SetMemoryPolicy(const ManagedMemoryPolicy& policy) override;
+  virtual void SetTreeActivationCallback(const base::Closure&) override {}
 
   int begin_frame_count() { return begin_frame_count_; }
 
diff --git a/cc/test/fake_painted_scrollbar_layer.h b/cc/test/fake_painted_scrollbar_layer.h
index 5e2fa18..f531299 100644
--- a/cc/test/fake_painted_scrollbar_layer.h
+++ b/cc/test/fake_painted_scrollbar_layer.h
@@ -21,9 +21,9 @@ class FakePaintedScrollbarLayer : public PaintedScrollbarLayer {
   void reset_update_count() { update_count_ = 0; }
 
   virtual bool Update(ResourceUpdateQueue* queue,
-                      const OcclusionTracker<Layer>* occlusion) OVERRIDE;
+                      const OcclusionTracker<Layer>* occlusion) override;
 
-  virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE;
+  virtual void PushPropertiesTo(LayerImpl* layer) override;
 
   scoped_ptr<base::AutoReset<bool> > IgnoreSetNeedsCommit();
 
diff --git a/cc/test/fake_picture_layer.h b/cc/test/fake_picture_layer.h
index 10f9a9c..332e63f 100644
--- a/cc/test/fake_picture_layer.h
+++ b/cc/test/fake_picture_layer.h
@@ -18,7 +18,7 @@ class FakePictureLayer : public PictureLayer {
   }
 
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
+      override;
 
   size_t update_count() const { return update_count_; }
   void reset_update_count() { update_count_ = 0; }
@@ -31,11 +31,11 @@ class FakePictureLayer : public PictureLayer {
   }
 
   virtual bool Update(ResourceUpdateQueue* queue,
-                      const OcclusionTracker<Layer>* occlusion) OVERRIDE;
+                      const OcclusionTracker<Layer>* occlusion) override;
 
-  virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE;
+  virtual void PushPropertiesTo(LayerImpl* layer) override;
 
-  virtual void OnOutputSurfaceCreated() OVERRIDE;
+  virtual void OnOutputSurfaceCreated() override;
   size_t output_surface_created_count() const {
     return output_surface_created_count_;
   }
diff --git a/cc/test/fake_picture_layer_impl.h b/cc/test/fake_picture_layer_impl.h
index a06805c..e35fb69 100644
--- a/cc/test/fake_picture_layer_impl.h
+++ b/cc/test/fake_picture_layer_impl.h
@@ -34,19 +34,19 @@ class FakePictureLayerImpl : public PictureLayerImpl {
   }
 
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
+      override;
   virtual void AppendQuads(RenderPass* render_pass,
                            const OcclusionTracker<LayerImpl>& occlusion_tracker,
-                           AppendQuadsData* append_quads_data) OVERRIDE;
+                           AppendQuadsData* append_quads_data) override;
   virtual gfx::Size CalculateTileSize(
-      const gfx::Size& content_bounds) const OVERRIDE;
+      const gfx::Size& content_bounds) const override;
 
-  virtual void DidBecomeActive() OVERRIDE;
+  virtual void DidBecomeActive() override;
   size_t did_become_active_call_count() {
     return did_become_active_call_count_;
   }
 
-  virtual bool HasValidTilePriorities() const OVERRIDE;
+  virtual bool HasValidTilePriorities() const override;
   void set_has_valid_tile_priorities(bool has_valid_priorities) {
     has_valid_tile_priorities_ = has_valid_priorities;
     use_set_valid_tile_priorities_flag_ = true;
@@ -115,7 +115,7 @@ class FakePictureLayerImpl : public PictureLayerImpl {
   size_t release_resources_count() const { return release_resources_count_; }
   void reset_release_resources_count() { release_resources_count_ = 0; }
 
-  virtual void ReleaseResources() OVERRIDE;
+  virtual void ReleaseResources() override;
 
  protected:
   FakePictureLayerImpl(
diff --git a/cc/test/fake_picture_layer_tiling_client.h b/cc/test/fake_picture_layer_tiling_client.h
index edd2a61..e3b2659 100644
--- a/cc/test/fake_picture_layer_tiling_client.h
+++ b/cc/test/fake_picture_layer_tiling_client.h
@@ -22,23 +22,23 @@ class FakePictureLayerTilingClient : public PictureLayerTilingClient {
 
   // PictureLayerTilingClient implementation.
   virtual scoped_refptr<Tile> CreateTile(
-      PictureLayerTiling* tiling, const gfx::Rect& rect) OVERRIDE;
-  virtual PicturePileImpl* GetPile() OVERRIDE;
+      PictureLayerTiling* tiling, const gfx::Rect& rect) override;
+  virtual PicturePileImpl* GetPile() override;
   virtual gfx::Size CalculateTileSize(
-      const gfx::Size& content_bounds) const OVERRIDE;
-  virtual size_t GetMaxTilesForInterestArea() const OVERRIDE;
-  virtual float GetSkewportTargetTimeInSeconds() const OVERRIDE;
-  virtual int GetSkewportExtrapolationLimitInContentPixels() const OVERRIDE;
+      const gfx::Size& content_bounds) const override;
+  virtual size_t GetMaxTilesForInterestArea() const override;
+  virtual float GetSkewportTargetTimeInSeconds() const override;
+  virtual int GetSkewportExtrapolationLimitInContentPixels() const override;
 
   void SetTileSize(const gfx::Size& tile_size);
   gfx::Size TileSize() const { return tile_size_; }
 
-  virtual const Region* GetInvalidation() OVERRIDE;
+  virtual const Region* GetInvalidation() override;
   virtual const PictureLayerTiling* GetTwinTiling(
-      const PictureLayerTiling* tiling) const OVERRIDE;
+      const PictureLayerTiling* tiling) const override;
   virtual PictureLayerTiling* GetRecycledTwinTiling(
-      const PictureLayerTiling* tiling) OVERRIDE;
-  virtual WhichTree GetTree() const OVERRIDE;
+      const PictureLayerTiling* tiling) override;
+  virtual WhichTree GetTree() const override;
 
   void set_twin_tiling(PictureLayerTiling* tiling) { twin_tiling_ = tiling; }
   void set_recycled_twin_tiling(PictureLayerTiling* tiling) {
diff --git a/cc/test/fake_proxy.h b/cc/test/fake_proxy.h
index 03eafb1..21324c1 100644
--- a/cc/test/fake_proxy.h
+++ b/cc/test/fake_proxy.h
@@ -21,30 +21,30 @@ class FakeProxy : public Proxy {
 
   void SetLayerTreeHost(LayerTreeHost* host);
 
-  virtual void FinishAllRendering() OVERRIDE {}
-  virtual bool IsStarted() const OVERRIDE;
-  virtual void SetOutputSurface(scoped_ptr<OutputSurface>) OVERRIDE {}
-  virtual void SetLayerTreeHostClientReady() OVERRIDE {}
-  virtual void SetVisible(bool visible) OVERRIDE {}
-  virtual const RendererCapabilities& GetRendererCapabilities() const OVERRIDE;
-  virtual void SetNeedsAnimate() OVERRIDE {}
-  virtual void SetNeedsUpdateLayers() OVERRIDE {}
-  virtual void SetNeedsCommit() OVERRIDE {}
-  virtual void SetNeedsRedraw(const gfx::Rect& damage_rect) OVERRIDE {}
-  virtual void SetNextCommitWaitsForActivation() OVERRIDE {}
-  virtual void NotifyInputThrottledUntilCommit() OVERRIDE {}
-  virtual void SetDeferCommits(bool defer_commits) OVERRIDE {}
-  virtual void MainThreadHasStoppedFlinging() OVERRIDE {}
-  virtual bool BeginMainFrameRequested() const OVERRIDE;
-  virtual bool CommitRequested() const OVERRIDE;
-  virtual void Start() OVERRIDE {}
-  virtual void Stop() OVERRIDE {}
-  virtual void ForceSerializeOnSwapBuffers() OVERRIDE {}
-  virtual size_t MaxPartialTextureUpdates() const OVERRIDE;
-  virtual bool SupportsImplScrolling() const OVERRIDE;
-  virtual void SetDebugState(const LayerTreeDebugState& debug_state) OVERRIDE {}
-  virtual bool MainFrameWillHappenForTesting() OVERRIDE;
-  virtual void AsValueInto(base::debug::TracedValue* state) const OVERRIDE;
+  virtual void FinishAllRendering() override {}
+  virtual bool IsStarted() const override;
+  virtual void SetOutputSurface(scoped_ptr<OutputSurface>) override {}
+  virtual void SetLayerTreeHostClientReady() override {}
+  virtual void SetVisible(bool visible) override {}
+  virtual const RendererCapabilities& GetRendererCapabilities() const override;
+  virtual void SetNeedsAnimate() override {}
+  virtual void SetNeedsUpdateLayers() override {}
+  virtual void SetNeedsCommit() override {}
+  virtual void SetNeedsRedraw(const gfx::Rect& damage_rect) override {}
+  virtual void SetNextCommitWaitsForActivation() override {}
+  virtual void NotifyInputThrottledUntilCommit() override {}
+  virtual void SetDeferCommits(bool defer_commits) override {}
+  virtual void MainThreadHasStoppedFlinging() override {}
+  virtual bool BeginMainFrameRequested() const override;
+  virtual bool CommitRequested() const override;
+  virtual void Start() override {}
+  virtual void Stop() override {}
+  virtual void ForceSerializeOnSwapBuffers() override {}
+  virtual size_t MaxPartialTextureUpdates() const override;
+  virtual bool SupportsImplScrolling() const override;
+  virtual void SetDebugState(const LayerTreeDebugState& debug_state) override {}
+  virtual bool MainFrameWillHappenForTesting() override;
+  virtual void AsValueInto(base::debug::TracedValue* state) const override;
 
   virtual RendererCapabilities& GetRendererCapabilities();
   void SetMaxPartialTextureUpdates(size_t max);
diff --git a/cc/test/fake_renderer_client.h b/cc/test/fake_renderer_client.h
index 9854b01..0248249 100644
--- a/cc/test/fake_renderer_client.h
+++ b/cc/test/fake_renderer_client.h
@@ -14,7 +14,7 @@ class FakeRendererClient : public RendererClient {
   FakeRendererClient();
 
   // RendererClient methods.
-  virtual void SetFullRootLayerDamage() OVERRIDE;
+  virtual void SetFullRootLayerDamage() override;
 
   // Methods added for test.
   int set_full_root_layer_damage_count() const {
diff --git a/cc/test/fake_scoped_ui_resource.h b/cc/test/fake_scoped_ui_resource.h
index 970d7b0..3de9af2 100644
--- a/cc/test/fake_scoped_ui_resource.h
+++ b/cc/test/fake_scoped_ui_resource.h
@@ -17,7 +17,7 @@ class FakeScopedUIResource : public ScopedUIResource {
   static scoped_ptr<FakeScopedUIResource> Create(LayerTreeHost* host);
 
   virtual UIResourceBitmap GetBitmap(UIResourceId uid,
-                                     bool resource_lost) OVERRIDE;
+                                     bool resource_lost) override;
   void ResetCounters();
 
   int resource_create_count;
diff --git a/cc/test/fake_scrollbar.h b/cc/test/fake_scrollbar.h
index 8e6d454..638735d 100644
--- a/cc/test/fake_scrollbar.h
+++ b/cc/test/fake_scrollbar.h
@@ -18,17 +18,17 @@ class FakeScrollbar : public Scrollbar {
   virtual ~FakeScrollbar();
 
   // Scrollbar implementation.
-  virtual ScrollbarOrientation Orientation() const OVERRIDE;
-  virtual bool IsLeftSideVerticalScrollbar() const OVERRIDE;
-  virtual gfx::Point Location() const OVERRIDE;
-  virtual bool IsOverlay() const OVERRIDE;
-  virtual bool HasThumb() const OVERRIDE;
-  virtual int ThumbThickness() const OVERRIDE;
-  virtual int ThumbLength() const OVERRIDE;
-  virtual gfx::Rect TrackRect() const OVERRIDE;
+  virtual ScrollbarOrientation Orientation() const override;
+  virtual bool IsLeftSideVerticalScrollbar() const override;
+  virtual gfx::Point Location() const override;
+  virtual bool IsOverlay() const override;
+  virtual bool HasThumb() const override;
+  virtual int ThumbThickness() const override;
+  virtual int ThumbLength() const override;
+  virtual gfx::Rect TrackRect() const override;
   virtual void PaintPart(SkCanvas* canvas,
                          ScrollbarPart part,
-                         const gfx::Rect& content_rect) OVERRIDE;
+                         const gfx::Rect& content_rect) override;
 
   void set_location(const gfx::Point& location) { location_ = location; }
   void set_track_rect(const gfx::Rect& track_rect) { track_rect_ = track_rect; }
diff --git a/cc/test/fake_tile_manager.cc b/cc/test/fake_tile_manager.cc
index 6243ae2..6767c9f 100644
--- a/cc/test/fake_tile_manager.cc
+++ b/cc/test/fake_tile_manager.cc
@@ -17,9 +17,9 @@ namespace {
 class FakeRasterizerImpl : public Rasterizer, public RasterizerTaskClient {
  public:
   // Overridden from Rasterizer:
-  virtual void SetClient(RasterizerClient* client) OVERRIDE {}
-  virtual void Shutdown() OVERRIDE {}
-  virtual void ScheduleTasks(RasterTaskQueue* queue) OVERRIDE {
+  virtual void SetClient(RasterizerClient* client) override {}
+  virtual void Shutdown() override {}
+  virtual void ScheduleTasks(RasterTaskQueue* queue) override {
     for (RasterTaskQueue::Item::Vector::const_iterator it =
              queue->items.begin();
          it != queue->items.end();
@@ -33,7 +33,7 @@ class FakeRasterizerImpl : public Rasterizer, public RasterizerTaskClient {
       completed_tasks_.push_back(task);
     }
   }
-  virtual void CheckForCompletedTasks() OVERRIDE {
+  virtual void CheckForCompletedTasks() override {
     for (RasterTask::Vector::iterator it = completed_tasks_.begin();
          it != completed_tasks_.end();
          ++it) {
@@ -50,11 +50,11 @@ class FakeRasterizerImpl : public Rasterizer, public RasterizerTaskClient {
 
   // Overridden from RasterizerTaskClient:
   virtual scoped_ptr<RasterBuffer> AcquireBufferForRaster(
-      const Resource* resource) OVERRIDE {
+      const Resource* resource) override {
     return nullptr;
   }
   virtual void ReleaseBufferForRaster(
-      scoped_ptr<RasterBuffer> buffer) OVERRIDE {}
+      scoped_ptr<RasterBuffer> buffer) override {}
 
  private:
   RasterTask::Vector completed_tasks_;
diff --git a/cc/test/fake_tile_manager.h b/cc/test/fake_tile_manager.h
index 9fdf7a7..36a0530 100644
--- a/cc/test/fake_tile_manager.h
+++ b/cc/test/fake_tile_manager.h
@@ -22,7 +22,7 @@ class FakeTileManager : public TileManager {
   void AssignMemoryToTiles(
       const GlobalStateThatImpactsTilePriority& state);
 
-  virtual void Release(Tile* tile) OVERRIDE;
+  virtual void Release(Tile* tile) override;
 
   std::vector<Tile*> tiles_for_raster;
   PrioritizedTileSet all_tiles;
diff --git a/cc/test/fake_tile_manager_client.h b/cc/test/fake_tile_manager_client.h
index 9b5bf5d..fde6c52 100644
--- a/cc/test/fake_tile_manager_client.h
+++ b/cc/test/fake_tile_manager_client.h
@@ -18,13 +18,13 @@ class FakeTileManagerClient : public TileManagerClient {
 
   // TileManagerClient implementation.
   virtual const std::vector<PictureLayerImpl*>& GetPictureLayers()
-      const OVERRIDE;
-  virtual void NotifyReadyToActivate() OVERRIDE {}
-  virtual void NotifyTileStateChanged(const Tile* tile) OVERRIDE {}
+      const override;
+  virtual void NotifyReadyToActivate() override {}
+  virtual void NotifyTileStateChanged(const Tile* tile) override {}
   virtual void BuildRasterQueue(RasterTilePriorityQueue* queue,
-                                TreePriority tree_priority) OVERRIDE {}
+                                TreePriority tree_priority) override {}
   virtual void BuildEvictionQueue(EvictionTilePriorityQueue* queue,
-                                  TreePriority tree_priority) OVERRIDE {}
+                                  TreePriority tree_priority) override {}
 
  private:
   std::vector<PictureLayerImpl*> picture_layers_;
diff --git a/cc/test/fake_ui_resource_layer_tree_host_impl.h b/cc/test/fake_ui_resource_layer_tree_host_impl.h
index e6cfafb..9d6eac4 100644
--- a/cc/test/fake_ui_resource_layer_tree_host_impl.h
+++ b/cc/test/fake_ui_resource_layer_tree_host_impl.h
@@ -17,14 +17,14 @@ class FakeUIResourceLayerTreeHostImpl : public FakeLayerTreeHostImpl {
   virtual ~FakeUIResourceLayerTreeHostImpl();
 
   virtual void CreateUIResource(UIResourceId uid,
-                                const UIResourceBitmap& bitmap) OVERRIDE;
+                                const UIResourceBitmap& bitmap) override;
 
-  virtual void DeleteUIResource(UIResourceId uid) OVERRIDE;
+  virtual void DeleteUIResource(UIResourceId uid) override;
 
   virtual ResourceProvider::ResourceId ResourceIdForUIResource(
-      UIResourceId uid) const OVERRIDE;
+      UIResourceId uid) const override;
 
-  virtual bool IsUIResourceOpaque(UIResourceId uid) const OVERRIDE;
+  virtual bool IsUIResourceOpaque(UIResourceId uid) const override;
 
  private:
   ResourceProvider::ResourceId fake_next_resource_id_;
diff --git a/cc/test/fake_video_frame_provider.h b/cc/test/fake_video_frame_provider.h
index fc462e4..f586adb 100644
--- a/cc/test/fake_video_frame_provider.h
+++ b/cc/test/fake_video_frame_provider.h
@@ -16,10 +16,10 @@ class FakeVideoFrameProvider : public VideoFrameProvider {
   FakeVideoFrameProvider();
   virtual ~FakeVideoFrameProvider();
 
-  virtual void SetVideoFrameProviderClient(Client* client) OVERRIDE;
-  virtual scoped_refptr<media::VideoFrame> GetCurrentFrame() OVERRIDE;
+  virtual void SetVideoFrameProviderClient(Client* client) override;
+  virtual scoped_refptr<media::VideoFrame> GetCurrentFrame() override;
   virtual void PutCurrentFrame(const scoped_refptr<media::VideoFrame>&)
-      OVERRIDE {}
+      override {}
 
   Client* client() { return client_; }
 
diff --git a/cc/test/layer_tree_pixel_test.h b/cc/test/layer_tree_pixel_test.h
index 5a3685f..a29e0f12 100644
--- a/cc/test/layer_tree_pixel_test.h
+++ b/cc/test/layer_tree_pixel_test.h
@@ -34,17 +34,17 @@ class LayerTreePixelTest : public LayerTreeTest {
   LayerTreePixelTest();
   virtual ~LayerTreePixelTest();
 
-  virtual scoped_ptr<OutputSurface> CreateOutputSurface(bool fallback) OVERRIDE;
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE;
+  virtual scoped_ptr<OutputSurface> CreateOutputSurface(bool fallback) override;
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) override;
 
   virtual scoped_ptr<CopyOutputRequest> CreateCopyOutputRequest();
 
   void ReadbackResult(scoped_ptr<CopyOutputResult> result);
 
-  virtual void BeginTest() OVERRIDE;
-  virtual void SetupTree() OVERRIDE;
-  virtual void AfterTest() OVERRIDE;
-  virtual void EndTest() OVERRIDE;
+  virtual void BeginTest() override;
+  virtual void SetupTree() override;
+  virtual void AfterTest() override;
+  virtual void EndTest() override;
 
   void TryEndTest();
 
diff --git a/cc/test/layer_tree_test.cc b/cc/test/layer_tree_test.cc
index 9296040..9b9bae6 100644
--- a/cc/test/layer_tree_test.cc
+++ b/cc/test/layer_tree_test.cc
@@ -68,29 +68,29 @@ class ThreadProxyForTest : public ThreadProxy {
  private:
   TestHooks* test_hooks_;
 
-  virtual void ScheduledActionSendBeginMainFrame() OVERRIDE {
+  virtual void ScheduledActionSendBeginMainFrame() override {
     test_hooks_->ScheduledActionWillSendBeginMainFrame();
     ThreadProxy::ScheduledActionSendBeginMainFrame();
     test_hooks_->ScheduledActionSendBeginMainFrame();
   }
 
-  virtual DrawResult ScheduledActionDrawAndSwapIfPossible() OVERRIDE {
+  virtual DrawResult ScheduledActionDrawAndSwapIfPossible() override {
     DrawResult result = ThreadProxy::ScheduledActionDrawAndSwapIfPossible();
     test_hooks_->ScheduledActionDrawAndSwapIfPossible();
     return result;
   }
 
-  virtual void ScheduledActionAnimate() OVERRIDE {
+  virtual void ScheduledActionAnimate() override {
     ThreadProxy::ScheduledActionAnimate();
     test_hooks_->ScheduledActionAnimate();
   }
 
-  virtual void ScheduledActionCommit() OVERRIDE {
+  virtual void ScheduledActionCommit() override {
     ThreadProxy::ScheduledActionCommit();
     test_hooks_->ScheduledActionCommit();
   }
 
-  virtual void ScheduledActionBeginOutputSurfaceCreation() OVERRIDE {
+  virtual void ScheduledActionBeginOutputSurfaceCreation() override {
     ThreadProxy::ScheduledActionBeginOutputSurfaceCreation();
     test_hooks_->ScheduledActionBeginOutputSurfaceCreation();
   }
@@ -141,65 +141,65 @@ class LayerTreeHostImplForTesting : public LayerTreeHostImpl {
         block_notify_ready_to_activate_for_testing_(false),
         notify_ready_to_activate_was_blocked_(false) {}
 
-  virtual void WillBeginImplFrame(const BeginFrameArgs& args) OVERRIDE {
+  virtual void WillBeginImplFrame(const BeginFrameArgs& args) override {
     LayerTreeHostImpl::WillBeginImplFrame(args);
     test_hooks_->WillBeginImplFrameOnThread(this, args);
   }
 
-  virtual void BeginMainFrameAborted(bool did_handle) OVERRIDE {
+  virtual void BeginMainFrameAborted(bool did_handle) override {
     LayerTreeHostImpl::BeginMainFrameAborted(did_handle);
     test_hooks_->BeginMainFrameAbortedOnThread(this, did_handle);
   }
 
-  virtual void BeginCommit() OVERRIDE {
+  virtual void BeginCommit() override {
     LayerTreeHostImpl::BeginCommit();
     test_hooks_->BeginCommitOnThread(this);
   }
 
-  virtual void CommitComplete() OVERRIDE {
+  virtual void CommitComplete() override {
     LayerTreeHostImpl::CommitComplete();
     test_hooks_->CommitCompleteOnThread(this);
   }
 
-  virtual DrawResult PrepareToDraw(FrameData* frame) OVERRIDE {
+  virtual DrawResult PrepareToDraw(FrameData* frame) override {
     DrawResult draw_result = LayerTreeHostImpl::PrepareToDraw(frame);
     return test_hooks_->PrepareToDrawOnThread(this, frame, draw_result);
   }
 
   virtual void DrawLayers(FrameData* frame,
-                          base::TimeTicks frame_begin_time) OVERRIDE {
+                          base::TimeTicks frame_begin_time) override {
     LayerTreeHostImpl::DrawLayers(frame, frame_begin_time);
     test_hooks_->DrawLayersOnThread(this);
   }
 
-  virtual bool SwapBuffers(const LayerTreeHostImpl::FrameData& frame) OVERRIDE {
+  virtual bool SwapBuffers(const LayerTreeHostImpl::FrameData& frame) override {
     bool result = LayerTreeHostImpl::SwapBuffers(frame);
     test_hooks_->SwapBuffersOnThread(this, result);
     return result;
   }
 
-  virtual void DidSwapBuffersComplete() OVERRIDE {
+  virtual void DidSwapBuffersComplete() override {
     LayerTreeHostImpl::DidSwapBuffersComplete();
     test_hooks_->SwapBuffersCompleteOnThread(this);
   }
 
-  virtual void ReclaimResources(const CompositorFrameAck* ack) OVERRIDE {
+  virtual void ReclaimResources(const CompositorFrameAck* ack) override {
     LayerTreeHostImpl::ReclaimResources(ack);
   }
 
-  virtual void UpdateVisibleTiles() OVERRIDE {
+  virtual void UpdateVisibleTiles() override {
     LayerTreeHostImpl::UpdateVisibleTiles();
     test_hooks_->UpdateVisibleTilesOnThread(this);
   }
 
-  virtual void NotifyReadyToActivate() OVERRIDE {
+  virtual void NotifyReadyToActivate() override {
     if (block_notify_ready_to_activate_for_testing_)
       notify_ready_to_activate_was_blocked_ = true;
     else
       client_->NotifyReadyToActivate();
   }
 
-  virtual void BlockNotifyReadyToActivateForTesting(bool block) OVERRIDE {
+  virtual void BlockNotifyReadyToActivateForTesting(bool block) override {
     block_notify_ready_to_activate_for_testing_ = block;
     if (!block && notify_ready_to_activate_was_blocked_) {
       NotifyReadyToActivate();
@@ -207,7 +207,7 @@ class LayerTreeHostImplForTesting : public LayerTreeHostImpl {
     }
   }
 
-  virtual void ActivateSyncTree() OVERRIDE {
+  virtual void ActivateSyncTree() override {
     test_hooks_->WillActivateTreeOnThread(this);
     LayerTreeHostImpl::ActivateSyncTree();
     DCHECK(!pending_tree());
@@ -215,24 +215,24 @@ class LayerTreeHostImplForTesting : public LayerTreeHostImpl {
   }
 
   virtual bool InitializeRenderer(scoped_ptr<OutputSurface> output_surface)
-      OVERRIDE {
+      override {
     bool success = LayerTreeHostImpl::InitializeRenderer(output_surface.Pass());
     test_hooks_->InitializedRendererOnThread(this, success);
     return success;
   }
 
-  virtual void SetVisible(bool visible) OVERRIDE {
+  virtual void SetVisible(bool visible) override {
     LayerTreeHostImpl::SetVisible(visible);
     test_hooks_->DidSetVisibleOnImplTree(this, visible);
   }
 
-  virtual void AnimateLayers(base::TimeTicks monotonic_time) OVERRIDE {
+  virtual void AnimateLayers(base::TimeTicks monotonic_time) override {
     test_hooks_->WillAnimateLayers(this, monotonic_time);
     LayerTreeHostImpl::AnimateLayers(monotonic_time);
     test_hooks_->AnimateLayers(this, monotonic_time);
   }
 
-  virtual void UpdateAnimationState(bool start_ready_animations) OVERRIDE {
+  virtual void UpdateAnimationState(bool start_ready_animations) override {
     LayerTreeHostImpl::UpdateAnimationState(start_ready_animations);
     bool has_unfinished_animation = false;
     AnimationRegistrar::AnimationControllerMap::const_iterator iter =
@@ -246,7 +246,7 @@ class LayerTreeHostImplForTesting : public LayerTreeHostImpl {
     test_hooks_->UpdateAnimationState(this, has_unfinished_animation);
   }
 
-  virtual base::TimeDelta LowFrequencyAnimationInterval() const OVERRIDE {
+  virtual base::TimeDelta LowFrequencyAnimationInterval() const override {
     return test_hooks_->LowFrequencyAnimationInterval();
   }
 
@@ -266,24 +266,24 @@ class LayerTreeHostClientForTesting : public LayerTreeHostClient,
   }
   virtual ~LayerTreeHostClientForTesting() {}
 
-  virtual void WillBeginMainFrame(int frame_id) OVERRIDE {
+  virtual void WillBeginMainFrame(int frame_id) override {
     test_hooks_->WillBeginMainFrame();
   }
 
-  virtual void DidBeginMainFrame() OVERRIDE {
+  virtual void DidBeginMainFrame() override {
     test_hooks_->DidBeginMainFrame();
   }
 
-  virtual void BeginMainFrame(const BeginFrameArgs& args) OVERRIDE {
+  virtual void BeginMainFrame(const BeginFrameArgs& args) override {
     test_hooks_->BeginMainFrame(args);
   }
 
-  virtual void Layout() OVERRIDE { test_hooks_->Layout(); }
+  virtual void Layout() override { test_hooks_->Layout(); }
 
   virtual void ApplyViewportDeltas(const gfx::Vector2d& inner_delta,
                                    const gfx::Vector2d& outer_delta,
                                    float page_scale,
-                                   float top_controls_delta) OVERRIDE {
+                                   float top_controls_delta) override {
     test_hooks_->ApplyViewportDeltas(inner_delta,
                                      outer_delta,
                                      page_scale,
@@ -291,38 +291,38 @@ class LayerTreeHostClientForTesting : public LayerTreeHostClient,
   }
   virtual void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
                                    float scale,
-                                   float top_controls_delta) OVERRIDE {
+                                   float top_controls_delta) override {
     test_hooks_->ApplyViewportDeltas(scroll_delta,
                                      scale,
                                      top_controls_delta);
   }
 
-  virtual void RequestNewOutputSurface(bool fallback) OVERRIDE {
+  virtual void RequestNewOutputSurface(bool fallback) override {
     test_hooks_->RequestNewOutputSurface(fallback);
   }
 
-  virtual void DidInitializeOutputSurface() OVERRIDE {
+  virtual void DidInitializeOutputSurface() override {
     test_hooks_->DidInitializeOutputSurface();
   }
 
-  virtual void DidFailToInitializeOutputSurface() OVERRIDE {
+  virtual void DidFailToInitializeOutputSurface() override {
     test_hooks_->DidFailToInitializeOutputSurface();
   }
 
-  virtual void WillCommit() OVERRIDE { test_hooks_->WillCommit(); }
+  virtual void WillCommit() override { test_hooks_->WillCommit(); }
 
-  virtual void DidCommit() OVERRIDE { test_hooks_->DidCommit(); }
+  virtual void DidCommit() override { test_hooks_->DidCommit(); }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     test_hooks_->DidCommitAndDrawFrame();
   }
 
-  virtual void DidCompleteSwapBuffers() OVERRIDE {
+  virtual void DidCompleteSwapBuffers() override {
     test_hooks_->DidCompleteSwapBuffers();
   }
 
-  virtual void DidPostSwapBuffers() OVERRIDE {}
-  virtual void DidAbortSwapBuffers() OVERRIDE {}
+  virtual void DidPostSwapBuffers() override {}
+  virtual void DidAbortSwapBuffers() override {}
 
  private:
   explicit LayerTreeHostClientForTesting(TestHooks* test_hooks)
@@ -356,7 +356,7 @@ class LayerTreeHostForTesting : public LayerTreeHost {
   }
 
   virtual scoped_ptr<LayerTreeHostImpl> CreateLayerTreeHostImpl(
-      LayerTreeHostImplClient* host_impl_client) OVERRIDE {
+      LayerTreeHostImplClient* host_impl_client) override {
     return LayerTreeHostImplForTesting::Create(
         test_hooks_,
         settings(),
@@ -366,7 +366,7 @@ class LayerTreeHostForTesting : public LayerTreeHost {
         rendering_stats_instrumentation());
   }
 
-  virtual void SetNeedsCommit() OVERRIDE {
+  virtual void SetNeedsCommit() override {
     if (!test_started_)
       return;
     LayerTreeHost::SetNeedsCommit();
@@ -374,7 +374,7 @@ class LayerTreeHostForTesting : public LayerTreeHost {
 
   void set_test_started(bool started) { test_started_ = started; }
 
-  virtual void DidDeferCommit() OVERRIDE { test_hooks_->DidDeferCommit(); }
+  virtual void DidDeferCommit() override { test_hooks_->DidDeferCommit(); }
 
  private:
   LayerTreeHostForTesting(TestHooks* test_hooks,
diff --git a/cc/test/layer_tree_test.h b/cc/test/layer_tree_test.h
index 36f37ef..af0c554 100644
--- a/cc/test/layer_tree_test.h
+++ b/cc/test/layer_tree_test.h
@@ -92,10 +92,10 @@ class TestHooks : public AnimationDelegate {
   // Implementation of AnimationDelegate:
   virtual void NotifyAnimationStarted(base::TimeTicks monotonic_time,
                                       Animation::TargetProperty target_property)
-      OVERRIDE {}
+      override {}
   virtual void NotifyAnimationFinished(
       base::TimeTicks monotonic_time,
-      Animation::TargetProperty target_property) OVERRIDE {}
+      Animation::TargetProperty target_property) override {}
 
   virtual void RequestNewOutputSurface(bool fallback) = 0;
 };
@@ -187,7 +187,7 @@ class LayerTreeTest : public testing::Test, public TestHooks {
   void DestroyLayerTreeHost();
 
   // By default, output surface recreation is synchronous.
-  virtual void RequestNewOutputSurface(bool fallback) OVERRIDE;
+  virtual void RequestNewOutputSurface(bool fallback) override;
   // Override this for pixel tests, where you need a real output surface.
   virtual scoped_ptr<OutputSurface> CreateOutputSurface(bool fallback);
   // Override this for unit tests, which should not produce pixel output.
diff --git a/cc/test/ordered_simple_task_runner.h b/cc/test/ordered_simple_task_runner.h
index 54a2c27..68c9587 100644
--- a/cc/test/ordered_simple_task_runner.h
+++ b/cc/test/ordered_simple_task_runner.h
@@ -55,13 +55,13 @@ class OrderedSimpleTaskRunner : public base::SingleThreadTaskRunner {
   // base::TestSimpleTaskRunner implementation:
   virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
                                const base::Closure& task,
-                               base::TimeDelta delay) OVERRIDE;
+                               base::TimeDelta delay) override;
   virtual bool PostNonNestableDelayedTask(
       const tracked_objects::Location& from_here,
       const base::Closure& task,
-      base::TimeDelta delay) OVERRIDE;
+      base::TimeDelta delay) override;
 
-  virtual bool RunsTasksOnCurrentThread() const OVERRIDE;
+  virtual bool RunsTasksOnCurrentThread() const override;
 
   // Set a maximum number of tasks to run at once. Useful as a timeout to
   // prevent infinite task loops.
diff --git a/cc/test/pixel_comparator.h b/cc/test/pixel_comparator.h
index 0f24da0..0d418e8 100644
--- a/cc/test/pixel_comparator.h
+++ b/cc/test/pixel_comparator.h
@@ -29,7 +29,7 @@ class ExactPixelComparator : public PixelComparator {
   // and report the number of pixels with an error on LOG(ERROR). Differences
   // in the alpha channel are ignored.
   virtual bool Compare(const SkBitmap& actual_bmp,
-                       const SkBitmap& expected_bmp) const OVERRIDE;
+                       const SkBitmap& expected_bmp) const override;
 
  private:
   // Exclude alpha channel from comparison?
@@ -52,7 +52,7 @@ class FuzzyPixelComparator : public PixelComparator {
   // specified limits. Otherwise, returns false and reports the error metrics on
   // LOG(ERROR). Differences in the alpha channel are ignored.
   virtual bool Compare(const SkBitmap& actual_bmp,
-                       const SkBitmap& expected_bmp) const OVERRIDE;
+                       const SkBitmap& expected_bmp) const override;
 
  private:
   // Exclude alpha channel from comparison?
diff --git a/cc/test/pixel_test.h b/cc/test/pixel_test.h
index 94c6fa9..17ecffb 100644
--- a/cc/test/pixel_test.h
+++ b/cc/test/pixel_test.h
@@ -62,7 +62,7 @@ class PixelTest : public testing::Test, RendererClient {
   void EnableExternalStencilTest();
 
   // RendererClient implementation.
-  virtual void SetFullRootLayerDamage() OVERRIDE {}
+  virtual void SetFullRootLayerDamage() override {}
 
  private:
   void ReadbackResult(base::Closure quit_run_loop,
@@ -85,7 +85,7 @@ class RendererPixelTest : public PixelTest {
   bool ExpandedViewport() const;
 
  protected:
-  virtual void SetUp() OVERRIDE;
+  virtual void SetUp() override;
 };
 
 // Wrappers to differentiate renderers where the the output surface and viewport
diff --git a/cc/test/pixel_test_output_surface.h b/cc/test/pixel_test_output_surface.h
index d3ec612..ce9d79c 100644
--- a/cc/test/pixel_test_output_surface.h
+++ b/cc/test/pixel_test_output_surface.h
@@ -16,8 +16,8 @@ class PixelTestOutputSurface : public OutputSurface {
   explicit PixelTestOutputSurface(
       scoped_ptr<SoftwareOutputDevice> software_device);
 
-  virtual void Reshape(const gfx::Size& size, float scale_factor) OVERRIDE;
-  virtual bool HasExternalStencilTest() const OVERRIDE;
+  virtual void Reshape(const gfx::Size& size, float scale_factor) override;
+  virtual bool HasExternalStencilTest() const override;
 
   void set_surface_expansion_size(const gfx::Size& surface_expansion_size) {
     surface_expansion_size_ = surface_expansion_size;
diff --git a/cc/test/pixel_test_software_output_device.h b/cc/test/pixel_test_software_output_device.h
index fd8f4b0..1315b4a 100644
--- a/cc/test/pixel_test_software_output_device.h
+++ b/cc/test/pixel_test_software_output_device.h
@@ -11,7 +11,7 @@ namespace cc {
 
 class PixelTestSoftwareOutputDevice : public SoftwareOutputDevice {
  public:
-  virtual void Resize(const gfx::Size& pixel_size, float scale_factor) OVERRIDE;
+  virtual void Resize(const gfx::Size& pixel_size, float scale_factor) override;
 
   void set_surface_expansion_size(const gfx::Size& surface_expansion_size) {
     surface_expansion_size_ = surface_expansion_size;
diff --git a/cc/test/scheduler_test_common.h b/cc/test/scheduler_test_common.h
index 2c6a8be..2cb878a 100644
--- a/cc/test/scheduler_test_common.h
+++ b/cc/test/scheduler_test_common.h
@@ -24,7 +24,7 @@ class FakeTimeSourceClient : public TimeSourceClient {
   bool TickCalled() const { return tick_called_; }
 
   // TimeSourceClient implementation.
-  virtual void OnTimerTick() OVERRIDE;
+  virtual void OnTimerTick() override;
 
  protected:
   bool tick_called_;
@@ -39,7 +39,7 @@ class FakeDelayBasedTimeSource : public DelayBasedTimeSource {
   }
 
   void SetNow(base::TimeTicks time) { now_ = time; }
-  virtual base::TimeTicks Now() const OVERRIDE;
+  virtual base::TimeTicks Now() const override;
 
  protected:
   FakeDelayBasedTimeSource(base::TimeDelta interval,
@@ -67,8 +67,8 @@ class TestDelayBasedTimeSource : public DelayBasedTimeSource {
 
   // Overridden from DelayBasedTimeSource
   virtual ~TestDelayBasedTimeSource();
-  virtual base::TimeTicks Now() const OVERRIDE;
-  virtual std::string TypeString() const OVERRIDE;
+  virtual base::TimeTicks Now() const override;
+  virtual std::string TypeString() const override;
 
   scoped_refptr<TestNowSource> now_src_;
 };
@@ -89,8 +89,8 @@ struct FakeBeginFrameSource : public BeginFrameSourceMixIn {
   }
 
   // BeginFrameSource
-  virtual void DidFinishFrame(size_t remaining_frames) OVERRIDE;
-  virtual void AsValueInto(base::debug::TracedValue* dict) const OVERRIDE;
+  virtual void DidFinishFrame(size_t remaining_frames) override;
+  virtual void AsValueInto(base::debug::TracedValue* dict) const override;
 
   virtual ~FakeBeginFrameSource() {}
 };
@@ -110,7 +110,7 @@ class TestBackToBackBeginFrameSource : public BackToBackBeginFrameSource {
   TestBackToBackBeginFrameSource(scoped_refptr<TestNowSource> now_src,
                                  base::SingleThreadTaskRunner* task_runner);
 
-  virtual base::TimeTicks Now() OVERRIDE;
+  virtual base::TimeTicks Now() override;
 
   scoped_refptr<TestNowSource> now_src_;
 };
@@ -141,9 +141,9 @@ class TestSchedulerFrameSourcesConstructor
 
  protected:
   virtual BeginFrameSource* ConstructPrimaryFrameSource(
-      Scheduler* scheduler) OVERRIDE;
+      Scheduler* scheduler) override;
   virtual BeginFrameSource* ConstructBackgroundFrameSource(
-      Scheduler* scheduler) OVERRIDE;
+      Scheduler* scheduler) override;
 
   OrderedSimpleTaskRunner* test_task_runner_;
   TestNowSource* now_src_;
@@ -189,7 +189,7 @@ class TestScheduler : public Scheduler {
 
  protected:
   // Overridden from Scheduler.
-  virtual base::TimeTicks Now() const OVERRIDE;
+  virtual base::TimeTicks Now() const override;
 
  private:
   TestScheduler(
diff --git a/cc/test/solid_color_content_layer_client.h b/cc/test/solid_color_content_layer_client.h
index 6d4ea47..7e6ceb6 100644
--- a/cc/test/solid_color_content_layer_client.h
+++ b/cc/test/solid_color_content_layer_client.h
@@ -16,12 +16,12 @@ class SolidColorContentLayerClient : public ContentLayerClient {
   explicit SolidColorContentLayerClient(SkColor color) : color_(color) {}
 
   // ContentLayerClient implementation.
-  virtual void DidChangeLayerCanUseLCDText() OVERRIDE {}
+  virtual void DidChangeLayerCanUseLCDText() override {}
   virtual void PaintContents(
       SkCanvas* canvas,
       const gfx::Rect& rect,
-      ContentLayerClient::GraphicsContextStatus gc_status) OVERRIDE;
-  virtual bool FillsBoundsCompletely() const OVERRIDE;
+      ContentLayerClient::GraphicsContextStatus gc_status) override;
+  virtual bool FillsBoundsCompletely() const override;
 
  private:
   SkColor color_;
diff --git a/cc/test/test_context_provider.h b/cc/test/test_context_provider.h
index 75c7663..cf0292d 100644
--- a/cc/test/test_context_provider.h
+++ b/cc/test/test_context_provider.h
@@ -27,18 +27,18 @@ class TestContextProvider : public ContextProvider {
   static scoped_refptr<TestContextProvider> Create(
       scoped_ptr<TestWebGraphicsContext3D> context);
 
-  virtual bool BindToCurrentThread() OVERRIDE;
-  virtual Capabilities ContextCapabilities() OVERRIDE;
-  virtual gpu::gles2::GLES2Interface* ContextGL() OVERRIDE;
-  virtual gpu::ContextSupport* ContextSupport() OVERRIDE;
-  virtual class GrContext* GrContext() OVERRIDE;
-  virtual bool IsContextLost() OVERRIDE;
-  virtual void VerifyContexts() OVERRIDE;
-  virtual void DeleteCachedResources() OVERRIDE;
-  virtual bool DestroyedOnMainThread() OVERRIDE;
-  virtual void SetLostContextCallback(const LostContextCallback& cb) OVERRIDE;
+  virtual bool BindToCurrentThread() override;
+  virtual Capabilities ContextCapabilities() override;
+  virtual gpu::gles2::GLES2Interface* ContextGL() override;
+  virtual gpu::ContextSupport* ContextSupport() override;
+  virtual class GrContext* GrContext() override;
+  virtual bool IsContextLost() override;
+  virtual void VerifyContexts() override;
+  virtual void DeleteCachedResources() override;
+  virtual bool DestroyedOnMainThread() override;
+  virtual void SetLostContextCallback(const LostContextCallback& cb) override;
   virtual void SetMemoryPolicyChangedCallback(
-      const MemoryPolicyChangedCallback& cb) OVERRIDE;
+      const MemoryPolicyChangedCallback& cb) override;
 
   TestWebGraphicsContext3D* TestContext3d();
 
diff --git a/cc/test/test_context_support.h b/cc/test/test_context_support.h
index 0ffc683..c9b0d14 100644
--- a/cc/test/test_context_support.h
+++ b/cc/test/test_context_support.h
@@ -19,19 +19,19 @@ class TestContextSupport : public gpu::ContextSupport {
 
   // gpu::ContextSupport implementation.
   virtual void SignalSyncPoint(uint32 sync_point,
-                               const base::Closure& callback) OVERRIDE;
+                               const base::Closure& callback) override;
   virtual void SignalQuery(uint32 query,
-                           const base::Closure& callback) OVERRIDE;
-  virtual void SetSurfaceVisible(bool visible) OVERRIDE;
-  virtual void Swap() OVERRIDE;
-  virtual void PartialSwapBuffers(const gfx::Rect& sub_buffer) OVERRIDE;
-  virtual uint32 InsertFutureSyncPointCHROMIUM() OVERRIDE;
-  virtual void RetireSyncPointCHROMIUM(uint32 sync_point) OVERRIDE;
+                           const base::Closure& callback) override;
+  virtual void SetSurfaceVisible(bool visible) override;
+  virtual void Swap() override;
+  virtual void PartialSwapBuffers(const gfx::Rect& sub_buffer) override;
+  virtual uint32 InsertFutureSyncPointCHROMIUM() override;
+  virtual void RetireSyncPointCHROMIUM(uint32 sync_point) override;
   virtual void ScheduleOverlayPlane(int plane_z_order,
                                     gfx::OverlayTransform plane_transform,
                                     unsigned overlay_texture_id,
                                     const gfx::Rect& display_bounds,
-                                    const gfx::RectF& uv_rect) OVERRIDE;
+                                    const gfx::RectF& uv_rect) override;
 
   void CallAllSyncPointCallbacks();
 
diff --git a/cc/test/test_gles2_interface.h b/cc/test/test_gles2_interface.h
index ad53c04..e720022 100644
--- a/cc/test/test_gles2_interface.h
+++ b/cc/test/test_gles2_interface.h
@@ -15,59 +15,59 @@ class TestGLES2Interface : public gpu::gles2::GLES2InterfaceStub {
   explicit TestGLES2Interface(TestWebGraphicsContext3D* test_context);
   virtual ~TestGLES2Interface();
 
-  virtual void GenTextures(GLsizei n, GLuint* textures) OVERRIDE;
-  virtual void GenBuffers(GLsizei n, GLuint* buffers) OVERRIDE;
-  virtual void GenFramebuffers(GLsizei n, GLuint* framebuffers) OVERRIDE;
-  virtual void GenRenderbuffers(GLsizei n, GLuint* renderbuffers) OVERRIDE;
-  virtual void GenQueriesEXT(GLsizei n, GLuint* queries) OVERRIDE;
-
-  virtual void DeleteTextures(GLsizei n, const GLuint* textures) OVERRIDE;
-  virtual void DeleteBuffers(GLsizei n, const GLuint* buffers) OVERRIDE;
+  virtual void GenTextures(GLsizei n, GLuint* textures) override;
+  virtual void GenBuffers(GLsizei n, GLuint* buffers) override;
+  virtual void GenFramebuffers(GLsizei n, GLuint* framebuffers) override;
+  virtual void GenRenderbuffers(GLsizei n, GLuint* renderbuffers) override;
+  virtual void GenQueriesEXT(GLsizei n, GLuint* queries) override;
+
+  virtual void DeleteTextures(GLsizei n, const GLuint* textures) override;
+  virtual void DeleteBuffers(GLsizei n, const GLuint* buffers) override;
   virtual void DeleteFramebuffers(GLsizei n,
-                                  const GLuint* framebuffers) OVERRIDE;
-  virtual void DeleteQueriesEXT(GLsizei n, const GLuint* queries) OVERRIDE;
+                                  const GLuint* framebuffers) override;
+  virtual void DeleteQueriesEXT(GLsizei n, const GLuint* queries) override;
 
-  virtual GLuint CreateShader(GLenum type) OVERRIDE;
-  virtual GLuint CreateProgram() OVERRIDE;
+  virtual GLuint CreateShader(GLenum type) override;
+  virtual GLuint CreateProgram() override;
 
-  virtual void BindTexture(GLenum target, GLuint texture) OVERRIDE;
+  virtual void BindTexture(GLenum target, GLuint texture) override;
 
-  virtual void GetIntegerv(GLenum pname, GLint* params) OVERRIDE;
-  virtual void GetShaderiv(GLuint shader, GLenum pname, GLint* params) OVERRIDE;
+  virtual void GetIntegerv(GLenum pname, GLint* params) override;
+  virtual void GetShaderiv(GLuint shader, GLenum pname, GLint* params) override;
   virtual void GetProgramiv(GLuint program,
                             GLenum pname,
-                            GLint* params) OVERRIDE;
+                            GLint* params) override;
   virtual void GetShaderPrecisionFormat(GLenum shadertype,
                                         GLenum precisiontype,
                                         GLint* range,
-                                        GLint* precision) OVERRIDE;
-  virtual GLenum CheckFramebufferStatus(GLenum target) OVERRIDE;
+                                        GLint* precision) override;
+  virtual GLenum CheckFramebufferStatus(GLenum target) override;
 
-  virtual void ActiveTexture(GLenum target) OVERRIDE;
+  virtual void ActiveTexture(GLenum target) override;
   virtual void Viewport(GLint x, GLint y, GLsizei width, GLsizei height)
-      OVERRIDE;
-  virtual void UseProgram(GLuint program) OVERRIDE;
+      override;
+  virtual void UseProgram(GLuint program) override;
   virtual void Scissor(GLint x, GLint y, GLsizei width, GLsizei height)
-      OVERRIDE;
+      override;
   virtual void DrawElements(GLenum mode,
                             GLsizei count,
                             GLenum type,
-                            const void* indices) OVERRIDE;
+                            const void* indices) override;
   virtual void ClearColor(GLclampf red,
                           GLclampf green,
                           GLclampf blue,
-                          GLclampf alpha) OVERRIDE;
-  virtual void ClearStencil(GLint s) OVERRIDE;
-  virtual void Clear(GLbitfield mask) OVERRIDE;
-  virtual void Flush() OVERRIDE;
-  virtual void Finish() OVERRIDE;
-  virtual void ShallowFlushCHROMIUM() OVERRIDE;
-  virtual void Enable(GLenum cap) OVERRIDE;
-  virtual void Disable(GLenum cap) OVERRIDE;
-
-  virtual void BindBuffer(GLenum target, GLuint buffer) OVERRIDE;
-  virtual void BindRenderbuffer(GLenum target, GLuint buffer) OVERRIDE;
-  virtual void BindFramebuffer(GLenum target, GLuint buffer) OVERRIDE;
+                          GLclampf alpha) override;
+  virtual void ClearStencil(GLint s) override;
+  virtual void Clear(GLbitfield mask) override;
+  virtual void Flush() override;
+  virtual void Finish() override;
+  virtual void ShallowFlushCHROMIUM() override;
+  virtual void Enable(GLenum cap) override;
+  virtual void Disable(GLenum cap) override;
+
+  virtual void BindBuffer(GLenum target, GLuint buffer) override;
+  virtual void BindRenderbuffer(GLenum target, GLuint buffer) override;
+  virtual void BindFramebuffer(GLenum target, GLuint buffer) override;
 
   virtual void TexImage2D(GLenum target,
                           GLint level,
@@ -77,7 +77,7 @@ class TestGLES2Interface : public gpu::gles2::GLES2InterfaceStub {
                           GLint border,
                           GLenum format,
                           GLenum type,
-                          const void* pixels) OVERRIDE;
+                          const void* pixels) override;
   virtual void TexSubImage2D(GLenum target,
                              GLint level,
                              GLint xoffset,
@@ -86,18 +86,18 @@ class TestGLES2Interface : public gpu::gles2::GLES2InterfaceStub {
                              GLsizei height,
                              GLenum format,
                              GLenum type,
-                             const void* pixels) OVERRIDE;
+                             const void* pixels) override;
   virtual void TexStorage2DEXT(GLenum target,
                                GLsizei levels,
                                GLenum internalformat,
                                GLsizei width,
-                               GLsizei height) OVERRIDE;
+                               GLsizei height) override;
   virtual void TexImageIOSurface2DCHROMIUM(GLenum target,
                                            GLsizei width,
                                            GLsizei height,
                                            GLuint io_surface_id,
-                                           GLuint plane) OVERRIDE;
-  virtual void TexParameteri(GLenum target, GLenum pname, GLint param) OVERRIDE;
+                                           GLuint plane) override;
+  virtual void TexParameteri(GLenum target, GLenum pname, GLint param) override;
 
   virtual void AsyncTexImage2DCHROMIUM(GLenum target,
                                        GLint level,
@@ -107,7 +107,7 @@ class TestGLES2Interface : public gpu::gles2::GLES2InterfaceStub {
                                        GLint border,
                                        GLenum format,
                                        GLenum type,
-                                       const void* pixels) OVERRIDE;
+                                       const void* pixels) override;
   virtual void AsyncTexSubImage2DCHROMIUM(GLenum target,
                                           GLint level,
                                           GLint xoffset,
@@ -116,7 +116,7 @@ class TestGLES2Interface : public gpu::gles2::GLES2InterfaceStub {
                                           GLsizei height,
                                           GLenum format,
                                           GLenum type,
-                                          const void* pixels) OVERRIDE;
+                                          const void* pixels) override;
   virtual void CompressedTexImage2D(GLenum target,
                                     GLint level,
                                     GLenum internalformat,
@@ -124,74 +124,74 @@ class TestGLES2Interface : public gpu::gles2::GLES2InterfaceStub {
                                     GLsizei height,
                                     GLint border,
                                     GLsizei image_size,
-                                    const void* data) OVERRIDE;
-  virtual void WaitAsyncTexImage2DCHROMIUM(GLenum target) OVERRIDE;
+                                    const void* data) override;
+  virtual void WaitAsyncTexImage2DCHROMIUM(GLenum target) override;
   virtual GLuint CreateImageCHROMIUM(GLsizei width,
                                      GLsizei height,
                                      GLenum internalformat,
-                                     GLenum usage) OVERRIDE;
-  virtual void DestroyImageCHROMIUM(GLuint image_id) OVERRIDE;
-  virtual void* MapImageCHROMIUM(GLuint image_id) OVERRIDE;
+                                     GLenum usage) override;
+  virtual void DestroyImageCHROMIUM(GLuint image_id) override;
+  virtual void* MapImageCHROMIUM(GLuint image_id) override;
   virtual void GetImageParameterivCHROMIUM(GLuint image_id,
                                            GLenum pname,
-                                           GLint* params) OVERRIDE;
-  virtual void UnmapImageCHROMIUM(GLuint image_id) OVERRIDE;
+                                           GLint* params) override;
+  virtual void UnmapImageCHROMIUM(GLuint image_id) override;
   virtual GLuint CreateGpuMemoryBufferImageCHROMIUM(GLsizei width,
                                                     GLsizei height,
                                                     GLenum internalformat,
-                                                    GLenum usage) OVERRIDE;
-  virtual void BindTexImage2DCHROMIUM(GLenum target, GLint image_id) OVERRIDE;
+                                                    GLenum usage) override;
+  virtual void BindTexImage2DCHROMIUM(GLenum target, GLint image_id) override;
   virtual void ReleaseTexImage2DCHROMIUM(GLenum target,
-                                         GLint image_id) OVERRIDE;
+                                         GLint image_id) override;
   virtual void FramebufferRenderbuffer(GLenum target,
                                        GLenum attachment,
                                        GLenum renderbuffertarget,
-                                       GLuint renderbuffer) OVERRIDE;
+                                       GLuint renderbuffer) override;
   virtual void FramebufferTexture2D(GLenum target,
                                     GLenum attachment,
                                     GLenum textarget,
                                     GLuint texture,
-                                    GLint level) OVERRIDE;
+                                    GLint level) override;
   virtual void RenderbufferStorage(GLenum target,
                                    GLenum internalformat,
                                    GLsizei width,
-                                   GLsizei height) OVERRIDE;
+                                   GLsizei height) override;
 
-  virtual void* MapBufferCHROMIUM(GLuint target, GLenum access) OVERRIDE;
-  virtual GLboolean UnmapBufferCHROMIUM(GLuint target) OVERRIDE;
+  virtual void* MapBufferCHROMIUM(GLuint target, GLenum access) override;
+  virtual GLboolean UnmapBufferCHROMIUM(GLuint target) override;
   virtual void BufferData(GLenum target,
                           GLsizeiptr size,
                           const void* data,
-                          GLenum usage) OVERRIDE;
+                          GLenum usage) override;
 
-  virtual void WaitSyncPointCHROMIUM(GLuint sync_point) OVERRIDE;
-  virtual GLuint InsertSyncPointCHROMIUM() OVERRIDE;
+  virtual void WaitSyncPointCHROMIUM(GLuint sync_point) override;
+  virtual GLuint InsertSyncPointCHROMIUM() override;
 
-  virtual void BeginQueryEXT(GLenum target, GLuint id) OVERRIDE;
-  virtual void EndQueryEXT(GLenum target) OVERRIDE;
+  virtual void BeginQueryEXT(GLenum target, GLuint id) override;
+  virtual void EndQueryEXT(GLenum target) override;
   virtual void GetQueryObjectuivEXT(GLuint id,
                                     GLenum pname,
-                                    GLuint* params) OVERRIDE;
+                                    GLuint* params) override;
 
   virtual void DiscardFramebufferEXT(GLenum target,
                                      GLsizei count,
-                                     const GLenum* attachments) OVERRIDE;
-  virtual void GenMailboxCHROMIUM(GLbyte* mailbox) OVERRIDE;
+                                     const GLenum* attachments) override;
+  virtual void GenMailboxCHROMIUM(GLbyte* mailbox) override;
   virtual void ProduceTextureCHROMIUM(GLenum target,
-                                      const GLbyte* mailbox) OVERRIDE;
+                                      const GLbyte* mailbox) override;
   virtual void ProduceTextureDirectCHROMIUM(GLuint texture,
                                             GLenum target,
-                                            const GLbyte* mailbox) OVERRIDE;
+                                            const GLbyte* mailbox) override;
   virtual void ConsumeTextureCHROMIUM(GLenum target,
-                                      const GLbyte* mailbox) OVERRIDE;
+                                      const GLbyte* mailbox) override;
   virtual GLuint CreateAndConsumeTextureCHROMIUM(
       GLenum target,
-      const GLbyte* mailbox) OVERRIDE;
+      const GLbyte* mailbox) override;
 
   virtual void ResizeCHROMIUM(GLuint width,
                               GLuint height,
-                              float device_scale) OVERRIDE;
-  virtual void LoseContextCHROMIUM(GLenum current, GLenum other) OVERRIDE;
+                              float device_scale) override;
+  virtual void LoseContextCHROMIUM(GLenum current, GLenum other) override;
 
  private:
   TestWebGraphicsContext3D* test_context_;
diff --git a/cc/test/test_in_process_context_provider.h b/cc/test/test_in_process_context_provider.h
index 721caba..5e6a9785 100644
--- a/cc/test/test_in_process_context_provider.h
+++ b/cc/test/test_in_process_context_provider.h
@@ -22,20 +22,20 @@ class TestInProcessContextProvider : public ContextProvider {
  public:
   TestInProcessContextProvider();
 
-  virtual bool BindToCurrentThread() OVERRIDE;
-  virtual gpu::gles2::GLES2Interface* ContextGL() OVERRIDE;
-  virtual gpu::ContextSupport* ContextSupport() OVERRIDE;
-  virtual class GrContext* GrContext() OVERRIDE;
-  virtual Capabilities ContextCapabilities() OVERRIDE;
-  virtual bool IsContextLost() OVERRIDE;
-  virtual void VerifyContexts() OVERRIDE;
-  virtual void DeleteCachedResources() OVERRIDE;
-  virtual bool DestroyedOnMainThread() OVERRIDE;
+  virtual bool BindToCurrentThread() override;
+  virtual gpu::gles2::GLES2Interface* ContextGL() override;
+  virtual gpu::ContextSupport* ContextSupport() override;
+  virtual class GrContext* GrContext() override;
+  virtual Capabilities ContextCapabilities() override;
+  virtual bool IsContextLost() override;
+  virtual void VerifyContexts() override;
+  virtual void DeleteCachedResources() override;
+  virtual bool DestroyedOnMainThread() override;
   virtual void SetLostContextCallback(
-      const LostContextCallback& lost_context_callback) OVERRIDE;
+      const LostContextCallback& lost_context_callback) override;
   virtual void SetMemoryPolicyChangedCallback(
       const MemoryPolicyChangedCallback& memory_policy_changed_callback)
-      OVERRIDE;
+      override;
 
  protected:
   friend class base::RefCountedThreadSafe<TestInProcessContextProvider>;
diff --git a/cc/test/test_shared_bitmap_manager.h b/cc/test/test_shared_bitmap_manager.h
index 29529409..ccda52c 100644
--- a/cc/test/test_shared_bitmap_manager.h
+++ b/cc/test/test_shared_bitmap_manager.h
@@ -18,14 +18,14 @@ class TestSharedBitmapManager : public SharedBitmapManager {
   virtual ~TestSharedBitmapManager();
 
   virtual scoped_ptr<SharedBitmap> AllocateSharedBitmap(const gfx::Size& size)
-      OVERRIDE;
+      override;
 
   virtual scoped_ptr<SharedBitmap> GetSharedBitmapFromId(
       const gfx::Size&,
-      const SharedBitmapId& id) OVERRIDE;
+      const SharedBitmapId& id) override;
 
   virtual scoped_ptr<SharedBitmap> GetBitmapForSharedMemory(
-      base::SharedMemory* memory) OVERRIDE;
+      base::SharedMemory* memory) override;
 
  private:
   base::Lock lock_;
diff --git a/cc/test/tiled_layer_test_common.h b/cc/test/tiled_layer_test_common.h
index 2634621..29f06a7 100644
--- a/cc/test/tiled_layer_test_common.h
+++ b/cc/test/tiled_layer_test_common.h
@@ -30,7 +30,7 @@ class FakeLayerUpdater : public LayerUpdater {
     virtual void Update(ResourceUpdateQueue* queue,
                         const gfx::Rect& source_rect,
                         const gfx::Vector2d& dest_offset,
-                        bool partial_update) OVERRIDE;
+                        bool partial_update) override;
 
    private:
     FakeLayerUpdater* layer_;
@@ -42,13 +42,13 @@ class FakeLayerUpdater : public LayerUpdater {
   FakeLayerUpdater();
 
   virtual scoped_ptr<LayerUpdater::Resource> CreateResource(
-      PrioritizedResourceManager* resource) OVERRIDE;
+      PrioritizedResourceManager* resource) override;
 
   virtual void PrepareToUpdate(const gfx::Size& content_size,
                                const gfx::Rect& paint_rect,
                                const gfx::Size& tile_size,
                                float contents_width_scale,
-                               float contents_height_scale) OVERRIDE;
+                               float contents_height_scale) override;
   // Sets the rect to invalidate during the next call to PrepareToUpdate().
   // After the next call to PrepareToUpdate() the rect is reset.
   void SetRectToInvalidate(const gfx::Rect& rect, FakeTiledLayer* layer);
@@ -102,15 +102,15 @@ class FakeTiledLayer : public TiledLayer {
   using TiledLayer::NumPaintedTiles;
   using TiledLayer::IdlePaintRect;
 
-  virtual void SetNeedsDisplayRect(const gfx::RectF& rect) OVERRIDE;
+  virtual void SetNeedsDisplayRect(const gfx::RectF& rect) override;
   const gfx::RectF& last_needs_display_rect() const {
     return last_needs_display_rect_;
   }
 
   virtual void SetTexturePriorities(
-      const PriorityCalculator& priority_calculator) OVERRIDE;
+      const PriorityCalculator& priority_calculator) override;
 
-  virtual PrioritizedResourceManager* ResourceManager() OVERRIDE;
+  virtual PrioritizedResourceManager* ResourceManager() override;
   FakeLayerUpdater* fake_layer_updater() { return fake_updater_.get(); }
   gfx::RectF update_rect() { return update_rect_; }
 
@@ -120,8 +120,8 @@ class FakeTiledLayer : public TiledLayer {
   void ResetNumDependentsNeedPushProperties();
 
  protected:
-  virtual LayerUpdater* Updater() const OVERRIDE;
-  virtual void CreateUpdaterIfNeeded() OVERRIDE {}
+  virtual LayerUpdater* Updater() const override;
+  virtual void CreateUpdaterIfNeeded() override {}
   virtual ~FakeTiledLayer();
 
  private:
@@ -141,7 +141,7 @@ class FakeTiledLayerWithScaledBounds : public FakeTiledLayer {
   virtual void CalculateContentsScale(float ideal_contents_scale,
                                       float* contents_scale_x,
                                       float* contents_scale_y,
-                                      gfx::Size* content_bounds) OVERRIDE;
+                                      gfx::Size* content_bounds) override;
 
  protected:
   virtual ~FakeTiledLayerWithScaledBounds();
diff --git a/cc/trees/layer_tree_host_common_perftest.cc b/cc/trees/layer_tree_host_common_perftest.cc
index d334e96..e378561 100644
--- a/cc/trees/layer_tree_host_common_perftest.cc
+++ b/cc/trees/layer_tree_host_common_perftest.cc
@@ -50,7 +50,7 @@ class LayerTreeHostCommonPerfTest : public LayerTreeTest {
     ASSERT_TRUE(base::ReadFileToString(json_file, &json_));
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     gfx::Size viewport = gfx::Size(720, 1038);
     layer_tree_host()->SetViewportSize(viewport);
     scoped_refptr<Layer> root =
@@ -61,7 +61,7 @@ class LayerTreeHostCommonPerfTest : public LayerTreeTest {
 
   void SetTestName(const std::string& name) { test_name_ = name; }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     CHECK(!test_name_.empty()) << "Must SetTestName() before TearDown().";
     perf_test::PrintResult("calc_draw_props_time",
                            "",
@@ -84,7 +84,7 @@ class CalcDrawPropsMainTest : public LayerTreeHostCommonPerfTest {
     RunTest(false, false, false);
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     timer_.Reset();
 
     do {
@@ -121,11 +121,11 @@ class CalcDrawPropsImplTest : public LayerTreeHostCommonPerfTest {
     RunTestWithImplSidePainting();
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     timer_.Reset();
     LayerTreeImpl* active_tree = host_impl->active_tree();
 
@@ -169,9 +169,9 @@ class LayerSorterMainTest : public CalcDrawPropsImplTest {
  public:
   void RunSortLayers() { RunTest(false, false, false); }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     LayerTreeImpl* active_tree = host_impl->active_tree();
     // First build the tree and then we'll start running tests on layersorter
     // itself
@@ -221,9 +221,9 @@ class BspTreePerfTest : public LayerSorterMainTest {
     num_duplicates_ = num_duplicates;
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     LayerTreeImpl* active_tree = host_impl->active_tree();
     // First build the tree and then we'll start running tests on layersorter
     // itself
diff --git a/cc/trees/layer_tree_host_common_unittest.cc b/cc/trees/layer_tree_host_common_unittest.cc
index 7278b33..9efcaea 100644
--- a/cc/trees/layer_tree_host_common_unittest.cc
+++ b/cc/trees/layer_tree_host_common_unittest.cc
@@ -40,7 +40,7 @@ class LayerWithForcedDrawsContent : public Layer {
  public:
   LayerWithForcedDrawsContent() {}
 
-  virtual bool DrawsContent() const OVERRIDE;
+  virtual bool DrawsContent() const override;
 
  private:
   virtual ~LayerWithForcedDrawsContent() {}
@@ -55,9 +55,9 @@ class MockContentLayerClient : public ContentLayerClient {
   virtual void PaintContents(
       SkCanvas* canvas,
       const gfx::Rect& clip,
-      ContentLayerClient::GraphicsContextStatus gc_status) OVERRIDE {}
-  virtual void DidChangeLayerCanUseLCDText() OVERRIDE {}
-  virtual bool FillsBoundsCompletely() const OVERRIDE { return false; }
+      ContentLayerClient::GraphicsContextStatus gc_status) override {}
+  virtual void DidChangeLayerCanUseLCDText() override {}
+  virtual bool FillsBoundsCompletely() const override { return false; }
 };
 
 scoped_refptr<ContentLayer> CreateDrawableContentLayer(
@@ -4018,7 +4018,7 @@ class NoScaleContentLayer : public ContentLayer {
   virtual void CalculateContentsScale(float ideal_contents_scale,
                                       float* contents_scale_x,
                                       float* contents_scale_y,
-                                      gfx::Size* content_bounds) OVERRIDE {
+                                      gfx::Size* content_bounds) override {
     // Skip over the ContentLayer to the base Layer class.
     Layer::CalculateContentsScale(ideal_contents_scale,
                                   contents_scale_x,
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index dd000d6..b7b7f0e 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -145,7 +145,7 @@ class LayerTreeHostImplTimeSourceAdapter : public TimeSourceClient {
     time_source_->SetActive(false);
   }
 
-  virtual void OnTimerTick() OVERRIDE {
+  virtual void OnTimerTick() override {
     // In single threaded mode we attempt to simulate changing the current
     // thread by maintaining a fake thread id. When we switch from one
     // thread to another, we construct DebugScopedSetXXXThread objects that
diff --git a/cc/trees/layer_tree_host_impl.h b/cc/trees/layer_tree_host_impl.h
index fad9f08..a987d46 100644
--- a/cc/trees/layer_tree_host_impl.h
+++ b/cc/trees/layer_tree_host_impl.h
@@ -125,44 +125,44 @@ class CC_EXPORT LayerTreeHostImpl
   virtual ~LayerTreeHostImpl();
 
   // BeginFrameSourceMixIn implementation
-  virtual void OnNeedsBeginFramesChange(bool needs_begin_frames) OVERRIDE;
+  virtual void OnNeedsBeginFramesChange(bool needs_begin_frames) override;
 
   // InputHandler implementation
-  virtual void BindToClient(InputHandlerClient* client) OVERRIDE;
+  virtual void BindToClient(InputHandlerClient* client) override;
   virtual InputHandler::ScrollStatus ScrollBegin(
       const gfx::Point& viewport_point,
-      InputHandler::ScrollInputType type) OVERRIDE;
+      InputHandler::ScrollInputType type) override;
   virtual InputHandler::ScrollStatus ScrollAnimated(
       const gfx::Point& viewport_point,
-      const gfx::Vector2dF& scroll_delta) OVERRIDE;
+      const gfx::Vector2dF& scroll_delta) override;
   virtual bool ScrollBy(const gfx::Point& viewport_point,
-                        const gfx::Vector2dF& scroll_delta) OVERRIDE;
+                        const gfx::Vector2dF& scroll_delta) override;
   virtual bool ScrollVerticallyByPage(const gfx::Point& viewport_point,
-                                      ScrollDirection direction) OVERRIDE;
+                                      ScrollDirection direction) override;
   virtual void SetRootLayerScrollOffsetDelegate(
-      LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate) OVERRIDE;
-  virtual void OnRootLayerDelegatedScrollOffsetChanged() OVERRIDE;
-  virtual void ScrollEnd() OVERRIDE;
-  virtual InputHandler::ScrollStatus FlingScrollBegin() OVERRIDE;
-  virtual void MouseMoveAt(const gfx::Point& viewport_point) OVERRIDE;
-  virtual void PinchGestureBegin() OVERRIDE;
+      LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate) override;
+  virtual void OnRootLayerDelegatedScrollOffsetChanged() override;
+  virtual void ScrollEnd() override;
+  virtual InputHandler::ScrollStatus FlingScrollBegin() override;
+  virtual void MouseMoveAt(const gfx::Point& viewport_point) override;
+  virtual void PinchGestureBegin() override;
   virtual void PinchGestureUpdate(float magnify_delta,
-                                  const gfx::Point& anchor) OVERRIDE;
-  virtual void PinchGestureEnd() OVERRIDE;
-  virtual void SetNeedsAnimate() OVERRIDE;
+                                  const gfx::Point& anchor) override;
+  virtual void PinchGestureEnd() override;
+  virtual void SetNeedsAnimate() override;
   virtual bool IsCurrentlyScrollingLayerAt(
       const gfx::Point& viewport_point,
-      InputHandler::ScrollInputType type) OVERRIDE;
+      InputHandler::ScrollInputType type) override;
   virtual bool HaveTouchEventHandlersAt(
-      const gfx::Point& viewport_port) OVERRIDE;
+      const gfx::Point& viewport_port) override;
   virtual scoped_ptr<SwapPromiseMonitor> CreateLatencyInfoSwapPromiseMonitor(
-      ui::LatencyInfo* latency) OVERRIDE;
+      ui::LatencyInfo* latency) override;
 
   // TopControlsManagerClient implementation.
-  virtual void SetControlsTopOffset(float offset) OVERRIDE;
-  virtual float ControlsTopOffset() const OVERRIDE;
-  virtual void DidChangeTopControlsPosition() OVERRIDE;
-  virtual bool HaveRootScrollLayer() const OVERRIDE;
+  virtual void SetControlsTopOffset(float offset) override;
+  virtual float ControlsTopOffset() const override;
+  virtual void DidChangeTopControlsPosition() override;
+  virtual bool HaveRootScrollLayer() const override;
 
   struct CC_EXPORT FrameData : public RenderPassSink {
     FrameData();
@@ -179,7 +179,7 @@ class CC_EXPORT LayerTreeHostImpl
     bool has_no_damage;
 
     // RenderPassSink implementation.
-    virtual void AppendRenderPass(scoped_ptr<RenderPass> render_pass) OVERRIDE;
+    virtual void AppendRenderPass(scoped_ptr<RenderPass> render_pass) override;
   };
 
   virtual void BeginMainFrameAborted(bool did_handle);
@@ -231,30 +231,30 @@ class CC_EXPORT LayerTreeHostImpl
   const gfx::Rect ViewportRectForTilePriority() const;
 
   // RendererClient implementation.
-  virtual void SetFullRootLayerDamage() OVERRIDE;
+  virtual void SetFullRootLayerDamage() override;
 
   // TileManagerClient implementation.
   virtual const std::vector<PictureLayerImpl*>& GetPictureLayers()
-      const OVERRIDE;
-  virtual void NotifyReadyToActivate() OVERRIDE;
-  virtual void NotifyTileStateChanged(const Tile* tile) OVERRIDE;
+      const override;
+  virtual void NotifyReadyToActivate() override;
+  virtual void NotifyTileStateChanged(const Tile* tile) override;
   virtual void BuildRasterQueue(RasterTilePriorityQueue* queue,
-                                TreePriority tree_priority) OVERRIDE;
+                                TreePriority tree_priority) override;
   virtual void BuildEvictionQueue(EvictionTilePriorityQueue* queue,
-                                  TreePriority tree_priority) OVERRIDE;
+                                  TreePriority tree_priority) override;
 
   // ScrollbarAnimationControllerClient implementation.
   virtual void PostDelayedScrollbarFade(const base::Closure& start_fade,
-                                        base::TimeDelta delay) OVERRIDE;
-  virtual void SetNeedsScrollbarAnimationFrame() OVERRIDE;
+                                        base::TimeDelta delay) override;
+  virtual void SetNeedsScrollbarAnimationFrame() override;
 
   // OutputSurfaceClient implementation.
-  virtual void DeferredInitialize() OVERRIDE;
-  virtual void ReleaseGL() OVERRIDE;
+  virtual void DeferredInitialize() override;
+  virtual void ReleaseGL() override;
   virtual void CommitVSyncParameters(base::TimeTicks timebase,
-                                     base::TimeDelta interval) OVERRIDE;
-  virtual void SetNeedsRedrawRect(const gfx::Rect& rect) OVERRIDE;
-  virtual void BeginFrame(const BeginFrameArgs& args) OVERRIDE;
+                                     base::TimeDelta interval) override;
+  virtual void SetNeedsRedrawRect(const gfx::Rect& rect) override;
+  virtual void BeginFrame(const BeginFrameArgs& args) override;
 
   virtual void SetExternalDrawConstraints(
       const gfx::Transform& transform,
@@ -262,14 +262,14 @@ class CC_EXPORT LayerTreeHostImpl
       const gfx::Rect& clip,
       const gfx::Rect& viewport_rect_for_tile_priority,
       const gfx::Transform& transform_for_tile_priority,
-      bool resourceless_software_draw) OVERRIDE;
-  virtual void DidLoseOutputSurface() OVERRIDE;
-  virtual void DidSwapBuffers() OVERRIDE;
-  virtual void DidSwapBuffersComplete() OVERRIDE;
-  virtual void ReclaimResources(const CompositorFrameAck* ack) OVERRIDE;
-  virtual void SetMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE;
+      bool resourceless_software_draw) override;
+  virtual void DidLoseOutputSurface() override;
+  virtual void DidSwapBuffers() override;
+  virtual void DidSwapBuffersComplete() override;
+  virtual void ReclaimResources(const CompositorFrameAck* ack) override;
+  virtual void SetMemoryPolicy(const ManagedMemoryPolicy& policy) override;
   virtual void SetTreeActivationCallback(const base::Closure& callback)
-      OVERRIDE;
+      override;
 
   // Called from LayerTreeImpl.
   void OnCanDrawStateChangedForTree();
@@ -427,7 +427,7 @@ class CC_EXPORT LayerTreeHostImpl
     return begin_impl_frame_interval_;
   }
 
-  virtual void AsValueInto(base::debug::TracedValue* value) const OVERRIDE;
+  virtual void AsValueInto(base::debug::TracedValue* value) const override;
   void AsValueWithFrameInto(FrameData* frame,
                             base::debug::TracedValue* value) const;
   scoped_refptr<base::debug::ConvertableToTraceFormat> AsValue() const;
diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index cb52be7..81a7e60 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -105,64 +105,64 @@ class LayerTreeHostImplTest : public testing::Test,
     return settings;
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     CreateHostImpl(DefaultSettings(), CreateOutputSurface());
   }
 
-  virtual void TearDown() OVERRIDE {}
+  virtual void TearDown() override {}
 
-  virtual void UpdateRendererCapabilitiesOnImplThread() OVERRIDE {}
-  virtual void DidLoseOutputSurfaceOnImplThread() OVERRIDE {}
+  virtual void UpdateRendererCapabilitiesOnImplThread() override {}
+  virtual void DidLoseOutputSurfaceOnImplThread() override {}
   virtual void CommitVSyncParameters(base::TimeTicks timebase,
-                                     base::TimeDelta interval) OVERRIDE {}
-  virtual void SetEstimatedParentDrawTime(base::TimeDelta draw_time) OVERRIDE {}
-  virtual void SetMaxSwapsPendingOnImplThread(int max) OVERRIDE {}
-  virtual void DidSwapBuffersOnImplThread() OVERRIDE {}
-  virtual void DidSwapBuffersCompleteOnImplThread() OVERRIDE {}
-  virtual void OnCanDrawStateChanged(bool can_draw) OVERRIDE {
+                                     base::TimeDelta interval) override {}
+  virtual void SetEstimatedParentDrawTime(base::TimeDelta draw_time) override {}
+  virtual void SetMaxSwapsPendingOnImplThread(int max) override {}
+  virtual void DidSwapBuffersOnImplThread() override {}
+  virtual void DidSwapBuffersCompleteOnImplThread() override {}
+  virtual void OnCanDrawStateChanged(bool can_draw) override {
     on_can_draw_state_changed_called_ = true;
   }
-  virtual void NotifyReadyToActivate() OVERRIDE {
+  virtual void NotifyReadyToActivate() override {
     did_notify_ready_to_activate_ = true;
     host_impl_->ActivateSyncTree();
   }
-  virtual void SetNeedsRedrawOnImplThread() OVERRIDE {
+  virtual void SetNeedsRedrawOnImplThread() override {
     did_request_redraw_ = true;
   }
   virtual void SetNeedsRedrawRectOnImplThread(
-      const gfx::Rect& damage_rect) OVERRIDE {
+      const gfx::Rect& damage_rect) override {
     did_request_redraw_ = true;
   }
-  virtual void SetNeedsAnimateOnImplThread() OVERRIDE {
+  virtual void SetNeedsAnimateOnImplThread() override {
     did_request_animate_ = true;
   }
-  virtual void SetNeedsManageTilesOnImplThread() OVERRIDE {
+  virtual void SetNeedsManageTilesOnImplThread() override {
     did_request_manage_tiles_ = true;
   }
-  virtual void DidInitializeVisibleTileOnImplThread() OVERRIDE {
+  virtual void DidInitializeVisibleTileOnImplThread() override {
     did_upload_visible_tile_ = true;
   }
-  virtual void SetNeedsCommitOnImplThread() OVERRIDE {
+  virtual void SetNeedsCommitOnImplThread() override {
     did_request_commit_ = true;
   }
   virtual void PostAnimationEventsToMainThreadOnImplThread(
-      scoped_ptr<AnimationEventsVector> events) OVERRIDE {}
+      scoped_ptr<AnimationEventsVector> events) override {}
   virtual bool ReduceContentsTextureMemoryOnImplThread(
-      size_t limit_bytes, int priority_cutoff) OVERRIDE {
+      size_t limit_bytes, int priority_cutoff) override {
     current_limit_bytes_ = limit_bytes;
     current_priority_cutoff_value_ = priority_cutoff;
     return reduce_memory_result_;
   }
-  virtual bool IsInsideDraw() OVERRIDE { return false; }
-  virtual void RenewTreePriority() OVERRIDE {}
+  virtual bool IsInsideDraw() override { return false; }
+  virtual void RenewTreePriority() override {}
   virtual void PostDelayedScrollbarFadeOnImplThread(
       const base::Closure& start_fade,
-      base::TimeDelta delay) OVERRIDE {
+      base::TimeDelta delay) override {
     scrollbar_fade_start_ = start_fade;
     requested_scrollbar_animation_delay_ = delay;
   }
-  virtual void DidActivateSyncTree() OVERRIDE {}
-  virtual void DidManageTiles() OVERRIDE {}
+  virtual void DidActivateSyncTree() override {}
+  virtual void DidManageTiles() override {}
 
   void set_reduce_memory_result(bool reduce_memory_result) {
     reduce_memory_result_ = reduce_memory_result;
@@ -1368,7 +1368,7 @@ class LayerTreeHostImplOverridePhysicalTime : public LayerTreeHostImpl {
                           manager,
                           0) {}
 
-  virtual BeginFrameArgs CurrentBeginFrameArgs() const OVERRIDE {
+  virtual BeginFrameArgs CurrentBeginFrameArgs() const override {
     return CreateBeginFrameArgsForTesting(fake_current_physical_time_);
   }
 
@@ -1708,7 +1708,7 @@ class DidDrawCheckLayer : public LayerImpl {
   }
 
   virtual bool WillDraw(DrawMode draw_mode, ResourceProvider* provider)
-      OVERRIDE {
+      override {
     will_draw_called_ = true;
     if (will_draw_returns_false_)
       return false;
@@ -1717,12 +1717,12 @@ class DidDrawCheckLayer : public LayerImpl {
 
   virtual void AppendQuads(RenderPass* render_pass,
                            const OcclusionTracker<LayerImpl>& occlusion_tracker,
-                           AppendQuadsData* append_quads_data) OVERRIDE {
+                           AppendQuadsData* append_quads_data) override {
     append_quads_called_ = true;
     LayerImpl::AppendQuads(render_pass, occlusion_tracker, append_quads_data);
   }
 
-  virtual void DidDraw(ResourceProvider* provider) OVERRIDE {
+  virtual void DidDraw(ResourceProvider* provider) override {
     did_draw_called_ = true;
     LayerImpl::DidDraw(provider);
   }
@@ -1940,7 +1940,7 @@ class MissingTextureAnimatingLayer : public DidDrawCheckLayer {
 
   virtual void AppendQuads(RenderPass* render_pass,
                            const OcclusionTracker<LayerImpl>& occlusion_tracker,
-                           AppendQuadsData* append_quads_data) OVERRIDE {
+                           AppendQuadsData* append_quads_data) override {
     LayerImpl::AppendQuads(render_pass, occlusion_tracker, append_quads_data);
     if (had_incomplete_tile_)
       append_quads_data->num_incomplete_tiles++;
@@ -3283,11 +3283,11 @@ class TestScrollOffsetDelegate : public LayerScrollOffsetDelegate {
 
   virtual ~TestScrollOffsetDelegate() {}
 
-  virtual gfx::ScrollOffset GetTotalScrollOffset() OVERRIDE {
+  virtual gfx::ScrollOffset GetTotalScrollOffset() override {
     return getter_return_value_;
   }
 
-  virtual bool IsExternalFlingActive() const OVERRIDE { return false; }
+  virtual bool IsExternalFlingActive() const override { return false; }
 
   virtual void UpdateRootLayerState(
       const gfx::ScrollOffset& total_scroll_offset,
@@ -3295,7 +3295,7 @@ class TestScrollOffsetDelegate : public LayerScrollOffsetDelegate {
       const gfx::SizeF& scrollable_size,
       float page_scale_factor,
       float min_page_scale_factor,
-      float max_page_scale_factor) OVERRIDE {
+      float max_page_scale_factor) override {
     DCHECK(total_scroll_offset.x() <= max_scroll_offset.x());
     DCHECK(total_scroll_offset.y() <= max_scroll_offset.y());
     last_set_scroll_offset_ = total_scroll_offset;
@@ -3739,7 +3739,7 @@ class BlendStateCheckLayer : public LayerImpl {
 
   virtual void AppendQuads(RenderPass* render_pass,
                            const OcclusionTracker<LayerImpl>& occlusion_tracker,
-                           AppendQuadsData* append_quads_data) OVERRIDE {
+                           AppendQuadsData* append_quads_data) override {
     quads_appended_ = true;
 
     gfx::Rect opaque_rect;
@@ -4149,7 +4149,7 @@ class LayerTreeHostImplViewportCoveredTest : public LayerTreeHostImplTest {
     host_impl_->DidDrawAllLayers(frame);
   }
 
-  virtual void DidActivateSyncTree() OVERRIDE {
+  virtual void DidActivateSyncTree() override {
     did_activate_pending_tree_ = true;
   }
 
@@ -4503,7 +4503,7 @@ class FakeLayerWithQuads : public LayerImpl {
 
   virtual void AppendQuads(RenderPass* render_pass,
                            const OcclusionTracker<LayerImpl>& occlusion_tracker,
-                           AppendQuadsData* append_quads_data) OVERRIDE {
+                           AppendQuadsData* append_quads_data) override {
     SharedQuadState* shared_quad_state =
         render_pass->CreateAndAppendSharedQuadState();
     PopulateSharedQuadState(shared_quad_state);
@@ -4951,7 +4951,7 @@ TEST_F(LayerTreeHostImplTest, ReleaseContentsTextureShouldTriggerCommit) {
 class LayerTreeHostImplTestWithDelegatingRenderer
     : public LayerTreeHostImplTest {
  protected:
-  virtual scoped_ptr<OutputSurface> CreateOutputSurface() OVERRIDE {
+  virtual scoped_ptr<OutputSurface> CreateOutputSurface() override {
     return FakeOutputSurface::CreateDelegating3d();
   }
 
@@ -5041,7 +5041,7 @@ class FakeMaskLayerImpl : public LayerImpl {
     return make_scoped_ptr(new FakeMaskLayerImpl(tree_impl, id));
   }
 
-  virtual ResourceProvider::ResourceId ContentsResourceId() const OVERRIDE {
+  virtual ResourceProvider::ResourceId ContentsResourceId() const override {
     return 0;
   }
 
@@ -5771,7 +5771,7 @@ class CompositorFrameMetadataTest : public LayerTreeHostImplTest {
   CompositorFrameMetadataTest()
       : swap_buffers_complete_(0) {}
 
-  virtual void DidSwapBuffersCompleteOnImplThread() OVERRIDE {
+  virtual void DidSwapBuffersCompleteOnImplThread() override {
     swap_buffers_complete_++;
   }
 
@@ -5796,11 +5796,11 @@ class CountingSoftwareDevice : public SoftwareOutputDevice {
  public:
   CountingSoftwareDevice() : frames_began_(0), frames_ended_(0) {}
 
-  virtual SkCanvas* BeginPaint(const gfx::Rect& damage_rect) OVERRIDE {
+  virtual SkCanvas* BeginPaint(const gfx::Rect& damage_rect) override {
     ++frames_began_;
     return SoftwareOutputDevice::BeginPaint(damage_rect);
   }
-  virtual void EndPaint(SoftwareFrameData* frame_data) OVERRIDE {
+  virtual void EndPaint(SoftwareFrameData* frame_data) override {
     ++frames_ended_;
     SoftwareOutputDevice::EndPaint(frame_data);
   }
@@ -5894,7 +5894,7 @@ TEST_F(LayerTreeHostImplTest,
 
 class LayerTreeHostImplTestDeferredInitialize : public LayerTreeHostImplTest {
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     LayerTreeHostImplTest::SetUp();
 
     set_reduce_memory_result(false);
@@ -5915,7 +5915,7 @@ class LayerTreeHostImplTestDeferredInitialize : public LayerTreeHostImplTest {
     onscreen_context_provider_ = TestContextProvider::Create();
   }
 
-  virtual void UpdateRendererCapabilitiesOnImplThread() OVERRIDE {
+  virtual void UpdateRendererCapabilitiesOnImplThread() override {
     did_update_renderer_capabilities_ = true;
   }
 
@@ -6082,7 +6082,7 @@ TEST_F(LayerTreeHostImplTest, RequireHighResAfterGpuRasterizationToggles) {
 
 class LayerTreeHostImplTestManageTiles : public LayerTreeHostImplTest {
  public:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     LayerTreeSettings settings;
     settings.impl_side_painting = true;
 
@@ -6634,15 +6634,15 @@ class SimpleSwapPromiseMonitor : public SwapPromiseMonitor {
 
   virtual ~SimpleSwapPromiseMonitor() {}
 
-  virtual void OnSetNeedsCommitOnMain() OVERRIDE {
+  virtual void OnSetNeedsCommitOnMain() override {
     (*set_needs_commit_count_)++;
   }
 
-  virtual void OnSetNeedsRedrawOnImpl() OVERRIDE {
+  virtual void OnSetNeedsRedrawOnImpl() override {
     (*set_needs_redraw_count_)++;
   }
 
-  virtual void OnForwardScrollUpdateToMainThreadOnImpl() OVERRIDE {
+  virtual void OnForwardScrollUpdateToMainThreadOnImpl() override {
     (*forward_to_main_count_)++;
   }
 
@@ -6742,7 +6742,7 @@ TEST_F(LayerTreeHostImplTest, SimpleSwapPromiseMonitor) {
 
 class LayerTreeHostImplWithTopControlsTest : public LayerTreeHostImplTest {
  public:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     LayerTreeSettings settings = DefaultSettings();
     settings.calculate_top_controls_position = true;
     settings.top_controls_height = top_controls_height_;
@@ -7061,7 +7061,7 @@ TEST_F(LayerTreeHostImplVirtualViewportTest, FlingScrollBubblesToInner) {
 
 class LayerTreeHostImplWithImplicitLimitsTest : public LayerTreeHostImplTest {
  public:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     LayerTreeSettings settings = DefaultSettings();
     settings.max_memory_for_prepaint_percentage = 50;
     CreateHostImpl(settings, CreateOutputSurface());
@@ -7252,7 +7252,7 @@ TEST_F(LayerTreeHostImplTest, DidBecomeActive) {
 class LayerTreeHostImplCountingLostSurfaces : public LayerTreeHostImplTest {
  public:
   LayerTreeHostImplCountingLostSurfaces() : num_lost_surfaces_(0) {}
-  virtual void DidLoseOutputSurfaceOnImplThread() OVERRIDE {
+  virtual void DidLoseOutputSurfaceOnImplThread() override {
     num_lost_surfaces_++;
   }
 
diff --git a/cc/trees/layer_tree_host_perftest.cc b/cc/trees/layer_tree_host_perftest.cc
index 6e43ddf..a516a50 100644
--- a/cc/trees/layer_tree_host_perftest.cc
+++ b/cc/trees/layer_tree_host_perftest.cc
@@ -44,34 +44,34 @@ class LayerTreeHostPerfTest : public LayerTreeTest {
         measure_commit_cost_(false) {
   }
 
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     settings->throttle_frame_production = false;
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     BuildTree();
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void BeginMainFrame(const BeginFrameArgs& args) OVERRIDE {
+  virtual void BeginMainFrame(const BeginFrameArgs& args) override {
     if (begin_frame_driven_drawing_ && !TestEnded()) {
       layer_tree_host()->SetNeedsAnimate();
       layer_tree_host()->SetNextCommitForcesRedraw();
     }
   }
 
-  virtual void BeginCommitOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void BeginCommitOnThread(LayerTreeHostImpl* host_impl) override {
     if (measure_commit_cost_)
       commit_timer_.Start();
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     if (measure_commit_cost_ && draw_timer_.IsWarmedUp()) {
       commit_timer_.NextLap();
     }
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     if (TestEnded() || CleanUpStarted())
       return;
     draw_timer_.NextLap();
@@ -91,7 +91,7 @@ class LayerTreeHostPerfTest : public LayerTreeTest {
 
   virtual void BuildTree() {}
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     CHECK(!test_name_.empty()) << "Must SetTestName() before AfterTest().";
     perf_test::PrintResult("layer_tree_host_frame_time", "", test_name_,
                            1000 * draw_timer_.MsPerLap(), "us", true);
@@ -131,7 +131,7 @@ class LayerTreeHostPerfTestJsonReader : public LayerTreeHostPerfTest {
     ASSERT_TRUE(base::ReadFileToString(json_file, &json_));
   }
 
-  virtual void BuildTree() OVERRIDE {
+  virtual void BuildTree() override {
     gfx::Size viewport = gfx::Size(720, 1038);
     layer_tree_host()->SetViewportSize(viewport);
     scoped_refptr<Layer> root = ParseTreeFromJson(json_,
@@ -178,7 +178,7 @@ TEST_F(LayerTreeHostPerfTestJsonReader,
 class LayerTreeHostPerfTestLeafInvalidates
     : public LayerTreeHostPerfTestJsonReader {
  public:
-  virtual void BuildTree() OVERRIDE {
+  virtual void BuildTree() override {
     LayerTreeHostPerfTestJsonReader::BuildTree();
 
     // Find a leaf layer.
@@ -188,7 +188,7 @@ class LayerTreeHostPerfTestLeafInvalidates
     }
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     if (TestEnded())
       return;
 
@@ -221,13 +221,13 @@ class ScrollingLayerTreePerfTest : public LayerTreeHostPerfTestJsonReader {
       : LayerTreeHostPerfTestJsonReader() {
   }
 
-  virtual void BuildTree() OVERRIDE {
+  virtual void BuildTree() override {
     LayerTreeHostPerfTestJsonReader::BuildTree();
     scrollable_ = layer_tree_host()->root_layer()->children()[1];
     ASSERT_TRUE(scrollable_.get());
   }
 
-  virtual void Layout() OVERRIDE {
+  virtual void Layout() override {
     if (TestEnded())
       return;
     static const gfx::Vector2d delta = gfx::Vector2d(0, 10);
@@ -262,7 +262,7 @@ class BrowserCompositorInvalidateLayerTreePerfTest
         next_sync_point_(1),
         clean_up_started_(false) {}
 
-  virtual void BuildTree() OVERRIDE {
+  virtual void BuildTree() override {
     LayerTreeHostPerfTestJsonReader::BuildTree();
     tab_contents_ =
         static_cast<TextureLayer*>(
@@ -273,7 +273,7 @@ class BrowserCompositorInvalidateLayerTreePerfTest
     ASSERT_TRUE(tab_contents_.get());
   }
 
-  virtual void WillCommit() OVERRIDE {
+  virtual void WillCommit() override {
     if (CleanUpStarted())
       return;
     gpu::Mailbox gpu_mailbox;
@@ -289,13 +289,13 @@ class BrowserCompositorInvalidateLayerTreePerfTest
     tab_contents_->SetTextureMailbox(mailbox, callback.Pass());
   }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     if (CleanUpStarted())
       return;
     layer_tree_host()->SetNeedsCommit();
   }
 
-  virtual void CleanUpAndEndTest(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void CleanUpAndEndTest(LayerTreeHostImpl* host_impl) override {
     clean_up_started_ = true;
     MainThreadTaskRunner()->PostTask(
         FROM_HERE,
@@ -310,7 +310,7 @@ class BrowserCompositorInvalidateLayerTreePerfTest
     EndTest();
   }
 
-  virtual bool CleanUpStarted() OVERRIDE { return clean_up_started_; }
+  virtual bool CleanUpStarted() override { return clean_up_started_; }
 
  private:
   scoped_refptr<TextureLayer> tab_contents_;
diff --git a/cc/trees/layer_tree_host_pixeltest_filters.cc b/cc/trees/layer_tree_host_pixeltest_filters.cc
index 5303ed1..4afc4ec 100644
--- a/cc/trees/layer_tree_host_pixeltest_filters.cc
+++ b/cc/trees/layer_tree_host_pixeltest_filters.cc
@@ -159,12 +159,12 @@ TEST_F(LayerTreeHostFiltersPixelTest, BackgroundFilterBlurOffAxis) {
 
 class LayerTreeHostFiltersScaledPixelTest
     : public LayerTreeHostFiltersPixelTest {
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     // Required so that device scale is inherited by content scale.
     settings->layer_transforms_should_scale_layer_contents = true;
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     layer_tree_host()->SetDeviceScaleFactor(device_scale_factor_);
     LayerTreePixelTest::SetupTree();
   }
diff --git a/cc/trees/layer_tree_host_pixeltest_masks.cc b/cc/trees/layer_tree_host_pixeltest_masks.cc
index 5d5022f..bd32119 100644
--- a/cc/trees/layer_tree_host_pixeltest_masks.cc
+++ b/cc/trees/layer_tree_host_pixeltest_masks.cc
@@ -22,14 +22,14 @@ class MaskContentLayerClient : public ContentLayerClient {
   MaskContentLayerClient() {}
   virtual ~MaskContentLayerClient() {}
 
-  virtual void DidChangeLayerCanUseLCDText() OVERRIDE {}
+  virtual void DidChangeLayerCanUseLCDText() override {}
 
-  virtual bool FillsBoundsCompletely() const OVERRIDE { return false; }
+  virtual bool FillsBoundsCompletely() const override { return false; }
 
   virtual void PaintContents(
       SkCanvas* canvas,
       const gfx::Rect& rect,
-      ContentLayerClient::GraphicsContextStatus gc_status) OVERRIDE {
+      ContentLayerClient::GraphicsContextStatus gc_status) override {
     SkPaint paint;
     paint.setStyle(SkPaint::kStroke_Style);
     paint.setStrokeWidth(SkIntToScalar(2));
diff --git a/cc/trees/layer_tree_host_pixeltest_on_demand_raster.cc b/cc/trees/layer_tree_host_pixeltest_on_demand_raster.cc
index 64b8bc3..c63e082 100644
--- a/cc/trees/layer_tree_host_pixeltest_on_demand_raster.cc
+++ b/cc/trees/layer_tree_host_pixeltest_on_demand_raster.cc
@@ -22,11 +22,11 @@ namespace {
 
 class LayerTreeHostOnDemandRasterPixelTest : public LayerTreePixelTest {
  public:
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     settings->impl_side_painting = true;
   }
 
-  virtual void BeginCommitOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void BeginCommitOnThread(LayerTreeHostImpl* impl) override {
     // Not enough memory available. Enforce on-demand rasterization.
     impl->SetMemoryPolicy(
         ManagedMemoryPolicy(1, gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING,
@@ -34,7 +34,7 @@ class LayerTreeHostOnDemandRasterPixelTest : public LayerTreePixelTest {
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
-                                   bool result) OVERRIDE {
+                                   bool result) override {
     // Find the PictureLayerImpl ask it to append quads to check their material.
     // The PictureLayerImpl is assumed to be the first child of the root layer
     // in the active tree.
@@ -64,14 +64,14 @@ class BlueYellowLayerClient : public ContentLayerClient {
   explicit BlueYellowLayerClient(gfx::Rect layer_rect)
       : layer_rect_(layer_rect) {}
 
-  virtual void DidChangeLayerCanUseLCDText() OVERRIDE { }
+  virtual void DidChangeLayerCanUseLCDText() override { }
 
-  virtual bool FillsBoundsCompletely() const OVERRIDE { return false; }
+  virtual bool FillsBoundsCompletely() const override { return false; }
 
   virtual void PaintContents(
       SkCanvas* canvas,
       const gfx::Rect& clip,
-      ContentLayerClient::GraphicsContextStatus gc_status) OVERRIDE {
+      ContentLayerClient::GraphicsContextStatus gc_status) override {
     SkPaint paint;
     paint.setColor(SK_ColorBLUE);
     canvas->drawRect(SkRect::MakeWH(layer_rect_.width(),
@@ -113,7 +113,7 @@ TEST_F(LayerTreeHostOnDemandRasterPixelTest, RasterPictureLayer) {
 
 class LayerTreeHostOnDemandRasterPixelTestWithGpuRasterizationForced
     : public LayerTreeHostOnDemandRasterPixelTest {
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     LayerTreeHostOnDemandRasterPixelTest::InitializeSettings(settings);
     settings->gpu_rasterization_forced = true;
   }
diff --git a/cc/trees/layer_tree_host_pixeltest_readback.cc b/cc/trees/layer_tree_host_pixeltest_readback.cc
index bbf9668..1b7679b 100644
--- a/cc/trees/layer_tree_host_pixeltest_readback.cc
+++ b/cc/trees/layer_tree_host_pixeltest_readback.cc
@@ -24,7 +24,7 @@ class LayerTreeHostReadbackPixelTest : public LayerTreePixelTest {
   LayerTreeHostReadbackPixelTest()
       : insert_copy_request_after_frame_count_(0) {}
 
-  virtual scoped_ptr<CopyOutputRequest> CreateCopyOutputRequest() OVERRIDE {
+  virtual scoped_ptr<CopyOutputRequest> CreateCopyOutputRequest() override {
     scoped_ptr<CopyOutputRequest> request;
 
     switch (test_type_) {
@@ -51,7 +51,7 @@ class LayerTreeHostReadbackPixelTest : public LayerTreePixelTest {
     return request.Pass();
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     if (insert_copy_request_after_frame_count_ == 0) {
       Layer* const target =
           readback_target_ ? readback_target_ : layer_tree_host()->root_layer();
@@ -60,7 +60,7 @@ class LayerTreeHostReadbackPixelTest : public LayerTreePixelTest {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     if (insert_copy_request_after_frame_count_ ==
         layer_tree_host()->source_frame_number()) {
       Layer* const target =
@@ -920,17 +920,17 @@ class LayerTreeHostReadbackDeviceScalePixelTest
         green_client_(SK_ColorGREEN),
         blue_client_(SK_ColorBLUE) {}
 
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     // Cause the device scale factor to be inherited by contents scales.
     settings->layer_transforms_should_scale_layer_contents = true;
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     layer_tree_host()->SetDeviceScaleFactor(device_scale_factor_);
     LayerTreePixelTest::SetupTree();
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     EXPECT_EQ(device_scale_factor_,
               host_impl->active_tree()->device_scale_factor());
   }
diff --git a/cc/trees/layer_tree_host_unittest.cc b/cc/trees/layer_tree_host_unittest.cc
index 4a3fa7e..d8b8b3e 100644
--- a/cc/trees/layer_tree_host_unittest.cc
+++ b/cc/trees/layer_tree_host_unittest.cc
@@ -75,22 +75,22 @@ class LayerTreeHostTestSetNeedsCommit1 : public LayerTreeHostTest {
  public:
   LayerTreeHostTestSetNeedsCommit1() : num_commits_(0), num_draws_(0) {}
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostSetNeedsCommitToMainThread();
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     num_draws_++;
     if (!impl->active_tree()->source_frame_number())
       EndTest();
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     num_commits_++;
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     EXPECT_LE(1, num_commits_);
     EXPECT_LE(1, num_draws_);
   }
@@ -108,13 +108,13 @@ class LayerTreeHostTestSetNeedsCommit2 : public LayerTreeHostTest {
  public:
   LayerTreeHostTestSetNeedsCommit2() : num_commits_(0), num_draws_(0) {}
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     ++num_draws_;
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     ++num_commits_;
     switch (num_commits_) {
       case 1:
@@ -128,7 +128,7 @@ class LayerTreeHostTestSetNeedsCommit2 : public LayerTreeHostTest {
     }
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     EXPECT_EQ(2, num_commits_);
     EXPECT_LE(1, num_draws_);
   }
@@ -143,7 +143,7 @@ MULTI_THREAD_TEST_F(LayerTreeHostTestSetNeedsCommit2);
 // Verify that we pass property values in PushPropertiesTo.
 class LayerTreeHostTestPushPropertiesTo : public LayerTreeHostTest {
  protected:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(gfx::Size(10, 10));
     layer_tree_host()->SetRootLayer(root);
@@ -158,16 +158,16 @@ class LayerTreeHostTestPushPropertiesTo : public LayerTreeHostTest {
     DONE,
   };
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     index_ = STARTUP;
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     VerifyAfterValues(impl->active_tree()->root_layer());
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     SetBeforeValues(layer_tree_host()->root_layer());
     VerifyBeforeValues(layer_tree_host()->root_layer());
 
@@ -180,7 +180,7 @@ class LayerTreeHostTestPushPropertiesTo : public LayerTreeHostTest {
     SetAfterValues(layer_tree_host()->root_layer());
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   void VerifyBeforeValues(Layer* layer) {
     EXPECT_EQ(gfx::Size(10, 10).ToString(), layer->bounds().ToString());
@@ -239,9 +239,9 @@ class LayerTreeHostTestSetNeedsRedraw : public LayerTreeHostTest {
  public:
   LayerTreeHostTestSetNeedsRedraw() : num_commits_(0), num_draws_(0) {}
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     EXPECT_EQ(0, impl->active_tree()->source_frame_number());
     if (!num_draws_) {
       // Redraw again to verify that the second redraw doesn't commit.
@@ -252,12 +252,12 @@ class LayerTreeHostTestSetNeedsRedraw : public LayerTreeHostTest {
     num_draws_++;
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     EXPECT_EQ(0, num_draws_);
     num_commits_++;
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     EXPECT_GE(2, num_draws_);
     EXPECT_EQ(1, num_commits_);
   }
@@ -279,7 +279,7 @@ class LayerTreeHostTestSetNeedsRedrawRect : public LayerTreeHostTest {
         invalid_rect_(10, 10, 20, 20),
         root_layer_(ContentLayer::Create(&client_)) {}
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(bounds_);
     layer_tree_host()->SetRootLayer(root_layer_);
@@ -290,7 +290,7 @@ class LayerTreeHostTestSetNeedsRedrawRect : public LayerTreeHostTest {
   virtual DrawResult PrepareToDrawOnThread(
       LayerTreeHostImpl* host_impl,
       LayerTreeHostImpl::FrameData* frame_data,
-      DrawResult draw_result) OVERRIDE {
+      DrawResult draw_result) override {
     EXPECT_EQ(DRAW_SUCCESS, draw_result);
 
     gfx::RectF root_damage_rect;
@@ -308,7 +308,7 @@ class LayerTreeHostTestSetNeedsRedrawRect : public LayerTreeHostTest {
     return draw_result;
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     if (!num_draws_) {
       PostSetNeedsRedrawRectToMainThread(invalid_rect_);
     } else {
@@ -317,7 +317,7 @@ class LayerTreeHostTestSetNeedsRedrawRect : public LayerTreeHostTest {
     num_draws_++;
   }
 
-  virtual void AfterTest() OVERRIDE { EXPECT_EQ(2, num_draws_); }
+  virtual void AfterTest() override { EXPECT_EQ(2, num_draws_); }
 
  private:
   int num_draws_;
@@ -331,11 +331,11 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSetNeedsRedrawRect);
 
 class LayerTreeHostTestNoExtraCommitFromInvalidate : public LayerTreeHostTest {
  public:
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     settings->layer_transforms_should_scale_layer_contents = true;
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     root_layer_ = Layer::Create();
     root_layer_->SetBounds(gfx::Size(10, 20));
 
@@ -347,14 +347,14 @@ class LayerTreeHostTestNoExtraCommitFromInvalidate : public LayerTreeHostTest {
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->active_tree()->source_frame_number() == 1)
       EndTest();
   }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // Changing the device scale factor causes a commit. It also changes
@@ -368,7 +368,7 @@ class LayerTreeHostTestNoExtraCommitFromInvalidate : public LayerTreeHostTest {
     }
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     EXPECT_EQ(gfx::Size(4, 4).ToString(),
               scaled_layer_->content_bounds().ToString());
   }
@@ -384,11 +384,11 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestNoExtraCommitFromInvalidate);
 class LayerTreeHostTestNoExtraCommitFromScrollbarInvalidate
     : public LayerTreeHostTest {
  public:
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     settings->layer_transforms_should_scale_layer_contents = true;
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     root_layer_ = Layer::Create();
     root_layer_->SetBounds(gfx::Size(10, 20));
 
@@ -405,14 +405,14 @@ class LayerTreeHostTestNoExtraCommitFromScrollbarInvalidate
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->active_tree()->source_frame_number() == 1)
       EndTest();
   }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // Changing the device scale factor causes a commit. It also changes
@@ -426,7 +426,7 @@ class LayerTreeHostTestNoExtraCommitFromScrollbarInvalidate
     }
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     EXPECT_EQ(gfx::Size(40, 40).ToString(),
               scrollbar_->content_bounds().ToString());
   }
@@ -448,7 +448,7 @@ class LayerTreeHostTestSetNextCommitForcesRedraw : public LayerTreeHostTest {
         invalid_rect_(10, 10, 20, 20),
         root_layer_(ContentLayer::Create(&client_)) {}
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(bounds_);
     layer_tree_host()->SetRootLayer(root_layer_);
@@ -456,7 +456,7 @@ class LayerTreeHostTestSetNextCommitForcesRedraw : public LayerTreeHostTest {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     if (num_draws_ == 3 && host_impl->settings().impl_side_painting)
       host_impl->SetNeedsRedrawRect(invalid_rect_);
   }
@@ -464,7 +464,7 @@ class LayerTreeHostTestSetNextCommitForcesRedraw : public LayerTreeHostTest {
   virtual DrawResult PrepareToDrawOnThread(
       LayerTreeHostImpl* host_impl,
       LayerTreeHostImpl::FrameData* frame_data,
-      DrawResult draw_result) OVERRIDE {
+      DrawResult draw_result) override {
     EXPECT_EQ(DRAW_SUCCESS, draw_result);
 
     gfx::RectF root_damage_rect;
@@ -492,7 +492,7 @@ class LayerTreeHostTestSetNextCommitForcesRedraw : public LayerTreeHostTest {
     return draw_result;
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     switch (num_draws_) {
       case 0:
       case 1:
@@ -519,7 +519,7 @@ class LayerTreeHostTestSetNextCommitForcesRedraw : public LayerTreeHostTest {
     num_draws_++;
   }
 
-  virtual void AfterTest() OVERRIDE { EXPECT_EQ(5, num_draws_); }
+  virtual void AfterTest() override { EXPECT_EQ(5, num_draws_); }
 
  private:
   int num_draws_;
@@ -538,7 +538,7 @@ class LayerTreeHostTestUndrawnLayersDamageLater : public LayerTreeHostTest {
   LayerTreeHostTestUndrawnLayersDamageLater()
       : root_layer_(ContentLayer::Create(&client_)) {}
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(gfx::Size(50, 50));
     layer_tree_host()->SetRootLayer(root_layer_);
@@ -557,12 +557,12 @@ class LayerTreeHostTestUndrawnLayersDamageLater : public LayerTreeHostTest {
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   virtual DrawResult PrepareToDrawOnThread(
       LayerTreeHostImpl* host_impl,
       LayerTreeHostImpl::FrameData* frame_data,
-      DrawResult draw_result) OVERRIDE {
+      DrawResult draw_result) override {
     EXPECT_EQ(DRAW_SUCCESS, draw_result);
 
     gfx::RectF root_damage_rect;
@@ -590,7 +590,7 @@ class LayerTreeHostTestUndrawnLayersDamageLater : public LayerTreeHostTest {
     return draw_result;
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // Test not owning the surface.
@@ -612,7 +612,7 @@ class LayerTreeHostTestUndrawnLayersDamageLater : public LayerTreeHostTest {
     }
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   FakeContentLayerClient client_;
@@ -632,7 +632,7 @@ class LayerTreeHostTestUndrawnLayersPushContentBoundsLater
   LayerTreeHostTestUndrawnLayersPushContentBoundsLater()
       : root_layer_(Layer::Create()) {}
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(gfx::Size(20, 20));
     layer_tree_host()->SetRootLayer(root_layer_);
@@ -649,9 +649,9 @@ class LayerTreeHostTestUndrawnLayersPushContentBoundsLater
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     LayerImpl* root = host_impl->active_tree()->root_layer();
     LayerImpl* parent = root->children()[0];
     LayerImpl* child = parent->children()[0];
@@ -671,7 +671,7 @@ class LayerTreeHostTestUndrawnLayersPushContentBoundsLater
     }
   }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         parent_layer_->SetOpacity(1.0f);
@@ -683,7 +683,7 @@ class LayerTreeHostTestUndrawnLayersPushContentBoundsLater
     }
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   scoped_refptr<Layer> root_layer_;
@@ -700,21 +700,21 @@ class LayerTreeHostTestCommit : public LayerTreeHostTest {
  public:
   LayerTreeHostTestCommit() {}
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     layer_tree_host()->SetViewportSize(gfx::Size(20, 20));
     layer_tree_host()->set_background_color(SK_ColorGRAY);
 
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     EXPECT_EQ(gfx::Size(20, 20), impl->DrawViewportSize());
     EXPECT_EQ(SK_ColorGRAY, impl->active_tree()->background_color());
 
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestCommit);
@@ -728,20 +728,20 @@ class LayerTreeHostTestFrameTimeUpdatesAfterActivationFails
   LayerTreeHostTestFrameTimeUpdatesAfterActivationFails()
       : frame_count_with_pending_tree_(0) {}
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     layer_tree_host()->SetViewportSize(gfx::Size(20, 20));
     layer_tree_host()->set_background_color(SK_ColorGRAY);
 
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void BeginCommitOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void BeginCommitOnThread(LayerTreeHostImpl* impl) override {
     EXPECT_EQ(frame_count_with_pending_tree_, 0);
     impl->BlockNotifyReadyToActivateForTesting(true);
   }
 
   virtual void WillBeginImplFrameOnThread(LayerTreeHostImpl* impl,
-                                          const BeginFrameArgs& args) OVERRIDE {
+                                          const BeginFrameArgs& args) override {
     if (impl->pending_tree())
       frame_count_with_pending_tree_++;
 
@@ -753,7 +753,7 @@ class LayerTreeHostTestFrameTimeUpdatesAfterActivationFails
     }
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     if (frame_count_with_pending_tree_ > 1) {
       EXPECT_NE(first_frame_time_.ToInternalValue(), 0);
       EXPECT_NE(first_frame_time_.ToInternalValue(),
@@ -765,12 +765,12 @@ class LayerTreeHostTestFrameTimeUpdatesAfterActivationFails
     EXPECT_FALSE(impl->settings().impl_side_painting);
     EndTest();
   }
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     if (impl->settings().impl_side_painting)
       EXPECT_NE(frame_count_with_pending_tree_, 1);
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   int frame_count_with_pending_tree_;
@@ -786,14 +786,14 @@ class LayerTreeHostTestFrameTimeUpdatesAfterDraw : public LayerTreeHostTest {
  public:
   LayerTreeHostTestFrameTimeUpdatesAfterDraw() : frame_(0) {}
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     layer_tree_host()->SetViewportSize(gfx::Size(20, 20));
     layer_tree_host()->set_background_color(SK_ColorGRAY);
 
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     frame_++;
     if (frame_ == 1) {
       first_frame_time_ = impl->CurrentBeginFrameArgs().frame_time;
@@ -811,7 +811,7 @@ class LayerTreeHostTestFrameTimeUpdatesAfterDraw : public LayerTreeHostTest {
     EndTest();
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     // Ensure there isn't a commit between the two draws, to ensure that a
     // commit isn't required for updating the current frame time. We can
     // only check for this in the multi-threaded case, since in the single-
@@ -820,7 +820,7 @@ class LayerTreeHostTestFrameTimeUpdatesAfterDraw : public LayerTreeHostTest {
       EXPECT_EQ(0, frame_);
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   int frame_;
@@ -835,7 +835,7 @@ class LayerTreeHostTestStartPageScaleAnimation : public LayerTreeHostTest {
  public:
   LayerTreeHostTestStartPageScaleAnimation() {}
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     LayerTreeHostTest::SetupTree();
 
     if (layer_tree_host()->settings().impl_side_painting) {
@@ -861,18 +861,18 @@ class LayerTreeHostTestStartPageScaleAnimation : public LayerTreeHostTest {
     layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.5f, 2.f);
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   virtual void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
                                    float scale,
-                                   float) OVERRIDE {
+                                   float) override {
     gfx::ScrollOffset offset = scroll_layer_->scroll_offset();
     scroll_layer_->SetScrollOffset(ScrollOffsetWithDelta(offset,
                                                          scroll_delta));
     layer_tree_host()->SetPageScaleFactorAndLimits(scale, 0.5f, 2.f);
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     // We get one commit before the first draw, and the animation doesn't happen
     // until the second draw.
     switch (impl->active_tree()->source_frame_number()) {
@@ -892,7 +892,7 @@ class LayerTreeHostTestStartPageScaleAnimation : public LayerTreeHostTest {
     }
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         layer_tree_host()->StartPageScaleAnimation(
@@ -901,7 +901,7 @@ class LayerTreeHostTestStartPageScaleAnimation : public LayerTreeHostTest {
     }
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   FakeContentLayerClient client_;
   scoped_refptr<Layer> scroll_layer_;
@@ -913,7 +913,7 @@ class LayerTreeHostTestSetVisible : public LayerTreeHostTest {
  public:
   LayerTreeHostTestSetVisible() : num_draws_(0) {}
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostSetNeedsCommitToMainThread();
     PostSetVisibleToMainThread(false);
     // This is suppressed while we're invisible.
@@ -922,13 +922,13 @@ class LayerTreeHostTestSetVisible : public LayerTreeHostTest {
     PostSetVisibleToMainThread(true);
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     EXPECT_TRUE(impl->visible());
     ++num_draws_;
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE { EXPECT_EQ(1, num_draws_); }
+  virtual void AfterTest() override { EXPECT_EQ(1, num_draws_); }
 
  private:
   int num_draws_;
@@ -945,13 +945,13 @@ class TestOpacityChangeLayerDelegate : public ContentLayerClient {
   virtual void PaintContents(
       SkCanvas* canvas,
       const gfx::Rect& clip,
-      ContentLayerClient::GraphicsContextStatus gc_status) OVERRIDE {
+      ContentLayerClient::GraphicsContextStatus gc_status) override {
     // Set layer opacity to 0.
     if (test_layer_)
       test_layer_->SetOpacity(0.f);
   }
-  virtual void DidChangeLayerCanUseLCDText() OVERRIDE {}
-  virtual bool FillsBoundsCompletely() const OVERRIDE { return false; }
+  virtual void DidChangeLayerCanUseLCDText() override {}
+  virtual bool FillsBoundsCompletely() const override { return false; }
 
  private:
   Layer* test_layer_;
@@ -968,7 +968,7 @@ class ContentLayerWithUpdateTracking : public ContentLayer {
   void ResetPaintContentsCount() { paint_contents_count_ = 0; }
 
   virtual bool Update(ResourceUpdateQueue* queue,
-                      const OcclusionTracker<Layer>* occlusion) OVERRIDE {
+                      const OcclusionTracker<Layer>* occlusion) override {
     bool updated = ContentLayer::Update(queue, occlusion);
     paint_contents_count_++;
     return updated;
@@ -996,18 +996,18 @@ class LayerTreeHostTestOpacityChange : public LayerTreeHostTest {
     test_opacity_change_delegate_.SetTestLayer(update_check_layer_.get());
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     layer_tree_host()->SetViewportSize(gfx::Size(10, 10));
     layer_tree_host()->root_layer()->AddChild(update_check_layer_);
 
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     // Update() should have been called once.
     EXPECT_EQ(1, update_check_layer_->PaintContentsCount());
   }
@@ -1028,7 +1028,7 @@ class NoScaleContentLayer : public ContentLayer {
   virtual void CalculateContentsScale(float ideal_contents_scale,
                                       float* contents_scale_x,
                                       float* contents_scale_y,
-                                      gfx::Size* contentBounds) OVERRIDE {
+                                      gfx::Size* contentBounds) override {
     // Skip over the ContentLayer's method to the base Layer class.
     Layer::CalculateContentsScale(ideal_contents_scale,
                                   contents_scale_x,
@@ -1049,7 +1049,7 @@ class LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers
       : root_layer_(NoScaleContentLayer::Create(&client_)),
         child_layer_(ContentLayer::Create(&client_)) {}
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     layer_tree_host()->SetViewportSize(gfx::Size(60, 60));
     layer_tree_host()->SetDeviceScaleFactor(1.5);
     EXPECT_EQ(gfx::Size(60, 60), layer_tree_host()->device_viewport_size());
@@ -1068,7 +1068,7 @@ class LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     // Should only do one commit.
     EXPECT_EQ(0, impl->active_tree()->source_frame_number());
     // Device scale factor should come over to impl.
@@ -1134,7 +1134,7 @@ class LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   FakeContentLayerClient client_;
@@ -1147,7 +1147,7 @@ MULTI_THREAD_TEST_F(LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers);
 // Verify atomicity of commits and reuse of textures.
 class LayerTreeHostTestDirectRendererAtomicCommit : public LayerTreeHostTest {
  public:
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     settings->texture_id_allocation_chunk_size = 1;
     // Make sure partial texture updates are turned off.
     settings->max_partial_texture_updates = 0;
@@ -1155,7 +1155,7 @@ class LayerTreeHostTestDirectRendererAtomicCommit : public LayerTreeHostTest {
     settings->scrollbar_animator = LayerTreeSettings::NoAnimator;
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     layer_ = FakeContentLayer::Create(&client_);
     layer_->SetBounds(gfx::Size(10, 20));
 
@@ -1172,12 +1172,12 @@ class LayerTreeHostTestDirectRendererAtomicCommit : public LayerTreeHostTest {
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     drew_frame_ = -1;
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     ASSERT_EQ(0u, layer_tree_host()->settings().max_partial_texture_updates);
 
     TestWebGraphicsContext3D* context = TestContext();
@@ -1218,7 +1218,7 @@ class LayerTreeHostTestDirectRendererAtomicCommit : public LayerTreeHostTest {
     }
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     TestWebGraphicsContext3D* context = TestContext();
 
     if (drew_frame_ == impl->active_tree()->source_frame_number()) {
@@ -1235,12 +1235,12 @@ class LayerTreeHostTestDirectRendererAtomicCommit : public LayerTreeHostTest {
       PostSetNeedsCommitToMainThread();
   }
 
-  virtual void Layout() OVERRIDE {
+  virtual void Layout() override {
     layer_->SetNeedsDisplay();
     scrollbar_->SetNeedsDisplay();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  protected:
   FakeContentLayerClient client_;
@@ -1255,7 +1255,7 @@ MULTI_THREAD_DIRECT_RENDERER_NOIMPL_TEST_F(
 class LayerTreeHostTestDelegatingRendererAtomicCommit
     : public LayerTreeHostTestDirectRendererAtomicCommit {
  public:
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     ASSERT_EQ(0u, layer_tree_host()->settings().max_partial_texture_updates);
 
     TestWebGraphicsContext3D* context = TestContext();
@@ -1322,7 +1322,7 @@ static void SetLayerPropertiesForTesting(Layer* layer,
 class LayerTreeHostTestAtomicCommitWithPartialUpdate
     : public LayerTreeHostTest {
  public:
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     settings->texture_id_allocation_chunk_size = 1;
     // Allow one partial texture update.
     settings->max_partial_texture_updates = 1;
@@ -1330,7 +1330,7 @@ class LayerTreeHostTestAtomicCommitWithPartialUpdate
     settings->impl_side_painting = false;
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     parent_ = FakeContentLayer::Create(&client_);
     parent_->SetBounds(gfx::Size(10, 20));
 
@@ -1344,9 +1344,9 @@ class LayerTreeHostTestAtomicCommitWithPartialUpdate
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         parent_->SetNeedsDisplay();
@@ -1373,7 +1373,7 @@ class LayerTreeHostTestAtomicCommitWithPartialUpdate
     }
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     ASSERT_EQ(1u, layer_tree_host()->settings().max_partial_texture_updates);
 
     TestWebGraphicsContext3D* context = TestContext();
@@ -1463,7 +1463,7 @@ class LayerTreeHostTestAtomicCommitWithPartialUpdate
     }
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     EXPECT_LT(impl->active_tree()->source_frame_number(), 5);
 
     TestWebGraphicsContext3D* context = TestContext();
@@ -1480,7 +1480,7 @@ class LayerTreeHostTestAtomicCommitWithPartialUpdate
     context->ResetUsedTextures();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   FakeContentLayerClient client_;
@@ -1495,7 +1495,7 @@ SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
 class LayerTreeHostTestSurfaceNotAllocatedForLayersOutsideMemoryLimit
     : public LayerTreeHostTest {
  protected:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     root_layer_ = FakeContentLayer::Create(&client_);
     root_layer_->SetBounds(gfx::Size(100, 100));
 
@@ -1521,9 +1521,9 @@ class LayerTreeHostTestSurfaceNotAllocatedForLayersOutsideMemoryLimit
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     Renderer* renderer = host_impl->renderer();
     RenderPassId surface1_render_pass_id = host_impl->active_tree()
                                                ->root_layer()
@@ -1560,12 +1560,12 @@ class LayerTreeHostTestSurfaceNotAllocatedForLayersOutsideMemoryLimit
     }
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     if (layer_tree_host()->source_frame_number() < 2)
       root_layer_->SetNeedsDisplay();
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     EXPECT_LE(2u, root_layer_->update_count());
     EXPECT_LE(2u, surface_layer1_->update_count());
     EXPECT_LE(2u, surface_layer2_->update_count());
@@ -1590,13 +1590,13 @@ class EvictionTestLayer : public Layer {
   }
 
   virtual bool Update(ResourceUpdateQueue*,
-                      const OcclusionTracker<Layer>*) OVERRIDE;
-  virtual bool DrawsContent() const OVERRIDE { return true; }
+                      const OcclusionTracker<Layer>*) override;
+  virtual bool DrawsContent() const override { return true; }
 
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE;
-  virtual void PushPropertiesTo(LayerImpl* impl) OVERRIDE;
-  virtual void SetTexturePriorities(const PriorityCalculator&) OVERRIDE;
+      override;
+  virtual void PushPropertiesTo(LayerImpl* impl) override;
+  virtual void SetTexturePriorities(const PriorityCalculator&) override;
 
   bool HaveBackingTexture() const {
     return texture_.get() ? texture_->have_backing_texture() : false;
@@ -1629,7 +1629,7 @@ class EvictionTestLayerImpl : public LayerImpl {
 
   virtual void AppendQuads(RenderPass* render_pass,
                            const OcclusionTracker<LayerImpl>& occlusion_tracker,
-                           AppendQuadsData* append_quads_data) OVERRIDE {
+                           AppendQuadsData* append_quads_data) override {
     ASSERT_TRUE(has_texture_);
     ASSERT_NE(0u, layer_tree_impl()->resource_provider()->num_resources());
   }
@@ -1683,7 +1683,7 @@ class LayerTreeHostTestEvictTextures : public LayerTreeHostTest {
         impl_for_evict_textures_(0),
         num_commits_(0) {}
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     layer_tree_host()->SetRootLayer(layer_);
     layer_tree_host()->SetViewportSize(gfx::Size(10, 20));
 
@@ -1733,7 +1733,7 @@ class LayerTreeHostTestEvictTextures : public LayerTreeHostTest {
   // the beginFrame/commit pair.
   // Commits 5+6 test the path where an eviction happens during the eviction
   // recovery path.
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     switch (num_commits_) {
       case 1:
         EXPECT_TRUE(layer_->HaveBackingTexture());
@@ -1761,11 +1761,11 @@ class LayerTreeHostTestEvictTextures : public LayerTreeHostTest {
     }
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     impl_for_evict_textures_ = impl;
   }
 
-  virtual void Layout() OVERRIDE {
+  virtual void Layout() override {
     ++num_commits_;
     switch (num_commits_) {
       case 1:
@@ -1794,7 +1794,7 @@ class LayerTreeHostTestEvictTextures : public LayerTreeHostTest {
     }
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   FakeContentLayerClient client_;
@@ -1810,7 +1810,7 @@ class LayerTreeHostTestContinuousInvalidate : public LayerTreeHostTest {
   LayerTreeHostTestContinuousInvalidate()
       : num_commit_complete_(0), num_draw_layers_(0) {}
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     layer_tree_host()->SetViewportSize(gfx::Size(10, 10));
     layer_tree_host()->root_layer()->SetBounds(gfx::Size(10, 10));
 
@@ -1823,24 +1823,24 @@ class LayerTreeHostTestContinuousInvalidate : public LayerTreeHostTest {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     if (num_draw_layers_ == 2)
       return;
     content_layer_->SetNeedsDisplay();
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     if (num_draw_layers_ == 1)
       num_commit_complete_++;
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     num_draw_layers_++;
     if (num_draw_layers_ == 2)
       EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     // Check that we didn't commit twice between first and second draw.
     EXPECT_EQ(1, num_commit_complete_);
   }
@@ -1859,14 +1859,14 @@ class LayerTreeHostTestDeferCommits : public LayerTreeHostTest {
   LayerTreeHostTestDeferCommits()
       : num_commits_deferred_(0), num_complete_commits_(0) {}
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DidDeferCommit() OVERRIDE {
+  virtual void DidDeferCommit() override {
     num_commits_deferred_++;
     layer_tree_host()->SetDeferCommits(false);
   }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     num_complete_commits_++;
     switch (num_complete_commits_) {
       case 1:
@@ -1883,7 +1883,7 @@ class LayerTreeHostTestDeferCommits : public LayerTreeHostTest {
     }
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     EXPECT_EQ(1, num_commits_deferred_);
     EXPECT_EQ(2, num_complete_commits_);
   }
@@ -2056,7 +2056,7 @@ class LayerTreeHostTestShutdownWithOnlySomeResourcesEvicted
         child_layer2_(FakeContentLayer::Create(&client_)),
         num_commits_(0) {}
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     layer_tree_host()->SetViewportSize(gfx::Size(100, 100));
     root_layer_->SetBounds(gfx::Size(100, 100));
     child_layer1_->SetBounds(gfx::Size(100, 100));
@@ -2068,7 +2068,7 @@ class LayerTreeHostTestShutdownWithOnlySomeResourcesEvicted
   }
 
   virtual void DidSetVisibleOnImplTree(LayerTreeHostImpl* host_impl,
-                                       bool visible) OVERRIDE {
+                                       bool visible) override {
     if (visible) {
       // One backing should remain unevicted.
       EXPECT_EQ(
@@ -2086,7 +2086,7 @@ class LayerTreeHostTestShutdownWithOnlySomeResourcesEvicted
     EndTest();
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     ++num_commits_;
     switch (num_commits_) {
       case 1:
@@ -2118,7 +2118,7 @@ class LayerTreeHostTestShutdownWithOnlySomeResourcesEvicted
     }
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   FakeContentLayerClient client_;
@@ -2145,14 +2145,14 @@ class LayerTreeHostTestLCDNotification : public LayerTreeHostTest {
     virtual void PaintContents(
         SkCanvas* canvas,
         const gfx::Rect& clip,
-        ContentLayerClient::GraphicsContextStatus gc_status) OVERRIDE {
+        ContentLayerClient::GraphicsContextStatus gc_status) override {
       ++paint_count_;
     }
-    virtual void DidChangeLayerCanUseLCDText() OVERRIDE {
+    virtual void DidChangeLayerCanUseLCDText() override {
       ++lcd_notification_count_;
       layer_->SetNeedsDisplay();
     }
-    virtual bool FillsBoundsCompletely() const OVERRIDE { return false; }
+    virtual bool FillsBoundsCompletely() const override { return false; }
 
    private:
     Layer* layer_;
@@ -2160,7 +2160,7 @@ class LayerTreeHostTestLCDNotification : public LayerTreeHostTest {
     int lcd_notification_count_;
   };
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     scoped_refptr<Layer> root_layer;
     if (layer_tree_host()->settings().impl_side_painting)
       root_layer = PictureLayer::Create(&client_);
@@ -2180,10 +2180,10 @@ class LayerTreeHostTestLCDNotification : public LayerTreeHostTest {
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
-  virtual void AfterTest() OVERRIDE {}
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
+  virtual void AfterTest() override {}
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // The first update consists of one LCD notification and one paint.
@@ -2228,11 +2228,11 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestLCDNotification);
 // Verify that the BeginFrame notification is used to initiate rendering.
 class LayerTreeHostTestBeginFrameNotification : public LayerTreeHostTest {
  public:
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     settings->begin_frame_scheduling_enabled = true;
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     // This will trigger a SetNeedsBeginFrame which will trigger a
     // BeginFrame.
     PostSetNeedsCommitToMainThread();
@@ -2241,12 +2241,12 @@ class LayerTreeHostTestBeginFrameNotification : public LayerTreeHostTest {
   virtual DrawResult PrepareToDrawOnThread(
       LayerTreeHostImpl* host_impl,
       LayerTreeHostImpl::FrameData* frame,
-      DrawResult draw_result) OVERRIDE {
+      DrawResult draw_result) override {
     EndTest();
     return DRAW_SUCCESS;
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   base::TimeTicks frame_time_;
@@ -2257,14 +2257,14 @@ MULTI_THREAD_TEST_F(LayerTreeHostTestBeginFrameNotification);
 class LayerTreeHostTestBeginFrameNotificationShutdownWhileEnabled
     : public LayerTreeHostTest {
  public:
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     settings->begin_frame_scheduling_enabled = true;
     settings->using_synchronous_renderer_compositor = true;
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     // The BeginFrame notification is turned off now but will get enabled
     // once we return. End test while it's enabled.
     ImplThreadTaskRunner()->PostTask(
@@ -2273,7 +2273,7 @@ class LayerTreeHostTestBeginFrameNotificationShutdownWhileEnabled
                    base::Unretained(this)));
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 };
 
 MULTI_THREAD_TEST_F(
@@ -2284,13 +2284,13 @@ class LayerTreeHostTestAbortedCommitDoesntStall : public LayerTreeHostTest {
   LayerTreeHostTestAbortedCommitDoesntStall()
       : commit_count_(0), commit_abort_count_(0), commit_complete_count_(0) {}
 
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     settings->begin_frame_scheduling_enabled = true;
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     commit_count_++;
     if (commit_count_ == 4) {
       // After two aborted commits, request a real commit now to make sure a
@@ -2301,13 +2301,13 @@ class LayerTreeHostTestAbortedCommitDoesntStall : public LayerTreeHostTest {
   }
 
   virtual void BeginMainFrameAbortedOnThread(LayerTreeHostImpl* host_impl,
-                                             bool did_handle) OVERRIDE {
+                                             bool did_handle) override {
     commit_abort_count_++;
     // Initiate another abortable commit.
     host_impl->SetNeedsCommit();
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     commit_complete_count_++;
     if (commit_complete_count_ == 1) {
       // Initiate an abortable commit after the first commit.
@@ -2317,7 +2317,7 @@ class LayerTreeHostTestAbortedCommitDoesntStall : public LayerTreeHostTest {
     }
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     EXPECT_EQ(commit_count_, 5);
     EXPECT_EQ(commit_abort_count_, 3);
     EXPECT_EQ(commit_complete_count_, 2);
@@ -2330,7 +2330,7 @@ class LayerTreeHostTestAbortedCommitDoesntStall : public LayerTreeHostTest {
 
 class LayerTreeHostTestAbortedCommitDoesntStallSynchronousCompositor
     : public LayerTreeHostTestAbortedCommitDoesntStall {
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     LayerTreeHostTestAbortedCommitDoesntStall::InitializeSettings(settings);
     settings->using_synchronous_renderer_compositor = true;
   }
@@ -2341,7 +2341,7 @@ MULTI_THREAD_TEST_F(
 
 class LayerTreeHostTestAbortedCommitDoesntStallDisabledVsync
     : public LayerTreeHostTestAbortedCommitDoesntStall {
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     LayerTreeHostTestAbortedCommitDoesntStall::InitializeSettings(settings);
     settings->throttle_frame_production = false;
   }
@@ -2352,11 +2352,11 @@ MULTI_THREAD_TEST_F(LayerTreeHostTestAbortedCommitDoesntStallDisabledVsync);
 class LayerTreeHostTestUninvertibleTransformDoesNotBlockActivation
     : public LayerTreeHostTest {
  protected:
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     settings->impl_side_painting = true;
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     LayerTreeHostTest::SetupTree();
 
     scoped_refptr<Layer> layer = PictureLayer::Create(&client_);
@@ -2365,13 +2365,13 @@ class LayerTreeHostTestUninvertibleTransformDoesNotBlockActivation
     layer_tree_host()->root_layer()->AddChild(layer);
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   FakeContentLayerClient client_;
 };
@@ -2391,13 +2391,13 @@ class LayerTreeHostTestChangeLayerPropertiesInPaintContents
     virtual void PaintContents(
         SkCanvas* canvas,
         const gfx::Rect& clip,
-        ContentLayerClient::GraphicsContextStatus gc_status) OVERRIDE {
+        ContentLayerClient::GraphicsContextStatus gc_status) override {
       layer_->SetBounds(gfx::Size(2, 2));
     }
 
-    virtual void DidChangeLayerCanUseLCDText() OVERRIDE {}
+    virtual void DidChangeLayerCanUseLCDText() override {}
 
-    virtual bool FillsBoundsCompletely() const OVERRIDE { return false; }
+    virtual bool FillsBoundsCompletely() const override { return false; }
 
    private:
     Layer* layer_;
@@ -2405,7 +2405,7 @@ class LayerTreeHostTestChangeLayerPropertiesInPaintContents
 
   LayerTreeHostTestChangeLayerPropertiesInPaintContents() : num_commits_(0) {}
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     scoped_refptr<ContentLayer> root_layer = ContentLayer::Create(&client_);
     root_layer->SetIsDrawable(true);
     root_layer->SetBounds(gfx::Size(1, 1));
@@ -2416,10 +2416,10 @@ class LayerTreeHostTestChangeLayerPropertiesInPaintContents
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
-  virtual void AfterTest() OVERRIDE {}
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
+  virtual void AfterTest() override {}
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     num_commits_++;
     if (num_commits_ == 1) {
       LayerImpl* root_layer = host_impl->active_tree()->root_layer();
@@ -2445,7 +2445,7 @@ class MockIOSurfaceWebGraphicsContext3D : public TestWebGraphicsContext3D {
     test_capabilities_.gpu.texture_rectangle = true;
   }
 
-  virtual GLuint createTexture() OVERRIDE {
+  virtual GLuint createTexture() override {
     return 1;
   }
   MOCK_METHOD1(activeTexture, void(GLenum texture));
@@ -2471,7 +2471,7 @@ class MockIOSurfaceWebGraphicsContext3D : public TestWebGraphicsContext3D {
 class LayerTreeHostTestIOSurfaceDrawing : public LayerTreeHostTest {
  protected:
   virtual scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface(bool fallback)
-      OVERRIDE {
+      override {
     scoped_ptr<MockIOSurfaceWebGraphicsContext3D> mock_context_owned(
         new MockIOSurfaceWebGraphicsContext3D);
     mock_context_ = mock_context_owned.get();
@@ -2482,7 +2482,7 @@ class LayerTreeHostTestIOSurfaceDrawing : public LayerTreeHostTest {
       return FakeOutputSurface::Create3d(mock_context_owned.Pass());
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     LayerTreeHostTest::SetupTree();
 
     layer_tree_host()->root_layer()->SetIsDrawable(false);
@@ -2498,9 +2498,9 @@ class LayerTreeHostTestIOSurfaceDrawing : public LayerTreeHostTest {
     layer_tree_host()->root_layer()->AddChild(io_surface_layer);
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     EXPECT_EQ(0u, host_impl->resource_provider()->num_resources());
     // In WillDraw, the IOSurfaceLayer sets up the io surface texture.
 
@@ -2541,7 +2541,7 @@ class LayerTreeHostTestIOSurfaceDrawing : public LayerTreeHostTest {
   virtual DrawResult PrepareToDrawOnThread(
       LayerTreeHostImpl* host_impl,
       LayerTreeHostImpl::FrameData* frame,
-      DrawResult draw_result) OVERRIDE {
+      DrawResult draw_result) override {
     Mock::VerifyAndClearExpectations(&mock_context_);
     ResourceProvider* resource_provider = host_impl->resource_provider();
     EXPECT_EQ(1u, resource_provider->num_resources());
@@ -2573,14 +2573,14 @@ class LayerTreeHostTestIOSurfaceDrawing : public LayerTreeHostTest {
     return draw_result;
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     Mock::VerifyAndClearExpectations(&mock_context_);
 
     EXPECT_CALL(*mock_context_, deleteTexture(1)).Times(AtLeast(1));
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   int io_surface_id_;
   MockIOSurfaceWebGraphicsContext3D* mock_context_;
@@ -2591,7 +2591,7 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestIOSurfaceDrawing);
 
 class LayerTreeHostTestNumFramesPending : public LayerTreeHostTest {
  public:
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     frame_ = 0;
     PostSetNeedsCommitToMainThread();
   }
@@ -2600,7 +2600,7 @@ class LayerTreeHostTestNumFramesPending : public LayerTreeHostTest {
   // Round 2: commit only (no draw/swap)
   // Round 3: draw only (no commit)
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     int commit = layer_tree_host()->source_frame_number();
     switch (commit) {
       case 2:
@@ -2611,7 +2611,7 @@ class LayerTreeHostTestNumFramesPending : public LayerTreeHostTest {
     }
   }
 
-  virtual void DidCompleteSwapBuffers() OVERRIDE {
+  virtual void DidCompleteSwapBuffers() override {
     int commit = layer_tree_host()->source_frame_number();
     ++frame_;
     switch (frame_) {
@@ -2628,7 +2628,7 @@ class LayerTreeHostTestNumFramesPending : public LayerTreeHostTest {
     }
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  protected:
   int frame_;
@@ -2645,12 +2645,12 @@ TEST_F(LayerTreeHostTestNumFramesPending, DISABLED_GLRenderer) {
 
 class LayerTreeHostTestDeferredInitialize : public LayerTreeHostTest {
  public:
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     // PictureLayer can only be used with impl side painting enabled.
     settings->impl_side_painting = true;
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     layer_ = FakePictureLayer::Create(&client_);
     // Force commits to not be aborted so new frames get drawn, otherwise
     // the renderer gets deferred initialized but nothing new needs drawing.
@@ -2659,7 +2659,7 @@ class LayerTreeHostTestDeferredInitialize : public LayerTreeHostTest {
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     did_initialize_gl_ = false;
     did_release_gl_ = false;
     last_source_frame_number_drawn_ = -1;  // Never drawn.
@@ -2667,7 +2667,7 @@ class LayerTreeHostTestDeferredInitialize : public LayerTreeHostTest {
   }
 
   virtual scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface(bool fallback)
-      OVERRIDE {
+      override {
     scoped_ptr<TestWebGraphicsContext3D> context3d(
         TestWebGraphicsContext3D::Create());
 
@@ -2676,7 +2676,7 @@ class LayerTreeHostTestDeferredInitialize : public LayerTreeHostTest {
         delegating_renderer());
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     ASSERT_TRUE(host_impl->RootLayer());
     FakePictureLayerImpl* layer_impl =
         static_cast<FakePictureLayerImpl*>(host_impl->RootLayer());
@@ -2733,7 +2733,7 @@ class LayerTreeHostTestDeferredInitialize : public LayerTreeHostTest {
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
-                                   bool result) OVERRIDE {
+                                   bool result) override {
     ASSERT_TRUE(result);
     DelegatedFrameData* delegated_frame_data =
         output_surface()->last_sent_frame().delegated_frame_data.get();
@@ -2750,7 +2750,7 @@ class LayerTreeHostTestDeferredInitialize : public LayerTreeHostTest {
     host_impl->ReclaimResources(&ack);
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     EXPECT_TRUE(did_initialize_gl_);
     EXPECT_TRUE(did_release_gl_);
   }
@@ -2767,7 +2767,7 @@ MULTI_THREAD_TEST_F(LayerTreeHostTestDeferredInitialize);
 
 class LayerTreeHostTestDeferredInitializeWithGpuRasterization
     : public LayerTreeHostTestDeferredInitialize {
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     // PictureLayer can only be used with impl side painting enabled.
     settings->impl_side_painting = true;
     settings->gpu_rasterization_enabled = true;
@@ -2782,13 +2782,13 @@ class LayerTreeHostTestUIResource : public LayerTreeHostTest {
  public:
   LayerTreeHostTestUIResource() : num_ui_resources_(0) {}
 
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     settings->texture_id_allocation_chunk_size = 1;
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     int frame = layer_tree_host()->source_frame_number();
     switch (frame) {
       case 1:
@@ -2849,17 +2849,17 @@ class LayerTreeHostTestUIResource : public LayerTreeHostTest {
     }
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     if (!layer_tree_host()->settings().impl_side_painting)
       PerformTest(impl);
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     if (layer_tree_host()->settings().impl_side_painting)
       PerformTest(impl);
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   // Must clear all resources before exiting.
@@ -2888,7 +2888,7 @@ class PushPropertiesCountingLayerImpl : public LayerImpl {
 
   virtual ~PushPropertiesCountingLayerImpl() {}
 
-  virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE {
+  virtual void PushPropertiesTo(LayerImpl* layer) override {
     LayerImpl::PushPropertiesTo(layer);
     push_properties_count_++;
     // Push state to the active tree because we can only access it from there.
@@ -2897,7 +2897,7 @@ class PushPropertiesCountingLayerImpl : public LayerImpl {
   }
 
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE {
+      override {
     return PushPropertiesCountingLayerImpl::Create(tree_impl, id());
   }
 
@@ -2920,7 +2920,7 @@ class PushPropertiesCountingLayer : public Layer {
     return new PushPropertiesCountingLayer();
   }
 
-  virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE {
+  virtual void PushPropertiesTo(LayerImpl* layer) override {
     Layer::PushPropertiesTo(layer);
     push_properties_count_++;
     if (persist_needs_push_properties_)
@@ -2928,7 +2928,7 @@ class PushPropertiesCountingLayer : public Layer {
   }
 
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE {
+      override {
     return PushPropertiesCountingLayerImpl::Create(tree_impl, id());
   }
 
@@ -2954,7 +2954,7 @@ class PushPropertiesCountingLayer : public Layer {
 
 class LayerTreeHostTestLayersPushProperties : public LayerTreeHostTest {
  protected:
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     num_commits_ = 0;
     expected_push_properties_root_ = 0;
     expected_push_properties_child_ = 0;
@@ -2965,7 +2965,7 @@ class LayerTreeHostTestLayersPushProperties : public LayerTreeHostTest {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     root_ = PushPropertiesCountingLayer::Create();
     child_ = PushPropertiesCountingLayer::Create();
     child2_ = PushPropertiesCountingLayer::Create();
@@ -2984,7 +2984,7 @@ class LayerTreeHostTestLayersPushProperties : public LayerTreeHostTest {
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     ++num_commits_;
 
     EXPECT_EQ(expected_push_properties_root_, root_->push_properties_count());
@@ -3124,7 +3124,7 @@ class LayerTreeHostTestLayersPushProperties : public LayerTreeHostTest {
       ++expected_push_properties_leaf_layer_;
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   int num_commits_;
   FakeContentLayerClient client_;
@@ -3147,7 +3147,7 @@ MULTI_THREAD_TEST_F(LayerTreeHostTestLayersPushProperties);
 class LayerTreeHostTestImplLayersPushProperties
     : public LayerTreeHostTestLayersPushProperties {
  protected:
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     expected_push_properties_root_impl_ = 0;
     expected_push_properties_child_impl_ = 0;
     expected_push_properties_grandchild_impl_ = 0;
@@ -3156,7 +3156,7 @@ class LayerTreeHostTestImplLayersPushProperties
     LayerTreeHostTestLayersPushProperties::BeginTest();
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     // These commits are in response to the changes made in
     // LayerTreeHostTestLayersPushProperties::DidCommitAndDrawFrame()
     switch (num_commits_) {
@@ -3347,9 +3347,9 @@ TEST_F(LayerTreeHostTestImplLayersPushProperties, DelegatingRenderer) {
 class LayerTreeHostTestPropertyChangesDuringUpdateArePushed
     : public LayerTreeHostTest {
  protected:
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     root_ = Layer::Create();
     root_->SetBounds(gfx::Size(1, 1));
 
@@ -3364,7 +3364,7 @@ class LayerTreeHostTestPropertyChangesDuringUpdateArePushed
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 0:
         break;
@@ -3393,7 +3393,7 @@ class LayerTreeHostTestPropertyChangesDuringUpdateArePushed
     }
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   scoped_refptr<Layer> root_;
   scoped_refptr<FakePaintedScrollbarLayer> scrollbar_layer_;
@@ -3403,9 +3403,9 @@ MULTI_THREAD_TEST_F(LayerTreeHostTestPropertyChangesDuringUpdateArePushed);
 
 class LayerTreeHostTestSetDrawableCausesCommit : public LayerTreeHostTest {
  protected:
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     root_ = PushPropertiesCountingLayer::Create();
     child_ = PushPropertiesCountingLayer::Create();
     root_->AddChild(child_);
@@ -3414,7 +3414,7 @@ class LayerTreeHostTestSetDrawableCausesCommit : public LayerTreeHostTest {
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 0:
         break;
@@ -3446,7 +3446,7 @@ class LayerTreeHostTestSetDrawableCausesCommit : public LayerTreeHostTest {
     }
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   scoped_refptr<PushPropertiesCountingLayer> root_;
   scoped_refptr<PushPropertiesCountingLayer> child_;
@@ -3457,7 +3457,7 @@ MULTI_THREAD_TEST_F(LayerTreeHostTestSetDrawableCausesCommit);
 class LayerTreeHostTestCasePushPropertiesThreeGrandChildren
     : public LayerTreeHostTest {
  protected:
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     expected_push_properties_root_ = 0;
     expected_push_properties_child_ = 0;
     expected_push_properties_grandchild1_ = 0;
@@ -3466,7 +3466,7 @@ class LayerTreeHostTestCasePushPropertiesThreeGrandChildren
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     root_ = PushPropertiesCountingLayer::Create();
     child_ = PushPropertiesCountingLayer::Create();
     grandchild1_ = PushPropertiesCountingLayer::Create();
@@ -3482,7 +3482,7 @@ class LayerTreeHostTestCasePushPropertiesThreeGrandChildren
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   FakeContentLayerClient client_;
   scoped_refptr<PushPropertiesCountingLayer> root_;
@@ -3500,7 +3500,7 @@ class LayerTreeHostTestCasePushPropertiesThreeGrandChildren
 class LayerTreeHostTestPushPropertiesAddingToTreeRequiresPush
     : public LayerTreeHostTestCasePushPropertiesThreeGrandChildren {
  protected:
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     int last_source_frame_number = layer_tree_host()->source_frame_number() - 1;
     switch (last_source_frame_number) {
       case 0:
@@ -3540,7 +3540,7 @@ MULTI_THREAD_TEST_F(LayerTreeHostTestPushPropertiesAddingToTreeRequiresPush);
 class LayerTreeHostTestPushPropertiesRemovingChildStopsRecursion
     : public LayerTreeHostTestCasePushPropertiesThreeGrandChildren {
  protected:
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     int last_source_frame_number = layer_tree_host()->source_frame_number() - 1;
     switch (last_source_frame_number) {
       case 0:
@@ -3623,7 +3623,7 @@ MULTI_THREAD_TEST_F(LayerTreeHostTestPushPropertiesRemovingChildStopsRecursion);
 class LayerTreeHostTestPushPropertiesRemovingChildStopsRecursionWithPersistence
     : public LayerTreeHostTestCasePushPropertiesThreeGrandChildren {
  protected:
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     int last_source_frame_number = layer_tree_host()->source_frame_number() - 1;
     switch (last_source_frame_number) {
       case 0:
@@ -3671,7 +3671,7 @@ MULTI_THREAD_TEST_F(
 class LayerTreeHostTestPushPropertiesSetPropertiesWhileOutsideTree
     : public LayerTreeHostTestCasePushPropertiesThreeGrandChildren {
  protected:
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     int last_source_frame_number = layer_tree_host()->source_frame_number() - 1;
     switch (last_source_frame_number) {
       case 0:
@@ -3739,7 +3739,7 @@ MULTI_THREAD_TEST_F(
 class LayerTreeHostTestPushPropertiesSetPropertyInParentThenChild
     : public LayerTreeHostTestCasePushPropertiesThreeGrandChildren {
  protected:
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     int last_source_frame_number = layer_tree_host()->source_frame_number() - 1;
     switch (last_source_frame_number) {
       case 0:
@@ -3803,7 +3803,7 @@ MULTI_THREAD_TEST_F(
 class LayerTreeHostTestPushPropertiesSetPropertyInChildThenParent
     : public LayerTreeHostTestCasePushPropertiesThreeGrandChildren {
  protected:
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     int last_source_frame_number = layer_tree_host()->source_frame_number() - 1;
     switch (last_source_frame_number) {
       case 0:
@@ -3870,7 +3870,7 @@ class LayerTreeHostTestTreeActivationCallback : public LayerTreeHostTest {
   LayerTreeHostTestTreeActivationCallback()
       : num_commits_(0), callback_count_(0) {}
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     EXPECT_TRUE(HasImplThread());
     PostSetNeedsCommitToMainThread();
   }
@@ -3878,7 +3878,7 @@ class LayerTreeHostTestTreeActivationCallback : public LayerTreeHostTest {
   virtual DrawResult PrepareToDrawOnThread(
       LayerTreeHostImpl* host_impl,
       LayerTreeHostImpl::FrameData* frame_data,
-      DrawResult draw_result) OVERRIDE {
+      DrawResult draw_result) override {
     ++num_commits_;
     switch (num_commits_) {
       case 1:
@@ -3907,7 +3907,7 @@ class LayerTreeHostTestTreeActivationCallback : public LayerTreeHostTest {
         host_impl, frame_data, draw_result);
   }
 
-  virtual void AfterTest() OVERRIDE { EXPECT_EQ(3, num_commits_); }
+  virtual void AfterTest() override { EXPECT_EQ(3, num_commits_); }
 
   void SetCallback(bool enable) {
     output_surface()->SetTreeActivationCallback(
@@ -3936,7 +3936,7 @@ class LayerInvalidateCausesDraw : public LayerTreeHostTest {
  public:
   LayerInvalidateCausesDraw() : num_commits_(0), num_draws_(0) {}
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     ASSERT_TRUE(!!invalidate_layer_.get())
         << "Derived tests must set this in SetupTree";
 
@@ -3944,23 +3944,23 @@ class LayerInvalidateCausesDraw : public LayerTreeHostTest {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     // After commit, invalidate the layer.  This should cause a commit.
     if (layer_tree_host()->source_frame_number() == 1)
       invalidate_layer_->SetNeedsDisplay();
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     num_draws_++;
     if (impl->active_tree()->source_frame_number() == 1)
       EndTest();
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     num_commits_++;
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     EXPECT_GE(2, num_commits_);
     EXPECT_GE(2, num_draws_);
   }
@@ -3978,7 +3978,7 @@ class LayerInvalidateCausesDraw : public LayerTreeHostTest {
 // response to that invalidation.
 class LayerTreeHostTestVideoLayerInvalidate : public LayerInvalidateCausesDraw {
  public:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     LayerTreeHostTest::SetupTree();
     scoped_refptr<VideoLayer> video_layer =
         VideoLayer::Create(&provider_, media::VIDEO_ROTATION_0);
@@ -4001,7 +4001,7 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestVideoLayerInvalidate);
 class LayerTreeHostTestIOSurfaceLayerInvalidate
     : public LayerInvalidateCausesDraw {
  public:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     LayerTreeHostTest::SetupTree();
     scoped_refptr<IOSurfaceLayer> layer = IOSurfaceLayer::Create();
     layer->SetBounds(gfx::Size(10, 10));
@@ -4020,7 +4020,7 @@ SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
 
 class LayerTreeHostTestPushHiddenLayer : public LayerTreeHostTest {
  protected:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     root_layer_ = Layer::Create();
     root_layer_->SetPosition(gfx::Point());
     root_layer_->SetBounds(gfx::Size(10, 10));
@@ -4041,9 +4041,9 @@ class LayerTreeHostTestPushHiddenLayer : public LayerTreeHostTest {
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // The layer type used does not need to push properties every frame.
@@ -4063,7 +4063,7 @@ class LayerTreeHostTestPushHiddenLayer : public LayerTreeHostTest {
     }
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* root = impl->active_tree()->root_layer();
     LayerImpl* parent = root->children()[0];
     LayerImpl* child = parent->children()[0];
@@ -4075,7 +4075,7 @@ class LayerTreeHostTestPushHiddenLayer : public LayerTreeHostTest {
     }
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   scoped_refptr<Layer> root_layer_;
   scoped_refptr<SolidColorLayer> parent_layer_;
@@ -4086,11 +4086,11 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestPushHiddenLayer);
 
 class LayerTreeHostTestUpdateLayerInEmptyViewport : public LayerTreeHostTest {
  protected:
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     settings->impl_side_painting = true;
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     root_layer_ = FakePictureLayer::Create(&client_);
     root_layer_->SetBounds(gfx::Size(10, 10));
 
@@ -4098,21 +4098,21 @@ class LayerTreeHostTestUpdateLayerInEmptyViewport : public LayerTreeHostTest {
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     // The viewport is empty, but we still need to update layers on the main
     // thread.
     layer_tree_host()->SetViewportSize(gfx::Size(0, 0));
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     // The layer should be updated even though the viewport is empty, so we
     // are capable of drawing it on the impl tree.
     EXPECT_GT(root_layer_->update_count(), 0u);
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> root_layer_;
@@ -4126,7 +4126,7 @@ class LayerTreeHostTestAbortEvictedTextures : public LayerTreeHostTest {
       : num_will_begin_main_frames_(0), num_impl_commits_(0) {}
 
  protected:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     scoped_refptr<SolidColorLayer> root_layer = SolidColorLayer::Create();
     root_layer->SetBounds(gfx::Size(200, 200));
     root_layer->SetIsDrawable(true);
@@ -4135,9 +4135,9 @@ class LayerTreeHostTestAbortEvictedTextures : public LayerTreeHostTest {
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void WillBeginMainFrame() OVERRIDE {
+  virtual void WillBeginMainFrame() override {
     num_will_begin_main_frames_++;
     switch (num_will_begin_main_frames_) {
       case 2:
@@ -4148,11 +4148,11 @@ class LayerTreeHostTestAbortEvictedTextures : public LayerTreeHostTest {
     }
   }
 
-  virtual void BeginCommitOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void BeginCommitOnThread(LayerTreeHostImpl* impl) override {
     num_impl_commits_++;
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     switch (impl->SourceAnimationFrameNumber()) {
       case 1:
         // Prevent draws until commit.
@@ -4167,7 +4167,7 @@ class LayerTreeHostTestAbortEvictedTextures : public LayerTreeHostTest {
     }
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     // Ensure that the commit was truly aborted.
     EXPECT_EQ(2, num_will_begin_main_frames_);
     EXPECT_EQ(1, num_impl_commits_);
@@ -4183,12 +4183,12 @@ MULTI_THREAD_TEST_F(LayerTreeHostTestAbortEvictedTextures);
 
 class LayerTreeHostTestMaxTransferBufferUsageBytes : public LayerTreeHostTest {
  protected:
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     settings->impl_side_painting = true;
   }
 
   virtual scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface(bool fallback)
-      OVERRIDE {
+      override {
     scoped_refptr<TestContextProvider> context_provider =
         TestContextProvider::Create();
     context_provider->SetMaxTransferBufferUsageBytes(1024 * 1024);
@@ -4198,7 +4198,7 @@ class LayerTreeHostTestMaxTransferBufferUsageBytes : public LayerTreeHostTest {
       return FakeOutputSurface::Create3d(context_provider);
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
     scoped_refptr<FakePictureLayer> root_layer =
         FakePictureLayer::Create(&client_);
@@ -4209,9 +4209,9 @@ class LayerTreeHostTestMaxTransferBufferUsageBytes : public LayerTreeHostTest {
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     TestWebGraphicsContext3D* context = TestContext();
 
     // Expect that the transfer buffer memory used is equal to the
@@ -4220,7 +4220,7 @@ class LayerTreeHostTestMaxTransferBufferUsageBytes : public LayerTreeHostTest {
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   FakeContentLayerClient client_;
@@ -4235,14 +4235,14 @@ class LayerTreeHostTestMemoryLimits : public LayerTreeHostTest {
  public:
   LayerTreeHostTestMemoryLimits() : num_commits_(0) {}
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void WillCommit() OVERRIDE {
+  virtual void WillCommit() override {
     // Some commits are aborted, so increment number of attempted commits here.
     num_commits_++;
   }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     switch (num_commits_) {
       case 1:
         // Verify default values.
@@ -4287,7 +4287,7 @@ class LayerTreeHostTestMemoryLimits : public LayerTreeHostTest {
     }
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     switch (num_commits_) {
       case 1:
         break;
@@ -4312,7 +4312,7 @@ class LayerTreeHostTestMemoryLimits : public LayerTreeHostTest {
     }
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   int num_commits_;
@@ -4330,7 +4330,7 @@ class LayerTreeHostTestSetMemoryPolicyOnLostOutputSurface
         second_output_surface_memory_limit_(1234321) {}
 
   virtual scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface(bool fallback)
-      OVERRIDE {
+      override {
     if (!first_context_provider_.get()) {
       first_context_provider_ = TestContextProvider::Create();
     } else {
@@ -4355,16 +4355,16 @@ class LayerTreeHostTestSetMemoryPolicyOnLostOutputSurface
     return output_surface.Pass();
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     root_ = FakeContentLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
     layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     // Lost context sometimes takes two frames to recreate. The third frame
     // is sometimes aborted, so wait until the fourth frame to verify that
     // the memory has been set, and the fifth frame to end the test.
@@ -4376,7 +4376,7 @@ class LayerTreeHostTestSetMemoryPolicyOnLostOutputSurface
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* impl,
-                                   bool result) OVERRIDE {
+                                   bool result) override {
     switch (impl->active_tree()->source_frame_number()) {
       case 1:
         EXPECT_EQ(first_output_surface_memory_limit_,
@@ -4392,7 +4392,7 @@ class LayerTreeHostTestSetMemoryPolicyOnLostOutputSurface
     }
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   scoped_refptr<TestContextProvider> first_context_provider_;
   scoped_refptr<TestContextProvider> second_context_provider_;
@@ -4429,14 +4429,14 @@ class TestSwapPromise : public SwapPromise {
     result_->dtor_called = true;
   }
 
-  virtual void DidSwap(CompositorFrameMetadata* metadata) OVERRIDE {
+  virtual void DidSwap(CompositorFrameMetadata* metadata) override {
     base::AutoLock lock(result_->lock);
     EXPECT_FALSE(result_->did_swap_called);
     EXPECT_FALSE(result_->did_not_swap_called);
     result_->did_swap_called = true;
   }
 
-  virtual void DidNotSwap(DidNotSwapReason reason) OVERRIDE {
+  virtual void DidNotSwap(DidNotSwapReason reason) override {
     base::AutoLock lock(result_->lock);
     EXPECT_FALSE(result_->did_swap_called);
     EXPECT_FALSE(result_->did_not_swap_called);
@@ -4444,7 +4444,7 @@ class TestSwapPromise : public SwapPromise {
     result_->reason = reason;
   }
 
-  virtual int64 TraceId() const OVERRIDE { return 0; }
+  virtual int64 TraceId() const override { return 0; }
 
  private:
   // Not owned.
@@ -4456,16 +4456,16 @@ class LayerTreeHostTestBreakSwapPromise : public LayerTreeHostTest {
   LayerTreeHostTestBreakSwapPromise()
       : commit_count_(0), commit_complete_count_(0) {}
 
-  virtual void WillBeginMainFrame() OVERRIDE {
+  virtual void WillBeginMainFrame() override {
     ASSERT_LE(commit_count_, 2);
     scoped_ptr<SwapPromise> swap_promise(
         new TestSwapPromise(&swap_promise_result_[commit_count_]));
     layer_tree_host()->QueueSwapPromise(swap_promise.Pass());
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     commit_count_++;
     if (commit_count_ == 2) {
       // This commit will finish.
@@ -4473,7 +4473,7 @@ class LayerTreeHostTestBreakSwapPromise : public LayerTreeHostTest {
     }
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     commit_complete_count_++;
     if (commit_complete_count_ == 1) {
       // This commit will be aborted because no actual update.
@@ -4483,7 +4483,7 @@ class LayerTreeHostTestBreakSwapPromise : public LayerTreeHostTest {
     }
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     // 3 commits are scheduled. 2 completes. 1 is aborted.
     EXPECT_EQ(commit_count_, 3);
     EXPECT_EQ(commit_complete_count_, 2);
@@ -4527,14 +4527,14 @@ MULTI_THREAD_TEST_F(LayerTreeHostTestBreakSwapPromise);
 class LayerTreeHostTestBreakSwapPromiseForVisibilityAbortedCommit
     : public LayerTreeHostTest {
  protected:
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     layer_tree_host()->SetDeferCommits(true);
     layer_tree_host()->SetNeedsCommit();
   }
 
-  virtual void DidDeferCommit() OVERRIDE {
+  virtual void DidDeferCommit() override {
     layer_tree_host()->SetVisible(false);
     scoped_ptr<SwapPromise> swap_promise(
         new TestSwapPromise(&swap_promise_result_));
@@ -4543,11 +4543,11 @@ class LayerTreeHostTestBreakSwapPromiseForVisibilityAbortedCommit
   }
 
   virtual void BeginMainFrameAbortedOnThread(LayerTreeHostImpl* host_impl,
-                                             bool did_handle) OVERRIDE {
+                                             bool did_handle) override {
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     {
       base::AutoLock lock(swap_promise_result_.lock);
       EXPECT_FALSE(swap_promise_result_.did_swap_called);
@@ -4566,16 +4566,16 @@ SINGLE_AND_MULTI_THREAD_TEST_F(
 class LayerTreeHostTestBreakSwapPromiseForContextAbortedCommit
     : public LayerTreeHostTest {
  protected:
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     if (TestEnded())
       return;
     layer_tree_host()->SetDeferCommits(true);
     layer_tree_host()->SetNeedsCommit();
   }
 
-  virtual void DidDeferCommit() OVERRIDE {
+  virtual void DidDeferCommit() override {
     layer_tree_host()->DidLoseOutputSurface();
     scoped_ptr<SwapPromise> swap_promise(
         new TestSwapPromise(&swap_promise_result_));
@@ -4584,7 +4584,7 @@ class LayerTreeHostTestBreakSwapPromiseForContextAbortedCommit
   }
 
   virtual void BeginMainFrameAbortedOnThread(LayerTreeHostImpl* host_impl,
-                                             bool did_handle) OVERRIDE {
+                                             bool did_handle) override {
     EndTest();
     // This lets the test finally commit and exit.
     MainThreadTaskRunner()->PostTask(
@@ -4598,7 +4598,7 @@ class LayerTreeHostTestBreakSwapPromiseForContextAbortedCommit
     layer_tree_host()->OnCreateAndInitializeOutputSurfaceAttempted(true);
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     {
       base::AutoLock lock(swap_promise_result_.lock);
       EXPECT_FALSE(swap_promise_result_.did_swap_called);
@@ -4625,15 +4625,15 @@ class SimpleSwapPromiseMonitor : public SwapPromiseMonitor {
 
   virtual ~SimpleSwapPromiseMonitor() {}
 
-  virtual void OnSetNeedsCommitOnMain() OVERRIDE {
+  virtual void OnSetNeedsCommitOnMain() override {
     (*set_needs_commit_count_)++;
   }
 
-  virtual void OnSetNeedsRedrawOnImpl() OVERRIDE {
+  virtual void OnSetNeedsRedrawOnImpl() override {
     ADD_FAILURE() << "Should not get called on main thread.";
   }
 
-  virtual void OnForwardScrollUpdateToMainThreadOnImpl() OVERRIDE {
+  virtual void OnForwardScrollUpdateToMainThreadOnImpl() override {
     ADD_FAILURE() << "Should not get called on main thread.";
   }
 
@@ -4643,9 +4643,9 @@ class SimpleSwapPromiseMonitor : public SwapPromiseMonitor {
 
 class LayerTreeHostTestSimpleSwapPromiseMonitor : public LayerTreeHostTest {
  public:
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void WillBeginMainFrame() OVERRIDE {
+  virtual void WillBeginMainFrame() override {
     if (TestEnded())
       return;
 
@@ -4694,7 +4694,7 @@ class LayerTreeHostTestSimpleSwapPromiseMonitor : public LayerTreeHostTest {
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSimpleSwapPromiseMonitor);
@@ -4702,18 +4702,18 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSimpleSwapPromiseMonitor);
 class LayerTreeHostTestHighResRequiredAfterEvictingUIResources
     : public LayerTreeHostTest {
  protected:
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     settings->impl_side_painting = true;
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     LayerTreeHostTest::SetupTree();
     ui_resource_ = FakeScopedUIResource::Create(layer_tree_host());
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     host_impl->EvictAllUIResources();
     // Existence of evicted UI resources will trigger NEW_CONTENT_TAKES_PRIORITY
     // mode. Active tree should require high-res to draw after entering this
@@ -4722,7 +4722,7 @@ class LayerTreeHostTestHighResRequiredAfterEvictingUIResources
     EXPECT_TRUE(host_impl->active_tree()->RequiresHighResToDraw());
   }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     int frame = layer_tree_host()->source_frame_number();
     switch (frame) {
       case 1:
@@ -4735,7 +4735,7 @@ class LayerTreeHostTestHighResRequiredAfterEvictingUIResources
     }
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   FakeContentLayerClient client_;
   scoped_ptr<FakeScopedUIResource> ui_resource_;
@@ -4746,14 +4746,14 @@ class LayerTreeHostTestHighResRequiredAfterEvictingUIResources
 
 class LayerTreeHostTestGpuRasterizationDefault : public LayerTreeHostTest {
  protected:
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     settings->impl_side_painting = true;
 
     EXPECT_FALSE(settings->gpu_rasterization_enabled);
     EXPECT_FALSE(settings->gpu_rasterization_forced);
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     LayerTreeHostTest::SetupTree();
 
     scoped_refptr<PictureLayer> layer = PictureLayer::Create(&layer_client_);
@@ -4762,7 +4762,7 @@ class LayerTreeHostTestGpuRasterizationDefault : public LayerTreeHostTest {
     layer_tree_host()->root_layer()->AddChild(layer);
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     Layer* root = layer_tree_host()->root_layer();
     PictureLayer* layer = static_cast<PictureLayer*>(root->child_at(0));
     PicturePile* pile = layer->GetPicturePileForTesting();
@@ -4782,18 +4782,18 @@ class LayerTreeHostTestGpuRasterizationDefault : public LayerTreeHostTest {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     EXPECT_FALSE(host_impl->pending_tree()->use_gpu_rasterization());
     EXPECT_FALSE(host_impl->use_gpu_rasterization());
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     EXPECT_FALSE(host_impl->active_tree()->use_gpu_rasterization());
     EXPECT_FALSE(host_impl->use_gpu_rasterization());
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   FakeContentLayerClient layer_client_;
 };
@@ -4802,14 +4802,14 @@ MULTI_THREAD_TEST_F(LayerTreeHostTestGpuRasterizationDefault);
 
 class LayerTreeHostTestGpuRasterizationEnabled : public LayerTreeHostTest {
  protected:
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     settings->impl_side_painting = true;
 
     EXPECT_FALSE(settings->gpu_rasterization_enabled);
     settings->gpu_rasterization_enabled = true;
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     LayerTreeHostTest::SetupTree();
 
     scoped_refptr<PictureLayer> layer = PictureLayer::Create(&layer_client_);
@@ -4818,7 +4818,7 @@ class LayerTreeHostTestGpuRasterizationEnabled : public LayerTreeHostTest {
     layer_tree_host()->root_layer()->AddChild(layer);
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     Layer* root = layer_tree_host()->root_layer();
     PictureLayer* layer = static_cast<PictureLayer*>(root->child_at(0));
     PicturePile* pile = layer->GetPicturePileForTesting();
@@ -4847,18 +4847,18 @@ class LayerTreeHostTestGpuRasterizationEnabled : public LayerTreeHostTest {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     EXPECT_FALSE(host_impl->pending_tree()->use_gpu_rasterization());
     EXPECT_FALSE(host_impl->use_gpu_rasterization());
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     EXPECT_FALSE(host_impl->active_tree()->use_gpu_rasterization());
     EXPECT_FALSE(host_impl->use_gpu_rasterization());
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   FakeContentLayerClient layer_client_;
 };
@@ -4867,14 +4867,14 @@ MULTI_THREAD_TEST_F(LayerTreeHostTestGpuRasterizationEnabled);
 
 class LayerTreeHostTestGpuRasterizationForced : public LayerTreeHostTest {
  protected:
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     settings->impl_side_painting = true;
 
     EXPECT_FALSE(settings->gpu_rasterization_forced);
     settings->gpu_rasterization_forced = true;
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     LayerTreeHostTest::SetupTree();
 
     scoped_refptr<PictureLayer> layer = PictureLayer::Create(&layer_client_);
@@ -4883,7 +4883,7 @@ class LayerTreeHostTestGpuRasterizationForced : public LayerTreeHostTest {
     layer_tree_host()->root_layer()->AddChild(layer);
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     Layer* root = layer_tree_host()->root_layer();
     PictureLayer* layer = static_cast<PictureLayer*>(root->child_at(0));
     PicturePile* pile = layer->GetPicturePileForTesting();
@@ -4912,18 +4912,18 @@ class LayerTreeHostTestGpuRasterizationForced : public LayerTreeHostTest {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     EXPECT_TRUE(host_impl->pending_tree()->use_gpu_rasterization());
     EXPECT_TRUE(host_impl->use_gpu_rasterization());
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     EXPECT_TRUE(host_impl->active_tree()->use_gpu_rasterization());
     EXPECT_TRUE(host_impl->use_gpu_rasterization());
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   FakeContentLayerClient layer_client_;
 };
@@ -4938,7 +4938,7 @@ class LayerTreeHostTestContinuousPainting : public LayerTreeHostTest {
  protected:
   enum { kExpectedNumCommits = 10 };
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     scoped_refptr<Layer> root_layer = Layer::Create();
     root_layer->SetBounds(bounds_);
 
@@ -4958,7 +4958,7 @@ class LayerTreeHostTestContinuousPainting : public LayerTreeHostTest {
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     MainThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(
@@ -4976,11 +4976,11 @@ class LayerTreeHostTestContinuousPainting : public LayerTreeHostTest {
                                           milliseconds_per_frame));
   }
 
-  virtual void BeginMainFrame(const BeginFrameArgs& args) OVERRIDE {
+  virtual void BeginMainFrame(const BeginFrameArgs& args) override {
     child_layer_->SetNeedsDisplay();
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     EXPECT_LE(kExpectedNumCommits, num_commits_);
     EXPECT_LE(kExpectedNumCommits, num_draws_);
     int update_count = content_layer_.get()
@@ -4989,12 +4989,12 @@ class LayerTreeHostTestContinuousPainting : public LayerTreeHostTest {
     EXPECT_LE(kExpectedNumCommits, update_count);
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     if (++num_draws_ == kExpectedNumCommits)
       EndTest();
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     ++num_commits_;
   }
 
@@ -5028,24 +5028,24 @@ class LayerTreeHostTestActivateOnInvisible : public LayerTreeHostTest {
   LayerTreeHostTestActivateOnInvisible()
       : activation_count_(0), visible_(true) {}
 
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     settings->impl_side_painting = true;
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     // Kick off the test with a commit.
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void BeginCommitOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void BeginCommitOnThread(LayerTreeHostImpl* host_impl) override {
     // Make sure we don't activate using the notify signal from tile manager.
     host_impl->BlockNotifyReadyToActivateForTesting(true);
   }
 
-  virtual void DidCommit() OVERRIDE { layer_tree_host()->SetVisible(false); }
+  virtual void DidCommit() override { layer_tree_host()->SetVisible(false); }
 
   virtual void DidSetVisibleOnImplTree(LayerTreeHostImpl* host_impl,
-                                       bool visible) OVERRIDE {
+                                       bool visible) override {
     visible_ = visible;
 
     // Once invisible, we can go visible again.
@@ -5057,12 +5057,12 @@ class LayerTreeHostTestActivateOnInvisible : public LayerTreeHostTest {
     }
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     ++activation_count_;
     EXPECT_FALSE(visible_);
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     // Ensure we activated even though the signal was blocked.
     EXPECT_EQ(1, activation_count_);
     EXPECT_TRUE(visible_);
diff --git a/cc/trees/layer_tree_host_unittest_animation.cc b/cc/trees/layer_tree_host_unittest_animation.cc
index da4acb9..593c5c7 100644
--- a/cc/trees/layer_tree_host_unittest_animation.cc
+++ b/cc/trees/layer_tree_host_unittest_animation.cc
@@ -21,7 +21,7 @@ namespace {
 
 class LayerTreeHostAnimationTest : public LayerTreeTest {
  public:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     LayerTreeTest::SetupTree();
     layer_tree_host()->root_layer()->set_layer_animation_delegate(this);
   }
@@ -35,11 +35,11 @@ class LayerTreeHostAnimationTestSetNeedsAnimateShouldNotSetCommitRequested
   LayerTreeHostAnimationTestSetNeedsAnimateShouldNotSetCommitRequested()
       : num_commits_(0) {}
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void BeginMainFrame(const BeginFrameArgs& args) OVERRIDE {
+  virtual void BeginMainFrame(const BeginFrameArgs& args) override {
     // We skip the first commit because its the commit that populates the
     // impl thread with a tree. After the second commit, the test is done.
     if (num_commits_ != 1)
@@ -52,7 +52,7 @@ class LayerTreeHostAnimationTestSetNeedsAnimateShouldNotSetCommitRequested
     // verify that CommitRequested has gone back to false.
   }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     if (!num_commits_) {
       EXPECT_FALSE(layer_tree_host()->CommitRequested());
       layer_tree_host()->SetNeedsAnimate();
@@ -66,7 +66,7 @@ class LayerTreeHostAnimationTestSetNeedsAnimateShouldNotSetCommitRequested
     num_commits_++;
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   int num_commits_;
@@ -86,11 +86,11 @@ class LayerTreeHostAnimationTestSetNeedsAnimateInsideAnimationCallback
   LayerTreeHostAnimationTestSetNeedsAnimateInsideAnimationCallback()
       : num_begin_frames_(0) {}
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void BeginMainFrame(const BeginFrameArgs& args) OVERRIDE {
+  virtual void BeginMainFrame(const BeginFrameArgs& args) override {
     if (!num_begin_frames_) {
       layer_tree_host()->SetNeedsAnimate();
       num_begin_frames_++;
@@ -99,7 +99,7 @@ class LayerTreeHostAnimationTestSetNeedsAnimateInsideAnimationCallback
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   int num_begin_frames_;
@@ -117,13 +117,13 @@ class LayerTreeHostAnimationTestAddAnimation
   LayerTreeHostAnimationTestAddAnimation()
       : num_begin_frames_(0), received_animation_started_notification_(false) {}
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostAddInstantAnimationToMainThread(layer_tree_host()->root_layer());
   }
 
   virtual void UpdateAnimationState(
       LayerTreeHostImpl* host_impl,
-      bool has_unfinished_animation) OVERRIDE {
+      bool has_unfinished_animation) override {
     if (!num_begin_frames_) {
       // The animation had zero duration so LayerTreeHostImpl should no
       // longer need to animate its layers.
@@ -148,7 +148,7 @@ class LayerTreeHostAnimationTestAddAnimation
 
   virtual void NotifyAnimationStarted(
       base::TimeTicks monotonic_time,
-      Animation::TargetProperty target_property) OVERRIDE {
+      Animation::TargetProperty target_property) override {
     received_animation_started_notification_ = true;
     start_time_ = monotonic_time;
     if (num_begin_frames_) {
@@ -165,7 +165,7 @@ class LayerTreeHostAnimationTestAddAnimation
     }
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   int num_begin_frames_;
@@ -183,17 +183,17 @@ class LayerTreeHostAnimationTestCheckerboardDoesNotStarveDraws
   LayerTreeHostAnimationTestCheckerboardDoesNotStarveDraws()
       : started_animating_(false) {}
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostAddAnimationToMainThread(layer_tree_host()->root_layer());
   }
 
   virtual void AnimateLayers(
       LayerTreeHostImpl* host_impl,
-      base::TimeTicks monotonic_time) OVERRIDE {
+      base::TimeTicks monotonic_time) override {
     started_animating_ = true;
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     if (started_animating_)
       EndTest();
   }
@@ -201,11 +201,11 @@ class LayerTreeHostAnimationTestCheckerboardDoesNotStarveDraws
   virtual DrawResult PrepareToDrawOnThread(
       LayerTreeHostImpl* host_impl,
       LayerTreeHostImpl::FrameData* frame,
-      DrawResult draw_result) OVERRIDE {
+      DrawResult draw_result) override {
     return DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
   }
 
-  virtual void AfterTest() OVERRIDE { }
+  virtual void AfterTest() override { }
 
  private:
   bool started_animating_;
@@ -221,13 +221,13 @@ class LayerTreeHostAnimationTestAnimationsGetDeleted
   LayerTreeHostAnimationTestAnimationsGetDeleted()
       : started_animating_(false) {}
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostAddAnimationToMainThread(layer_tree_host()->root_layer());
   }
 
   virtual void AnimateLayers(
       LayerTreeHostImpl* host_impl,
-      base::TimeTicks monotonic_time) OVERRIDE {
+      base::TimeTicks monotonic_time) override {
     bool have_animations = !host_impl->animation_registrar()->
         active_animation_controllers().empty();
     if (!started_animating_ && have_animations) {
@@ -241,13 +241,13 @@ class LayerTreeHostAnimationTestAnimationsGetDeleted
 
   virtual void NotifyAnimationFinished(
       base::TimeTicks monotonic_time,
-      Animation::TargetProperty target_property) OVERRIDE {
+      Animation::TargetProperty target_property) override {
     // Animations on the impl-side controller only get deleted during a commit,
     // so we need to schedule a commit.
     layer_tree_host()->SetNeedsCommit();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   bool started_animating_;
@@ -262,7 +262,7 @@ class LayerTreeHostAnimationTestTickAnimationWhileBackgrounded
   LayerTreeHostAnimationTestTickAnimationWhileBackgrounded()
       : num_begin_frames_(0) {}
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostAddLongAnimationToMainThread(layer_tree_host()->root_layer());
   }
 
@@ -271,7 +271,7 @@ class LayerTreeHostAnimationTestTickAnimationWhileBackgrounded
   // mode.
   virtual void WillAnimateLayers(
       LayerTreeHostImpl* host_impl,
-      base::TimeTicks monotonic_time) OVERRIDE {
+      base::TimeTicks monotonic_time) override {
     // Verify that the host can draw, it's just not visible.
     EXPECT_TRUE(host_impl->CanDraw());
     if (num_begin_frames_ < 2) {
@@ -286,7 +286,7 @@ class LayerTreeHostAnimationTestTickAnimationWhileBackgrounded
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   int num_begin_frames_;
@@ -304,18 +304,18 @@ class LayerTreeHostAnimationTestAnimationTickTimeIsMonotonic
   LayerTreeHostAnimationTestAnimationTickTimeIsMonotonic()
       : has_background_ticked_(false), num_foreground_animates_(0) {}
 
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     // Make sure that drawing many times doesn't cause a checkerboarded
     // animation to start so we avoid flake in this test.
     settings->timeout_and_draw_when_animation_checkerboards = false;
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostAddLongAnimationToMainThread(layer_tree_host()->root_layer());
   }
 
   virtual void AnimateLayers(LayerTreeHostImpl* host_impl,
-                             base::TimeTicks monotonic_time) OVERRIDE {
+                             base::TimeTicks monotonic_time) override {
     EXPECT_GE(monotonic_time, last_tick_time_);
     last_tick_time_ = monotonic_time;
     if (host_impl->visible()) {
@@ -333,13 +333,13 @@ class LayerTreeHostAnimationTestAnimationTickTimeIsMonotonic
   virtual DrawResult PrepareToDrawOnThread(
       LayerTreeHostImpl* host_impl,
       LayerTreeHostImpl::FrameData* frame,
-      DrawResult draw_result) OVERRIDE {
+      DrawResult draw_result) override {
     if (TestEnded())
       return draw_result;
     return DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   bool has_background_ticked_;
@@ -358,22 +358,22 @@ class LayerTreeHostAnimationTestNoBackgroundTickingWithoutActiveTree
   LayerTreeHostAnimationTestNoBackgroundTickingWithoutActiveTree()
       : active_tree_was_animated_(false) {}
 
-  virtual base::TimeDelta LowFrequencyAnimationInterval() const OVERRIDE {
+  virtual base::TimeDelta LowFrequencyAnimationInterval() const override {
     return base::TimeDelta::FromMilliseconds(4);
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostAddAnimationToMainThread(layer_tree_host()->root_layer());
   }
 
   virtual void NotifyAnimationFinished(
       base::TimeTicks monotonic_time,
-      Animation::TargetProperty target_property) OVERRIDE {
+      Animation::TargetProperty target_property) override {
     // Replace animated commits with an empty tree.
     layer_tree_host()->SetRootLayer(make_scoped_refptr<Layer>(NULL));
   }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     // This alternates setting an empty tree and a non-empty tree with an
     // animation.
     switch (layer_tree_host()->source_frame_number()) {
@@ -394,14 +394,14 @@ class LayerTreeHostAnimationTestNoBackgroundTickingWithoutActiveTree
     }
   }
 
-  virtual void BeginCommitOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void BeginCommitOnThread(LayerTreeHostImpl* host_impl) override {
     // At the start of every commit, block activations and make sure
     // we are backgrounded.
     host_impl->BlockNotifyReadyToActivateForTesting(true);
     PostSetVisibleToMainThread(false);
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     if (!host_impl->settings().impl_side_painting) {
       // There are no activations to block if we're not impl-side-painting,
       // so just advance the test immediately.
@@ -429,7 +429,7 @@ class LayerTreeHostAnimationTestNoBackgroundTickingWithoutActiveTree
     host_impl->BlockNotifyReadyToActivateForTesting(false);
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     active_tree_was_animated_ = false;
 
     // Verify that commits are actually alternating with empty / non-empty
@@ -463,7 +463,7 @@ class LayerTreeHostAnimationTestNoBackgroundTickingWithoutActiveTree
   }
 
   virtual void WillAnimateLayers(LayerTreeHostImpl* host_impl,
-                                 base::TimeTicks monotonic_time) OVERRIDE {
+                                 base::TimeTicks monotonic_time) override {
     EXPECT_TRUE(host_impl->active_tree()->root_layer());
     active_tree_was_animated_ = true;
   }
@@ -477,7 +477,7 @@ class LayerTreeHostAnimationTestNoBackgroundTickingWithoutActiveTree
     PostSetVisibleToMainThread(true);
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   bool active_tree_was_animated_;
 };
@@ -491,20 +491,20 @@ class LayerTreeHostAnimationTestAddAnimationWithTimingFunction
  public:
   LayerTreeHostAnimationTestAddAnimationWithTimingFunction() {}
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
     content_ = FakeContentLayer::Create(&client_);
     content_->SetBounds(gfx::Size(4, 4));
     layer_tree_host()->root_layer()->AddChild(content_);
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostAddAnimationToMainThread(content_.get());
   }
 
   virtual void AnimateLayers(
       LayerTreeHostImpl* host_impl,
-      base::TimeTicks monotonic_time) OVERRIDE {
+      base::TimeTicks monotonic_time) override {
     LayerAnimationController* controller_impl =
         host_impl->active_tree()->root_layer()->children()[0]->
         layer_animation_controller();
@@ -528,7 +528,7 @@ class LayerTreeHostAnimationTestAddAnimationWithTimingFunction
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> content_;
@@ -546,7 +546,7 @@ class LayerTreeHostAnimationTestSynchronizeAnimationStartTimes
       : main_start_time_(-1.0),
         impl_start_time_(-1.0) {}
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
     content_ = FakeContentLayer::Create(&client_);
     content_->SetBounds(gfx::Size(4, 4));
@@ -554,13 +554,13 @@ class LayerTreeHostAnimationTestSynchronizeAnimationStartTimes
     layer_tree_host()->root_layer()->AddChild(content_);
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostAddAnimationToMainThread(content_.get());
   }
 
   virtual void NotifyAnimationStarted(
       base::TimeTicks monotonic_time,
-      Animation::TargetProperty target_property) OVERRIDE {
+      Animation::TargetProperty target_property) override {
     LayerAnimationController* controller =
         layer_tree_host()->root_layer()->children()[0]->
         layer_animation_controller();
@@ -576,7 +576,7 @@ class LayerTreeHostAnimationTestSynchronizeAnimationStartTimes
 
   virtual void UpdateAnimationState(
       LayerTreeHostImpl* impl_host,
-      bool has_unfinished_animation) OVERRIDE {
+      bool has_unfinished_animation) override {
     LayerAnimationController* controller =
         impl_host->active_tree()->root_layer()->children()[0]->
         layer_animation_controller();
@@ -593,7 +593,7 @@ class LayerTreeHostAnimationTestSynchronizeAnimationStartTimes
       EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     EXPECT_FLOAT_EQ(impl_start_time_, main_start_time_);
   }
 
@@ -613,13 +613,13 @@ class LayerTreeHostAnimationTestAnimationFinishedEvents
  public:
   LayerTreeHostAnimationTestAnimationFinishedEvents() {}
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostAddInstantAnimationToMainThread(layer_tree_host()->root_layer());
   }
 
   virtual void NotifyAnimationFinished(
       base::TimeTicks monotonic_time,
-      Animation::TargetProperty target_property) OVERRIDE {
+      Animation::TargetProperty target_property) override {
     LayerAnimationController* controller =
         layer_tree_host()->root_layer()->layer_animation_controller();
     Animation* animation =
@@ -629,7 +629,7 @@ class LayerTreeHostAnimationTestAnimationFinishedEvents
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
@@ -644,17 +644,17 @@ class LayerTreeHostAnimationTestDoNotSkipLayersWithAnimatedOpacity
       : update_check_layer_(FakeContentLayer::Create(&client_)) {
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     update_check_layer_->SetOpacity(0.f);
     layer_tree_host()->SetRootLayer(update_check_layer_);
     LayerTreeHostAnimationTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostAddAnimationToMainThread(update_check_layer_.get());
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     LayerAnimationController* controller_impl =
         host_impl->active_tree()->root_layer()->layer_animation_controller();
     Animation* animation_impl =
@@ -663,7 +663,7 @@ class LayerTreeHostAnimationTestDoNotSkipLayersWithAnimatedOpacity
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     // Update() should have been called once, proving that the layer was not
     // skipped.
     EXPECT_EQ(1u, update_check_layer_->update_count());
@@ -687,11 +687,11 @@ class LayerTreeHostAnimationTestLayerAddedWithAnimation
  public:
   LayerTreeHostAnimationTestLayerAddedWithAnimation() {}
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     if (layer_tree_host()->source_frame_number() == 1) {
       scoped_refptr<Layer> layer = Layer::Create();
       layer->set_layer_animation_delegate(this);
@@ -710,11 +710,11 @@ class LayerTreeHostAnimationTestLayerAddedWithAnimation
 
   virtual void AnimateLayers(
       LayerTreeHostImpl* impl_host,
-      base::TimeTicks monotonic_time) OVERRIDE {
+      base::TimeTicks monotonic_time) override {
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
@@ -726,9 +726,9 @@ class LayerTreeHostAnimationTestCancelAnimateCommit
   LayerTreeHostAnimationTestCancelAnimateCommit()
       : num_begin_frames_(0), num_commit_calls_(0), num_draw_calls_(0) {}
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void BeginMainFrame(const BeginFrameArgs& args) OVERRIDE {
+  virtual void BeginMainFrame(const BeginFrameArgs& args) override {
     num_begin_frames_++;
     // No-op animate will cancel the commit.
     if (layer_tree_host()->source_frame_number() == 1) {
@@ -738,19 +738,19 @@ class LayerTreeHostAnimationTestCancelAnimateCommit
     layer_tree_host()->SetNeedsAnimate();
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     num_commit_calls_++;
     if (impl->active_tree()->source_frame_number() > 1)
       FAIL() << "Commit should have been canceled.";
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     num_draw_calls_++;
     if (impl->active_tree()->source_frame_number() > 1)
       FAIL() << "Draw should have been canceled.";
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     EXPECT_EQ(2, num_begin_frames_);
     EXPECT_EQ(1, num_commit_calls_);
     EXPECT_EQ(1, num_draw_calls_);
@@ -772,23 +772,23 @@ class LayerTreeHostAnimationTestForceRedraw
   LayerTreeHostAnimationTestForceRedraw()
       : num_animate_(0), num_draw_layers_(0) {}
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void BeginMainFrame(const BeginFrameArgs& args) OVERRIDE {
+  virtual void BeginMainFrame(const BeginFrameArgs& args) override {
     if (++num_animate_ < 2)
       layer_tree_host()->SetNeedsAnimate();
   }
 
-  virtual void Layout() OVERRIDE {
+  virtual void Layout() override {
     layer_tree_host()->SetNextCommitForcesRedraw();
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     if (++num_draw_layers_ == 2)
       EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     // The first commit will always draw; make sure the second draw triggered
     // by the animation was not cancelled.
     EXPECT_EQ(2, num_draw_layers_);
@@ -808,21 +808,21 @@ class LayerTreeHostAnimationTestAnimateAfterSetNeedsCommit
   LayerTreeHostAnimationTestAnimateAfterSetNeedsCommit()
       : num_animate_(0), num_draw_layers_(0) {}
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void BeginMainFrame(const BeginFrameArgs& args) OVERRIDE {
+  virtual void BeginMainFrame(const BeginFrameArgs& args) override {
     if (++num_animate_ <= 2) {
       layer_tree_host()->SetNeedsCommit();
       layer_tree_host()->SetNeedsAnimate();
     }
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     if (++num_draw_layers_ == 2)
       EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     // The first commit will always draw; make sure the second draw triggered
     // by the SetNeedsCommit was not cancelled.
     EXPECT_EQ(2, num_draw_layers_);
@@ -843,7 +843,7 @@ class LayerTreeHostAnimationTestRunAnimationWhenNotCanDraw
  public:
   LayerTreeHostAnimationTestRunAnimationWhenNotCanDraw() : started_times_(0) {}
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
     content_ = FakeContentLayer::Create(&client_);
     content_->SetBounds(gfx::Size(4, 4));
@@ -851,24 +851,24 @@ class LayerTreeHostAnimationTestRunAnimationWhenNotCanDraw
     layer_tree_host()->root_layer()->AddChild(content_);
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     layer_tree_host()->SetViewportSize(gfx::Size());
     PostAddAnimationToMainThread(content_.get());
   }
 
   virtual void NotifyAnimationStarted(
       base::TimeTicks monotonic_time,
-      Animation::TargetProperty target_property) OVERRIDE {
+      Animation::TargetProperty target_property) override {
     started_times_++;
   }
 
   virtual void NotifyAnimationFinished(
       base::TimeTicks monotonic_time,
-      Animation::TargetProperty target_property) OVERRIDE {
+      Animation::TargetProperty target_property) override {
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     EXPECT_EQ(1, started_times_);
   }
 
@@ -888,7 +888,7 @@ class LayerTreeHostAnimationTestRunAnimationWhenNotVisible
  public:
   LayerTreeHostAnimationTestRunAnimationWhenNotVisible() : started_times_(0) {}
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
     content_ = FakeContentLayer::Create(&client_);
     content_->SetBounds(gfx::Size(4, 4));
@@ -896,32 +896,32 @@ class LayerTreeHostAnimationTestRunAnimationWhenNotVisible
     layer_tree_host()->root_layer()->AddChild(content_);
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     visible_ = true;
     PostAddAnimationToMainThread(content_.get());
   }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     visible_ = false;
     layer_tree_host()->SetVisible(false);
   }
 
   virtual void NotifyAnimationStarted(
       base::TimeTicks monotonic_time,
-      Animation::TargetProperty target_property) OVERRIDE {
+      Animation::TargetProperty target_property) override {
     EXPECT_FALSE(visible_);
     started_times_++;
   }
 
   virtual void NotifyAnimationFinished(
       base::TimeTicks monotonic_time,
-      Animation::TargetProperty target_property) OVERRIDE {
+      Animation::TargetProperty target_property) override {
     EXPECT_FALSE(visible_);
     EXPECT_EQ(1, started_times_);
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   bool visible_;
@@ -937,7 +937,7 @@ SINGLE_AND_MULTI_THREAD_TEST_F(
 // checkerboard.
 class LayerTreeHostAnimationTestCheckerboardDoesntStartAnimations
     : public LayerTreeHostAnimationTest {
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
     content_ = FakeContentLayer::Create(&client_);
     content_->SetBounds(gfx::Size(4, 4));
@@ -945,13 +945,13 @@ class LayerTreeHostAnimationTestCheckerboardDoesntStartAnimations
     layer_tree_host()->root_layer()->AddChild(content_);
   }
 
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     // Make sure that drawing many times doesn't cause a checkerboarded
     // animation to start so we avoid flake in this test.
     settings->timeout_and_draw_when_animation_checkerboards = false;
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     prevented_draw_ = 0;
     added_animations_ = 0;
     started_times_ = 0;
@@ -962,7 +962,7 @@ class LayerTreeHostAnimationTestCheckerboardDoesntStartAnimations
   virtual DrawResult PrepareToDrawOnThread(
       LayerTreeHostImpl* host_impl,
       LayerTreeHostImpl::FrameData* frame_data,
-      DrawResult draw_result) OVERRIDE {
+      DrawResult draw_result) override {
     if (added_animations_ < 2)
       return draw_result;
     if (TestEnded())
@@ -974,7 +974,7 @@ class LayerTreeHostAnimationTestCheckerboardDoesntStartAnimations
     return DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // The animation is longer than 1 BeginFrame interval.
@@ -991,13 +991,13 @@ class LayerTreeHostAnimationTestCheckerboardDoesntStartAnimations
 
   virtual void NotifyAnimationStarted(
       base::TimeTicks monotonic_time,
-      Animation::TargetProperty target_property) OVERRIDE {
+      Animation::TargetProperty target_property) override {
     if (TestEnded())
       return;
     started_times_++;
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     // Make sure we tried to draw the second animation but failed.
     EXPECT_LT(0, prevented_draw_);
     // The first animation should be started, but the second should not because
@@ -1023,7 +1023,7 @@ class LayerTreeHostAnimationTestScrollOffsetChangesArePropagated
  public:
   LayerTreeHostAnimationTestScrollOffsetChangesArePropagated() {}
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
 
     scroll_layer_ = FakeContentLayer::Create(&client_);
@@ -1033,11 +1033,11 @@ class LayerTreeHostAnimationTestScrollOffsetChangesArePropagated
     layer_tree_host()->root_layer()->AddChild(scroll_layer_);
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1: {
         scoped_ptr<ScrollOffsetAnimationCurve> curve(
@@ -1062,7 +1062,7 @@ class LayerTreeHostAnimationTestScrollOffsetChangesArePropagated
     }
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   FakeContentLayerClient client_;
@@ -1080,22 +1080,22 @@ class LayerTreeHostAnimationTestFrozenAnimationTickTime
   LayerTreeHostAnimationTestFrozenAnimationTickTime()
       : started_animating_(false), num_commits_(0), num_draw_attempts_(2) {}
 
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     // Make sure that drawing many times doesn't cause a checkerboarded
     // animation to start so we avoid flake in this test.
     settings->timeout_and_draw_when_animation_checkerboards = false;
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostAddAnimationToMainThread(layer_tree_host()->root_layer());
   }
 
-  virtual void BeginMainFrame(const BeginFrameArgs& args) OVERRIDE {
+  virtual void BeginMainFrame(const BeginFrameArgs& args) override {
     last_main_thread_tick_time_ = args.frame_time;
   }
 
   virtual void AnimateLayers(LayerTreeHostImpl* host_impl,
-                             base::TimeTicks monotonic_time) OVERRIDE {
+                             base::TimeTicks monotonic_time) override {
     if (TestEnded())
       return;
     if (!started_animating_) {
@@ -1110,7 +1110,7 @@ class LayerTreeHostAnimationTestFrozenAnimationTickTime
 
   virtual DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                            LayerTreeHostImpl::FrameData* frame,
-                                           DrawResult draw_result) OVERRIDE {
+                                           DrawResult draw_result) override {
     if (TestEnded())
       return draw_result;
     num_draw_attempts_++;
@@ -1121,7 +1121,7 @@ class LayerTreeHostAnimationTestFrozenAnimationTickTime
     return DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
   }
 
-  virtual void BeginCommitOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void BeginCommitOnThread(LayerTreeHostImpl* host_impl) override {
     if (!started_animating_)
       return;
     expected_impl_tick_time_ =
@@ -1129,7 +1129,7 @@ class LayerTreeHostAnimationTestFrozenAnimationTickTime
     num_commits_++;
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   bool started_animating_;
@@ -1151,9 +1151,9 @@ class LayerTreeHostAnimationTestAnimationsAddedToNewAndExistingLayers
   LayerTreeHostAnimationTestAnimationsAddedToNewAndExistingLayers()
       : frame_count_with_pending_tree_(0) {}
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     if (layer_tree_host()->source_frame_number() == 1) {
       AddAnimatedTransformToLayer(layer_tree_host()->root_layer(), 4, 1, 1);
     } else if (layer_tree_host()->source_frame_number() == 2) {
@@ -1168,11 +1168,11 @@ class LayerTreeHostAnimationTestAnimationsAddedToNewAndExistingLayers
     }
   }
 
-  virtual void BeginCommitOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void BeginCommitOnThread(LayerTreeHostImpl* host_impl) override {
     host_impl->BlockNotifyReadyToActivateForTesting(true);
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     // For the commit that added animations to new and existing layers, keep
     // blocking activation. We want to verify that even with activation blocked,
     // the animation on the layer that's already in the active tree won't get a
@@ -1183,7 +1183,7 @@ class LayerTreeHostAnimationTestAnimationsAddedToNewAndExistingLayers
   }
 
   virtual void WillBeginImplFrameOnThread(LayerTreeHostImpl* host_impl,
-                                          const BeginFrameArgs& args) OVERRIDE {
+                                          const BeginFrameArgs& args) override {
     if (!host_impl->pending_tree() ||
         host_impl->pending_tree()->source_frame_number() != 2)
       return;
@@ -1194,7 +1194,7 @@ class LayerTreeHostAnimationTestAnimationsAddedToNewAndExistingLayers
   }
 
   virtual void UpdateAnimationState(LayerTreeHostImpl* host_impl,
-                                    bool has_unfinished_animation) OVERRIDE {
+                                    bool has_unfinished_animation) override {
     LayerAnimationController* root_controller_impl =
         host_impl->active_tree()->root_layer()->layer_animation_controller();
     Animation* root_animation =
@@ -1215,7 +1215,7 @@ class LayerTreeHostAnimationTestAnimationsAddedToNewAndExistingLayers
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   int frame_count_with_pending_tree_;
@@ -1230,16 +1230,16 @@ class LayerTreeHostAnimationTestAddAnimationAfterAnimating
   LayerTreeHostAnimationTestAddAnimationAfterAnimating()
       : num_swap_buffers_(0) {}
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
     content_ = Layer::Create();
     content_->SetBounds(gfx::Size(4, 4));
     layer_tree_host()->root_layer()->AddChild(content_);
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // First frame: add an animation to the root layer.
@@ -1254,7 +1254,7 @@ class LayerTreeHostAnimationTestAddAnimationAfterAnimating
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
-                                   bool result) OVERRIDE {
+                                   bool result) override {
     // After both animations have started, verify that they have valid
     // start times.
     num_swap_buffers_++;
@@ -1279,7 +1279,7 @@ class LayerTreeHostAnimationTestAddAnimationAfterAnimating
     }
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   scoped_refptr<Layer> content_;
diff --git a/cc/trees/layer_tree_host_unittest_context.cc b/cc/trees/layer_tree_host_unittest_context.cc
index 07e12a2..0f6bcaf 100644
--- a/cc/trees/layer_tree_host_unittest_context.cc
+++ b/cc/trees/layer_tree_host_unittest_context.cc
@@ -82,7 +82,7 @@ class LayerTreeHostContextTest : public LayerTreeTest {
   }
 
   virtual scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface(bool fallback)
-      OVERRIDE {
+      override {
     if (times_to_fail_create_) {
       --times_to_fail_create_;
       ExpectCreateToFail();
@@ -106,7 +106,7 @@ class LayerTreeHostContextTest : public LayerTreeTest {
   virtual DrawResult PrepareToDrawOnThread(
       LayerTreeHostImpl* host_impl,
       LayerTreeHostImpl::FrameData* frame,
-      DrawResult draw_result) OVERRIDE {
+      DrawResult draw_result) override {
     EXPECT_EQ(DRAW_SUCCESS, draw_result);
     if (!times_to_lose_during_draw_)
       return draw_result;
@@ -120,7 +120,7 @@ class LayerTreeHostContextTest : public LayerTreeTest {
     return draw_result;
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     committed_at_least_once_ = true;
 
     if (!times_to_lose_during_commit_)
@@ -132,11 +132,11 @@ class LayerTreeHostContextTest : public LayerTreeTest {
     times_to_fail_recreate_ = 0;
   }
 
-  virtual void DidFailToInitializeOutputSurface() OVERRIDE {
+  virtual void DidFailToInitializeOutputSurface() override {
     ++times_create_failed_;
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     LayerTreeTest::TearDown();
     EXPECT_EQ(times_to_expect_create_failed_, times_create_failed_);
   }
@@ -168,9 +168,9 @@ class LayerTreeHostContextTestLostContextSucceeds
         recovered_context_(true),
         first_initialized_(false) {}
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void RequestNewOutputSurface(bool fallback) OVERRIDE {
+  virtual void RequestNewOutputSurface(bool fallback) override {
     if (async_output_surface_creation_) {
       MainThreadTaskRunner()->PostTask(
           FROM_HERE,
@@ -188,7 +188,7 @@ class LayerTreeHostContextTestLostContextSucceeds
         LayerTreeHostContextTest::CreateOutputSurface(fallback));
   }
 
-  virtual void DidInitializeOutputSurface() OVERRIDE {
+  virtual void DidInitializeOutputSurface() override {
     if (first_initialized_)
       ++num_losses_;
     else
@@ -197,9 +197,9 @@ class LayerTreeHostContextTestLostContextSucceeds
     recovered_context_ = true;
   }
 
-  virtual void AfterTest() OVERRIDE { EXPECT_EQ(11u, test_case_); }
+  virtual void AfterTest() override { EXPECT_EQ(11u, test_case_); }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     // If the last frame had a context loss, then we'll commit again to
     // recover.
     if (!recovered_context_)
@@ -351,24 +351,24 @@ class LayerTreeHostClientNotReadyDoesNotCreateOutputSurface
   LayerTreeHostClientNotReadyDoesNotCreateOutputSurface()
       : LayerTreeHostContextTest() {}
 
-  virtual void WillBeginTest() OVERRIDE {
+  virtual void WillBeginTest() override {
     // Override and do not signal SetLayerTreeHostClientReady.
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostSetNeedsCommitToMainThread();
     EndTest();
   }
 
   virtual scoped_ptr<OutputSurface> CreateOutputSurface(bool fallback)
-      OVERRIDE {
+      override {
     EXPECT_TRUE(false);
     return nullptr;
   }
 
-  virtual void DidInitializeOutputSurface() OVERRIDE { EXPECT_TRUE(false); }
+  virtual void DidInitializeOutputSurface() override { EXPECT_TRUE(false); }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
   }
 };
 
@@ -378,7 +378,7 @@ SINGLE_AND_MULTI_THREAD_TEST_F(
 class LayerTreeHostContextTestLostContextSucceedsWithContent
     : public LayerTreeHostContextTestLostContextSucceeds {
  public:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     root_ = Layer::Create();
     root_->SetBounds(gfx::Size(10, 10));
     root_->SetIsDrawable(true);
@@ -401,7 +401,7 @@ class LayerTreeHostContextTestLostContextSucceedsWithContent
     LayerTreeHostContextTest::SetupTree();
   }
 
-  virtual void InvalidateAndSetNeedsCommit() OVERRIDE {
+  virtual void InvalidateAndSetNeedsCommit() override {
     // Invalidate the render surface so we don't try to use a cached copy of the
     // surface.  We want to make sure to test the drawing paths for drawing to
     // a child surface.
@@ -409,7 +409,7 @@ class LayerTreeHostContextTestLostContextSucceedsWithContent
     LayerTreeHostContextTestLostContextSucceeds::InvalidateAndSetNeedsCommit();
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     if (!host_impl->settings().impl_side_painting) {
       FakeContentLayerImpl* content_impl = static_cast<FakeContentLayerImpl*>(
           host_impl->active_tree()->root_layer()->children()[0]);
@@ -449,12 +449,12 @@ class LayerTreeHostContextTestCreateOutputSurfaceFails
     times_to_fail_create_ = times_to_fail_;
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostSetNeedsCommitToMainThread();
   }
 
   virtual scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface(bool fallback)
-      OVERRIDE {
+      override {
     scoped_ptr<FakeOutputSurface> surface =
         LayerTreeHostContextTest::CreateFakeOutputSurface(fallback);
 
@@ -465,13 +465,13 @@ class LayerTreeHostContextTestCreateOutputSurfaceFails
     return surface.Pass();
   }
 
-  virtual void DidInitializeOutputSurface() OVERRIDE { times_initialized_++; }
+  virtual void DidInitializeOutputSurface() override { times_initialized_++; }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     EXPECT_EQ(times_to_fail_, times_create_failed_);
     EXPECT_NE(0, times_initialized_);
     EXPECT_EQ(expect_fallback_attempt_, did_attempt_fallback_);
@@ -515,7 +515,7 @@ class LayerTreeHostContextTestLostContextAndEvictTextures
         num_commits_(0),
         lost_context_(false) {}
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     // Paint non-solid color.
     SkPaint paint;
     paint.setColor(SkColorSetARGB(100, 80, 200, 200));
@@ -534,7 +534,7 @@ class LayerTreeHostContextTestLostContextAndEvictTextures
     LayerTreeHostContextTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void PostEvictTextures() {
     if (HasImplThread()) {
@@ -558,7 +558,7 @@ class LayerTreeHostContextTestLostContextAndEvictTextures
     }
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     if (num_commits_ > 1)
       return;
     if (!layer_tree_host()->settings().impl_side_painting) {
@@ -567,7 +567,7 @@ class LayerTreeHostContextTestLostContextAndEvictTextures
     PostEvictTextures();
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     LayerTreeHostContextTest::CommitCompleteOnThread(impl);
     if (num_commits_ > 1)
       return;
@@ -578,7 +578,7 @@ class LayerTreeHostContextTestLostContextAndEvictTextures
     }
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     if (impl->settings().impl_side_painting) {
       FakePictureLayerImpl* picture_impl =
           static_cast<FakePictureLayerImpl*>(impl->active_tree()->root_layer());
@@ -594,9 +594,9 @@ class LayerTreeHostContextTestLostContextAndEvictTextures
       EndTest();
   }
 
-  virtual void DidInitializeOutputSurface() OVERRIDE {}
+  virtual void DidInitializeOutputSurface() override {}
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  protected:
   bool lose_after_evict_;
@@ -681,7 +681,7 @@ class LayerTreeHostContextTestLostContextWhileUpdatingResources
   LayerTreeHostContextTestLostContextWhileUpdatingResources()
       : num_children_(50), times_to_lose_on_end_query_(3) {}
 
-  virtual scoped_ptr<TestWebGraphicsContext3D> CreateContext3d() OVERRIDE {
+  virtual scoped_ptr<TestWebGraphicsContext3D> CreateContext3d() override {
     scoped_ptr<TestWebGraphicsContext3D> context =
         LayerTreeHostContextTest::CreateContext3d();
     if (times_to_lose_on_end_query_) {
@@ -691,7 +691,7 @@ class LayerTreeHostContextTestLostContextWhileUpdatingResources
     return context.Pass();
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     if (layer_tree_host()->settings().impl_side_painting)
       parent_ = FakePictureLayer::Create(&client_);
     else
@@ -714,14 +714,14 @@ class LayerTreeHostContextTestLostContextWhileUpdatingResources
     LayerTreeHostContextTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     EXPECT_EQ(0, times_to_lose_on_end_query_);
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     EXPECT_EQ(0, times_to_lose_on_end_query_);
   }
 
@@ -740,7 +740,7 @@ class LayerTreeHostContextTestLayersNotified : public LayerTreeHostContextTest {
   LayerTreeHostContextTestLayersNotified()
       : LayerTreeHostContextTest(), num_commits_(0) {}
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     if (layer_tree_host()->settings().impl_side_painting) {
       root_ = FakePictureLayer::Create(&client_);
       child_ = FakePictureLayer::Create(&client_);
@@ -758,9 +758,9 @@ class LayerTreeHostContextTestLayersNotified : public LayerTreeHostContextTest {
     LayerTreeHostContextTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     LayerTreeHostContextTest::DidActivateTreeOnThread(host_impl);
 
     FakePictureLayerImpl* root_picture = NULL;
@@ -822,7 +822,7 @@ class LayerTreeHostContextTestLayersNotified : public LayerTreeHostContextTest {
     }
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   int num_commits_;
@@ -856,7 +856,7 @@ class LayerTreeHostContextTestDontUseLostResources
 
   static void EmptyReleaseCallback(unsigned sync_point, bool lost) {}
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     gpu::gles2::GLES2Interface* gl =
         child_output_surface_->context_provider()->ContextGL();
 
@@ -1012,9 +1012,9 @@ class LayerTreeHostContextTestDontUseLostResources
     LayerTreeHostContextTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     LayerTreeHostContextTest::CommitCompleteOnThread(host_impl);
 
     if (host_impl->active_tree()->source_frame_number() == 3) {
@@ -1029,7 +1029,7 @@ class LayerTreeHostContextTestDontUseLostResources
   virtual DrawResult PrepareToDrawOnThread(
       LayerTreeHostImpl* host_impl,
       LayerTreeHostImpl::FrameData* frame,
-      DrawResult draw_result) OVERRIDE {
+      DrawResult draw_result) override {
     if (host_impl->active_tree()->source_frame_number() == 2) {
       // Lose the context during draw on the second commit. This will cause
       // a third commit to recover.
@@ -1039,7 +1039,7 @@ class LayerTreeHostContextTestDontUseLostResources
   }
 
   virtual scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface(bool fallback)
-      OVERRIDE {
+      override {
     // This will get called twice:
     // First when we create the initial output surface...
     if (layer_tree_host()->source_frame_number() > 0) {
@@ -1049,7 +1049,7 @@ class LayerTreeHostContextTestDontUseLostResources
     return LayerTreeHostContextTest::CreateFakeOutputSurface(fallback);
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     ASSERT_TRUE(layer_tree_host()->hud_layer());
     // End the test once we know the 3nd frame drew.
     if (layer_tree_host()->source_frame_number() < 5) {
@@ -1060,7 +1060,7 @@ class LayerTreeHostContextTestDontUseLostResources
     }
   }
 
-  virtual void AfterTest() OVERRIDE { EXPECT_TRUE(lost_context_); }
+  virtual void AfterTest() override { EXPECT_TRUE(lost_context_); }
 
  private:
   FakeContentLayerClient client_;
@@ -1089,7 +1089,7 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostContextTestDontUseLostResources);
 class ImplSidePaintingLayerTreeHostContextTest
     : public LayerTreeHostContextTest {
  public:
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     settings->impl_side_painting = true;
   }
 };
@@ -1097,7 +1097,7 @@ class ImplSidePaintingLayerTreeHostContextTest
 class LayerTreeHostContextTestImplSidePainting
     : public ImplSidePaintingLayerTreeHostContextTest {
  public:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(gfx::Size(10, 10));
     root->SetIsDrawable(true);
@@ -1111,14 +1111,14 @@ class LayerTreeHostContextTestImplSidePainting
     LayerTreeHostContextTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     times_to_lose_during_commit_ = 1;
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
-  virtual void DidInitializeOutputSurface() OVERRIDE { EndTest(); }
+  virtual void DidInitializeOutputSurface() override { EndTest(); }
 
  private:
   FakeContentLayerClient client_;
@@ -1130,7 +1130,7 @@ class ScrollbarLayerLostContext : public LayerTreeHostContextTest {
  public:
   ScrollbarLayerLostContext() : commits_(0) {}
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     scoped_refptr<Layer> scroll_layer = Layer::Create();
     scrollbar_layer_ =
         FakePaintedScrollbarLayer::Create(false, true, scroll_layer->id());
@@ -1140,9 +1140,9 @@ class ScrollbarLayerLostContext : public LayerTreeHostContextTest {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     LayerTreeHostContextTest::CommitCompleteOnThread(impl);
 
     ++commits_;
@@ -1174,11 +1174,11 @@ SINGLE_AND_MULTI_THREAD_TEST_F(ScrollbarLayerLostContext);
 class UIResourceLostTest : public LayerTreeHostContextTest {
  public:
   UIResourceLostTest() : time_step_(0) {}
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     settings->texture_id_allocation_chunk_size = 1;
   }
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
-  virtual void AfterTest() OVERRIDE {}
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
+  virtual void AfterTest() override {}
 
   // This is called on the main thread after each commit and
   // DidActivateTreeOnThread, with the value of time_step_ at the time
@@ -1225,7 +1225,7 @@ class UIResourceLostTestSimple : public UIResourceLostTest {
   // activated.
   virtual void StepCompleteOnImplThread(LayerTreeHostImpl* impl) = 0;
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     if (!layer_tree_host()->settings().impl_side_painting) {
       StepCompleteOnImplThread(impl);
       PostStepCompleteToMainThread();
@@ -1233,7 +1233,7 @@ class UIResourceLostTestSimple : public UIResourceLostTest {
     }
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     if (layer_tree_host()->settings().impl_side_painting) {
       StepCompleteOnImplThread(impl);
       PostStepCompleteToMainThread();
@@ -1245,7 +1245,7 @@ class UIResourceLostTestSimple : public UIResourceLostTest {
 // Losing context after an UI resource has been created.
 class UIResourceLostAfterCommit : public UIResourceLostTestSimple {
  public:
-  virtual void StepCompleteOnMainThread(int step) OVERRIDE {
+  virtual void StepCompleteOnMainThread(int step) override {
     EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
     switch (step) {
       case 0:
@@ -1265,7 +1265,7 @@ class UIResourceLostAfterCommit : public UIResourceLostTestSimple {
     }
   }
 
-  virtual void StepCompleteOnImplThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void StepCompleteOnImplThread(LayerTreeHostImpl* impl) override {
     LayerTreeHostContextTest::CommitCompleteOnThread(impl);
     switch (time_step_) {
       case 1:
@@ -1304,7 +1304,7 @@ class UIResourceLostBeforeCommit : public UIResourceLostTestSimple {
  public:
   UIResourceLostBeforeCommit() : test_id0_(0), test_id1_(0) {}
 
-  virtual void StepCompleteOnMainThread(int step) OVERRIDE {
+  virtual void StepCompleteOnMainThread(int step) override {
     switch (step) {
       case 0:
         ui_resource_ = FakeScopedUIResource::Create(layer_tree_host());
@@ -1354,7 +1354,7 @@ class UIResourceLostBeforeCommit : public UIResourceLostTestSimple {
     }
   }
 
-  virtual void StepCompleteOnImplThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void StepCompleteOnImplThread(LayerTreeHostImpl* impl) override {
     LayerTreeHostContextTest::CommitCompleteOnThread(impl);
     switch (time_step_) {
       case 1:
@@ -1400,7 +1400,7 @@ SINGLE_AND_MULTI_THREAD_TEST_F(UIResourceLostBeforeCommit);
 // Losing UI resource before the pending trees is activated but after the
 // commit.  Impl-side-painting only.
 class UIResourceLostBeforeActivateTree : public UIResourceLostTest {
-  virtual void StepCompleteOnMainThread(int step) OVERRIDE {
+  virtual void StepCompleteOnMainThread(int step) override {
     EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
     switch (step) {
       case 0:
@@ -1423,7 +1423,7 @@ class UIResourceLostBeforeActivateTree : public UIResourceLostTest {
     }
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     LayerTreeHostContextTest::CommitCompleteOnThread(impl);
     switch (time_step_) {
       case 2:
@@ -1435,7 +1435,7 @@ class UIResourceLostBeforeActivateTree : public UIResourceLostTest {
     }
   }
 
-  virtual void WillActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void WillActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     switch (time_step_) {
       case 1:
         // The resource creation callback has been called.
@@ -1452,7 +1452,7 @@ class UIResourceLostBeforeActivateTree : public UIResourceLostTest {
     }
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     LayerTreeHostContextTest::DidActivateTreeOnThread(impl);
     switch (time_step_) {
       case 1:
@@ -1491,7 +1491,7 @@ TEST_F(UIResourceLostBeforeActivateTree,
 // Resources evicted explicitly and by visibility changes.
 class UIResourceLostEviction : public UIResourceLostTestSimple {
  public:
-  virtual void StepCompleteOnMainThread(int step) OVERRIDE {
+  virtual void StepCompleteOnMainThread(int step) override {
     EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
     switch (step) {
       case 0:
@@ -1514,7 +1514,7 @@ class UIResourceLostEviction : public UIResourceLostTestSimple {
   }
 
   virtual void DidSetVisibleOnImplTree(LayerTreeHostImpl* impl,
-                                       bool visible) OVERRIDE {
+                                       bool visible) override {
     TestWebGraphicsContext3D* context = TestContext();
     if (!visible) {
       // All resources should have been evicted.
@@ -1530,7 +1530,7 @@ class UIResourceLostEviction : public UIResourceLostTestSimple {
     }
   }
 
-  virtual void StepCompleteOnImplThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void StepCompleteOnImplThread(LayerTreeHostImpl* impl) override {
     TestWebGraphicsContext3D* context = TestContext();
     LayerTreeHostContextTest::CommitCompleteOnThread(impl);
     switch (time_step_) {
@@ -1578,7 +1578,7 @@ class LayerTreeHostContextTestSurfaceCreateCallback
   LayerTreeHostContextTestSurfaceCreateCallback()
       : LayerTreeHostContextTest() {}
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     if (layer_tree_host()->settings().impl_side_painting) {
       picture_layer_ = FakePictureLayer::Create(&client_);
       picture_layer_->SetBounds(gfx::Size(10, 20));
@@ -1592,9 +1592,9 @@ class LayerTreeHostContextTestSurfaceCreateCallback
     LayerTreeHostContextTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         if (layer_tree_host()->settings().impl_side_painting)
@@ -1626,7 +1626,7 @@ class LayerTreeHostContextTestSurfaceCreateCallback
     }
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     LayerTreeHostContextTest::CommitCompleteOnThread(impl);
     switch (LastCommittedSourceFrameNumber(impl)) {
       case 0:
@@ -1642,7 +1642,7 @@ class LayerTreeHostContextTestSurfaceCreateCallback
     }
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  protected:
   FakeContentLayerClient client_;
@@ -1655,12 +1655,12 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostContextTestSurfaceCreateCallback);
 class LayerTreeHostContextTestLoseAfterSendingBeginMainFrame
     : public LayerTreeHostContextTest {
  protected:
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     deferred_ = false;
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void ScheduledActionWillSendBeginMainFrame() OVERRIDE {
+  virtual void ScheduledActionWillSendBeginMainFrame() override {
     if (deferred_)
       return;
     deferred_ = true;
@@ -1696,14 +1696,14 @@ class LayerTreeHostContextTestLoseAfterSendingBeginMainFrame
     layer_tree_host()->SetDeferCommits(defer_commits);
   }
 
-  virtual void WillBeginMainFrame() OVERRIDE {
+  virtual void WillBeginMainFrame() override {
     // Don't begin a frame with a lost surface.
     EXPECT_FALSE(layer_tree_host()->output_surface_lost());
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE { EndTest(); }
+  virtual void DidCommitAndDrawFrame() override { EndTest(); }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   bool deferred_;
 };
diff --git a/cc/trees/layer_tree_host_unittest_copyrequest.cc b/cc/trees/layer_tree_host_unittest_copyrequest.cc
index 6af1756..860f283 100644
--- a/cc/trees/layer_tree_host_unittest_copyrequest.cc
+++ b/cc/trees/layer_tree_host_unittest_copyrequest.cc
@@ -21,7 +21,7 @@ class LayerTreeHostCopyRequestTest : public LayerTreeTest {};
 class LayerTreeHostCopyRequestTestMultipleRequests
     : public LayerTreeHostCopyRequestTest {
  protected:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     root = FakeContentLayer::Create(&client_);
     root->SetBounds(gfx::Size(20, 20));
 
@@ -33,9 +33,9 @@ class LayerTreeHostCopyRequestTestMultipleRequests
     LayerTreeHostCopyRequestTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE { WaitForCallback(); }
+  virtual void DidCommitAndDrawFrame() override { WaitForCallback(); }
 
   void WaitForCallback() {
     base::MessageLoop::current()->PostTask(
@@ -101,10 +101,10 @@ class LayerTreeHostCopyRequestTestMultipleRequests
     callbacks_.push_back(result->size());
   }
 
-  virtual void AfterTest() OVERRIDE { EXPECT_EQ(4u, callbacks_.size()); }
+  virtual void AfterTest() override { EXPECT_EQ(4u, callbacks_.size()); }
 
   virtual scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface(bool fallback)
-      OVERRIDE {
+      override {
     if (use_gl_renderer_)
       return FakeOutputSurface::Create3d();
     return FakeOutputSurface::CreateSoftware(
@@ -146,7 +146,7 @@ TEST_F(LayerTreeHostCopyRequestTestMultipleRequests,
 class LayerTreeHostCopyRequestTestLayerDestroyed
     : public LayerTreeHostCopyRequestTest {
  protected:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     root_ = FakeContentLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
 
@@ -162,12 +162,12 @@ class LayerTreeHostCopyRequestTestLayerDestroyed
     LayerTreeHostCopyRequestTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     callback_count_ = 0;
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     int frame = layer_tree_host()->source_frame_number();
     switch (frame) {
       case 1:
@@ -224,7 +224,7 @@ class LayerTreeHostCopyRequestTestLayerDestroyed
     ++callback_count_;
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   int callback_count_;
   FakeContentLayerClient client_;
@@ -238,7 +238,7 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostCopyRequestTestLayerDestroyed);
 class LayerTreeHostCopyRequestTestInHiddenSubtree
     : public LayerTreeHostCopyRequestTest {
  protected:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     root_ = FakeContentLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
 
@@ -267,7 +267,7 @@ class LayerTreeHostCopyRequestTestInHiddenSubtree
             base::Unretained(this))));
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     callback_count_ = 0;
     PostSetNeedsCommitToMainThread();
 
@@ -321,7 +321,7 @@ class LayerTreeHostCopyRequestTestInHiddenSubtree
     }
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   int callback_count_;
   FakeContentLayerClient client_;
@@ -337,7 +337,7 @@ SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_NOIMPL_TEST_F(
 class LayerTreeHostTestHiddenSurfaceNotAllocatedForSubtreeCopyRequest
     : public LayerTreeHostCopyRequestTest {
  protected:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     root_ = FakeContentLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
 
@@ -360,7 +360,7 @@ class LayerTreeHostTestHiddenSurfaceNotAllocatedForSubtreeCopyRequest
     LayerTreeHostCopyRequestTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     did_draw_ = false;
     PostSetNeedsCommitToMainThread();
 
@@ -377,7 +377,7 @@ class LayerTreeHostTestHiddenSurfaceNotAllocatedForSubtreeCopyRequest
     EndTest();
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     Renderer* renderer = host_impl->renderer();
 
     LayerImpl* root = host_impl->active_tree()->root_layer();
@@ -398,7 +398,7 @@ class LayerTreeHostTestHiddenSurfaceNotAllocatedForSubtreeCopyRequest
     did_draw_ = true;
   }
 
-  virtual void AfterTest() OVERRIDE { EXPECT_TRUE(did_draw_); }
+  virtual void AfterTest() override { EXPECT_TRUE(did_draw_); }
 
   FakeContentLayerClient client_;
   bool did_draw_;
@@ -415,7 +415,7 @@ SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
 class LayerTreeHostCopyRequestTestClippedOut
     : public LayerTreeHostCopyRequestTest {
  protected:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     root_ = FakeContentLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
 
@@ -433,7 +433,7 @@ class LayerTreeHostCopyRequestTestClippedOut
     LayerTreeHostCopyRequestTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostSetNeedsCommitToMainThread();
 
     copy_layer_->RequestCopyOfOutput(CopyOutputRequest::CreateBitmapRequest(
@@ -449,7 +449,7 @@ class LayerTreeHostCopyRequestTestClippedOut
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> root_;
@@ -463,7 +463,7 @@ SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
 class LayerTreeHostTestAsyncTwoReadbacksWithoutDraw
     : public LayerTreeHostCopyRequestTest {
  protected:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     root_ = FakeContentLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
 
@@ -482,7 +482,7 @@ class LayerTreeHostTestAsyncTwoReadbacksWithoutDraw
             base::Unretained(this))));
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     saw_copy_request_ = false;
     callback_count_ = 0;
     PostSetNeedsCommitToMainThread();
@@ -493,7 +493,7 @@ class LayerTreeHostTestAsyncTwoReadbacksWithoutDraw
     AddCopyRequest(copy_layer_.get());
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     if (impl->active_tree()->source_frame_number() == 0) {
       LayerImpl* root = impl->active_tree()->root_layer();
       EXPECT_TRUE(root->children()[0]->HasCopyRequest());
@@ -501,7 +501,7 @@ class LayerTreeHostTestAsyncTwoReadbacksWithoutDraw
     }
   }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     if (layer_tree_host()->source_frame_number() == 1) {
       // Allow drawing.
       layer_tree_host()->SetViewportSize(gfx::Size(root_->bounds()));
@@ -519,7 +519,7 @@ class LayerTreeHostTestAsyncTwoReadbacksWithoutDraw
       EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE { EXPECT_TRUE(saw_copy_request_); }
+  virtual void AfterTest() override { EXPECT_TRUE(saw_copy_request_); }
 
   bool saw_copy_request_;
   int callback_count_;
@@ -535,7 +535,7 @@ class LayerTreeHostCopyRequestTestLostOutputSurface
     : public LayerTreeHostCopyRequestTest {
  protected:
   virtual scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface(bool fallback)
-      OVERRIDE {
+      override {
     if (!first_context_provider_.get()) {
       first_context_provider_ = TestContextProvider::Create();
       return FakeOutputSurface::Create3d(first_context_provider_);
@@ -546,7 +546,7 @@ class LayerTreeHostCopyRequestTestLostOutputSurface
     return FakeOutputSurface::Create3d(second_context_provider_);
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     root_ = FakeContentLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
 
@@ -558,7 +558,7 @@ class LayerTreeHostCopyRequestTestLostOutputSurface
     LayerTreeHostCopyRequestTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {
     EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
@@ -573,7 +573,7 @@ class LayerTreeHostCopyRequestTestLostOutputSurface
     layer_tree_host()->SetNeedsCommit();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // The layers have been pushed to the impl side. The layer textures have
@@ -606,7 +606,7 @@ class LayerTreeHostCopyRequestTestLostOutputSurface
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* impl,
-                                   bool result) OVERRIDE {
+                                   bool result) override {
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
         // The layers have been drawn, so their textures have been allocated.
@@ -646,7 +646,7 @@ class LayerTreeHostCopyRequestTestLostOutputSurface
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   scoped_refptr<TestContextProvider> first_context_provider_;
   scoped_refptr<TestContextProvider> second_context_provider_;
@@ -665,12 +665,12 @@ class LayerTreeHostCopyRequestTestCountTextures
     : public LayerTreeHostCopyRequestTest {
  protected:
   virtual scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface(bool fallback)
-      OVERRIDE {
+      override {
     context_provider_ = TestContextProvider::Create();
     return FakeOutputSurface::Create3d(context_provider_);
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     root_ = FakeContentLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
 
@@ -682,7 +682,7 @@ class LayerTreeHostCopyRequestTestCountTextures
     LayerTreeHostCopyRequestTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     num_textures_without_readback_ = 0;
     num_textures_with_readback_ = 0;
     waited_sync_point_after_readback_ = 0;
@@ -691,7 +691,7 @@ class LayerTreeHostCopyRequestTestCountTextures
 
   virtual void RequestCopy(Layer* layer) = 0;
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // The layers have been pushed to the impl side. The layer textures have
@@ -702,7 +702,7 @@ class LayerTreeHostCopyRequestTestCountTextures
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* impl,
-                                   bool result) OVERRIDE {
+                                   bool result) override {
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
         // The layers have been drawn, so their textures have been allocated.
@@ -738,7 +738,7 @@ class LayerTreeHostCopyRequestTestCountTextures
 class LayerTreeHostCopyRequestTestCreatesTexture
     : public LayerTreeHostCopyRequestTestCountTextures {
  protected:
-  virtual void RequestCopy(Layer* layer) OVERRIDE {
+  virtual void RequestCopy(Layer* layer) override {
     // Request a normal texture copy. This should create a new texture.
     copy_layer_->RequestCopyOfOutput(
         CopyOutputRequest::CreateRequest(base::Bind(
@@ -758,7 +758,7 @@ class LayerTreeHostCopyRequestTestCreatesTexture
     release->Run(0, false);
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     // No sync point was needed.
     EXPECT_EQ(0u, waited_sync_point_after_readback_);
     // Except the copy to have made another texture.
@@ -772,7 +772,7 @@ SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_NOIMPL_TEST_F(
 class LayerTreeHostCopyRequestTestProvideTexture
     : public LayerTreeHostCopyRequestTestCountTextures {
  protected:
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     external_context_provider_ = TestContextProvider::Create();
     EXPECT_TRUE(external_context_provider_->BindToCurrentThread());
     LayerTreeHostCopyRequestTestCountTextures::BeginTest();
@@ -788,7 +788,7 @@ class LayerTreeHostCopyRequestTestProvideTexture
     EXPECT_FALSE(release);
   }
 
-  virtual void RequestCopy(Layer* layer) OVERRIDE {
+  virtual void RequestCopy(Layer* layer) override {
     // Request a copy to a provided texture. This should not create a new
     // texture.
     scoped_ptr<CopyOutputRequest> request =
@@ -807,7 +807,7 @@ class LayerTreeHostCopyRequestTestProvideTexture
     copy_layer_->RequestCopyOfOutput(request.Pass());
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     // Expect the compositor to have waited for the sync point in the provided
     // TextureMailbox.
     EXPECT_EQ(sync_point_, waited_sync_point_after_readback_);
@@ -825,7 +825,7 @@ SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_NOIMPL_TEST_F(
 class LayerTreeHostCopyRequestTestDestroyBeforeCopy
     : public LayerTreeHostCopyRequestTest {
  protected:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     root_ = FakeContentLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
 
@@ -837,7 +837,7 @@ class LayerTreeHostCopyRequestTestDestroyBeforeCopy
     LayerTreeHostCopyRequestTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     callback_count_ = 0;
     PostSetNeedsCommitToMainThread();
   }
@@ -847,7 +847,7 @@ class LayerTreeHostCopyRequestTestDestroyBeforeCopy
     ++callback_count_;
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     MainThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&LayerTreeHostCopyRequestTestDestroyBeforeCopy::DidActivate,
@@ -888,7 +888,7 @@ class LayerTreeHostCopyRequestTestDestroyBeforeCopy
     }
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   int callback_count_;
   FakeContentLayerClient client_;
@@ -902,7 +902,7 @@ SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
 class LayerTreeHostCopyRequestTestShutdownBeforeCopy
     : public LayerTreeHostCopyRequestTest {
  protected:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     root_ = FakeContentLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
 
@@ -914,7 +914,7 @@ class LayerTreeHostCopyRequestTestShutdownBeforeCopy
     LayerTreeHostCopyRequestTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     callback_count_ = 0;
     PostSetNeedsCommitToMainThread();
   }
@@ -924,7 +924,7 @@ class LayerTreeHostCopyRequestTestShutdownBeforeCopy
     ++callback_count_;
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     MainThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&LayerTreeHostCopyRequestTestShutdownBeforeCopy::DidActivate,
@@ -959,7 +959,7 @@ class LayerTreeHostCopyRequestTestShutdownBeforeCopy
     }
   }
 
-  virtual void AfterTest() OVERRIDE { EXPECT_EQ(1, callback_count_); }
+  virtual void AfterTest() override { EXPECT_EQ(1, callback_count_); }
 
   int callback_count_;
   FakeContentLayerClient client_;
diff --git a/cc/trees/layer_tree_host_unittest_damage.cc b/cc/trees/layer_tree_host_unittest_damage.cc
index 7d8535e..f8e44d5 100644
--- a/cc/trees/layer_tree_host_unittest_damage.cc
+++ b/cc/trees/layer_tree_host_unittest_damage.cc
@@ -26,7 +26,7 @@ class LayerTreeHostDamageTest : public LayerTreeTest {};
 // LayerTreeHost::SetNeedsRedraw should damage the whole viewport.
 class LayerTreeHostDamageTestSetNeedsRedraw
     : public LayerTreeHostDamageTest {
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     // Viewport is 10x10.
     scoped_refptr<FakeContentLayer> root = FakeContentLayer::Create(&client_);
     root->SetBounds(gfx::Size(10, 10));
@@ -35,12 +35,12 @@ class LayerTreeHostDamageTestSetNeedsRedraw
     LayerTreeHostDamageTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     draw_count_ = 0;
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         layer_tree_host()->SetNeedsRedraw();
@@ -51,7 +51,7 @@ class LayerTreeHostDamageTestSetNeedsRedraw
   virtual DrawResult PrepareToDrawOnThread(
       LayerTreeHostImpl* impl,
       LayerTreeHostImpl::FrameData* frame_data,
-      DrawResult draw_result) OVERRIDE {
+      DrawResult draw_result) override {
     EXPECT_EQ(DRAW_SUCCESS, draw_result);
 
     RenderSurfaceImpl* root_surface =
@@ -77,7 +77,7 @@ class LayerTreeHostDamageTestSetNeedsRedraw
     return draw_result;
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   int draw_count_;
   FakeContentLayerClient client_;
@@ -88,7 +88,7 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDamageTestSetNeedsRedraw);
 // LayerTreeHost::SetViewportSize should damage the whole viewport.
 class LayerTreeHostDamageTestSetViewportSize
     : public LayerTreeHostDamageTest {
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     // Viewport is 10x10.
     scoped_refptr<FakeContentLayer> root = FakeContentLayer::Create(&client_);
     root->SetBounds(gfx::Size(10, 10));
@@ -97,12 +97,12 @@ class LayerTreeHostDamageTestSetViewportSize
     LayerTreeHostDamageTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     draw_count_ = 0;
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         layer_tree_host()->SetViewportSize(gfx::Size(15, 15));
@@ -113,7 +113,7 @@ class LayerTreeHostDamageTestSetViewportSize
   virtual DrawResult PrepareToDrawOnThread(
       LayerTreeHostImpl* impl,
       LayerTreeHostImpl::FrameData* frame_data,
-      DrawResult draw_result) OVERRIDE {
+      DrawResult draw_result) override {
     EXPECT_EQ(DRAW_SUCCESS, draw_result);
 
     RenderSurfaceImpl* root_surface =
@@ -139,7 +139,7 @@ class LayerTreeHostDamageTestSetViewportSize
     return draw_result;
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   int draw_count_;
   FakeContentLayerClient client_;
@@ -149,14 +149,14 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDamageTestSetViewportSize);
 
 class LayerTreeHostDamageTestNoDamageDoesNotSwap
     : public LayerTreeHostDamageTest {
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     expect_swap_and_succeed_ = 0;
     did_swaps_ = 0;
     did_swap_and_succeed_ = 0;
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     scoped_refptr<FakeContentLayer> root = FakeContentLayer::Create(&client_);
     root->SetBounds(gfx::Size(10, 10));
 
@@ -172,7 +172,7 @@ class LayerTreeHostDamageTestNoDamageDoesNotSwap
   virtual DrawResult PrepareToDrawOnThread(
       LayerTreeHostImpl* host_impl,
       LayerTreeHostImpl::FrameData* frame_data,
-      DrawResult draw_result) OVERRIDE {
+      DrawResult draw_result) override {
     EXPECT_EQ(DRAW_SUCCESS, draw_result);
 
     int source_frame = host_impl->active_tree()->source_frame_number();
@@ -198,14 +198,14 @@ class LayerTreeHostDamageTestNoDamageDoesNotSwap
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
-                                   bool result) OVERRIDE {
+                                   bool result) override {
     ++did_swaps_;
     if (result)
       ++did_swap_and_succeed_;
     EXPECT_EQ(expect_swap_and_succeed_, did_swap_and_succeed_);
   }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     int next_frame = layer_tree_host()->source_frame_number();
     switch (next_frame) {
       case 1:
@@ -224,7 +224,7 @@ class LayerTreeHostDamageTestNoDamageDoesNotSwap
     }
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     EXPECT_EQ(4, did_swaps_);
     EXPECT_EQ(2, expect_swap_and_succeed_);
     EXPECT_EQ(expect_swap_and_succeed_, did_swap_and_succeed_);
@@ -241,11 +241,11 @@ SINGLE_AND_MULTI_THREAD_NOIMPL_TEST_F(
     LayerTreeHostDamageTestNoDamageDoesNotSwap);
 
 class LayerTreeHostDamageTestForcedFullDamage : public LayerTreeHostDamageTest {
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     root_ = FakeContentLayer::Create(&client_);
     child_ = FakeContentLayer::Create(&client_);
 
@@ -261,7 +261,7 @@ class LayerTreeHostDamageTestForcedFullDamage : public LayerTreeHostDamageTest {
   virtual DrawResult PrepareToDrawOnThread(
       LayerTreeHostImpl* host_impl,
       LayerTreeHostImpl::FrameData* frame_data,
-      DrawResult draw_result) OVERRIDE {
+      DrawResult draw_result) override {
     EXPECT_EQ(DRAW_SUCCESS, draw_result);
 
     RenderSurfaceImpl* root_surface =
@@ -334,7 +334,7 @@ class LayerTreeHostDamageTestForcedFullDamage : public LayerTreeHostDamageTest {
     return draw_result;
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     if (!TestEnded())
       layer_tree_host()->SetNeedsCommit();
 
@@ -344,7 +344,7 @@ class LayerTreeHostDamageTestForcedFullDamage : public LayerTreeHostDamageTest {
     }
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> root_;
@@ -355,7 +355,7 @@ class LayerTreeHostDamageTestForcedFullDamage : public LayerTreeHostDamageTest {
 SINGLE_AND_MULTI_THREAD_NOIMPL_TEST_F(LayerTreeHostDamageTestForcedFullDamage);
 
 class LayerTreeHostScrollbarDamageTest : public LayerTreeHostDamageTest {
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     scoped_refptr<Layer> root_layer = Layer::Create();
     root_layer->SetBounds(gfx::Size(400, 400));
     root_layer->SetMasksToBounds(true);
@@ -395,7 +395,7 @@ class LayerTreeHostScrollbarDamageTest : public LayerTreeHostDamageTest {
 
 class LayerTreeHostDamageTestScrollbarDoesDamage
     : public LayerTreeHostScrollbarDamageTest {
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     did_swaps_ = 0;
     PostSetNeedsCommitToMainThread();
   }
@@ -403,7 +403,7 @@ class LayerTreeHostDamageTestScrollbarDoesDamage
   virtual DrawResult PrepareToDrawOnThread(
       LayerTreeHostImpl* host_impl,
       LayerTreeHostImpl::FrameData* frame_data,
-      DrawResult draw_result) OVERRIDE {
+      DrawResult draw_result) override {
     EXPECT_EQ(DRAW_SUCCESS, draw_result);
     RenderSurfaceImpl* root_surface =
         host_impl->active_tree()->root_layer()->render_surface();
@@ -432,7 +432,7 @@ class LayerTreeHostDamageTestScrollbarDoesDamage
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
-                                   bool result) OVERRIDE {
+                                   bool result) override {
     ++did_swaps_;
     EXPECT_TRUE(result);
     LayerImpl* root = host_impl->active_tree()->root_layer();
@@ -458,7 +458,7 @@ class LayerTreeHostDamageTestScrollbarDoesDamage
     }
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     EXPECT_EQ(4, did_swaps_);
   }
 
@@ -469,7 +469,7 @@ MULTI_THREAD_TEST_F(LayerTreeHostDamageTestScrollbarDoesDamage);
 
 class LayerTreeHostDamageTestScrollbarCommitDoesNoDamage
     : public LayerTreeHostScrollbarDamageTest {
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     did_swaps_ = 0;
     PostSetNeedsCommitToMainThread();
   }
@@ -477,7 +477,7 @@ class LayerTreeHostDamageTestScrollbarCommitDoesNoDamage
   virtual DrawResult PrepareToDrawOnThread(
       LayerTreeHostImpl* host_impl,
       LayerTreeHostImpl::FrameData* frame_data,
-      DrawResult draw_result) OVERRIDE {
+      DrawResult draw_result) override {
     EXPECT_EQ(DRAW_SUCCESS, draw_result);
     RenderSurfaceImpl* root_surface =
         host_impl->active_tree()->root_layer()->render_surface();
@@ -508,7 +508,7 @@ class LayerTreeHostDamageTestScrollbarCommitDoesNoDamage
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
-                                   bool result) OVERRIDE {
+                                   bool result) override {
     ++did_swaps_;
     EXPECT_TRUE(result);
     LayerImpl* root = host_impl->active_tree()->root_layer();
@@ -535,7 +535,7 @@ class LayerTreeHostDamageTestScrollbarCommitDoesNoDamage
     }
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     EXPECT_EQ(3, did_swaps_);
   }
 
@@ -547,15 +547,15 @@ MULTI_THREAD_TEST_F(LayerTreeHostDamageTestScrollbarCommitDoesNoDamage);
 class LayerTreeHostDamageTestVisibleTilesStillTriggerDraws
     : public LayerTreeHostDamageTest {
 
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     settings->impl_side_painting = true;
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     scoped_refptr<FakePictureLayer> root = FakePictureLayer::Create(&client_);
     root->SetBounds(gfx::Size(500, 500));
     layer_tree_host()->SetRootLayer(root);
@@ -569,7 +569,7 @@ class LayerTreeHostDamageTestVisibleTilesStillTriggerDraws
   virtual DrawResult PrepareToDrawOnThread(
       LayerTreeHostImpl* host_impl,
       LayerTreeHostImpl::FrameData* frame_data,
-      DrawResult draw_result) OVERRIDE {
+      DrawResult draw_result) override {
     EXPECT_EQ(DRAW_SUCCESS, draw_result);
     prepare_to_draw_count_++;
     switch (prepare_to_draw_count_) {
@@ -600,7 +600,7 @@ class LayerTreeHostDamageTestVisibleTilesStillTriggerDraws
   }
 
   virtual void UpdateVisibleTilesOnThread(
-      LayerTreeHostImpl* host_impl) OVERRIDE {
+      LayerTreeHostImpl* host_impl) override {
     // Simulate creating some visible tiles (that trigger prepare-to-draws).
     // The first we make into a no-damage-frame during prepare-to-draw (see
     // above). This is to ensure we still get UpdateVisibleTiles calls after
@@ -618,13 +618,13 @@ class LayerTreeHostDamageTestVisibleTilesStillTriggerDraws
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
-                                   bool didSwap) OVERRIDE {
+                                   bool didSwap) override {
     if (!didSwap)
       return;
     ++swap_count_;
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     // We should keep getting update-visible-tiles calls
     // until we report there are no more incomplete-tiles.
     EXPECT_EQ(update_visible_tile_count_, 6);
diff --git a/cc/trees/layer_tree_host_unittest_delegated.cc b/cc/trees/layer_tree_host_unittest_delegated.cc
index 247d94e..095513b 100644
--- a/cc/trees/layer_tree_host_unittest_delegated.cc
+++ b/cc/trees/layer_tree_host_unittest_delegated.cc
@@ -251,7 +251,7 @@ class LayerTreeHostDelegatedTestCaseSingleDelegatedLayer
     resource_collection_->SetClient(this);
   }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     root_ = Layer::Create();
     root_->SetBounds(gfx::Size(15, 15));
 
@@ -259,7 +259,7 @@ class LayerTreeHostDelegatedTestCaseSingleDelegatedLayer
     LayerTreeHostDelegatedTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     resource_collection_->SetClient(this);
     PostSetNeedsCommitToMainThread();
   }
@@ -296,10 +296,10 @@ class LayerTreeHostDelegatedTestCaseSingleDelegatedLayer
     return delegated;
   }
 
-  virtual void AfterTest() OVERRIDE { resource_collection_->SetClient(NULL); }
+  virtual void AfterTest() override { resource_collection_->SetClient(NULL); }
 
   // DelegatedFrameProviderClient implementation.
-  virtual void UnusedResourcesAreAvailable() OVERRIDE { available_ = true; }
+  virtual void UnusedResourcesAreAvailable() override { available_ = true; }
 
   bool TestAndResetAvailable() {
     bool available = available_;
@@ -323,13 +323,13 @@ class LayerTreeHostDelegatedTestCreateChildId
         num_activates_(0),
         did_reset_child_id_(false) {}
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     if (TestEnded())
       return;
     SetFrameData(CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)));
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->active_tree()->source_frame_number() < 1)
       return;
 
@@ -360,7 +360,7 @@ class LayerTreeHostDelegatedTestCreateChildId
   }
 
   virtual void InitializedRendererOnThread(LayerTreeHostImpl* host_impl,
-                                           bool success) OVERRIDE {
+                                           bool success) override {
     EXPECT_TRUE(success);
 
     if (num_activates_ < 2)
@@ -391,7 +391,7 @@ class LayerTreeHostDelegatedTestInvalidFrameAfterContextLost
   LayerTreeHostDelegatedTestInvalidFrameAfterContextLost()
       : num_activates_(0), num_output_surfaces_initialized_(0) {}
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     if (TestEnded())
       return;
     scoped_ptr<DelegatedFrameData> frame1 =
@@ -401,7 +401,7 @@ class LayerTreeHostDelegatedTestInvalidFrameAfterContextLost
     SetFrameData(frame1.Pass());
   }
 
-  virtual void DidInitializeOutputSurface() OVERRIDE {
+  virtual void DidInitializeOutputSurface() override {
     if (!num_output_surfaces_initialized_++)
       return;
 
@@ -414,7 +414,7 @@ class LayerTreeHostDelegatedTestInvalidFrameAfterContextLost
     DCHECK(delegated_.get() == old_delegated.get());
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->active_tree()->source_frame_number() < 1)
       return;
 
@@ -435,7 +435,7 @@ class LayerTreeHostDelegatedTestInvalidFrameAfterContextLost
   }
 
   virtual void InitializedRendererOnThread(LayerTreeHostImpl* host_impl,
-                                           bool success) OVERRIDE {
+                                           bool success) override {
     EXPECT_TRUE(success);
 
     if (num_activates_ < 2)
@@ -450,7 +450,7 @@ class LayerTreeHostDelegatedTestInvalidFrameAfterContextLost
     EXPECT_EQ(0U, delegated_impl->Resources().size());
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     LayerTreeHostDelegatedTestCaseSingleDelegatedLayer::AfterTest();
     EXPECT_EQ(2, num_output_surfaces_initialized_);
   }
@@ -470,7 +470,7 @@ class LayerTreeHostDelegatedTestLayerUsesFrameDamage
       : LayerTreeHostDelegatedTestCaseSingleDelegatedLayer(),
         first_draw_for_source_frame_(true) {}
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     int next_source_frame_number = layer_tree_host()->source_frame_number();
     switch (next_source_frame_number) {
       case 1:
@@ -583,7 +583,7 @@ class LayerTreeHostDelegatedTestLayerUsesFrameDamage
   virtual DrawResult PrepareToDrawOnThread(
       LayerTreeHostImpl* host_impl,
       LayerTreeHostImpl::FrameData* frame,
-      DrawResult draw_result) OVERRIDE {
+      DrawResult draw_result) override {
     EXPECT_EQ(DRAW_SUCCESS, draw_result);
 
     if (!first_draw_for_source_frame_)
@@ -674,7 +674,7 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestLayerUsesFrameDamage);
 class LayerTreeHostDelegatedTestMergeResources
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
  public:
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     // Push two frames to the delegated renderer layer with no commit between.
 
     // The first frame has resource 999.
@@ -707,7 +707,7 @@ class LayerTreeHostDelegatedTestMergeResources
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
         static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
@@ -734,7 +734,7 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestMergeResources);
 class LayerTreeHostDelegatedTestRemapResourcesInQuads
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
  public:
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     // Generate a frame with two resources in it.
     scoped_ptr<DelegatedFrameData> frame =
         CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
@@ -747,7 +747,7 @@ class LayerTreeHostDelegatedTestRemapResourcesInQuads
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
         static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
@@ -783,11 +783,11 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestRemapResourcesInQuads);
 class LayerTreeHostDelegatedTestReturnUnusedResources
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
  public:
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     scoped_ptr<DelegatedFrameData> frame;
     ReturnedResourceArray resources;
 
@@ -856,7 +856,7 @@ class LayerTreeHostDelegatedTestReturnUnusedResources
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
-                                   bool result) OVERRIDE {
+                                   bool result) override {
     ReturnUnusedResourcesFromParent(host_impl);
   }
 };
@@ -867,11 +867,11 @@ SINGLE_AND_MULTI_THREAD_TEST_F(
 class LayerTreeHostDelegatedTestReusedResources
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
  public:
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     scoped_ptr<DelegatedFrameData> frame;
     ReturnedResourceArray resources;
 
@@ -928,7 +928,7 @@ class LayerTreeHostDelegatedTestReusedResources
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
-                                   bool result) OVERRIDE {
+                                   bool result) override {
     ReturnUnusedResourcesFromParent(host_impl);
   }
 };
@@ -938,11 +938,11 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestReusedResources);
 class LayerTreeHostDelegatedTestFrameBeforeAck
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
  public:
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     scoped_ptr<DelegatedFrameData> frame;
     ReturnedResourceArray resources;
 
@@ -997,7 +997,7 @@ class LayerTreeHostDelegatedTestFrameBeforeAck
     }
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->active_tree()->source_frame_number() != 3)
       return;
 
@@ -1028,7 +1028,7 @@ class LayerTreeHostDelegatedTestFrameBeforeAck
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
-                                   bool result) OVERRIDE {
+                                   bool result) override {
     ReturnUnusedResourcesFromParent(host_impl);
   }
 };
@@ -1038,11 +1038,11 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestFrameBeforeAck);
 class LayerTreeHostDelegatedTestFrameBeforeTakeResources
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
  public:
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     scoped_ptr<DelegatedFrameData> frame;
     ReturnedResourceArray resources;
 
@@ -1109,7 +1109,7 @@ class LayerTreeHostDelegatedTestFrameBeforeTakeResources
     }
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->active_tree()->source_frame_number() != 3)
       return;
 
@@ -1147,7 +1147,7 @@ class LayerTreeHostDelegatedTestFrameBeforeTakeResources
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
-                                   bool result) OVERRIDE {
+                                   bool result) override {
     ReturnUnusedResourcesFromParent(host_impl);
   }
 };
@@ -1158,11 +1158,11 @@ SINGLE_AND_MULTI_THREAD_TEST_F(
 class LayerTreeHostDelegatedTestBadFrame
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
  public:
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     scoped_ptr<DelegatedFrameData> frame;
     ReturnedResourceArray resources;
 
@@ -1230,7 +1230,7 @@ class LayerTreeHostDelegatedTestBadFrame
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
-                                   bool result) OVERRIDE {
+                                   bool result) override {
     if (host_impl->active_tree()->source_frame_number() < 1)
       return;
 
@@ -1312,11 +1312,11 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestBadFrame);
 class LayerTreeHostDelegatedTestUnnamedResource
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
  public:
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     scoped_ptr<DelegatedFrameData> frame;
     ReturnedResourceArray resources;
 
@@ -1352,7 +1352,7 @@ class LayerTreeHostDelegatedTestUnnamedResource
     }
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->active_tree()->source_frame_number() != 1)
       return;
 
@@ -1378,11 +1378,11 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestUnnamedResource);
 class LayerTreeHostDelegatedTestDontLeakResource
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
  public:
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     scoped_ptr<DelegatedFrameData> frame;
     ReturnedResourceArray resources;
 
@@ -1430,7 +1430,7 @@ class LayerTreeHostDelegatedTestDontLeakResource
     }
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->active_tree()->source_frame_number() != 1)
       return;
 
@@ -1451,7 +1451,7 @@ class LayerTreeHostDelegatedTestDontLeakResource
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
-                                   bool result) OVERRIDE {
+                                   bool result) override {
     ReturnUnusedResourcesFromParent(host_impl);
   }
 };
@@ -1461,7 +1461,7 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestDontLeakResource);
 class LayerTreeHostDelegatedTestResourceSentToParent
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
  public:
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     scoped_ptr<DelegatedFrameData> frame;
     ReturnedResourceArray resources;
 
@@ -1516,7 +1516,7 @@ class LayerTreeHostDelegatedTestResourceSentToParent
     host_impl->ReclaimResources(&ack);
   }
 
-  virtual void UnusedResourcesAreAvailable() OVERRIDE {
+  virtual void UnusedResourcesAreAvailable() override {
     EXPECT_EQ(3, layer_tree_host()->source_frame_number());
 
     ReturnedResourceArray resources;
@@ -1531,7 +1531,7 @@ class LayerTreeHostDelegatedTestResourceSentToParent
     EndTest();
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->active_tree()->source_frame_number() < 1)
       return;
 
@@ -1592,13 +1592,13 @@ SINGLE_AND_MULTI_THREAD_DELEGATING_RENDERER_TEST_F(
 class LayerTreeHostDelegatedTestCommitWithoutTake
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
  public:
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     // Prevent drawing with resources that are sent to the grandparent.
     layer_tree_host()->SetViewportSize(gfx::Size());
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     scoped_ptr<DelegatedFrameData> frame;
     ReturnedResourceArray resources;
 
@@ -1664,7 +1664,7 @@ class LayerTreeHostDelegatedTestCommitWithoutTake
     }
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->active_tree()->source_frame_number() < 1)
       return;
 
@@ -1714,7 +1714,7 @@ class DelegatedFrameIsActivatedDuringCommit
  protected:
   DelegatedFrameIsActivatedDuringCommit() : returned_resource_count_(0) {}
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     activate_count_ = 0;
 
     scoped_ptr<DelegatedFrameData> frame =
@@ -1726,11 +1726,11 @@ class DelegatedFrameIsActivatedDuringCommit
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void WillActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void WillActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     ++activate_count_;
   }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1: {
         // The first frame has been activated. Set a new frame, and
@@ -1757,7 +1757,7 @@ class DelegatedFrameIsActivatedDuringCommit
     }
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     switch (host_impl->active_tree()->source_frame_number()) {
       case 0: {
         // The activate for the 1st frame should have happened before now.
@@ -1782,11 +1782,11 @@ class DelegatedFrameIsActivatedDuringCommit
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
-                                   bool result) OVERRIDE {
+                                   bool result) override {
     ReturnUnusedResourcesFromParent(host_impl);
   }
 
-  virtual void UnusedResourcesAreAvailable() OVERRIDE {
+  virtual void UnusedResourcesAreAvailable() override {
     LayerTreeHostDelegatedTestCaseSingleDelegatedLayer::
         UnusedResourcesAreAvailable();
     ReturnedResourceArray resources;
@@ -1807,9 +1807,9 @@ SINGLE_AND_MULTI_THREAD_TEST_F(
 class LayerTreeHostDelegatedTestTwoImplLayers
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
  public:
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     scoped_ptr<DelegatedFrameData> frame;
     ReturnedResourceArray resources;
 
@@ -1857,7 +1857,7 @@ class LayerTreeHostDelegatedTestTwoImplLayers
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
-                                   bool result) OVERRIDE {
+                                   bool result) override {
     ReturnUnusedResourcesFromParent(host_impl);
   }
 };
@@ -1867,9 +1867,9 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestTwoImplLayers);
 class LayerTreeHostDelegatedTestTwoImplLayersTwoFrames
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
  public:
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     scoped_ptr<DelegatedFrameData> frame;
     ReturnedResourceArray resources;
 
@@ -1926,7 +1926,7 @@ class LayerTreeHostDelegatedTestTwoImplLayersTwoFrames
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
-                                   bool result) OVERRIDE {
+                                   bool result) override {
     ReturnUnusedResourcesFromParent(host_impl);
   }
 };
@@ -1937,9 +1937,9 @@ SINGLE_AND_MULTI_THREAD_TEST_F(
 class LayerTreeHostDelegatedTestTwoLayers
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
  public:
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     scoped_ptr<DelegatedFrameData> frame;
     ReturnedResourceArray resources;
 
@@ -2013,7 +2013,7 @@ class LayerTreeHostDelegatedTestTwoLayers
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
-                                   bool result) OVERRIDE {
+                                   bool result) override {
     ReturnUnusedResourcesFromParent(host_impl);
   }
 
@@ -2025,9 +2025,9 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestTwoLayers);
 class LayerTreeHostDelegatedTestRemoveAndAddToTree
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
  public:
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     scoped_ptr<DelegatedFrameData> frame;
     ReturnedResourceArray resources;
 
@@ -2105,7 +2105,7 @@ class LayerTreeHostDelegatedTestRemoveAndAddToTree
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
-                                   bool result) OVERRIDE {
+                                   bool result) override {
     ReturnUnusedResourcesFromParent(host_impl);
   }
 
@@ -2117,9 +2117,9 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestRemoveAndAddToTree);
 class LayerTreeHostDelegatedTestRemoveAndChangeResources
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
  public:
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() override {
     scoped_ptr<DelegatedFrameData> frame;
     ReturnedResourceArray resources;
 
@@ -2187,7 +2187,7 @@ class LayerTreeHostDelegatedTestRemoveAndChangeResources
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
-                                   bool result) OVERRIDE {
+                                   bool result) override {
     ReturnUnusedResourcesFromParent(host_impl);
   }
 
diff --git a/cc/trees/layer_tree_host_unittest_no_message_loop.cc b/cc/trees/layer_tree_host_unittest_no_message_loop.cc
index a48156b..fb0e2be 100644
--- a/cc/trees/layer_tree_host_unittest_no_message_loop.cc
+++ b/cc/trees/layer_tree_host_unittest_no_message_loop.cc
@@ -31,7 +31,7 @@ class NoMessageLoopOutputSurface : public OutputSurface {
   virtual ~NoMessageLoopOutputSurface() {}
 
   // OutputSurface overrides.
-  virtual void SwapBuffers(CompositorFrame* frame) OVERRIDE {
+  virtual void SwapBuffers(CompositorFrame* frame) override {
     DCHECK(client_);
     client_->DidSwapBuffers();
     client_->DidSwapBuffersComplete();
@@ -53,34 +53,34 @@ class LayerTreeHostNoMessageLoopTest
   virtual ~LayerTreeHostNoMessageLoopTest() {}
 
   // LayerTreeHostClient overrides.
-  virtual void WillBeginMainFrame(int frame_id) OVERRIDE {}
-  virtual void BeginMainFrame(const BeginFrameArgs& args) OVERRIDE {}
-  virtual void DidBeginMainFrame() OVERRIDE {}
-  virtual void Layout() OVERRIDE {}
+  virtual void WillBeginMainFrame(int frame_id) override {}
+  virtual void BeginMainFrame(const BeginFrameArgs& args) override {}
+  virtual void DidBeginMainFrame() override {}
+  virtual void Layout() override {}
   virtual void ApplyViewportDeltas(const gfx::Vector2d& inner_delta,
                                    const gfx::Vector2d& outer_delta,
                                    float page_scale,
-                                   float top_controls_delta) OVERRIDE {}
+                                   float top_controls_delta) override {}
   virtual void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
                                    float page_scale,
-                                   float top_controls_delta) OVERRIDE {}
-  virtual void RequestNewOutputSurface(bool fallback) OVERRIDE {
+                                   float top_controls_delta) override {}
+  virtual void RequestNewOutputSurface(bool fallback) override {
     layer_tree_host_->SetOutputSurface(
         make_scoped_ptr<OutputSurface>(new NoMessageLoopOutputSurface));
   }
-  virtual void DidInitializeOutputSurface() OVERRIDE {
+  virtual void DidInitializeOutputSurface() override {
     did_initialize_output_surface_ = true;
   }
-  virtual void WillCommit() OVERRIDE {}
-  virtual void DidCommit() OVERRIDE { did_commit_ = true; }
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void WillCommit() override {}
+  virtual void DidCommit() override { did_commit_ = true; }
+  virtual void DidCommitAndDrawFrame() override {
     did_commit_and_draw_frame_ = true;
   }
-  virtual void DidCompleteSwapBuffers() OVERRIDE {}
+  virtual void DidCompleteSwapBuffers() override {}
 
   // LayerTreeHostSingleThreadClient overrides.
-  virtual void DidPostSwapBuffers() OVERRIDE {}
-  virtual void DidAbortSwapBuffers() OVERRIDE {}
+  virtual void DidPostSwapBuffers() override {}
+  virtual void DidAbortSwapBuffers() override {}
 
   void RunTest() {
     no_loop_thread_.Start();
@@ -88,7 +88,7 @@ class LayerTreeHostNoMessageLoopTest
   }
 
   // base::DelegateSimpleThread::Delegate override.
-  virtual void Run() OVERRIDE {
+  virtual void Run() override {
     ASSERT_FALSE(base::MessageLoopProxy::current().get());
     RunTestWithoutMessageLoop();
     EXPECT_FALSE(base::MessageLoopProxy::current().get());
@@ -137,7 +137,7 @@ class LayerTreeHostNoMessageLoopTest
 class LayerTreeHostNoMessageLoopSmokeTest
     : public LayerTreeHostNoMessageLoopTest {
  protected:
-  virtual void RunTestWithoutMessageLoop() OVERRIDE {
+  virtual void RunTestWithoutMessageLoop() override {
     gfx::Size size(100, 100);
 
     // Set up root layer.
@@ -164,7 +164,7 @@ class LayerTreeHostNoMessageLoopDelegatedLayer
     : public LayerTreeHostNoMessageLoopTest,
       public DelegatedFrameResourceCollectionClient {
  protected:
-  virtual void RunTestWithoutMessageLoop() OVERRIDE {
+  virtual void RunTestWithoutMessageLoop() override {
     resource_collection_ = new DelegatedFrameResourceCollection;
     frame_provider_ = new DelegatedFrameProvider(
         resource_collection_.get(), CreateFrameDataWithResource(998));
@@ -198,7 +198,7 @@ class LayerTreeHostNoMessageLoopDelegatedLayer
   }
 
   // DelegatedFrameResourceCollectionClient overrides.
-  virtual void UnusedResourcesAreAvailable() OVERRIDE {}
+  virtual void UnusedResourcesAreAvailable() override {}
 
  private:
   scoped_ptr<DelegatedFrameData> CreateFrameDataWithResource(
diff --git a/cc/trees/layer_tree_host_unittest_occlusion.cc b/cc/trees/layer_tree_host_unittest_occlusion.cc
index 3a572d3..943299d 100644
--- a/cc/trees/layer_tree_host_unittest_occlusion.cc
+++ b/cc/trees/layer_tree_host_unittest_occlusion.cc
@@ -20,7 +20,7 @@ class TestLayer : public Layer {
   }
 
   virtual bool Update(ResourceUpdateQueue* update_queue,
-                      const OcclusionTracker<Layer>* occlusion) OVERRIDE {
+                      const OcclusionTracker<Layer>* occlusion) override {
     if (!occlusion)
       return false;
 
@@ -60,18 +60,18 @@ class LayerTreeHostOcclusionTest : public LayerTreeTest {
         mask_(TestLayer::Create()) {
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     TestLayer* root = static_cast<TestLayer*>(layer_tree_host()->root_layer());
     VerifyOcclusion(root);
 
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   void VerifyOcclusion(TestLayer* layer) const {
     EXPECT_EQ(layer->expected_occlusion().ToString(),
@@ -99,7 +99,7 @@ class LayerTreeHostOcclusionTest : public LayerTreeTest {
   }
 
  protected:
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     settings->minimum_occlusion_tracking_size = gfx::Size();
   }
 
@@ -116,7 +116,7 @@ class LayerTreeHostOcclusionTest : public LayerTreeTest {
 class LayerTreeHostOcclusionTestOcclusionSurfaceClipping
     : public LayerTreeHostOcclusionTest {
  public:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     // The child layer is a surface and the grand_child is opaque, but clipped
     // to the child and root
     SetLayerPropertiesForTesting(
@@ -146,7 +146,7 @@ SINGLE_AND_MULTI_THREAD_TEST_F(
 class LayerTreeHostOcclusionTestOcclusionSurfaceClippingOpaque
     : public LayerTreeHostOcclusionTest {
  public:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     // If the child layer is opaque, then it adds to the occlusion seen by the
     // root_.
     SetLayerPropertiesForTesting(
@@ -176,7 +176,7 @@ SINGLE_AND_MULTI_THREAD_TEST_F(
 class LayerTreeHostOcclusionTestOcclusionTwoChildren
     : public LayerTreeHostOcclusionTest {
  public:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     // Add a second child to the root layer and the regions should merge
     SetLayerPropertiesForTesting(
         root_.get(), NULL, identity_matrix_,
@@ -209,7 +209,7 @@ SINGLE_AND_MULTI_THREAD_TEST_F(
 class LayerTreeHostOcclusionTestOcclusionMask
     : public LayerTreeHostOcclusionTest {
  public:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     // If the child layer has a mask on it, then it shouldn't contribute to
     // occlusion on stuff below it.
     SetLayerPropertiesForTesting(
@@ -242,7 +242,7 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostOcclusionTestOcclusionMask);
 class LayerTreeHostOcclusionTestOcclusionMaskBelowOcclusion
     : public LayerTreeHostOcclusionTest {
  public:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     // If the child layer with a mask is below child2, then child2 should
     // contribute to occlusion on everything, and child shouldn't contribute
     // to the root_.
@@ -278,7 +278,7 @@ SINGLE_AND_MULTI_THREAD_TEST_F(
 class LayerTreeHostOcclusionTestOcclusionOpacity
     : public LayerTreeHostOcclusionTest {
  public:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     // If the child layer has a non-opaque opacity, then it shouldn't
     // contribute to occlusion on stuff below it
     SetLayerPropertiesForTesting(
@@ -311,7 +311,7 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostOcclusionTestOcclusionOpacity);
 class LayerTreeHostOcclusionTestOcclusionOpacityBelowOcclusion
     : public LayerTreeHostOcclusionTest {
  public:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     // If the child layer with non-opaque opacity is below child2, then
     // child2 should contribute to occlusion on everything, and child shouldn't
     // contribute to the root_.
@@ -347,7 +347,7 @@ SINGLE_AND_MULTI_THREAD_TEST_F(
 class LayerTreeHostOcclusionTestOcclusionBlending
     : public LayerTreeHostOcclusionTest {
  public:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     // If the child layer has a blend mode, then it shouldn't
     // contribute to occlusion on stuff below it
     SetLayerPropertiesForTesting(
@@ -380,7 +380,7 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostOcclusionTestOcclusionBlending);
 class LayerTreeHostOcclusionTestOcclusionBlendingBelowOcclusion
     : public LayerTreeHostOcclusionTest {
  public:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     // If the child layer with a blend mode is below child2, then
     // child2 should contribute to occlusion on everything, and child shouldn't
     // contribute to the root_.
@@ -415,7 +415,7 @@ SINGLE_AND_MULTI_THREAD_TEST_F(
 class LayerTreeHostOcclusionTestOcclusionOpacityFilter
     : public LayerTreeHostOcclusionTest {
  public:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     FilterOperations filters;
     filters.Append(FilterOperation::CreateOpacityFilter(0.5f));
 
@@ -467,7 +467,7 @@ SINGLE_AND_MULTI_THREAD_TEST_F(
 class LayerTreeHostOcclusionTestOcclusionBlurFilter
     : public LayerTreeHostOcclusionTest {
  public:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     gfx::Transform child_transform;
     child_transform.Translate(250.0, 250.0);
     child_transform.Rotate(90.0);
@@ -511,7 +511,7 @@ class LayerTreeHostOcclusionTestOcclusionCopyRequest
  public:
   static void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {}
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     // If the child layer has copy request, and is below child2,
     // then child should not inherit occlusion from outside its subtree.
     // The child layer will still receive occlusion from inside, and
@@ -546,7 +546,7 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostOcclusionTestOcclusionCopyRequest);
 class LayerTreeHostOcclusionTestOcclusionReplica
     : public LayerTreeHostOcclusionTest {
  public:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     // If the child layer has copy request, and is below child2,
     // then child should not inherit occlusion from outside its subtree.
     // The child layer will still receive occlusion from inside, and
@@ -581,7 +581,7 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostOcclusionTestOcclusionReplica);
 class LayerTreeHostOcclusionTestManySurfaces
     : public LayerTreeHostOcclusionTest {
  public:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     // We create enough RenderSurfaces that it will trigger Vector reallocation
     // while computing occlusion.
     std::vector<scoped_refptr<TestLayer> > layers;
diff --git a/cc/trees/layer_tree_host_unittest_picture.cc b/cc/trees/layer_tree_host_unittest_picture.cc
index 731f6921..a79d075 100644
--- a/cc/trees/layer_tree_host_unittest_picture.cc
+++ b/cc/trees/layer_tree_host_unittest_picture.cc
@@ -16,7 +16,7 @@ namespace {
 // These tests deal with picture layers.
 class LayerTreeHostPictureTest : public LayerTreeTest {
  protected:
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     // PictureLayer can only be used with impl side painting enabled.
     settings->impl_side_painting = true;
   }
@@ -24,7 +24,7 @@ class LayerTreeHostPictureTest : public LayerTreeTest {
 
 class LayerTreeHostPictureTestTwinLayer
     : public LayerTreeHostPictureTest {
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     LayerTreeHostPictureTest::SetupTree();
 
     scoped_refptr<FakePictureLayer> picture =
@@ -32,12 +32,12 @@ class LayerTreeHostPictureTestTwinLayer
     layer_tree_host()->root_layer()->AddChild(picture);
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     activates_ = 0;
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 2:
         // Drop the picture layer from the tree.
@@ -52,7 +52,7 @@ class LayerTreeHostPictureTestTwinLayer
     }
   }
 
-  virtual void WillActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void WillActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* pending_root_impl = impl->pending_tree()->root_layer();
     LayerImpl* active_root_impl = impl->active_tree()->root_layer();
 
@@ -88,7 +88,7 @@ class LayerTreeHostPictureTestTwinLayer
     EXPECT_EQ(active_picture_impl, pending_picture_impl->twin_layer());
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* active_root_impl = impl->active_tree()->root_layer();
 
     if (active_root_impl->children().empty()) {
@@ -107,7 +107,7 @@ class LayerTreeHostPictureTestTwinLayer
       EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   FakeContentLayerClient client_;
   int activates_;
diff --git a/cc/trees/layer_tree_host_unittest_proxy.cc b/cc/trees/layer_tree_host_unittest_proxy.cc
index 4f79311..5993479 100644
--- a/cc/trees/layer_tree_host_unittest_proxy.cc
+++ b/cc/trees/layer_tree_host_unittest_proxy.cc
@@ -37,8 +37,8 @@ class ProxyTest : public LayerTreeTest {
     RunTest(threaded, delegating_renderer, impl_side_painting);
   }
 
-  virtual void BeginTest() OVERRIDE {}
-  virtual void AfterTest() OVERRIDE {}
+  virtual void BeginTest() override {}
+  virtual void AfterTest() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ProxyTest);
@@ -46,28 +46,28 @@ class ProxyTest : public LayerTreeTest {
 
 class ProxyTestScheduledActionsBasic : public ProxyTest {
  protected:
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     proxy()->SetNeedsCommit();
   }
 
-  virtual void ScheduledActionBeginOutputSurfaceCreation() OVERRIDE {
+  virtual void ScheduledActionBeginOutputSurfaceCreation() override {
     EXPECT_EQ(0, action_phase_++);
   }
 
-  virtual void ScheduledActionSendBeginMainFrame() OVERRIDE {
+  virtual void ScheduledActionSendBeginMainFrame() override {
     EXPECT_EQ(1, action_phase_++);
   }
 
-  virtual void ScheduledActionCommit() OVERRIDE {
+  virtual void ScheduledActionCommit() override {
     EXPECT_EQ(2, action_phase_++);
   }
 
-  virtual void ScheduledActionDrawAndSwapIfPossible() OVERRIDE {
+  virtual void ScheduledActionDrawAndSwapIfPossible() override {
     EXPECT_EQ(3, action_phase_++);
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     EXPECT_EQ(4, action_phase_);
   }
 
@@ -109,7 +109,7 @@ class ThreadProxyTestSetNeedsCommit : public ThreadProxyTest {
   ThreadProxyTestSetNeedsCommit() {}
   virtual ~ThreadProxyTestSetNeedsCommit() {}
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     EXPECT_FALSE(ThreadProxyMainOnly().commit_requested);
     EXPECT_FALSE(ThreadProxyMainOnly().commit_request_sent_to_impl_thread);
 
@@ -119,7 +119,7 @@ class ThreadProxyTestSetNeedsCommit : public ThreadProxyTest {
     EXPECT_TRUE(ThreadProxyMainOnly().commit_request_sent_to_impl_thread);
   }
 
-  virtual void DidBeginMainFrame() OVERRIDE {
+  virtual void DidBeginMainFrame() override {
     EXPECT_FALSE(ThreadProxyMainOnly().commit_requested);
     EXPECT_FALSE(ThreadProxyMainOnly().commit_request_sent_to_impl_thread);
 
diff --git a/cc/trees/layer_tree_host_unittest_scroll.cc b/cc/trees/layer_tree_host_unittest_scroll.cc
index 4f18d00..82cee89 100644
--- a/cc/trees/layer_tree_host_unittest_scroll.cc
+++ b/cc/trees/layer_tree_host_unittest_scroll.cc
@@ -33,7 +33,7 @@ class LayerTreeHostScrollTestScrollSimple : public LayerTreeHostScrollTest {
         scroll_amount_(2, -1),
         num_scrolls_(0) {}
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     Layer* root_layer = layer_tree_host()->root_layer();
     scoped_refptr<Layer> scroll_layer = Layer::Create();
     root_layer->AddChild(scroll_layer);
@@ -48,7 +48,7 @@ class LayerTreeHostScrollTestScrollSimple : public LayerTreeHostScrollTest {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void Layout() OVERRIDE {
+  virtual void Layout() override {
     Layer* root = layer_tree_host()->root_layer();
     Layer* scroll_layer = root->children()[0].get();
     if (!layer_tree_host()->source_frame_number()) {
@@ -63,7 +63,7 @@ class LayerTreeHostScrollTestScrollSimple : public LayerTreeHostScrollTest {
     }
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* root = impl->active_tree()->root_layer();
     LayerImpl* scroll_layer = root->children()[0];
     EXPECT_VECTOR_EQ(gfx::Vector2d(), scroll_layer->ScrollDelta());
@@ -89,11 +89,11 @@ class LayerTreeHostScrollTestScrollSimple : public LayerTreeHostScrollTest {
 
   virtual void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
                                    float scale,
-                                   float top_controls_delta) OVERRIDE {
+                                   float top_controls_delta) override {
     num_scrolls_++;
   }
 
-  virtual void AfterTest() OVERRIDE { EXPECT_EQ(1, num_scrolls_); }
+  virtual void AfterTest() override { EXPECT_EQ(1, num_scrolls_); }
 
  private:
   gfx::ScrollOffset initial_scroll_;
@@ -110,7 +110,7 @@ class LayerTreeHostScrollTestScrollMultipleRedraw
   LayerTreeHostScrollTestScrollMultipleRedraw()
       : initial_scroll_(40, 10), scroll_amount_(-3, 17), num_scrolls_(0) {}
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     Layer* root_layer = layer_tree_host()->root_layer();
     scroll_layer_ = Layer::Create();
     root_layer->AddChild(scroll_layer_);
@@ -125,7 +125,7 @@ class LayerTreeHostScrollTestScrollMultipleRedraw
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void BeginCommitOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void BeginCommitOnThread(LayerTreeHostImpl* impl) override {
     switch (layer_tree_host()->source_frame_number()) {
       case 0:
         EXPECT_VECTOR_EQ(scroll_layer_->scroll_offset(), initial_scroll_);
@@ -144,7 +144,7 @@ class LayerTreeHostScrollTestScrollMultipleRedraw
     }
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* scroll_layer =
         impl->active_tree()->LayerById(scroll_layer_->id());
     if (impl->active_tree()->source_frame_number() == 0 &&
@@ -180,11 +180,11 @@ class LayerTreeHostScrollTestScrollMultipleRedraw
 
   virtual void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
                                    float scale,
-                                   float top_controls_delta) OVERRIDE {
+                                   float top_controls_delta) override {
     num_scrolls_++;
   }
 
-  virtual void AfterTest() OVERRIDE { EXPECT_EQ(1, num_scrolls_); }
+  virtual void AfterTest() override { EXPECT_EQ(1, num_scrolls_); }
 
  private:
   gfx::ScrollOffset initial_scroll_;
@@ -210,9 +210,9 @@ class LayerTreeHostScrollTestScrollAbortedCommit
         num_impl_commits_(0),
         num_impl_scrolls_(0) {}
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     LayerTreeHostScrollTest::SetupTree();
     Layer* root_layer = layer_tree_host()->root_layer();
     scoped_refptr<Layer> root_scroll_layer = Layer::Create();
@@ -228,7 +228,7 @@ class LayerTreeHostScrollTestScrollAbortedCommit
     layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.01f, 100.f);
   }
 
-  virtual void WillBeginMainFrame() OVERRIDE {
+  virtual void WillBeginMainFrame() override {
     num_will_begin_main_frames_++;
     Layer* root_scroll_layer =
         layer_tree_host()->root_layer()->children()[0].get();
@@ -280,17 +280,17 @@ class LayerTreeHostScrollTestScrollAbortedCommit
     }
   }
 
-  virtual void DidBeginMainFrame() OVERRIDE { num_did_begin_main_frames_++; }
+  virtual void DidBeginMainFrame() override { num_did_begin_main_frames_++; }
 
-  virtual void WillCommit() OVERRIDE { num_will_commits_++; }
+  virtual void WillCommit() override { num_will_commits_++; }
 
-  virtual void DidCommit() OVERRIDE { num_did_commits_++; }
+  virtual void DidCommit() override { num_did_commits_++; }
 
-  virtual void BeginCommitOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void BeginCommitOnThread(LayerTreeHostImpl* impl) override {
     num_impl_commits_++;
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* root_scroll_layer =
         impl->active_tree()->root_layer()->children()[0];
 
@@ -360,11 +360,11 @@ class LayerTreeHostScrollTestScrollAbortedCommit
 
   virtual void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
                                    float scale,
-                                   float top_controls_delta) OVERRIDE {
+                                   float top_controls_delta) override {
     num_impl_scrolls_++;
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     EXPECT_EQ(3, num_impl_scrolls_);
     // Verify that the embedder sees aborted commits as real commits.
     EXPECT_EQ(4, num_will_begin_main_frames_);
@@ -394,7 +394,7 @@ class LayerTreeHostScrollTestFractionalScroll : public LayerTreeHostScrollTest {
  public:
   LayerTreeHostScrollTestFractionalScroll() : scroll_amount_(1.75, 0) {}
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     LayerTreeHostScrollTest::SetupTree();
     Layer* root_layer = layer_tree_host()->root_layer();
     scoped_refptr<Layer> root_scroll_layer = Layer::Create();
@@ -411,11 +411,11 @@ class LayerTreeHostScrollTestFractionalScroll : public LayerTreeHostScrollTest {
     layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.01f, 100.f);
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* root = impl->active_tree()->root_layer();
     LayerImpl* scroll_layer = root->children()[0];
 
@@ -447,7 +447,7 @@ class LayerTreeHostScrollTestFractionalScroll : public LayerTreeHostScrollTest {
     scroll_layer->ScrollBy(scroll_amount_);
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   gfx::Vector2dF scroll_amount_;
@@ -463,7 +463,7 @@ class LayerTreeHostScrollTestCaseWithChild : public LayerTreeHostScrollTest {
         scroll_amount_(2, -1),
         num_scrolls_(0) {}
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     layer_tree_host()->SetDeviceScaleFactor(device_scale_factor_);
 
     scoped_refptr<Layer> root_layer = Layer::Create();
@@ -516,9 +516,9 @@ class LayerTreeHostScrollTestCaseWithChild : public LayerTreeHostScrollTest {
     LayerTreeHostScrollTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void WillCommit() OVERRIDE {
+  virtual void WillCommit() override {
     // Keep the test committing (otherwise the early out for no update
     // will stall the test).
     if (layer_tree_host()->source_frame_number() < 2) {
@@ -532,11 +532,11 @@ class LayerTreeHostScrollTestCaseWithChild : public LayerTreeHostScrollTest {
 
   virtual void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
                                    float scale,
-                                   float top_controls_delta) OVERRIDE {
+                                   float top_controls_delta) override {
     num_scrolls_++;
   }
 
-  virtual void Layout() OVERRIDE {
+  virtual void Layout() override {
     EXPECT_VECTOR_EQ(gfx::Vector2d(),
                      expected_no_scroll_layer_->scroll_offset());
 
@@ -561,7 +561,7 @@ class LayerTreeHostScrollTestCaseWithChild : public LayerTreeHostScrollTest {
     }
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* root_impl = impl->active_tree()->root_layer();
     FakePictureLayerImpl* root_scroll_layer_impl =
         static_cast<FakePictureLayerImpl*>(root_impl->children()[0]);
@@ -632,7 +632,7 @@ class LayerTreeHostScrollTestCaseWithChild : public LayerTreeHostScrollTest {
     }
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     if (scroll_child_layer_) {
       EXPECT_EQ(0, num_scrolls_);
       EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(javascript_scroll_,
@@ -748,11 +748,11 @@ TEST_F(LayerTreeHostScrollTestCaseWithChild,
 
 class ImplSidePaintingScrollTest : public LayerTreeHostScrollTest {
  public:
-  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+  virtual void InitializeSettings(LayerTreeSettings* settings) override {
     settings->impl_side_painting = true;
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     if (impl->pending_tree())
       impl->SetNeedsRedraw();
   }
@@ -767,7 +767,7 @@ class ImplSidePaintingScrollTestSimple : public ImplSidePaintingScrollTest {
         impl_thread_scroll2_(-3, 10),
         num_scrolls_(0) {}
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     LayerTreeHostScrollTest::SetupTree();
     Layer* root_layer = layer_tree_host()->root_layer();
     scoped_refptr<Layer> root_scroll_layer = Layer::Create();
@@ -785,11 +785,11 @@ class ImplSidePaintingScrollTestSimple : public ImplSidePaintingScrollTest {
     layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.01f, 100.f);
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void Layout() OVERRIDE {
+  virtual void Layout() override {
     Layer* root = layer_tree_host()->root_layer();
     Layer* scroll_layer = root->children()[0].get();
     if (!layer_tree_host()->source_frame_number()) {
@@ -807,14 +807,14 @@ class ImplSidePaintingScrollTestSimple : public ImplSidePaintingScrollTest {
     }
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     // We force a second draw here of the first commit before activating
     // the second commit.
     if (impl->active_tree()->source_frame_number() == 0)
       impl->SetNeedsRedraw();
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     ImplSidePaintingScrollTest::DrawLayersOnThread(impl);
 
     LayerImpl* root = impl->active_tree()->root_layer();
@@ -874,11 +874,11 @@ class ImplSidePaintingScrollTestSimple : public ImplSidePaintingScrollTest {
 
   virtual void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
                                    float scale,
-                                   float top_controls_delta) OVERRIDE {
+                                   float top_controls_delta) override {
     num_scrolls_++;
   }
 
-  virtual void AfterTest() OVERRIDE { EXPECT_EQ(1, num_scrolls_); }
+  virtual void AfterTest() override { EXPECT_EQ(1, num_scrolls_); }
 
  private:
   gfx::ScrollOffset initial_scroll_;
@@ -900,7 +900,7 @@ class ImplSidePaintingScrollTestImplOnlyScroll
   ImplSidePaintingScrollTestImplOnlyScroll()
       : initial_scroll_(20, 10), impl_thread_scroll_(-2, 3) {}
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     LayerTreeHostScrollTest::SetupTree();
     Layer* root_layer = layer_tree_host()->root_layer();
     scoped_refptr<Layer> root_scroll_layer = Layer::Create();
@@ -918,11 +918,11 @@ class ImplSidePaintingScrollTestImplOnlyScroll
     layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.01f, 100.f);
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void WillCommit() OVERRIDE {
+  virtual void WillCommit() override {
     Layer* root = layer_tree_host()->root_layer();
     Layer* scroll_layer = root->children()[0].get();
     switch (layer_tree_host()->source_frame_number()) {
@@ -938,7 +938,7 @@ class ImplSidePaintingScrollTestImplOnlyScroll
     }
   }
 
-  virtual void BeginCommitOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void BeginCommitOnThread(LayerTreeHostImpl* impl) override {
     // Scroll after the 2nd commit has started.
     if (impl->active_tree()->source_frame_number() == 0) {
       LayerImpl* active_root = impl->active_tree()->root_layer();
@@ -949,7 +949,7 @@ class ImplSidePaintingScrollTestImplOnlyScroll
     }
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     // We force a second draw here of the first commit before activating
     // the second commit.
     LayerImpl* active_root = impl->active_tree()->root_layer();
@@ -998,7 +998,7 @@ class ImplSidePaintingScrollTestImplOnlyScroll
     }
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     ImplSidePaintingScrollTest::DrawLayersOnThread(impl);
 
     LayerImpl* root = impl->active_tree()->root_layer();
@@ -1020,7 +1020,7 @@ class ImplSidePaintingScrollTestImplOnlyScroll
     }
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
  private:
   gfx::ScrollOffset initial_scroll_;
@@ -1034,15 +1034,15 @@ class LayerTreeHostScrollTestScrollZeroMaxScrollOffset
  public:
   LayerTreeHostScrollTestScrollZeroMaxScrollOffset() {}
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     LayerTreeTest::SetupTree();
     scoped_refptr<Layer> scroll_layer = Layer::Create();
     layer_tree_host()->root_layer()->AddChild(scroll_layer);
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+  virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* root = impl->active_tree()->root_layer();
     LayerImpl* scroll_layer = root->children()[0];
     scroll_layer->SetScrollClipLayer(root->id());
@@ -1069,7 +1069,7 @@ class LayerTreeHostScrollTestScrollZeroMaxScrollOffset
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
@@ -1081,17 +1081,17 @@ class ThreadCheckingInputHandlerClient : public InputHandlerClient {
                                    bool* received_stop_flinging)
       : task_runner_(runner), received_stop_flinging_(received_stop_flinging) {}
 
-  virtual void WillShutdown() OVERRIDE {
+  virtual void WillShutdown() override {
     if (!received_stop_flinging_)
       ADD_FAILURE() << "WillShutdown() called before fling stopped";
   }
 
-  virtual void Animate(base::TimeTicks time) OVERRIDE {
+  virtual void Animate(base::TimeTicks time) override {
     if (!task_runner_->BelongsToCurrentThread())
       ADD_FAILURE() << "Animate called on wrong thread";
   }
 
-  virtual void MainThreadHasStoppedFlinging() OVERRIDE {
+  virtual void MainThreadHasStoppedFlinging() override {
     if (!task_runner_->BelongsToCurrentThread())
       ADD_FAILURE() << "MainThreadHasStoppedFlinging called on wrong thread";
     *received_stop_flinging_ = true;
@@ -1100,7 +1100,7 @@ class ThreadCheckingInputHandlerClient : public InputHandlerClient {
   virtual void DidOverscroll(
       const gfx::PointF& causal_event_viewport_point,
       const gfx::Vector2dF& accumulated_overscroll,
-      const gfx::Vector2dF& latest_overscroll_delta) OVERRIDE {
+      const gfx::Vector2dF& latest_overscroll_delta) override {
     if (!task_runner_->BelongsToCurrentThread())
       ADD_FAILURE() << "DidOverscroll called on wrong thread";
   }
@@ -1155,7 +1155,7 @@ class LayerTreeHostScrollTestLayerStructureChange
   LayerTreeHostScrollTestLayerStructureChange()
       : scroll_destroy_whole_tree_(false) {}
 
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     scoped_refptr<Layer> root_layer = Layer::Create();
     root_layer->SetBounds(gfx::Size(10, 10));
 
@@ -1168,11 +1168,11 @@ class LayerTreeHostScrollTestLayerStructureChange
     LayerTreeHostScrollTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* root = impl->active_tree()->root_layer();
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
@@ -1187,7 +1187,7 @@ class LayerTreeHostScrollTestLayerStructureChange
     }
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() override {}
 
   virtual void DidScroll(Layer* layer) {
     if (scroll_destroy_whole_tree_) {
diff --git a/cc/trees/layer_tree_host_unittest_video.cc b/cc/trees/layer_tree_host_unittest_video.cc
index 7d0bb41..8d8b130 100644
--- a/cc/trees/layer_tree_host_unittest_video.cc
+++ b/cc/trees/layer_tree_host_unittest_video.cc
@@ -22,7 +22,7 @@ class LayerTreeHostVideoTest : public LayerTreeTest {};
 class LayerTreeHostVideoTestSetNeedsDisplay
     : public LayerTreeHostVideoTest {
  public:
-  virtual void SetupTree() OVERRIDE {
+  virtual void SetupTree() override {
     scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(gfx::Size(10, 10));
     root->SetIsDrawable(true);
@@ -39,14 +39,14 @@ class LayerTreeHostVideoTestSetNeedsDisplay
     LayerTreeHostVideoTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
+  virtual void BeginTest() override {
     num_draws_ = 0;
     PostSetNeedsCommitToMainThread();
   }
 
   virtual DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                            LayerTreeHostImpl::FrameData* frame,
-                                           DrawResult draw_result) OVERRIDE {
+                                           DrawResult draw_result) override {
     LayerImpl* root_layer = host_impl->active_tree()->root_layer();
     RenderSurfaceImpl* root_surface = root_layer->render_surface();
     gfx::RectF damage_rect =
@@ -70,7 +70,7 @@ class LayerTreeHostVideoTestSetNeedsDisplay
     return draw_result;
   }
 
-  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     VideoLayerImpl* video = static_cast<VideoLayerImpl*>(
         host_impl->active_tree()->root_layer()->children()[0]);
 
@@ -82,7 +82,7 @@ class LayerTreeHostVideoTestSetNeedsDisplay
     ++num_draws_;
   }
 
-  virtual void AfterTest() OVERRIDE {
+  virtual void AfterTest() override {
     EXPECT_EQ(2, num_draws_);
   }
 
diff --git a/cc/trees/layer_tree_impl.cc b/cc/trees/layer_tree_impl.cc
index 948c2ba..161b361 100644
--- a/cc/trees/layer_tree_impl.cc
+++ b/cc/trees/layer_tree_impl.cc
@@ -50,16 +50,16 @@ class LayerScrollOffsetDelegateProxy : public LayerImpl::ScrollOffsetDelegate {
 
   // LayerScrollOffsetDelegate implementation.
   virtual void SetTotalScrollOffset(
-      const gfx::ScrollOffset& new_offset) OVERRIDE {
+      const gfx::ScrollOffset& new_offset) override {
     last_set_scroll_offset_ = new_offset;
     layer_tree_impl_->UpdateScrollOffsetDelegate();
   }
 
-  virtual gfx::ScrollOffset GetTotalScrollOffset() OVERRIDE {
+  virtual gfx::ScrollOffset GetTotalScrollOffset() override {
     return layer_tree_impl_->GetDelegatedScrollOffset(layer_);
   }
 
-  virtual bool IsExternalFlingActive() const OVERRIDE {
+  virtual bool IsExternalFlingActive() const override {
     return delegate_->IsExternalFlingActive();
   }
 
diff --git a/cc/trees/occlusion_tracker_unittest.cc b/cc/trees/occlusion_tracker_unittest.cc
index 3c6c440..6ab3397 100644
--- a/cc/trees/occlusion_tracker_unittest.cc
+++ b/cc/trees/occlusion_tracker_unittest.cc
@@ -33,7 +33,7 @@ class TestContentLayer : public Layer {
     SetIsDrawable(true);
   }
 
-  virtual SimpleEnclosedRegion VisibleContentOpaqueRegion() const OVERRIDE {
+  virtual SimpleEnclosedRegion VisibleContentOpaqueRegion() const override {
     if (override_opaque_contents_rect_) {
       return SimpleEnclosedRegion(
           gfx::IntersectRects(opaque_contents_rect_, visible_content_rect()));
@@ -59,7 +59,7 @@ class TestContentLayerImpl : public LayerImpl {
     SetDrawsContent(true);
   }
 
-  virtual SimpleEnclosedRegion VisibleContentOpaqueRegion() const OVERRIDE {
+  virtual SimpleEnclosedRegion VisibleContentOpaqueRegion() const override {
     if (override_opaque_contents_rect_) {
       return SimpleEnclosedRegion(
           gfx::IntersectRects(opaque_contents_rect_, visible_content_rect()));
diff --git a/cc/trees/single_thread_proxy.h b/cc/trees/single_thread_proxy.h
index 17aec8e..21b9f88 100644
--- a/cc/trees/single_thread_proxy.h
+++ b/cc/trees/single_thread_proxy.h
@@ -32,79 +32,79 @@ class CC_EXPORT SingleThreadProxy : public Proxy,
   virtual ~SingleThreadProxy();
 
   // Proxy implementation
-  virtual void FinishAllRendering() OVERRIDE;
-  virtual bool IsStarted() const OVERRIDE;
-  virtual void SetOutputSurface(scoped_ptr<OutputSurface>) OVERRIDE;
-  virtual void SetLayerTreeHostClientReady() OVERRIDE;
-  virtual void SetVisible(bool visible) OVERRIDE;
-  virtual const RendererCapabilities& GetRendererCapabilities() const OVERRIDE;
-  virtual void SetNeedsAnimate() OVERRIDE;
-  virtual void SetNeedsUpdateLayers() OVERRIDE;
-  virtual void SetNeedsCommit() OVERRIDE;
-  virtual void SetNeedsRedraw(const gfx::Rect& damage_rect) OVERRIDE;
-  virtual void SetNextCommitWaitsForActivation() OVERRIDE;
-  virtual void NotifyInputThrottledUntilCommit() OVERRIDE {}
-  virtual void SetDeferCommits(bool defer_commits) OVERRIDE;
-  virtual bool CommitRequested() const OVERRIDE;
-  virtual bool BeginMainFrameRequested() const OVERRIDE;
-  virtual void MainThreadHasStoppedFlinging() OVERRIDE {}
-  virtual void Start() OVERRIDE;
-  virtual void Stop() OVERRIDE;
-  virtual size_t MaxPartialTextureUpdates() const OVERRIDE;
-  virtual void ForceSerializeOnSwapBuffers() OVERRIDE;
-  virtual bool SupportsImplScrolling() const OVERRIDE;
-  virtual void AsValueInto(base::debug::TracedValue* state) const OVERRIDE;
-  virtual bool MainFrameWillHappenForTesting() OVERRIDE;
+  virtual void FinishAllRendering() override;
+  virtual bool IsStarted() const override;
+  virtual void SetOutputSurface(scoped_ptr<OutputSurface>) override;
+  virtual void SetLayerTreeHostClientReady() override;
+  virtual void SetVisible(bool visible) override;
+  virtual const RendererCapabilities& GetRendererCapabilities() const override;
+  virtual void SetNeedsAnimate() override;
+  virtual void SetNeedsUpdateLayers() override;
+  virtual void SetNeedsCommit() override;
+  virtual void SetNeedsRedraw(const gfx::Rect& damage_rect) override;
+  virtual void SetNextCommitWaitsForActivation() override;
+  virtual void NotifyInputThrottledUntilCommit() override {}
+  virtual void SetDeferCommits(bool defer_commits) override;
+  virtual bool CommitRequested() const override;
+  virtual bool BeginMainFrameRequested() const override;
+  virtual void MainThreadHasStoppedFlinging() override {}
+  virtual void Start() override;
+  virtual void Stop() override;
+  virtual size_t MaxPartialTextureUpdates() const override;
+  virtual void ForceSerializeOnSwapBuffers() override;
+  virtual bool SupportsImplScrolling() const override;
+  virtual void AsValueInto(base::debug::TracedValue* state) const override;
+  virtual bool MainFrameWillHappenForTesting() override;
 
   // SchedulerClient implementation
-  virtual BeginFrameSource* ExternalBeginFrameSource() OVERRIDE;
-  virtual void WillBeginImplFrame(const BeginFrameArgs& args) OVERRIDE;
-  virtual void ScheduledActionSendBeginMainFrame() OVERRIDE;
-  virtual DrawResult ScheduledActionDrawAndSwapIfPossible() OVERRIDE;
-  virtual DrawResult ScheduledActionDrawAndSwapForced() OVERRIDE;
-  virtual void ScheduledActionCommit() OVERRIDE;
-  virtual void ScheduledActionAnimate() OVERRIDE;
-  virtual void ScheduledActionUpdateVisibleTiles() OVERRIDE;
-  virtual void ScheduledActionActivateSyncTree() OVERRIDE;
-  virtual void ScheduledActionBeginOutputSurfaceCreation() OVERRIDE;
-  virtual void ScheduledActionManageTiles() OVERRIDE;
-  virtual void DidAnticipatedDrawTimeChange(base::TimeTicks time) OVERRIDE;
-  virtual base::TimeDelta DrawDurationEstimate() OVERRIDE;
-  virtual base::TimeDelta BeginMainFrameToCommitDurationEstimate() OVERRIDE;
-  virtual base::TimeDelta CommitToActivateDurationEstimate() OVERRIDE;
-  virtual void DidBeginImplFrameDeadline() OVERRIDE;
+  virtual BeginFrameSource* ExternalBeginFrameSource() override;
+  virtual void WillBeginImplFrame(const BeginFrameArgs& args) override;
+  virtual void ScheduledActionSendBeginMainFrame() override;
+  virtual DrawResult ScheduledActionDrawAndSwapIfPossible() override;
+  virtual DrawResult ScheduledActionDrawAndSwapForced() override;
+  virtual void ScheduledActionCommit() override;
+  virtual void ScheduledActionAnimate() override;
+  virtual void ScheduledActionUpdateVisibleTiles() override;
+  virtual void ScheduledActionActivateSyncTree() override;
+  virtual void ScheduledActionBeginOutputSurfaceCreation() override;
+  virtual void ScheduledActionManageTiles() override;
+  virtual void DidAnticipatedDrawTimeChange(base::TimeTicks time) override;
+  virtual base::TimeDelta DrawDurationEstimate() override;
+  virtual base::TimeDelta BeginMainFrameToCommitDurationEstimate() override;
+  virtual base::TimeDelta CommitToActivateDurationEstimate() override;
+  virtual void DidBeginImplFrameDeadline() override;
 
   // LayerTreeHostImplClient implementation
-  virtual void UpdateRendererCapabilitiesOnImplThread() OVERRIDE;
-  virtual void DidLoseOutputSurfaceOnImplThread() OVERRIDE;
+  virtual void UpdateRendererCapabilitiesOnImplThread() override;
+  virtual void DidLoseOutputSurfaceOnImplThread() override;
   virtual void CommitVSyncParameters(base::TimeTicks timebase,
-                                     base::TimeDelta interval) OVERRIDE {}
-  virtual void SetEstimatedParentDrawTime(base::TimeDelta draw_time) OVERRIDE {}
-  virtual void SetMaxSwapsPendingOnImplThread(int max) OVERRIDE {}
-  virtual void DidSwapBuffersOnImplThread() OVERRIDE;
-  virtual void DidSwapBuffersCompleteOnImplThread() OVERRIDE;
-  virtual void OnCanDrawStateChanged(bool can_draw) OVERRIDE;
-  virtual void NotifyReadyToActivate() OVERRIDE;
-  virtual void SetNeedsRedrawOnImplThread() OVERRIDE;
+                                     base::TimeDelta interval) override {}
+  virtual void SetEstimatedParentDrawTime(base::TimeDelta draw_time) override {}
+  virtual void SetMaxSwapsPendingOnImplThread(int max) override {}
+  virtual void DidSwapBuffersOnImplThread() override;
+  virtual void DidSwapBuffersCompleteOnImplThread() override;
+  virtual void OnCanDrawStateChanged(bool can_draw) override;
+  virtual void NotifyReadyToActivate() override;
+  virtual void SetNeedsRedrawOnImplThread() override;
   virtual void SetNeedsRedrawRectOnImplThread(
-      const gfx::Rect& dirty_rect) OVERRIDE;
-  virtual void SetNeedsAnimateOnImplThread() OVERRIDE;
-  virtual void SetNeedsManageTilesOnImplThread() OVERRIDE;
-  virtual void DidInitializeVisibleTileOnImplThread() OVERRIDE;
-  virtual void SetNeedsCommitOnImplThread() OVERRIDE;
+      const gfx::Rect& dirty_rect) override;
+  virtual void SetNeedsAnimateOnImplThread() override;
+  virtual void SetNeedsManageTilesOnImplThread() override;
+  virtual void DidInitializeVisibleTileOnImplThread() override;
+  virtual void SetNeedsCommitOnImplThread() override;
   virtual void PostAnimationEventsToMainThreadOnImplThread(
-      scoped_ptr<AnimationEventsVector> events) OVERRIDE;
+      scoped_ptr<AnimationEventsVector> events) override;
   virtual bool ReduceContentsTextureMemoryOnImplThread(
       size_t limit_bytes,
-      int priority_cutoff) OVERRIDE;
-  virtual bool IsInsideDraw() OVERRIDE;
-  virtual void RenewTreePriority() OVERRIDE {}
+      int priority_cutoff) override;
+  virtual bool IsInsideDraw() override;
+  virtual void RenewTreePriority() override {}
   virtual void PostDelayedScrollbarFadeOnImplThread(
       const base::Closure& start_fade,
-      base::TimeDelta delay) OVERRIDE {}
-  virtual void DidActivateSyncTree() OVERRIDE {}
-  virtual void DidManageTiles() OVERRIDE;
-  virtual void SetDebugState(const LayerTreeDebugState& debug_state) OVERRIDE {}
+      base::TimeDelta delay) override {}
+  virtual void DidActivateSyncTree() override {}
+  virtual void DidManageTiles() override;
+  virtual void SetDebugState(const LayerTreeDebugState& debug_state) override {}
 
   void RequestNewOutputSurface();
 
diff --git a/cc/trees/thread_proxy.h b/cc/trees/thread_proxy.h
index ed5c269..817b36d 100644
--- a/cc/trees/thread_proxy.h
+++ b/cc/trees/thread_proxy.h
@@ -150,85 +150,85 @@ class CC_EXPORT ThreadProxy : public Proxy,
   const CompositorThreadOnly& impl() const;
 
   // Proxy implementation
-  virtual void FinishAllRendering() OVERRIDE;
-  virtual bool IsStarted() const OVERRIDE;
-  virtual void SetOutputSurface(scoped_ptr<OutputSurface>) OVERRIDE;
-  virtual void SetLayerTreeHostClientReady() OVERRIDE;
-  virtual void SetVisible(bool visible) OVERRIDE;
-  virtual const RendererCapabilities& GetRendererCapabilities() const OVERRIDE;
-  virtual void SetNeedsAnimate() OVERRIDE;
-  virtual void SetNeedsUpdateLayers() OVERRIDE;
-  virtual void SetNeedsCommit() OVERRIDE;
-  virtual void SetNeedsRedraw(const gfx::Rect& damage_rect) OVERRIDE;
-  virtual void SetNextCommitWaitsForActivation() OVERRIDE;
-  virtual void NotifyInputThrottledUntilCommit() OVERRIDE;
-  virtual void SetDeferCommits(bool defer_commits) OVERRIDE;
-  virtual bool CommitRequested() const OVERRIDE;
-  virtual bool BeginMainFrameRequested() const OVERRIDE;
-  virtual void MainThreadHasStoppedFlinging() OVERRIDE;
-  virtual void Start() OVERRIDE;
-  virtual void Stop() OVERRIDE;
-  virtual size_t MaxPartialTextureUpdates() const OVERRIDE;
-  virtual void ForceSerializeOnSwapBuffers() OVERRIDE;
-  virtual bool SupportsImplScrolling() const OVERRIDE;
-  virtual void SetDebugState(const LayerTreeDebugState& debug_state) OVERRIDE;
-  virtual void AsValueInto(base::debug::TracedValue* value) const OVERRIDE;
-  virtual bool MainFrameWillHappenForTesting() OVERRIDE;
+  virtual void FinishAllRendering() override;
+  virtual bool IsStarted() const override;
+  virtual void SetOutputSurface(scoped_ptr<OutputSurface>) override;
+  virtual void SetLayerTreeHostClientReady() override;
+  virtual void SetVisible(bool visible) override;
+  virtual const RendererCapabilities& GetRendererCapabilities() const override;
+  virtual void SetNeedsAnimate() override;
+  virtual void SetNeedsUpdateLayers() override;
+  virtual void SetNeedsCommit() override;
+  virtual void SetNeedsRedraw(const gfx::Rect& damage_rect) override;
+  virtual void SetNextCommitWaitsForActivation() override;
+  virtual void NotifyInputThrottledUntilCommit() override;
+  virtual void SetDeferCommits(bool defer_commits) override;
+  virtual bool CommitRequested() const override;
+  virtual bool BeginMainFrameRequested() const override;
+  virtual void MainThreadHasStoppedFlinging() override;
+  virtual void Start() override;
+  virtual void Stop() override;
+  virtual size_t MaxPartialTextureUpdates() const override;
+  virtual void ForceSerializeOnSwapBuffers() override;
+  virtual bool SupportsImplScrolling() const override;
+  virtual void SetDebugState(const LayerTreeDebugState& debug_state) override;
+  virtual void AsValueInto(base::debug::TracedValue* value) const override;
+  virtual bool MainFrameWillHappenForTesting() override;
 
   // LayerTreeHostImplClient implementation
-  virtual void UpdateRendererCapabilitiesOnImplThread() OVERRIDE;
-  virtual void DidLoseOutputSurfaceOnImplThread() OVERRIDE;
+  virtual void UpdateRendererCapabilitiesOnImplThread() override;
+  virtual void DidLoseOutputSurfaceOnImplThread() override;
   virtual void CommitVSyncParameters(base::TimeTicks timebase,
-                                     base::TimeDelta interval) OVERRIDE;
-  virtual void SetEstimatedParentDrawTime(base::TimeDelta draw_time) OVERRIDE;
-  virtual void SetMaxSwapsPendingOnImplThread(int max) OVERRIDE;
-  virtual void DidSwapBuffersOnImplThread() OVERRIDE;
-  virtual void DidSwapBuffersCompleteOnImplThread() OVERRIDE;
-  virtual void OnCanDrawStateChanged(bool can_draw) OVERRIDE;
-  virtual void NotifyReadyToActivate() OVERRIDE;
+                                     base::TimeDelta interval) override;
+  virtual void SetEstimatedParentDrawTime(base::TimeDelta draw_time) override;
+  virtual void SetMaxSwapsPendingOnImplThread(int max) override;
+  virtual void DidSwapBuffersOnImplThread() override;
+  virtual void DidSwapBuffersCompleteOnImplThread() override;
+  virtual void OnCanDrawStateChanged(bool can_draw) override;
+  virtual void NotifyReadyToActivate() override;
   // Please call these 3 functions through
   // LayerTreeHostImpl's SetNeedsRedraw(), SetNeedsRedrawRect() and
   // SetNeedsAnimate().
-  virtual void SetNeedsRedrawOnImplThread() OVERRIDE;
+  virtual void SetNeedsRedrawOnImplThread() override;
   virtual void SetNeedsRedrawRectOnImplThread(const gfx::Rect& dirty_rect)
-      OVERRIDE;
-  virtual void SetNeedsAnimateOnImplThread() OVERRIDE;
-  virtual void SetNeedsManageTilesOnImplThread() OVERRIDE;
-  virtual void DidInitializeVisibleTileOnImplThread() OVERRIDE;
-  virtual void SetNeedsCommitOnImplThread() OVERRIDE;
+      override;
+  virtual void SetNeedsAnimateOnImplThread() override;
+  virtual void SetNeedsManageTilesOnImplThread() override;
+  virtual void DidInitializeVisibleTileOnImplThread() override;
+  virtual void SetNeedsCommitOnImplThread() override;
   virtual void PostAnimationEventsToMainThreadOnImplThread(
-      scoped_ptr<AnimationEventsVector> queue) OVERRIDE;
+      scoped_ptr<AnimationEventsVector> queue) override;
   virtual bool ReduceContentsTextureMemoryOnImplThread(size_t limit_bytes,
                                                        int priority_cutoff)
-      OVERRIDE;
-  virtual bool IsInsideDraw() OVERRIDE;
-  virtual void RenewTreePriority() OVERRIDE;
+      override;
+  virtual bool IsInsideDraw() override;
+  virtual void RenewTreePriority() override;
   virtual void PostDelayedScrollbarFadeOnImplThread(
       const base::Closure& start_fade,
-      base::TimeDelta delay) OVERRIDE;
-  virtual void DidActivateSyncTree() OVERRIDE;
-  virtual void DidManageTiles() OVERRIDE;
+      base::TimeDelta delay) override;
+  virtual void DidActivateSyncTree() override;
+  virtual void DidManageTiles() override;
 
   // SchedulerClient implementation
-  virtual BeginFrameSource* ExternalBeginFrameSource() OVERRIDE;
-  virtual void WillBeginImplFrame(const BeginFrameArgs& args) OVERRIDE;
-  virtual void ScheduledActionSendBeginMainFrame() OVERRIDE;
-  virtual DrawResult ScheduledActionDrawAndSwapIfPossible() OVERRIDE;
-  virtual DrawResult ScheduledActionDrawAndSwapForced() OVERRIDE;
-  virtual void ScheduledActionAnimate() OVERRIDE;
-  virtual void ScheduledActionCommit() OVERRIDE;
-  virtual void ScheduledActionUpdateVisibleTiles() OVERRIDE;
-  virtual void ScheduledActionActivateSyncTree() OVERRIDE;
-  virtual void ScheduledActionBeginOutputSurfaceCreation() OVERRIDE;
-  virtual void ScheduledActionManageTiles() OVERRIDE;
-  virtual void DidAnticipatedDrawTimeChange(base::TimeTicks time) OVERRIDE;
-  virtual base::TimeDelta DrawDurationEstimate() OVERRIDE;
-  virtual base::TimeDelta BeginMainFrameToCommitDurationEstimate() OVERRIDE;
-  virtual base::TimeDelta CommitToActivateDurationEstimate() OVERRIDE;
-  virtual void DidBeginImplFrameDeadline() OVERRIDE;
+  virtual BeginFrameSource* ExternalBeginFrameSource() override;
+  virtual void WillBeginImplFrame(const BeginFrameArgs& args) override;
+  virtual void ScheduledActionSendBeginMainFrame() override;
+  virtual DrawResult ScheduledActionDrawAndSwapIfPossible() override;
+  virtual DrawResult ScheduledActionDrawAndSwapForced() override;
+  virtual void ScheduledActionAnimate() override;
+  virtual void ScheduledActionCommit() override;
+  virtual void ScheduledActionUpdateVisibleTiles() override;
+  virtual void ScheduledActionActivateSyncTree() override;
+  virtual void ScheduledActionBeginOutputSurfaceCreation() override;
+  virtual void ScheduledActionManageTiles() override;
+  virtual void DidAnticipatedDrawTimeChange(base::TimeTicks time) override;
+  virtual base::TimeDelta DrawDurationEstimate() override;
+  virtual base::TimeDelta BeginMainFrameToCommitDurationEstimate() override;
+  virtual base::TimeDelta CommitToActivateDurationEstimate() override;
+  virtual void DidBeginImplFrameDeadline() override;
 
   // ResourceUpdateControllerClient implementation
-  virtual void ReadyToFinalizeTextureUpdates() OVERRIDE;
+  virtual void ReadyToFinalizeTextureUpdates() override;
 
  protected:
   ThreadProxy(LayerTreeHost* layer_tree_host,
diff --git a/cc/trees/tree_synchronizer_unittest.cc b/cc/trees/tree_synchronizer_unittest.cc
index 007c857..faa86ce 100644
--- a/cc/trees/tree_synchronizer_unittest.cc
+++ b/cc/trees/tree_synchronizer_unittest.cc
@@ -55,11 +55,11 @@ class MockLayer : public Layer {
   }
 
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
-      OVERRIDE {
+      override {
     return MockLayerImpl::Create(tree_impl, layer_id_);
   }
 
-  virtual void PushPropertiesTo(LayerImpl* layer_impl) OVERRIDE {
+  virtual void PushPropertiesTo(LayerImpl* layer_impl) override {
     Layer::PushPropertiesTo(layer_impl);
 
     MockLayerImpl* mock_layer_impl = static_cast<MockLayerImpl*>(layer_impl);
@@ -91,7 +91,7 @@ class FakeLayerAnimationController : public LayerAnimationController {
   virtual ~FakeLayerAnimationController() {}
 
   virtual void PushAnimationUpdatesTo(LayerAnimationController* controller_impl)
-      OVERRIDE {
+      override {
     LayerAnimationController::PushAnimationUpdatesTo(controller_impl);
     synchronized_animations_ = true;
   }