Standardize usage of virtual/override/final in cc/

BUG=417463
TBR=enne@chromium.org

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

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

5 files changed, 73 insertions, 83 deletions

diff --git a/cc/scheduler/begin_frame_source.h b/cc/scheduler/begin_frame_source.h
index 3b8a576..3d849a4 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;
+  void OnBeginFrame(const BeginFrameArgs& args) override;
+  const BeginFrameArgs LastUsedBeginFrameArgs() const override;
 
   // Outputs last_begin_frame_args_
-  virtual void AsValueInto(base::debug::TracedValue* dict) const override;
+  void AsValueInto(base::debug::TracedValue* dict) const override;
 
  protected:
   // Subclasses should override this method!
@@ -131,18 +131,18 @@ class CC_EXPORT BeginFrameSource {
 //    in their own AsValueInto implementation.
 class CC_EXPORT BeginFrameSourceMixIn : public BeginFrameSource {
  public:
-  virtual ~BeginFrameSourceMixIn() {}
+  ~BeginFrameSourceMixIn() override {}
 
   // 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;
+  bool NeedsBeginFrames() const override;
+  void SetNeedsBeginFrames(bool needs_begin_frames) override;
+  void DidFinishFrame(size_t remaining_frames) override {}
+  void AddObserver(BeginFrameObserver* obs) override;
+  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;
+  void AsValueInto(base::debug::TracedValue* dict) const override;
 
  protected:
   BeginFrameSourceMixIn();
@@ -168,13 +168,13 @@ class CC_EXPORT BackToBackBeginFrameSource : public BeginFrameSourceMixIn {
  public:
   static scoped_ptr<BackToBackBeginFrameSource> Create(
       base::SingleThreadTaskRunner* task_runner);
-  virtual ~BackToBackBeginFrameSource();
+  ~BackToBackBeginFrameSource() override;
 
   // BeginFrameSource
-  virtual void DidFinishFrame(size_t remaining_frames) override;
+  void DidFinishFrame(size_t remaining_frames) override;
 
   // Tracing
-  virtual void AsValueInto(base::debug::TracedValue* dict) const override;
+  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;
+  void OnNeedsBeginFramesChange(bool needs_begin_frames) override;
 
   void BeginFrame();
 };
@@ -202,21 +202,20 @@ class CC_EXPORT SyntheticBeginFrameSource : public BeginFrameSourceMixIn,
       base::SingleThreadTaskRunner* task_runner,
       base::TimeTicks initial_vsync_timebase,
       base::TimeDelta initial_vsync_interval);
-  virtual ~SyntheticBeginFrameSource();
+  ~SyntheticBeginFrameSource() override;
 
   // BeginFrameSource
-  virtual bool NeedsBeginFrames() const override;
+  bool NeedsBeginFrames() const override;
 
   // Tracing
-  virtual void AsValueInto(base::debug::TracedValue* dict) const override;
+  void AsValueInto(base::debug::TracedValue* dict) const override;
 
   // VSyncParameterObserver
-  virtual void OnUpdateVSyncParameters(
-      base::TimeTicks new_vsync_timebase,
-      base::TimeDelta new_vsync_interval) override;
+  void OnUpdateVSyncParameters(base::TimeTicks new_vsync_timebase,
+                               base::TimeDelta new_vsync_interval) override;
 
   // TimeSourceClient
-  virtual void OnTimerTick() override;
+  void OnTimerTick() override;
 
  protected:
   explicit SyntheticBeginFrameSource(
@@ -226,7 +225,7 @@ class CC_EXPORT SyntheticBeginFrameSource : public BeginFrameSourceMixIn,
                                       BeginFrameArgs::BeginFrameArgsType type);
 
   // BeginFrameSourceMixIn
-  virtual void OnNeedsBeginFramesChange(bool needs_begin_frames) override;
+  void OnNeedsBeginFramesChange(bool needs_begin_frames) override;
 
   scoped_refptr<DelayBasedTimeSource> time_source_;
 };
