Replace FINAL and OVERRIDE with their C++11 counterparts in chrome/test

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 {
+  virtual void TopSitesLoaded(history::TopSites* top_sites) override {
     runner_->Quit();
   }
-  virtual void TopSitesChanged(history::TopSites* top_sites) OVERRIDE {}
+  virtual 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 {
+                             history::HistoryDatabase* db) override {
     return true;
   }
 
-  virtual void DoneRunOnMainThread() OVERRIDE {
+  virtual void DoneRunOnMainThread() override {
     base::MessageLoop::current()->Quit();
   }
 
  private:
   virtual ~QuittingHistoryDBTask() {}
 
   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();
   }
 };
 
 class TestExtensionURLRequestContextGetter
     : public net::URLRequestContextGetter {
  public:
-  virtual net::URLRequestContext* GetURLRequestContext() OVERRIDE {
+  virtual net::URLRequestContext* GetURLRequestContext() override {
     if (!context_.get())
       context_.reset(new TestExtensionURLRequestContext());
     return context_.get();
   }
   virtual scoped_refptr<base::SingleThreadTaskRunner>
-      GetNetworkTaskRunner() const OVERRIDE {
+      GetNetworkTaskRunner() const override {
     return BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO);
   }
 
  protected:
   virtual ~TestExtensionURLRequestContextGetter() {}
 
  private:
   scoped_ptr<net::URLRequestContext> context_;
 };
 
@@ skipping 839 matching lines @@
 #if defined(ENABLE_EXTENSIONS)
                             extension_policy_,
 #endif
                             pref_service_.Pass(),
                             original_profile,
                             guest_session_,
                             supervised_user_id_,
                             policy_service_.Pass(),
                             testing_factories_);
 }