Standardize usage of virtual/override/final in chrome/

chrome/test/base/testing_profile.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 "chrome/test/base/testing_profile.h"
 
 #include "base/base_paths.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 94 matching lines @@
 using testing::NiceMock;
 using testing::Return;
 
 namespace {
 
 // Used to make sure TopSites has finished loading
 class WaitTopSitesLoadedObserver : public history::TopSitesObserver {
  public:
   explicit WaitTopSitesLoadedObserver(content::MessageLoopRunner* runner)
       : runner_(runner) {}
-  virtual void TopSitesLoaded(history::TopSites* top_sites) override {
+  void TopSitesLoaded(history::TopSites* top_sites) override {
     runner_->Quit();
   }
-  virtual void TopSitesChanged(history::TopSites* top_sites) override {}
+  void TopSitesChanged(history::TopSites* top_sites) override {}
 
  private:
   // weak
   content::MessageLoopRunner* runner_;
 };
 
 // Task used to make sure history has finished processing a request. Intended
 // for use with BlockUntilHistoryProcessesPendingRequests.
 
 class QuittingHistoryDBTask : public history::HistoryDBTask {
  public:
   QuittingHistoryDBTask() {}
 
-  virtual bool RunOnDBThread(history::HistoryBackend* backend,
-                             history::HistoryDatabase* db) override {
+  bool RunOnDBThread(history::HistoryBackend* backend,
+                     history::HistoryDatabase* db) override {
     return true;
   }
 
-  virtual void DoneRunOnMainThread() override {
-    base::MessageLoop::current()->Quit();
-  }
+  void DoneRunOnMainThread() override { base::MessageLoop::current()->Quit(); }
 
  private:
-  virtual ~QuittingHistoryDBTask() {}
+  ~QuittingHistoryDBTask() override {}
 
   DISALLOW_COPY_AND_ASSIGN(QuittingHistoryDBTask);
 };
 
 class TestExtensionURLRequestContext : public net::URLRequestContext {
  public:
   TestExtensionURLRequestContext() {
     net::CookieMonster* cookie_monster =
         content::CreateCookieStore(content::CookieStoreConfig())->
             GetCookieMonster();
     const char* const schemes[] = {extensions::kExtensionScheme};
     cookie_monster->SetCookieableSchemes(schemes, arraysize(schemes));
     set_cookie_store(cookie_monster);
   }
 
-  virtual ~TestExtensionURLRequestContext() {
-    AssertNoURLRequests();
-  }
+  ~TestExtensionURLRequestContext() override { AssertNoURLRequests(); }
 };
 
 class TestExtensionURLRequestContextGetter
     : public net::URLRequestContextGetter {
  public:
-  virtual net::URLRequestContext* GetURLRequestContext() override {
+  net::URLRequestContext* GetURLRequestContext() override {
     if (!context_.get())
       context_.reset(new TestExtensionURLRequestContext());
     return context_.get();
   }
-  virtual scoped_refptr<base::SingleThreadTaskRunner>
-      GetNetworkTaskRunner() const override {
+  scoped_refptr<base::SingleThreadTaskRunner> GetNetworkTaskRunner()
+      const override {
     return BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO);
   }
 
  protected:
-  virtual ~TestExtensionURLRequestContextGetter() {}
+  ~TestExtensionURLRequestContextGetter() override {}
 
  private:
   scoped_ptr<net::URLRequestContext> context_;
 };
 
 #if defined(ENABLE_NOTIFICATIONS)
 KeyedService* CreateTestDesktopNotificationService(
     content::BrowserContext* profile) {
   return new DesktopNotificationService(static_cast<Profile*>(profile));
 }
@@ skipping 845 matching lines @@
 #if defined(ENABLE_EXTENSIONS)
                             extension_policy_,
 #endif
                             pref_service_.Pass(),
                             original_profile,
                             guest_session_,
                             supervised_user_id_,
                             policy_service_.Pass(),
                             testing_factories_);
 }