@@ -238,7 +237,7 @@ class CC_EXPORT BeginFrameSourceMultiplexer : public BeginFrameSourceMixIn,
                                               public BeginFrameObserver {
  public:
   static scoped_ptr<BeginFrameSourceMultiplexer> Create();
-  virtual ~BeginFrameSourceMultiplexer();
+  ~BeginFrameSourceMultiplexer() override;
 
   void SetMinimumInterval(base::TimeDelta new_minimum_interval);
 
@@ -251,16 +250,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;
+  void OnBeginFrame(const BeginFrameArgs& args) override;
+  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;
+  bool NeedsBeginFrames() const override;
+  void SetNeedsBeginFrames(bool needs_begin_frames) override;
+  void DidFinishFrame(size_t remaining_frames) override;
 
   // Tracing
-  virtual void AsValueInto(base::debug::TracedValue* dict) const override;
+  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 8abf1a9..b741e35 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 {
+  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 {
+  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(); }
+  base::TimeTicks Now() override { return now_src_->Now(); }
 
   scoped_refptr<TestNowSource> now_src_;
 };
diff --git a/cc/scheduler/delay_based_time_source.h b/cc/scheduler/delay_based_time_source.h
index 270102b..9f670d1 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;
+  base::TimeTicks Now() const override;
 
  protected:
   DelayBasedTimeSourceHighRes(base::TimeDelta interval,
                               base::SingleThreadTaskRunner* task_runner);
-  virtual ~DelayBasedTimeSourceHighRes();
+  ~DelayBasedTimeSourceHighRes() override;
 
-  virtual std::string TypeString() const override;
+  std::string TypeString() const override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DelayBasedTimeSourceHighRes);
diff --git a/cc/scheduler/scheduler.h b/cc/scheduler/scheduler.h
index 6da951c..f470d17 100644
--- a/cc/scheduler/scheduler.h
+++ b/cc/scheduler/scheduler.h
@@ -91,10 +91,10 @@ class CC_EXPORT Scheduler : public BeginFrameObserverMixIn,
                                          &frame_sources_constructor));
   }
 
-  virtual ~Scheduler();
+  ~Scheduler() override;
 
   // base::PowerObserver method.
-  virtual void OnPowerStateChange(bool on_battery_power) override;
+  void OnPowerStateChange(bool on_battery_power) override;
 
   const SchedulerSettings& settings() const { return settings_; }
 
@@ -158,14 +158,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;
+  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;
+  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 84d9fa3..7da6267 100644
--- a/cc/scheduler/scheduler_unittest.cc
+++ b/cc/scheduler/scheduler_unittest.cc
@@ -55,7 +55,7 @@ class FakeSchedulerClient : public SchedulerClient {
         FakeSchedulerClient* client)
         : client_(client) {}
 
