Standardize usage of virtual/override/final in chrome/browser/devtools/

chrome/browser/devtools/devtools_sanity_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 "base/bind.h"
 #include "base/cancelable_callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/path_service.h"
@@ skipping 141 matching lines @@
 };
 
 // Used to block until a dev tools window gets beforeunload event.
 class DevToolsWindowBeforeUnloadObserver
     : public content::WebContentsObserver {
  public:
   explicit DevToolsWindowBeforeUnloadObserver(DevToolsWindow*);
   void Wait();
  private:
   // Invoked when the beforeunload handler fires.
-  virtual void BeforeUnloadFired(const base::TimeTicks& proceed_time) override;
+  void BeforeUnloadFired(const base::TimeTicks& proceed_time) override;
 
   bool m_fired;
   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
   DISALLOW_COPY_AND_ASSIGN(DevToolsWindowBeforeUnloadObserver);
 };
 
 DevToolsWindowBeforeUnloadObserver::DevToolsWindowBeforeUnloadObserver(
     DevToolsWindow* devtools_window)
     : WebContentsObserver(
           DevToolsWindowTesting::Get(devtools_window)->main_web_contents()),
       m_fired(false) {
 }
 
 void DevToolsWindowBeforeUnloadObserver::Wait() {
   if (m_fired)
     return;
   message_loop_runner_ = new content::MessageLoopRunner;
   message_loop_runner_->Run();
 }
 
 void DevToolsWindowBeforeUnloadObserver::BeforeUnloadFired(
     const base::TimeTicks& proceed_time) {
   m_fired = true;
   if (message_loop_runner_.get())
     message_loop_runner_->Quit();
 }
 
 class DevToolsBeforeUnloadTest: public DevToolsSanityTest {
  public:
-  virtual void SetUpCommandLine(CommandLine* command_line) override {
+  void SetUpCommandLine(CommandLine* command_line) override {
     command_line->AppendSwitch(
         switches::kDisableHangMonitor);
   }
 
   void CloseInspectedTab() {
     browser()->tab_strip_model()->CloseWebContentsAt(0,
         TabStripModel::CLOSE_NONE);
   }
 
   void CloseDevToolsWindowAsync() {
@@ skipping 76 matching lines @@
     JavaScriptAppModalDialog* js_dialog =
         static_cast<JavaScriptAppModalDialog*>(dialog);
     NativeAppModalDialog* native_dialog = js_dialog->native_dialog();
     EXPECT_TRUE(native_dialog);
     return native_dialog;
   }
 };
 
 class DevToolsUnresponsiveBeforeUnloadTest: public DevToolsBeforeUnloadTest {
  public:
-  virtual void SetUpCommandLine(CommandLine* command_line) override {}
+  void SetUpCommandLine(CommandLine* command_line) override {}
 };
 
 void TimeoutCallback(const std::string& timeout_message) {
   ADD_FAILURE() << timeout_message;
   base::MessageLoop::current()->Quit();
 }
 
 // Base class for DevTools tests that test devtools functionality for
 // extensions and content scripts.
 class DevToolsExtensionTest : public DevToolsSanityTest,
@@ skipping 61 matching lines @@
       if (!(*iter)->IsLoading())
         ++iter;
       else
         content::RunMessageLoop();
     }
 
     timeout.Cancel();
     return true;
   }
 
