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

content/browser/service_worker/service_worker_url_request_job_unittest.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/basictypes.h"
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
@@ skipping 41 matching lines @@
  public:
   MockHttpProtocolHandler(
       base::WeakPtr<ServiceWorkerProviderHost> provider_host,
       base::WeakPtr<storage::BlobStorageContext> blob_storage_context)
       : provider_host_(provider_host),
         blob_storage_context_(blob_storage_context) {}
   virtual ~MockHttpProtocolHandler() {}
 
   virtual net::URLRequestJob* MaybeCreateJob(
       net::URLRequest* request,
-      net::NetworkDelegate* network_delegate) const OVERRIDE {
+      net::NetworkDelegate* network_delegate) const override {
     ServiceWorkerURLRequestJob* job =
         new ServiceWorkerURLRequestJob(request,
                                        network_delegate,
                                        provider_host_,
                                        blob_storage_context_,
                                        FETCH_REQUEST_MODE_NO_CORS,
                                        FETCH_CREDENTIALS_MODE_OMIT,
                                        REQUEST_CONTEXT_TYPE_HYPERLINK,
                                        REQUEST_CONTEXT_FRAME_TYPE_TOP_LEVEL,
                                        scoped_refptr<ResourceRequestBody>());
@@ skipping 18 matching lines @@
 
 }  // namespace
 
 class ServiceWorkerURLRequestJobTest : public testing::Test {
  protected:
   ServiceWorkerURLRequestJobTest()
       : thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP),
         blob_data_(new storage::BlobData("blob-id:myblob")) {}
   virtual ~ServiceWorkerURLRequestJobTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     browser_context_.reset(new TestBrowserContext);
     SetUpWithHelper(new EmbeddedWorkerTestHelper(kProcessID));
   }
 
   void SetUpWithHelper(EmbeddedWorkerTestHelper* helper) {
     helper_.reset(helper);
 
     registration_ = new ServiceWorkerRegistration(
         GURL("http://example.com/"),
         1L,
@@ skipping 22 matching lines @@
         "http",
         new MockHttpProtocolHandler(provider_host->AsWeakPtr(),
                                     blob_storage_context->AsWeakPtr()));
     url_request_job_factory_->SetProtocolHandler(
         "blob", CreateMockBlobProtocolHandler(blob_storage_context));
     url_request_context_.set_job_factory(url_request_job_factory_.get());
 
     helper_->context()->AddProviderHost(provider_host.Pass());
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     version_ = NULL;
     registration_ = NULL;
     helper_.reset();
   }
 
   void TestRequest(int expected_status_code,
                    const std::string& expected_status_text,
                    const std::string& expected_response) {
     request_ = url_request_context_.CreateRequest(
         GURL("http://example.com/foo.html"),
@@ skipping 39 matching lines @@
 class BlobResponder : public EmbeddedWorkerTestHelper {
  public:
   BlobResponder(int mock_render_process_id, const std::string& blob_uuid)
       : EmbeddedWorkerTestHelper(mock_render_process_id),
         blob_uuid_(blob_uuid) {}
   virtual ~BlobResponder() {}
 
  protected:
   virtual void OnFetchEvent(int embedded_worker_id,
                             int request_id,
-                            const ServiceWorkerFetchRequest& request) OVERRIDE {
+                            const ServiceWorkerFetchRequest& request) override {
     SimulateSend(new ServiceWorkerHostMsg_FetchEventFinished(
         embedded_worker_id,
         request_id,
         SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
         ServiceWorkerResponse(GURL(""),
                               200,
                               "OK",
                               blink::WebServiceWorkerResponseTypeDefault,
                               ServiceWorkerHeaderMap(),
                               blob_uuid_)));
@@ skipping 24 matching lines @@
 TEST_F(ServiceWorkerURLRequestJobTest, NonExistentBlobUUIDResponse) {
   SetUpWithHelper(new BlobResponder(kProcessID, "blob-id:nothing-is-here"));
   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
   TestRequest(500, "Service Worker Response Error", std::string());
 }
 
 // TODO(kinuko): Add more tests with different response data and also for
 // FallbackToNetwork case.
 
 }  // namespace content