-    virtual void OnNeedsBeginFramesChange(bool needs_begin_frames) override {
+    void OnNeedsBeginFramesChange(bool needs_begin_frames) override {
       if (needs_begin_frames) {
         client_->actions_.push_back("SetNeedsBeginFrames(true)");
       } else {
@@ -68,15 +68,13 @@ class FakeSchedulerClient : public SchedulerClient {
   class FakePowerMonitorSource : public base::PowerMonitorSource {
    public:
     FakePowerMonitorSource() {}
-    virtual ~FakePowerMonitorSource() {}
+    ~FakePowerMonitorSource() override {}
     void GeneratePowerStateEvent(bool on_battery_power) {
       on_battery_power_impl_ = on_battery_power;
       ProcessPowerEvent(POWER_STATE_EVENT);
       base::MessageLoop::current()->RunUntilIdle();
     }
-    virtual bool IsOnBatteryPowerImpl() override {
-      return on_battery_power_impl_;
-    }
+    bool IsOnBatteryPowerImpl() override { return on_battery_power_impl_; }
 
    private:
     bool on_battery_power_impl_;
@@ -134,7 +132,7 @@ class FakeSchedulerClient : public SchedulerClient {
     return scheduler_->settings().begin_frame_scheduling_enabled &&
            scheduler_->settings().throttle_frame_production;
   }
-  virtual FakeBeginFrameSource* ExternalBeginFrameSource() override {
+  FakeBeginFrameSource* ExternalBeginFrameSource() override {
     return &fake_frame_source_;
   }
 
@@ -192,19 +190,19 @@ class FakeSchedulerClient : public SchedulerClient {
     redraw_will_happen_if_update_visible_tiles_happens_ = redraw;
   }
   // SchedulerClient implementation.
-  virtual void WillBeginImplFrame(const BeginFrameArgs& args) override {
+  void WillBeginImplFrame(const BeginFrameArgs& args) override {
     actions_.push_back("WillBeginImplFrame");
     states_.push_back(scheduler_->AsValue());
   }
-  virtual void ScheduledActionSendBeginMainFrame() override {
+  void ScheduledActionSendBeginMainFrame() override {
     actions_.push_back("ScheduledActionSendBeginMainFrame");
     states_.push_back(scheduler_->AsValue());
   }
-  virtual void ScheduledActionAnimate() override {
+  void ScheduledActionAnimate() override {
     actions_.push_back("ScheduledActionAnimate");
     states_.push_back(scheduler_->AsValue());
   }
-  virtual DrawResult ScheduledActionDrawAndSwapIfPossible() override {
+  DrawResult ScheduledActionDrawAndSwapIfPossible() override {
     actions_.push_back("ScheduledActionDrawAndSwapIfPossible");
     states_.push_back(scheduler_->AsValue());
     num_draws_++;
@@ -226,48 +224,46 @@ class FakeSchedulerClient : public SchedulerClient {
     }
     return result;
   }
-  virtual DrawResult ScheduledActionDrawAndSwapForced() override {
+  DrawResult ScheduledActionDrawAndSwapForced() override {
     actions_.push_back("ScheduledActionDrawAndSwapForced");
     states_.push_back(scheduler_->AsValue());
     return DRAW_SUCCESS;
   }
-  virtual void ScheduledActionCommit() override {
+  void ScheduledActionCommit() override {
     actions_.push_back("ScheduledActionCommit");
     states_.push_back(scheduler_->AsValue());
   }
-  virtual void ScheduledActionUpdateVisibleTiles() override {
+  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 {
+  void ScheduledActionActivateSyncTree() override {
     actions_.push_back("ScheduledActionActivateSyncTree");
     states_.push_back(scheduler_->AsValue());
   }
-  virtual void ScheduledActionBeginOutputSurfaceCreation() override {
+  void ScheduledActionBeginOutputSurfaceCreation() override {
     actions_.push_back("ScheduledActionBeginOutputSurfaceCreation");
     states_.push_back(scheduler_->AsValue());
   }
-  virtual void ScheduledActionManageTiles() override {
+  void ScheduledActionManageTiles() override {
     actions_.push_back("ScheduledActionManageTiles");
     states_.push_back(scheduler_->AsValue());
   }
-  virtual void DidAnticipatedDrawTimeChange(base::TimeTicks) override {
+  void DidAnticipatedDrawTimeChange(base::TimeTicks) override {
     if (log_anticipated_draw_time_change_)
       actions_.push_back("DidAnticipatedDrawTimeChange");
   }
-  virtual base::TimeDelta DrawDurationEstimate() override {
-    return base::TimeDelta();
-  }
-  virtual base::TimeDelta BeginMainFrameToCommitDurationEstimate() override {
+  base::TimeDelta DrawDurationEstimate() override { return base::TimeDelta(); }
+  base::TimeDelta BeginMainFrameToCommitDurationEstimate() override {
     return base::TimeDelta();
   }
-  virtual base::TimeDelta CommitToActivateDurationEstimate() override {
+  base::TimeDelta CommitToActivateDurationEstimate() override {
     return base::TimeDelta();
   }
 
-  virtual void DidBeginImplFrameDeadline() override {}
+  void DidBeginImplFrameDeadline() override {}
 
   base::Callback<bool(void)> ImplFrameDeadlinePending(bool state) {
     return base::Bind(&FakeSchedulerClient::ImplFrameDeadlinePendingCallback,
@@ -491,23 +487,22 @@ TEST(SchedulerTest, RequestCommitAfterBeginMainFrameSent) {
 
 class SchedulerClientThatsetNeedsDrawInsideDraw : public FakeSchedulerClient {
  public:
-  virtual void ScheduledActionSendBeginMainFrame() override {}
-  virtual DrawResult ScheduledActionDrawAndSwapIfPossible()
-      override {
+  void ScheduledActionSendBeginMainFrame() override {}
+  DrawResult ScheduledActionDrawAndSwapIfPossible() override {
     // Only SetNeedsRedraw the first time this is called
     if (!num_draws_)
       scheduler_->SetNeedsRedraw();
     return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
   }
 
-  virtual DrawResult ScheduledActionDrawAndSwapForced() override {
+  DrawResult ScheduledActionDrawAndSwapForced() override {
     NOTREACHED();
     return DRAW_SUCCESS;
   }
 
-  virtual void ScheduledActionCommit() override {}
-  virtual void ScheduledActionBeginOutputSurfaceCreation() override {}
-  virtual void DidAnticipatedDrawTimeChange(base::TimeTicks) override {}
+  void ScheduledActionCommit() override {}
+  void ScheduledActionBeginOutputSurfaceCreation() override {}
+  void DidAnticipatedDrawTimeChange(base::TimeTicks) override {}
 };
 
 // Tests for two different situations:
@@ -602,9 +597,8 @@ class SchedulerClientThatSetNeedsCommitInsideDraw : public FakeSchedulerClient {
   SchedulerClientThatSetNeedsCommitInsideDraw()
       : set_needs_commit_on_next_draw_(false) {}
 
-  virtual void ScheduledActionSendBeginMainFrame() override {}
-  virtual DrawResult ScheduledActionDrawAndSwapIfPossible()
-      override {
+  void ScheduledActionSendBeginMainFrame() override {}
+  DrawResult ScheduledActionDrawAndSwapIfPossible() override {
     // Only SetNeedsCommit the first time this is called
     if (set_needs_commit_on_next_draw_) {
       scheduler_->SetNeedsCommit();
@@ -613,14 +607,14 @@ class SchedulerClientThatSetNeedsCommitInsideDraw : public FakeSchedulerClient {
     return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
   }
 
-  virtual DrawResult ScheduledActionDrawAndSwapForced() override {
+  DrawResult ScheduledActionDrawAndSwapForced() override {
     NOTREACHED();
     return DRAW_SUCCESS;
   }
 
-  virtual void ScheduledActionCommit() override {}
-  virtual void ScheduledActionBeginOutputSurfaceCreation() override {}
-  virtual void DidAnticipatedDrawTimeChange(base::TimeTicks) override {}
+  void ScheduledActionCommit() override {}
+  void ScheduledActionBeginOutputSurfaceCreation() override {}
+  void DidAnticipatedDrawTimeChange(base::TimeTicks) override {}
 
   void SetNeedsCommitOnNextDraw() { set_needs_commit_on_next_draw_ = true; }
 
@@ -757,8 +751,7 @@ TEST(SchedulerTest, NoSwapWhenDrawFails) {
 
 class SchedulerClientNeedsManageTilesInDraw : public FakeSchedulerClient {
  public:
-  virtual DrawResult ScheduledActionDrawAndSwapIfPossible()
-      override {
+  DrawResult ScheduledActionDrawAndSwapIfPossible() override {
     scheduler_->SetNeedsManageTiles();
     return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
   }
@@ -1079,13 +1072,11 @@ class SchedulerClientWithFixedEstimates : public FakeSchedulerClient {
             begin_main_frame_to_commit_duration),
         commit_to_activate_duration_(commit_to_activate_duration) {}
 
-  virtual base::TimeDelta DrawDurationEstimate() override {
-    return draw_duration_;
-  }
-  virtual base::TimeDelta BeginMainFrameToCommitDurationEstimate() override {
+  base::TimeDelta DrawDurationEstimate() override { return draw_duration_; }
+  base::TimeDelta BeginMainFrameToCommitDurationEstimate() override {
     return begin_main_frame_to_commit_duration_;
   }
-  virtual base::TimeDelta CommitToActivateDurationEstimate() override {
+  base::TimeDelta CommitToActivateDurationEstimate() override {
     return commit_to_activate_duration_;
   }