replace OVERRIDE and FINAL with override and final in chrome/browser/[j-q]*

chrome/browser/prerender/prerender_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 <deque>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 115 matching lines @@
 // The prerendered page is then displayed on a tab.  The Javascript function
 // DidDisplayPass() is called, and returns true if the page behaved as it
 // should while being displayed.
 
 namespace prerender {
 
 namespace {
 
 class MockNetworkChangeNotifierWIFI : public NetworkChangeNotifier {
  public:
-  virtual ConnectionType GetCurrentConnectionType() const OVERRIDE {
+  virtual ConnectionType GetCurrentConnectionType() const override {
     return NetworkChangeNotifier::CONNECTION_WIFI;
   }
 };
 
 class MockNetworkChangeNotifier4G : public NetworkChangeNotifier {
  public:
-  virtual ConnectionType GetCurrentConnectionType() const OVERRIDE {
+  virtual ConnectionType GetCurrentConnectionType() const override {
     return NetworkChangeNotifier::CONNECTION_4G;
   }
 };
 
 // Constants used in the test HTML files.
 const char* kReadyTitle = "READY";
 const char* kPassTitle = "PASS";
 
 std::string CreateClientRedirect(const std::string& dest_url) {
   const char* const kClientRedirectBase = "client-redirect?";
@@ skipping 80 matching lines @@
     }
 
    private:
     virtual ~DestructionMessageFilter() {
       content::BrowserThread::PostTask(
           content::BrowserThread::UI, FROM_HERE,
           base::Bind(&ChannelDestructionWatcher::OnChannelDestroyed,
                      base::Unretained(watcher_)));
     }
 
-    virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
+    virtual bool OnMessageReceived(const IPC::Message& message) override {
       return false;
     }
 
     ChannelDestructionWatcher* watcher_;
 
     DISALLOW_COPY_AND_ASSIGN(DestructionMessageFilter);
   };
 
   void OnChannelDestroyed() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 49 matching lines @@
 
   void set_did_start_loading() {
     did_start_loading_ = true;
   }
 
   void Wait() {
     loop_.Run();
   }
 
   // WebContentsObserver implementation:
-  virtual void DidStartLoading(RenderViewHost* render_view_host) OVERRIDE {
+  virtual void DidStartLoading(RenderViewHost* render_view_host) override {
     did_start_loading_ = true;
   }
-  virtual void DidStopLoading(RenderViewHost* render_view_host) OVERRIDE {
+  virtual void DidStopLoading(RenderViewHost* render_view_host) override {
     if (!did_start_loading_)
       return;
     number_of_loads_--;
     if (number_of_loads_ == 0)
       loop_.Quit();
   }
 
   // TabStripModelObserver implementation:
   virtual void TabReplacedAt(TabStripModel* tab_strip_model,
                              WebContents* old_contents,
                              WebContents* new_contents,
-                             int index) OVERRIDE {
+                             int index) override {
     if (old_contents != web_contents())
       return;
     // Switch to observing the new WebContents.
     Observe(new_contents);
     if (new_contents->IsLoading()) {
       // If the new WebContents is still loading, wait for it to complete. Only
       // one load post-swap is supported.
       did_start_loading_ = true;
       number_of_loads_ = 1;
     } else {
@@ skipping 86 matching lines @@
 
     // A used PrerenderContents will only be destroyed when we swap out
     // WebContents, at the end of a navigation caused by a call to
     // NavigateToURLImpl().
     if (final_status() == FINAL_STATUS_USED)
       EXPECT_TRUE(new_render_view_host_);
 
     EXPECT_EQ(should_be_shown_, was_shown_);
   }
 
-  virtual void RenderProcessGone(base::TerminationStatus status) OVERRIDE {
+  virtual void RenderProcessGone(base::TerminationStatus status) override {
     // On quit, it's possible to end up here when render processes are closed
     // before the PrerenderManager is destroyed.  As a result, it's possible to
     // get either FINAL_STATUS_APP_TERMINATING or FINAL_STATUS_RENDERER_CRASHED
     // on quit.
     //
     // It's also possible for this to be called after we've been notified of
     // app termination, but before we've been deleted, which is why the second
     // check is needed.
     if (expected_final_status_ == FINAL_STATUS_APP_TERMINATING &&
         final_status() != expected_final_status_) {
       expected_final_status_ = FINAL_STATUS_RENDERER_CRASHED;
     }
 
     PrerenderContents::RenderProcessGone(status);
   }
 
-  virtual bool CheckURL(const GURL& url) OVERRIDE {
+  virtual bool CheckURL(const GURL& url) override {
     // Prevent FINAL_STATUS_UNSUPPORTED_SCHEME when navigating to about:crash in
     // the PrerenderRendererCrash test.
     if (url.spec() != content::kChromeUICrashURL)
       return PrerenderContents::CheckURL(url);
     return true;
   }
 
   // For tests that open the prerender in a new background tab, the RenderView
   // will not have been made visible when the PrerenderContents is destroyed
   // even though it is used.
   void set_should_be_shown(bool value) { should_be_shown_ = value; }
 
   // For tests which do not know whether the prerender will be used.
   void set_skip_final_checks(bool value) { skip_final_checks_ = value; }
 
   FinalStatus expected_final_status() const { return expected_final_status_; }
 
  private:
   virtual void OnRenderViewHostCreated(
-      RenderViewHost* new_render_view_host) OVERRIDE {
+      RenderViewHost* new_render_view_host) override {
     // Used to make sure the RenderViewHost is hidden and, if used,
     // subsequently shown.
     notification_registrar().Add(
         this,
         content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
         content::Source<RenderWidgetHost>(new_render_view_host));
 
     new_render_view_host_ = new_render_view_host;
 
     PrerenderContents::OnRenderViewHostCreated(new_render_view_host);
   }
 
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details) OVERRIDE {
+                       const content::NotificationDetails& details) override {
     if (type ==
         content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED) {
       EXPECT_EQ(new_render_view_host_,
                 content::Source<RenderWidgetHost>(source).ptr());
       bool is_visible = *content::Details<bool>(details).ptr();
 
       if (!is_visible) {
         was_hidden_ = true;
       } else if (is_visible && was_hidden_) {
         // Once hidden, a prerendered RenderViewHost should only be shown after
@@ skipping 63 matching lines @@
   }
 
   void OnPrerenderCreated(TestPrerenderContents* contents) {
     DCHECK(!contents_);
     contents_ = contents;
     contents_->AddObserver(this);
     create_loop_.Quit();
   }
 
   // PrerenderContents::Observer implementation:
-  virtual void OnPrerenderStart(PrerenderContents* contents) OVERRIDE {
+  virtual void OnPrerenderStart(PrerenderContents* contents) override {
     start_loop_.Quit();
   }
 
-  virtual void OnPrerenderStopLoading(PrerenderContents* contents) OVERRIDE {
+  virtual void OnPrerenderStopLoading(PrerenderContents* contents) override {
     number_of_loads_++;
     if (load_waiter_ && number_of_loads_ >= expected_number_of_loads_)
       load_waiter_->Quit();
   }
 
-  virtual void OnPrerenderStop(PrerenderContents* contents) OVERRIDE {
+  virtual void OnPrerenderStop(PrerenderContents* contents) override {
     DCHECK(contents_);
     contents_ = NULL;
     stop_loop_.Quit();
     // If there is a WaitForLoads call and it has yet to see the expected number
     // of loads, stop the loop so the test fails instead of timing out.
     if (load_waiter_)
       load_waiter_->Quit();
   }
 
   virtual void OnPrerenderCreatedMatchCompleteReplacement(
-      PrerenderContents* contents, PrerenderContents* replacement) OVERRIDE {
+      PrerenderContents* contents, PrerenderContents* replacement) override {
   }
 
  private:
   TestPrerenderContents* contents_;
   int number_of_loads_;
 
   int expected_number_of_loads_;
   scoped_ptr<base::RunLoop> load_waiter_;
 
   base::RunLoop create_loop_;
@@ skipping 18 matching lines @@
         ExpectedContents(final_status, handle->AsWeakPtr()));
     return handle.Pass();
   }
 
   virtual PrerenderContents* CreatePrerenderContents(
       PrerenderManager* prerender_manager,
       Profile* profile,
       const GURL& url,
       const content::Referrer& referrer,
       Origin origin,
-      uint8 experiment_id) OVERRIDE {
+      uint8 experiment_id) override {
     ExpectedContents expected;
     if (!expected_contents_queue_.empty()) {
       expected = expected_contents_queue_.front();
       expected_contents_queue_.pop_front();
     }
     VLOG(1) << "Creating prerender contents for " << url.path() <<
                " with expected final status " << expected.final_status;
     VLOG(1) << expected_contents_queue_.size() << " left in the queue.";
     TestPrerenderContents* contents =
         new TestPrerenderContents(prerender_manager,
@@ skipping 31 matching lines @@
 
   // Called on the IO thread to check if the given url is safe or not.  If we
   // can synchronously determine that the url is safe, CheckUrl returns true.
   // Otherwise it returns false, and "client" is called asynchronously with the
   // result when it is ready.
   // Returns true, indicating a SAFE result, unless the URL is the fixed URL
   // specified by the user, and the user-specified result is not SAFE
   // (in which that result will be communicated back via a call into the
   // client, and false will be returned).
   // Overrides SafeBrowsingService::CheckBrowseUrl.
-  virtual bool CheckBrowseUrl(const GURL& gurl, Client* client) OVERRIDE {
+  virtual bool CheckBrowseUrl(const GURL& gurl, Client* client) override {
     if (gurl != url_ || threat_type_ == SB_THREAT_TYPE_SAFE)
       return true;
 
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&FakeSafeBrowsingDatabaseManager::OnCheckBrowseURLDone,
                    this, gurl, client));
     return false;
   }
 
@@ skipping 30 matching lines @@
 
   // Returned pointer has the same lifespan as the database_manager_ refcounted
   // object.
   FakeSafeBrowsingDatabaseManager* fake_database_manager() {
     return fake_database_manager_;
   }
 
  protected:
   virtual ~FakeSafeBrowsingService() { }
 
-  virtual SafeBrowsingDatabaseManager* CreateDatabaseManager() OVERRIDE {
+  virtual SafeBrowsingDatabaseManager* CreateDatabaseManager() override {
     fake_database_manager_ = new FakeSafeBrowsingDatabaseManager(this);
     return fake_database_manager_;
   }
 
  private:
   FakeSafeBrowsingDatabaseManager* fake_database_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeSafeBrowsingService);
 };
 
 // Factory that creates FakeSafeBrowsingService instances.
 class TestSafeBrowsingServiceFactory : public SafeBrowsingServiceFactory {
  public:
   TestSafeBrowsingServiceFactory() :
       most_recent_service_(NULL) { }
   virtual ~TestSafeBrowsingServiceFactory() { }
 
-  virtual SafeBrowsingService* CreateSafeBrowsingService() OVERRIDE {
+  virtual SafeBrowsingService* CreateSafeBrowsingService() override {
     most_recent_service_ =  new FakeSafeBrowsingService();
     return most_recent_service_;
   }
 
   FakeSafeBrowsingService* most_recent_service() const {
     return most_recent_service_;
   }
 
  private:
   FakeSafeBrowsingService* most_recent_service_;
 };
 #endif
 
 class FakeDevToolsClient : public content::DevToolsAgentHostClient {
  public:
   FakeDevToolsClient() {}
   virtual ~FakeDevToolsClient() {}
   virtual void DispatchProtocolMessage(
-      DevToolsAgentHost* agent_host, const std::string& message) OVERRIDE {}
+      DevToolsAgentHost* agent_host, const std::string& message) override {}
   virtual void AgentHostClosed(
-      DevToolsAgentHost* agent_host, bool replaced) OVERRIDE {}
+      DevToolsAgentHost* agent_host, bool replaced) override {}
 };
 
 class RestorePrerenderMode {
  public:
   RestorePrerenderMode() : prev_mode_(PrerenderManager::GetMode()) {
   }
 
   ~RestorePrerenderMode() { PrerenderManager::SetMode(prev_mode_); }
  private:
   PrerenderManager::PrerenderManagerMode prev_mode_;
 };
 
 // URLRequestJob (and associated handler) which hangs.
 class HangingURLRequestJob : public net::URLRequestJob {
  public:
   HangingURLRequestJob(net::URLRequest* request,
                           net::NetworkDelegate* network_delegate)
       : net::URLRequestJob(request, network_delegate) {
   }
 
-  virtual void Start() OVERRIDE {}
+  virtual void Start() override {}
 
  private:
   virtual ~HangingURLRequestJob() {}
 };
 
 class HangingFirstRequestInterceptor : public net::URLRequestInterceptor {
  public:
   HangingFirstRequestInterceptor(const base::FilePath& file,
                                  base::Closure callback)
       : file_(file),
         callback_(callback),
         first_run_(true) {
   }
   virtual ~HangingFirstRequestInterceptor() {}
 
   virtual net::URLRequestJob* MaybeInterceptRequest(
       net::URLRequest* request,
-      net::NetworkDelegate* network_delegate) const OVERRIDE {
+      net::NetworkDelegate* network_delegate) const override {
     if (first_run_) {
       first_run_ = false;
       if (!callback_.is_null()) {
         BrowserThread::PostTask(
             BrowserThread::UI, FROM_HERE, callback_);
       }
       return new HangingURLRequestJob(request, network_delegate);
     }
     return new net::URLRequestMockHTTPJob(
         request,
@@ skipping 31 matching lines @@
             request,
             delegate,
             file,
             BrowserThread::GetBlockingPool()->GetTaskRunnerWithShutdownBehavior(
                 base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)) {}
 
   void set_start_callback(const base::Closure& start_callback) {
     start_callback_ = start_callback;
   }
 
-  virtual void Start() OVERRIDE {
+  virtual void Start() override {
     if (!start_callback_.is_null())
       start_callback_.Run();
     net::URLRequestMockHTTPJob::Start();
   }
 
  private:
   virtual ~MockHTTPJob() {}
 
   base::Closure start_callback_;
 };
@@ skipping 35 matching lines @@
   CountingInterceptor(const base::FilePath& file,
                       const base::WeakPtr<RequestCounter>& counter)
       : file_(file),
         counter_(counter),
         weak_factory_(this) {
   }
   virtual ~CountingInterceptor() {}
 
   virtual net::URLRequestJob* MaybeInterceptRequest(
       net::URLRequest* request,
-      net::NetworkDelegate* network_delegate) const OVERRIDE {
+      net::NetworkDelegate* network_delegate) const override {
     MockHTTPJob* job = new MockHTTPJob(request, network_delegate, file_);
     job->set_start_callback(base::Bind(&CountingInterceptor::RequestStarted,
                                        weak_factory_.GetWeakPtr()));
     return job;
   }
 
   void RequestStarted() {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&RequestCounter::RequestStarted, counter_));
@@ skipping 28 matching lines @@
 }
 
 // A ContentBrowserClient that cancels all prerenderers on OpenURL.
 class TestContentBrowserClient : public chrome::ChromeContentBrowserClient {
  public:
   TestContentBrowserClient() {}
   virtual ~TestContentBrowserClient() {}
 
   // chrome::ChromeContentBrowserClient implementation.
   virtual bool ShouldAllowOpenURL(content::SiteInstance* site_instance,
-                                  const GURL& url) OVERRIDE {
+                                  const GURL& url) override {
     PrerenderManagerFactory::GetForProfile(
         Profile::FromBrowserContext(site_instance->GetBrowserContext()))
         ->CancelAllPrerenders();
     return chrome::ChromeContentBrowserClient::ShouldAllowOpenURL(site_instance,
                                                                   url);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestContentBrowserClient);
 };
 
 // A ContentBrowserClient that forces cross-process navigations.
 class SwapProcessesContentBrowserClient
     : public chrome::ChromeContentBrowserClient {
  public:
   SwapProcessesContentBrowserClient() {}
   virtual ~SwapProcessesContentBrowserClient() {}
 
   // chrome::ChromeContentBrowserClient implementation.
   virtual bool ShouldSwapProcessesForRedirect(
       content::ResourceContext* resource_context,
       const GURL& current_url,
-      const GURL& new_url) OVERRIDE {
+      const GURL& new_url) override {
     return true;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SwapProcessesContentBrowserClient);
 };
 
 // An ExternalProtocolHandler that blocks everything and asserts it never is
 // called.
 class NeverRunsExternalProtocolHandlerDelegate
     : public ExternalProtocolHandler::Delegate {
  public:
   // ExternalProtocolHandler::Delegate implementation.
   virtual ShellIntegration::DefaultProtocolClientWorker* CreateShellWorker(
       ShellIntegration::DefaultWebClientObserver* observer,
-      const std::string& protocol) OVERRIDE {
+      const std::string& protocol) override {
     NOTREACHED();
     // This will crash, but it shouldn't get this far with BlockState::BLOCK
     // anyway.
     return NULL;
   }
   virtual ExternalProtocolHandler::BlockState GetBlockState(
-      const std::string& scheme) OVERRIDE {
+      const std::string& scheme) override {
     // Block everything and fail the test.
     ADD_FAILURE();
     return ExternalProtocolHandler::BLOCK;
   }
-  virtual void BlockRequest() OVERRIDE { }
+  virtual void BlockRequest() override { }
   virtual void RunExternalProtocolDialog(const GURL& url,
                                          int render_process_host_id,
-                                         int routing_id) OVERRIDE {
+                                         int routing_id) override {
     NOTREACHED();
   }
-  virtual void LaunchUrlWithoutSecurityCheck(const GURL& url) OVERRIDE {
+  virtual void LaunchUrlWithoutSecurityCheck(const GURL& url) override {
     NOTREACHED();
   }
-  virtual void FinishedProcessingCheck() OVERRIDE {
+  virtual void FinishedProcessingCheck() override {
     NOTREACHED();
   }
 };
 
 base::FilePath GetTestPath(const std::string& file_name) {
   return ui_test_utils::GetTestFilePath(
       base::FilePath(FILE_PATH_LITERAL("prerender")),
       base::FilePath().AppendASCII(file_name));
 }
 
@@ skipping 15 matching lines @@
 
   virtual ~PrerenderBrowserTest() {}
 
   content::SessionStorageNamespace* GetSessionStorageNamespace() const {
     WebContents* web_contents = GetActiveWebContents();
     if (!web_contents)
       return NULL;
     return web_contents->GetController().GetDefaultSessionStorageNamespace();
   }
 
-  virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
+  virtual void SetUpInProcessBrowserTestFixture() override {
 #if defined(FULL_SAFE_BROWSING)
     SafeBrowsingService::RegisterFactory(safe_browsing_factory_.get());
 #endif
   }
 
-  virtual void TearDownInProcessBrowserTestFixture() OVERRIDE {
+  virtual void TearDownInProcessBrowserTestFixture() override {
 #if defined(FULL_SAFE_BROWSING)
     SafeBrowsingService::RegisterFactory(NULL);
 #endif
   }
 
-  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+  virtual void SetUpCommandLine(CommandLine* command_line) override {
     command_line->AppendSwitchASCII(switches::kPrerenderMode,
                                     switches::kPrerenderModeSwitchValueEnabled);
 #if defined(OS_MACOSX)
     // The plugins directory isn't read by default on the Mac, so it needs to be
     // explicitly registered.
     base::FilePath app_dir;
     PathService::Get(chrome::DIR_APP, &app_dir);
     command_line->AppendSwitchPath(
         switches::kExtraPluginDir,
         app_dir.Append(FILE_PATH_LITERAL("plugins")));
@@ skipping 68 matching lines @@
           preference_never_network_wifi);
     }
     {
       scoped_ptr<NetworkChangeNotifier> mock(new MockNetworkChangeNotifier4G);
       EXPECT_EQ(
           ShouldDisableLocalPredictorDueToPreferencesAndNetwork(profile),
           preference_never_network_4g);
     }
   }
 
-  virtual void SetUpOnMainThread() OVERRIDE {
+  virtual void SetUpOnMainThread() override {
     current_browser()->profile()->GetPrefs()->SetBoolean(
         prefs::kPromptForDownload, false);
     IncreasePrerenderMemory();
     if (autostart_test_server_)
       ASSERT_TRUE(test_server()->Start());
     ChromeResourceDispatcherHostDelegate::
         SetExternalProtocolHandlerDelegateForTesting(
             &external_protocol_handler_delegate_);
 
     PrerenderManager* prerender_manager = GetPrerenderManager();
@@ skipping 1837 matching lines @@
 }
 
 class TestClientCertStore : public net::ClientCertStore {
  public:
   TestClientCertStore() {}
   virtual ~TestClientCertStore() {}
 
   // net::ClientCertStore:
   virtual void GetClientCerts(const net::SSLCertRequestInfo& cert_request_info,
                               net::CertificateList* selected_certs,
-                              const base::Closure& callback) OVERRIDE {
+                              const base::Closure& callback) override {
     *selected_certs = net::CertificateList(
         1, scoped_refptr<net::X509Certificate>(
         new net::X509Certificate("test", "test", base::Time(), base::Time())));
     callback.Run();
   }
 };
 
 scoped_ptr<net::ClientCertStore> CreateCertStore() {
   return scoped_ptr<net::ClientCertStore>(new TestClientCertStore);
 }
@@ skipping 492 matching lines @@
                                       0);
   histogram_tester().ExpectTotalCount(
       "Prerender.websame_PerceivedPLTMatchedComplete", 1);
 }
 
 class PrerenderBrowserTestWithNaCl : public PrerenderBrowserTest {
  public:
   PrerenderBrowserTestWithNaCl() {}
   virtual ~PrerenderBrowserTestWithNaCl() {}
 
-  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+  virtual void SetUpCommandLine(CommandLine* command_line) override {
     PrerenderBrowserTest::SetUpCommandLine(command_line);
     command_line->AppendSwitch(switches::kEnableNaCl);
   }
 };
 
 // Check that NaCl plugins work when enabled, with prerendering.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTestWithNaCl,
                        PrerenderNaClPluginEnabled) {
 #if defined(OS_WIN) && defined(USE_ASH)
   // Disable this test in Metro+Ash for now (http://crbug.com/262796).
@@ skipping 65 matching lines @@
 // Test interaction of the webNavigation and tabs API with prerender.
 class PrerenderBrowserTestWithExtensions : public PrerenderBrowserTest,
                                            public ExtensionApiTest {
  public:
   PrerenderBrowserTestWithExtensions() {
     // The individual tests start the test server through ExtensionApiTest, so
     // the port number can be passed through to the extension.
     autostart_test_server_ = false;
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     PrerenderBrowserTest::SetUp();
   }
 
-  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+  virtual void SetUpCommandLine(CommandLine* command_line) override {
     PrerenderBrowserTest::SetUpCommandLine(command_line);
     ExtensionApiTest::SetUpCommandLine(command_line);
   }
 
-  virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
+  virtual void SetUpInProcessBrowserTestFixture() override {
     PrerenderBrowserTest::SetUpInProcessBrowserTestFixture();
     ExtensionApiTest::SetUpInProcessBrowserTestFixture();
   }
 
-  virtual void TearDownInProcessBrowserTestFixture() OVERRIDE {
+  virtual void TearDownInProcessBrowserTestFixture() override {
     PrerenderBrowserTest::TearDownInProcessBrowserTestFixture();
     ExtensionApiTest::TearDownInProcessBrowserTestFixture();
   }
 
-  virtual void SetUpOnMainThread() OVERRIDE {
+  virtual void SetUpOnMainThread() override {
     PrerenderBrowserTest::SetUpOnMainThread();
   }
 };
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTestWithExtensions, WebNavigation) {
   ASSERT_TRUE(StartSpawnedTestServer());
   extensions::FrameNavigationState::set_allow_extension_scheme(true);
 
   // Wait for the extension to set itself up and return control to us.
   ASSERT_TRUE(RunExtensionTest("webnavigation/prerender")) << message_;
@@ skipping 755 matching lines @@
 
 // Checks that a prerender which calls window.close() on itself is aborted.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderWindowClose) {
   DisableLoadEventCheck();
   PrerenderTestURL("files/prerender/prerender_window_close.html",
                    FINAL_STATUS_CLOSED, 0);
 }
 
 class PrerenderIncognitoBrowserTest : public PrerenderBrowserTest {
  public:
-  virtual void SetUpOnMainThread() OVERRIDE {
+  virtual void SetUpOnMainThread() override {
     Profile* normal_profile = current_browser()->profile();
     set_browser(ui_test_utils::OpenURLOffTheRecord(
         normal_profile, GURL("about:blank")));
     PrerenderBrowserTest::SetUpOnMainThread();
   }
 };
 
 // Checks that prerendering works in incognito mode.
 IN_PROC_BROWSER_TEST_F(PrerenderIncognitoBrowserTest, PrerenderIncognito) {
   PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
@@ skipping 174 matching lines @@
   TestShouldDisableLocalPredictorPreferenceNetworkMatrix(
       true /*preference_wifi_network_wifi*/,
       true /*preference_wifi_network_4g*/,
       true /*preference_always_network_wifi*/,
       false /*preference_always_network_4g*/,
       true /*preference_never_network_wifi*/,
       true /*preference_never_network_4g*/);
 }
 
 }  // namespace prerender