Standardize usage of virtual/override/final specifiers.

content/browser/web_contents/web_contents_view_aura_browsertest.cc

 // Copyright (c) 2012 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 "content/browser/web_contents/web_contents_view_aura.h"
 
 #include "base/command_line.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/test_timeouts.h"
@@ skipping 39 matching lines @@
       FROM_HERE,
       run_loop.QuitClosure(),
       base::TimeDelta::FromMillisecondsD(10));
   run_loop.Run();
 }
 
 // WebContentsDelegate which tracks vertical overscroll updates.
 class VerticalOverscrollTracker : public content::WebContentsDelegate {
  public:
   VerticalOverscrollTracker() : count_(0), completed_(false) {}
-  virtual ~VerticalOverscrollTracker() {}
+  ~VerticalOverscrollTracker() override {}
 
   int num_overscroll_updates() const {
     return count_;
   }
 
   bool overscroll_completed() const {
     return completed_;
   }
 
   void Reset() {
     count_ = 0;
     completed_ = false;
   }
 
  private:
-  virtual bool CanOverscrollContent() const override {
-    return true;
-  }
+  bool CanOverscrollContent() const override { return true; }
 
-  virtual void OverscrollUpdate(float delta_y) override {
-    ++count_;
-  }
+  void OverscrollUpdate(float delta_y) override { ++count_; }
 
-  virtual void OverscrollComplete() override {
-    completed_ = true;
-  }
+  void OverscrollComplete() override { completed_ = true; }
 
   int count_;
   bool completed_;
 
   DISALLOW_COPY_AND_ASSIGN(VerticalOverscrollTracker);
 };
 
 }  //namespace
 
 
 namespace content {
 
 // This class keeps track of the RenderViewHost whose screenshot was captured.
 class ScreenshotTracker : public NavigationEntryScreenshotManager {
  public:
   explicit ScreenshotTracker(NavigationControllerImpl* controller)
       : NavigationEntryScreenshotManager(controller),
         screenshot_taken_for_(NULL),
         waiting_for_screenshots_(0) {
   }
 
-  virtual ~ScreenshotTracker() {
-  }
+  ~ScreenshotTracker() override {}
 
   RenderViewHost* screenshot_taken_for() { return screenshot_taken_for_; }
 
   void Reset() {
     screenshot_taken_for_ = NULL;
     screenshot_set_.clear();
   }
 
   void SetScreenshotInterval(int interval_ms) {
     SetMinScreenshotIntervalMS(interval_ms);
   }
 
   void WaitUntilScreenshotIsReady() {
     if (!waiting_for_screenshots_)
       return;
     message_loop_runner_ = new content::MessageLoopRunner;
     message_loop_runner_->Run();
   }
 
   bool ScreenshotSetForEntry(NavigationEntryImpl* entry) const {
     return screenshot_set_.count(entry) > 0;
   }
 
  private:
   // Overridden from NavigationEntryScreenshotManager:
-  virtual void TakeScreenshotImpl(RenderViewHost* host,
-                                  NavigationEntryImpl* entry) override {
+  void TakeScreenshotImpl(RenderViewHost* host,
+                          NavigationEntryImpl* entry) override {
     ++waiting_for_screenshots_;
     screenshot_taken_for_ = host;
     NavigationEntryScreenshotManager::TakeScreenshotImpl(host, entry);
   }
 
-  virtual void OnScreenshotSet(NavigationEntryImpl* entry) override {
+  void OnScreenshotSet(NavigationEntryImpl* entry) override {
     --waiting_for_screenshots_;
     screenshot_set_[entry] = true;
     NavigationEntryScreenshotManager::OnScreenshotSet(entry);
     if (waiting_for_screenshots_ == 0 && message_loop_runner_.get())
       message_loop_runner_->Quit();
   }
 
   RenderViewHost* screenshot_taken_for_;
   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
   int waiting_for_screenshots_;
   std::map<NavigationEntryImpl*, bool> screenshot_set_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenshotTracker);
 };
 
 class NavigationWatcher : public WebContentsObserver {
  public:
   explicit NavigationWatcher(WebContents* contents)
       : WebContentsObserver(contents),
         navigated_(false),
         should_quit_loop_(false) {
   }
 
-  virtual ~NavigationWatcher() {}
+  ~NavigationWatcher() override {}
 
   void WaitUntilNavigationStarts() {
     if (navigated_)
       return;
     should_quit_loop_ = true;
     base::MessageLoop::current()->Run();
   }
 
  private:
   // Overridden from WebContentsObserver:
-  virtual void AboutToNavigateRenderView(RenderViewHost* host) override {
+  void AboutToNavigateRenderView(RenderViewHost* host) override {
     navigated_ = true;
     if (should_quit_loop_)
       base::MessageLoop::current()->Quit();
   }
 
   bool navigated_;
   bool should_quit_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(NavigationWatcher);
 };
 
 class InputEventMessageFilterWaitsForAcks : public BrowserMessageFilter {
  public:
   InputEventMessageFilterWaitsForAcks()
       : BrowserMessageFilter(InputMsgStart),
         type_(blink::WebInputEvent::Undefined),
         state_(INPUT_EVENT_ACK_STATE_UNKNOWN) {}
 
   void WaitForAck(blink::WebInputEvent::Type type) {
     base::RunLoop run_loop;
     base::AutoReset<base::Closure> reset_quit(&quit_, run_loop.QuitClosure());
     base::AutoReset<blink::WebInputEvent::Type> reset_type(&type_, type);
     run_loop.Run();
   }
 
   InputEventAckState last_ack_state() const { return state_; }
 
  protected:
-  virtual ~InputEventMessageFilterWaitsForAcks() {}
+  ~InputEventMessageFilterWaitsForAcks() override {}
 
  private:
   void ReceivedEventAck(blink::WebInputEvent::Type type,
                         InputEventAckState state) {
     if (type_ == type) {
       state_ = state;
       quit_.Run();
     }
   }
 
   // BrowserMessageFilter:
-  virtual bool OnMessageReceived(const IPC::Message& message) override {
+  bool OnMessageReceived(const IPC::Message& message) override {
     if (message.type() == InputHostMsg_HandleInputEvent_ACK::ID) {
       InputHostMsg_HandleInputEvent_ACK::Param params;
       InputHostMsg_HandleInputEvent_ACK::Read(&message, &params);
       blink::WebInputEvent::Type type = params.a.type;
       InputEventAckState ack = params.a.state;
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
           base::Bind(&InputEventMessageFilterWaitsForAcks::ReceivedEventAck,
                      this, type, ack));
     }
     return false;
@@ skipping 28 matching lines @@
     NavigateToURL(shell(), test_url);
 
     WebContentsImpl* web_contents =
         static_cast<WebContentsImpl*>(shell()->web_contents());
     NavigationControllerImpl* controller = &web_contents->GetController();
 
     screenshot_manager_ = new ScreenshotTracker(controller);
     controller->SetScreenshotManager(screenshot_manager_);
   }
 
-  virtual void SetUpCommandLine(CommandLine* cmd) override {
+  void SetUpCommandLine(CommandLine* cmd) override {
     cmd->AppendSwitchASCII(switches::kTouchEvents,
                            switches::kTouchEventsEnabled);
   }
 
   void TestOverscrollNavigation(bool touch_handler) {
     ASSERT_NO_FATAL_FAILURE(
         StartTestWithPage("files/overscroll_navigation.html"));
     WebContentsImpl* web_contents =
         static_cast<WebContentsImpl*>(shell()->web_contents());
     NavigationController& controller = web_contents->GetController();
@@ skipping 870 matching lines @@
     details = dispatcher->OnEventFromSource(&release);
     ASSERT_FALSE(details.dispatcher_destroyed);
     WaitAFrame();
 
     EXPECT_LT(0, tracker.num_overscroll_updates());
     EXPECT_FALSE(tracker.overscroll_completed());
   }
 }
 
 }  // namespace content