-  virtual void Observe(int type,
-                       const content::NotificationSource& source,
-                       const content::NotificationDetails& details) override {
+  void Observe(int type,
+               const content::NotificationSource& source,
+               const content::NotificationDetails& details) override {
     switch (type) {
       case extensions::NOTIFICATION_EXTENSION_LOADED_DEPRECATED:
       case extensions::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING:
         base::MessageLoopForUI::current()->Quit();
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 
   base::FilePath test_extensions_dir_;
 };
 
 class DevToolsExperimentalExtensionTest : public DevToolsExtensionTest {
  public:
-  virtual void SetUpCommandLine(CommandLine* command_line) override {
+  void SetUpCommandLine(CommandLine* command_line) override {
     command_line->AppendSwitch(
         extensions::switches::kEnableExperimentalExtensionApis);
   }
 };
 
 class WorkerDevToolsSanityTest : public InProcessBrowserTest {
  public:
   WorkerDevToolsSanityTest() : window_(NULL) {}
 
  protected:
   class WorkerData : public base::RefCountedThreadSafe<WorkerData> {
    public:
     WorkerData() : worker_process_id(0), worker_route_id(0) {}
     int worker_process_id;
     int worker_route_id;
 
    private:
     friend class base::RefCountedThreadSafe<WorkerData>;
     ~WorkerData() {}
   };
 
   class WorkerCreationObserver : public WorkerServiceObserver {
    public:
     explicit WorkerCreationObserver(const std::string& path,
                                     WorkerData* worker_data)
         : path_(path), worker_data_(worker_data) {}
 
    private:
-    virtual ~WorkerCreationObserver() {}
+    ~WorkerCreationObserver() override {}
 
-    virtual void WorkerCreated (
-        const GURL& url,
-        const base::string16& name,
-        int process_id,
-        int route_id) override {
+    void WorkerCreated(const GURL& url,
+                       const base::string16& name,
+                       int process_id,
+                       int route_id) override {
       if (url.path().rfind(path_) == std::string::npos)
         return;
       worker_data_->worker_process_id = process_id;
       worker_data_->worker_route_id = route_id;
       WorkerService::GetInstance()->RemoveObserver(this);
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
           base::MessageLoop::QuitClosure());
       delete this;
     }
     std::string path_;
     scoped_refptr<WorkerData> worker_data_;
   };
 
   class WorkerTerminationObserver : public WorkerServiceObserver {
    public:
     explicit WorkerTerminationObserver(WorkerData* worker_data)
         : worker_data_(worker_data) {
     }
 
    private:
-    virtual ~WorkerTerminationObserver() {}
+    ~WorkerTerminationObserver() override {}
 
-    virtual void WorkerDestroyed(int process_id, int route_id) override {
+    void WorkerDestroyed(int process_id, int route_id) override {
       ASSERT_EQ(worker_data_->worker_process_id, process_id);
       ASSERT_EQ(worker_data_->worker_route_id, route_id);
       WorkerService::GetInstance()->RemoveObserver(this);
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
           base::MessageLoop::QuitClosure());
       delete this;
     }
     scoped_refptr<WorkerData> worker_data_;
   };
 
@@ skipping 453 matching lines @@
   const std::string agent_id = agent_raw->GetId();
   ASSERT_EQ(agent_raw, DevToolsAgentHost::GetForId(agent_id).get())
       << "DevToolsAgentHost cannot be found by id";
   browser()->tab_strip_model()->
       CloseWebContentsAt(0, TabStripModel::CLOSE_NONE);
   ASSERT_FALSE(DevToolsAgentHost::GetForId(agent_id).get())
       << "DevToolsAgentHost is not released when the tab is closed";
 }
 
 class RemoteDebuggingTest: public ExtensionApiTest {
-  virtual void SetUpCommandLine(CommandLine* command_line) override {
+  void SetUpCommandLine(CommandLine* command_line) override {
     ExtensionApiTest::SetUpCommandLine(command_line);
     command_line->AppendSwitchASCII(switches::kRemoteDebuggingPort, "9222");
 
     // Override the extension root path.
     PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir_);
     test_data_dir_ = test_data_dir_.AppendASCII("devtools");
   }
 };
 
 IN_PROC_BROWSER_TEST_F(RemoteDebuggingTest, RemoteDebugger) {
 #if defined(OS_WIN) && defined(USE_ASH)
   // Disable this test in Metro+Ash for now (http://crbug.com/262796).
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
     return;
 #endif
 
   ASSERT_TRUE(RunExtensionTest("target_list")) << message_;
 }