replace OVERRIDE and FINAL with override and final in cc/

cc/scheduler/scheduler_unittest.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 #include "cc/scheduler/scheduler.h"
 
 #include <string>
 #include <vector>
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 35 matching lines @@
 class FakeSchedulerClient : public SchedulerClient {
  public:
   struct FakeBeginFrameSourceForFakeSchedulerClient
       : public FakeBeginFrameSource {
     FakeSchedulerClient* client_;
 
     explicit FakeBeginFrameSourceForFakeSchedulerClient(
         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 {
         client_->actions_.push_back("SetNeedsBeginFrames(false)");
       }
       client_->states_.push_back(client_->scheduler_->AsValue());
     }
   };
 
   FakeSchedulerClient()
@@ skipping 33 matching lines @@
   const char* Action(int i) const { return actions_[i]; }
   std::string StateForAction(int i) const { return states_[i]->ToString(); }
   base::TimeTicks posted_begin_impl_frame_deadline() const {
     return posted_begin_impl_frame_deadline_;
   }
 
   bool ExternalBeginFrame() {
     return scheduler_->settings().begin_frame_scheduling_enabled &&
            scheduler_->settings().throttle_frame_production;
   }
-  virtual FakeBeginFrameSource* ExternalBeginFrameSource() OVERRIDE {
+  virtual FakeBeginFrameSource* ExternalBeginFrameSource() override {
     return &fake_frame_source_;
   }
 
   void AdvanceFrame() {
     TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler.frames"),
                  "FakeSchedulerClient::AdvanceFrame");
     // EXPECT_TRUE(needs_begin_frames());
     if (ExternalBeginFrame()) {
       // Creep the time forward so that any BeginFrameArgs is not equal to the
       // last one otherwise we violate the BeginFrameSource contract.
@@ skipping 31 matching lines @@
   void SetSwapWillHappenIfDrawHappens(bool swap_will_happen_if_draw_happens) {
     swap_will_happen_if_draw_happens_ = swap_will_happen_if_draw_happens;
   }
   void SetAutomaticSwapAck(bool automatic_swap_ack) {
     automatic_swap_ack_ = automatic_swap_ack;
   }
   void SetRedrawWillHappenIfUpdateVisibleTilesHappens(bool redraw) {
     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_++;
     DrawResult result =
         draw_will_happen_ ? DRAW_SUCCESS : DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
     bool swap_will_happen =
         draw_will_happen_ && swap_will_happen_if_draw_happens_;
     if (swap_will_happen) {
       scheduler_->DidSwapBuffers();
       if (swap_contains_incomplete_tile_) {
         scheduler_->SetSwapUsedIncompleteTile(true);
         swap_contains_incomplete_tile_ = false;
       } else {
         scheduler_->SetSwapUsedIncompleteTile(false);
       }
 
       if (automatic_swap_ack_)
         scheduler_->DidSwapBuffersComplete();
     }
     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,
                       base::Unretained(this),
                       state);
   }
 
  protected:
   bool ImplFrameDeadlinePendingCallback(bool state) {
     return scheduler_->BeginImplFrameDeadlinePending() == state;
@@ skipping 200 matching lines @@
   // On the next BeginImplFrame, verify we go back to a quiescent state and
   // no longer request BeginImplFrames.
   client.AdvanceFrame();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_FALSE(client.needs_begin_frames());
   client.Reset();
 }
 
 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:
 // 1. the scheduler dropping SetNeedsRedraw requests that happen inside
 //    a ScheduledActionDrawAndSwap
 // 2. the scheduler drawing twice inside a single tick
 TEST(SchedulerTest, RequestRedrawInsideDraw) {
   SchedulerClientThatsetNeedsDrawInsideDraw client;
   SchedulerSettings default_scheduler_settings;
   TestScheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
@@ skipping 74 matching lines @@
   EXPECT_TRUE(scheduler->CommitPending());
   EXPECT_FALSE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_frames());
 }
 
 class SchedulerClientThatSetNeedsCommitInsideDraw : public FakeSchedulerClient {
  public:
   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();
       set_needs_commit_on_next_draw_ = false;
     }
     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; }
 
  private:
   bool set_needs_commit_on_next_draw_;
 };
 
 // Tests for the scheduler infinite-looping on SetNeedsCommit requests that
 // happen inside a ScheduledActionDrawAndSwap
 TEST(SchedulerTest, RequestCommitInsideDraw) {
@@ skipping 117 matching lines @@
   client.SetDrawWillHappen(false);
   client.SetNeedsCommitOnNextDraw();
   client.AdvanceFrame();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(2, client.num_draws());
 }
 
 class SchedulerClientNeedsManageTilesInDraw : public FakeSchedulerClient {
  public:
   virtual DrawResult ScheduledActionDrawAndSwapIfPossible()
-      OVERRIDE {
+      override {
     scheduler_->SetNeedsManageTiles();
     return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
   }
 };
 
 // Test manage tiles is independant of draws.
 TEST(SchedulerTest, ManageTiles) {
   SchedulerClientNeedsManageTilesInDraw client;
   SchedulerSettings default_scheduler_settings;
   TestScheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
@@ skipping 300 matching lines @@
  public:
   SchedulerClientWithFixedEstimates(
       base::TimeDelta draw_duration,
       base::TimeDelta begin_main_frame_to_commit_duration,
       base::TimeDelta commit_to_activate_duration)
       : draw_duration_(draw_duration),
         begin_main_frame_to_commit_duration_(
             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_;
   }
 
  private:
     base::TimeDelta draw_duration_;
     base::TimeDelta begin_main_frame_to_commit_duration_;
     base::TimeDelta commit_to_activate_duration_;
 };
 
 void MainFrameInHighLatencyMode(int64 begin_main_frame_to_commit_estimate_in_ms,
@@ skipping 899 matching lines @@
 
   client.Reset();
   scheduler->SetVisible(false);
   // Sync tree should be forced to activate.
   EXPECT_ACTION("SetNeedsBeginFrames(false)", client, 0, 2);
   EXPECT_ACTION("ScheduledActionActivateSyncTree", client, 1, 2);
 }
 
 }  // namespace
 }  // namespace cc