Replace FINAL and OVERRIDE with their C++11 counterparts in content

content/browser/service_worker/service_worker_browsertest.cc

 // Copyright 2014 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/callback.h"
 #include "base/command_line.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
@@ skipping 127 matching lines @@
 class WorkerActivatedObserver
     : public ServiceWorkerContextObserver,
       public base::RefCountedThreadSafe<WorkerActivatedObserver> {
  public:
   explicit WorkerActivatedObserver(ServiceWorkerContextWrapper* context)
       : context_(context) {}
   void Init() {
     RunOnIOThread(base::Bind(&WorkerActivatedObserver::InitOnIOThread, this));
   }
   // ServiceWorkerContextObserver overrides.
-  virtual void OnVersionStateChanged(int64 version_id) OVERRIDE {
+  virtual void OnVersionStateChanged(int64 version_id) override {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     const ServiceWorkerVersion* version =
         context_->context()->GetLiveVersion(version_id);
     if (version->status() == ServiceWorkerVersion::ACTIVATED) {
       context_->RemoveObserver(this);
       BrowserThread::PostTask(BrowserThread::UI,
                               FROM_HERE,
                               base::Bind(&WorkerActivatedObserver::Quit, this));
     }
   }
@@ skipping 31 matching lines @@
 // an experiration far in the future.
 class LongLivedResourceInterceptor : public net::URLRequestInterceptor {
  public:
   LongLivedResourceInterceptor(const std::string& body)
       : body_(body) {}
   virtual ~LongLivedResourceInterceptor() {}
 
   // net::URLRequestInterceptor implementation
   virtual net::URLRequestJob* MaybeInterceptRequest(
       net::URLRequest* request,
-      net::NetworkDelegate* network_delegate) const OVERRIDE {
+      net::NetworkDelegate* network_delegate) const override {
     const char kHeaders[] =
         "HTTP/1.1 200 OK\0"
         "Content-Type: text/javascript\0"
         "Expires: Thu, 1 Jan 2100 20:00:00 GMT\0"
         "\0";
     std::string headers(kHeaders, arraysize(kHeaders));
     return new net::URLRequestTestJob(
         request, network_delegate, headers, body_, true);
   }
 
@@ skipping 44 matching lines @@
       wrapper->context()->GetLiveVersion(version_id);
   *num_resources = static_cast<int>(version->script_cache_map()->size());
 }
 
 }  // namespace
 
 class ServiceWorkerBrowserTest : public ContentBrowserTest {
  protected:
   typedef ServiceWorkerBrowserTest self;
 
-  virtual void SetUpCommandLine(base::CommandLine* command_line) OVERRIDE {
+  virtual void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitch(
         switches::kEnableExperimentalWebPlatformFeatures);
   }
 
-  virtual void SetUpOnMainThread() OVERRIDE {
+  virtual void SetUpOnMainThread() override {
     ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
     StoragePartition* partition = BrowserContext::GetDefaultStoragePartition(
         shell()->web_contents()->GetBrowserContext());
     wrapper_ = static_cast<ServiceWorkerContextWrapper*>(
         partition->GetServiceWorkerContext());
 
     // Navigate to the page to set up a renderer page (where we can embed
     // a worker).
     NavigateToURLBlockUntilNavigationsComplete(
         shell(),
         embedded_test_server()->GetURL("/service_worker/empty.html"), 1);
 
     RunOnIOThread(base::Bind(&self::SetUpOnIOThread, this));
   }
 
-  virtual void TearDownOnMainThread() OVERRIDE {
+  virtual void TearDownOnMainThread() override {
     RunOnIOThread(base::Bind(&self::TearDownOnIOThread, this));
     wrapper_ = NULL;
   }
 
   virtual void SetUpOnIOThread() {}
   virtual void TearDownOnIOThread() {}
 
   ServiceWorkerContextWrapper* wrapper() { return wrapper_.get(); }
   ServiceWorkerContext* public_context() { return wrapper(); }
 
   void AssociateRendererProcessToPattern(const GURL& pattern) {
     wrapper_->process_manager()->AddProcessReferenceToPattern(
         pattern, shell()->web_contents()->GetRenderProcessHost()->GetID());
   }
 
  private:
   scoped_refptr<ServiceWorkerContextWrapper> wrapper_;
 };
 
 class EmbeddedWorkerBrowserTest : public ServiceWorkerBrowserTest,
                                   public EmbeddedWorkerInstance::Listener {
  public:
   typedef EmbeddedWorkerBrowserTest self;
 
   EmbeddedWorkerBrowserTest()
       : last_worker_status_(EmbeddedWorkerInstance::STOPPED),
         pause_mode_(DONT_PAUSE) {}
   virtual ~EmbeddedWorkerBrowserTest() {}
 
-  virtual void TearDownOnIOThread() OVERRIDE {
+  virtual void TearDownOnIOThread() override {
     if (worker_) {
       worker_->RemoveListener(this);
       worker_.reset();
     }
   }
 
   void StartOnIOThread() {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     worker_ = wrapper()->context()->embedded_worker_registry()->CreateWorker();
     EXPECT_EQ(EmbeddedWorkerInstance::STOPPED, worker_->status());
@@ skipping 33 matching lines @@
     last_worker_status_ = worker_->status();
     EXPECT_EQ(SERVICE_WORKER_OK, status);
     EXPECT_EQ(EmbeddedWorkerInstance::STOPPING, last_worker_status_);
 
     if (status != SERVICE_WORKER_OK && !done_closure_.is_null())
       done_closure_.Run();
   }
 
  protected:
   // EmbeddedWorkerInstance::Observer overrides:
-  virtual void OnStarted() OVERRIDE {
+  virtual void OnStarted() override {
     ASSERT_TRUE(worker_ != NULL);
     ASSERT_FALSE(done_closure_.is_null());
     last_worker_status_ = worker_->status();
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done_closure_);
   }
-  virtual void OnStopped() OVERRIDE {
+  virtual void OnStopped() override {
     ASSERT_TRUE(worker_ != NULL);
     ASSERT_FALSE(done_closure_.is_null());
     last_worker_status_ = worker_->status();
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done_closure_);
   }
-  virtual void OnPausedAfterDownload() OVERRIDE {
+  virtual void OnPausedAfterDownload() override {
     if (pause_mode_ == PAUSE_THEN_RESUME)
       worker_->ResumeAfterDownload();
     else if (pause_mode_ == PAUSE_THEN_STOP)
       worker_->Stop();
     else
       ASSERT_TRUE(false);
   }
   virtual void OnReportException(const base::string16& error_message,
                                  int line_number,
                                  int column_number,
-                                 const GURL& source_url) OVERRIDE {}
+                                 const GURL& source_url) override {}
   virtual void OnReportConsoleMessage(int source_identifier,
                                       int message_level,
                                       const base::string16& message,
                                       int line_number,
-                                      const GURL& source_url) OVERRIDE {}
-  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
+                                      const GURL& source_url) override {}
+  virtual bool OnMessageReceived(const IPC::Message& message) override {
     return false;
   }
 
   scoped_ptr<EmbeddedWorkerInstance> worker_;
   EmbeddedWorkerInstance::Status last_worker_status_;
 
   enum {
     DONT_PAUSE,
     PAUSE_THEN_RESUME,
     PAUSE_THEN_STOP,
   } pause_mode_;
 
   // Called by EmbeddedWorkerInstance::Observer overrides so that
   // test code can wait for the worker status notifications.
   base::Closure done_closure_;
 };
 
 class ServiceWorkerVersionBrowserTest : public ServiceWorkerBrowserTest {
  public:
   typedef ServiceWorkerVersionBrowserTest self;
 
   virtual ~ServiceWorkerVersionBrowserTest() {}
 
-  virtual void TearDownOnIOThread() OVERRIDE {
+  virtual void TearDownOnIOThread() override {
     registration_ = NULL;
     version_ = NULL;
   }
 
   void InstallTestHelper(const std::string& worker_url,
                          ServiceWorkerStatusCode expected_status) {
     RunOnIOThread(base::Bind(&self::SetUpRegistrationOnIOThread, this,
                              worker_url));
 
     // Dispatch install on a worker.
@@ skipping 512 matching lines @@
     RunOnIOThread(
         base::Bind(&ServiceWorkerBlackBoxBrowserTest::FindRegistrationOnIO,
                    this,
                    embedded_test_server()->GetURL("/service_worker/empty.html"),
                    &status));
     EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND, status);
   }
 }
 
 }  // namespace content