Replacing the OVERRIDE with override and FINAL with final in content/browser/appcache

content/browser/appcache/appcache_storage_impl_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 <stack>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/files/file_util.h"
@@ skipping 110 matching lines @@
       (*body) = "";
     }
   }
 };
 
 class MockHttpServerJobFactory
     : public net::URLRequestJobFactory::ProtocolHandler {
  public:
   virtual net::URLRequestJob* MaybeCreateJob(
       net::URLRequest* request,
-      net::NetworkDelegate* network_delegate) const OVERRIDE {
+      net::NetworkDelegate* network_delegate) const override {
     return MockHttpServer::CreateJob(request, network_delegate);
   }
 };
 
 class IOThread : public base::Thread {
  public:
   explicit IOThread(const char* name)
       : base::Thread(name) {
   }
 
   virtual ~IOThread() {
     Stop();
   }
 
   net::URLRequestContext* request_context() {
     return request_context_.get();
   }
 
-  virtual void Init() OVERRIDE {
+  virtual void Init() override {
     scoped_ptr<net::URLRequestJobFactoryImpl> factory(
         new net::URLRequestJobFactoryImpl());
     factory->SetProtocolHandler("http", new MockHttpServerJobFactory);
     job_factory_ = factory.Pass();
     request_context_.reset(new net::TestURLRequestContext());
     request_context_->set_job_factory(job_factory_.get());
     AppCacheInterceptor::EnsureRegistered();
   }
 
-  virtual void CleanUp() OVERRIDE {
+  virtual void CleanUp() override {
     request_context_.reset();
     job_factory_.reset();
   }
 
  private:
   scoped_ptr<net::URLRequestJobFactory> job_factory_;
   scoped_ptr<net::URLRequestContext> request_context_;
 };
 
 scoped_ptr<IOThread> io_thread;
 scoped_ptr<base::Thread> db_thread;
 
 }  // namespace
 
 class AppCacheStorageImplTest : public testing::Test {
  public:
   class MockStorageDelegate : public AppCacheStorage::Delegate {
    public:
     explicit MockStorageDelegate(AppCacheStorageImplTest* test)
         : loaded_cache_id_(0), stored_group_success_(false),
           would_exceed_quota_(false), obsoleted_success_(false),
           found_cache_id_(kAppCacheNoCacheId), test_(test) {
     }
 
-    virtual void OnCacheLoaded(AppCache* cache, int64 cache_id) OVERRIDE {
+    virtual void OnCacheLoaded(AppCache* cache, int64 cache_id) override {
       loaded_cache_ = cache;
       loaded_cache_id_ = cache_id;
       test_->ScheduleNextTask();
     }
 
     virtual void OnGroupLoaded(AppCacheGroup* group,
-                               const GURL& manifest_url) OVERRIDE {
+                               const GURL& manifest_url) override {
       loaded_group_ = group;
       loaded_manifest_url_ = manifest_url;
       loaded_groups_newest_cache_ = group ? group->newest_complete_cache()
                                           : NULL;
       test_->ScheduleNextTask();
     }
 
     virtual void OnGroupAndNewestCacheStored(
         AppCacheGroup* group, AppCache* newest_cache, bool success,
-        bool would_exceed_quota) OVERRIDE {
+        bool would_exceed_quota) override {
       stored_group_ = group;
       stored_group_success_ = success;
       would_exceed_quota_ = would_exceed_quota;
       test_->ScheduleNextTask();
     }
 
     virtual void OnGroupMadeObsolete(AppCacheGroup* group,
                                      bool success,
-                                     int response_code) OVERRIDE {
+                                     int response_code) override {
       obsoleted_group_ = group;
       obsoleted_success_ = success;
       test_->ScheduleNextTask();
     }
 
     virtual void OnMainResponseFound(const GURL& url,
                                      const AppCacheEntry& entry,
                                      const GURL& namespace_entry_url,
                                      const AppCacheEntry& fallback_entry,
                                      int64 cache_id,
                                      int64 group_id,
-                                     const GURL& manifest_url) OVERRIDE {
+                                     const GURL& manifest_url) override {
       found_url_ = url;
       found_entry_ = entry;
       found_namespace_entry_url_ = namespace_entry_url;
       found_fallback_entry_ = fallback_entry;
       found_cache_id_ = cache_id;
       found_group_id_ = group_id;
       found_manifest_url_ = manifest_url;
       test_->ScheduleNextTask();
     }
 
@@ skipping 23 matching lines @@
         : QuotaManager(true /* is_incognito */,
                        base::FilePath(),
                        io_thread->message_loop_proxy().get(),
                        db_thread->message_loop_proxy().get(),
                        NULL),
           async_(false) {}
 
     virtual void GetUsageAndQuota(
         const GURL& origin,
         storage::StorageType type,
-        const GetUsageAndQuotaCallback& callback) OVERRIDE {
+        const GetUsageAndQuotaCallback& callback) override {
       EXPECT_EQ(storage::kStorageTypeTemporary, type);
       if (async_) {
         base::MessageLoop::current()->PostTask(
             FROM_HERE,
             base::Bind(&MockQuotaManager::CallCallback,
                        base::Unretained(this),
                        callback));
         return;
       }
       CallCallback(callback);
@@ skipping 15 matching lines @@
         : QuotaManagerProxy(NULL, NULL),
           notify_storage_accessed_count_(0),
           notify_storage_modified_count_(0),
           last_delta_(0),
           mock_manager_(new MockQuotaManager) {
       manager_ = mock_manager_.get();
     }
 
     virtual void NotifyStorageAccessed(storage::QuotaClient::ID client_id,
                                        const GURL& origin,
-                                       storage::StorageType type) OVERRIDE {
+                                       storage::StorageType type) override {
       EXPECT_EQ(storage::QuotaClient::kAppcache, client_id);
       EXPECT_EQ(storage::kStorageTypeTemporary, type);
       ++notify_storage_accessed_count_;
       last_origin_ = origin;
     }
 
     virtual void NotifyStorageModified(storage::QuotaClient::ID client_id,
                                        const GURL& origin,
                                        storage::StorageType type,
-                                       int64 delta) OVERRIDE {
+                                       int64 delta) override {
       EXPECT_EQ(storage::QuotaClient::kAppcache, client_id);
       EXPECT_EQ(storage::kStorageTypeTemporary, type);
       ++notify_storage_modified_count_;
       last_origin_ = origin;
       last_delta_ = delta;
     }
 
     // Not needed for our tests.
-    virtual void RegisterClient(storage::QuotaClient* client) OVERRIDE {}
-    virtual void NotifyOriginInUse(const GURL& origin) OVERRIDE {}
-    virtual void NotifyOriginNoLongerInUse(const GURL& origin) OVERRIDE {}
+    virtual void RegisterClient(storage::QuotaClient* client) override {}
+    virtual void NotifyOriginInUse(const GURL& origin) override {}
+    virtual void NotifyOriginNoLongerInUse(const GURL& origin) override {}
     virtual void SetUsageCacheEnabled(storage::QuotaClient::ID client_id,
                                       const GURL& origin,
                                       storage::StorageType type,
-                                      bool enabled) OVERRIDE {}
+                                      bool enabled) override {}
     virtual void GetUsageAndQuota(
         base::SequencedTaskRunner* original_task_runner,
         const GURL& origin,
         storage::StorageType type,
-        const GetUsageAndQuotaCallback& callback) OVERRIDE {}
+        const GetUsageAndQuotaCallback& callback) override {}
 
     int notify_storage_accessed_count_;
     int notify_storage_modified_count_;
     GURL last_origin_;
     int last_delta_;
     scoped_refptr<MockQuotaManager> mock_manager_;
 
    protected:
     virtual ~MockQuotaManagerProxy() {}
   };
@@ skipping 1248 matching lines @@
   // They rely on running a mock http server on our IO thread,
   // and involves other appcache classes to get some code
   // coverage thruout when Reinitialize happens.
 
   class MockServiceObserver : public AppCacheServiceImpl::Observer {
    public:
     explicit MockServiceObserver(AppCacheStorageImplTest* test)
         : test_(test) {}
 
     virtual void OnServiceReinitialized(
-        AppCacheStorageReference* old_storage_ref) OVERRIDE {
+        AppCacheStorageReference* old_storage_ref) override {
       observed_old_storage_ = old_storage_ref;
       test_->ScheduleNextTask();
     }
 
     scoped_refptr<AppCacheStorageReference> observed_old_storage_;
     AppCacheStorageImplTest* test_;
   };
 
   class MockAppCacheFrontend : public AppCacheFrontend {
    public:
     MockAppCacheFrontend() : error_event_was_raised_(false) {}
 
     virtual void OnCacheSelected(
-        int host_id, const AppCacheInfo& info) OVERRIDE {}
+        int host_id, const AppCacheInfo& info) override {}
     virtual void OnStatusChanged(const std::vector<int>& host_ids,
-                                 AppCacheStatus status) OVERRIDE {}
+                                 AppCacheStatus status) override {}
     virtual void OnEventRaised(const std::vector<int>& host_ids,
-                               AppCacheEventID event_id) OVERRIDE {}
+                               AppCacheEventID event_id) override {}
     virtual void OnProgressEventRaised(
         const std::vector<int>& host_ids,
         const GURL& url,
-        int num_total, int num_complete) OVERRIDE {}
+        int num_total, int num_complete) override {}
     virtual void OnErrorEventRaised(const std::vector<int>& host_ids,
                                     const AppCacheErrorDetails& details)
-        OVERRIDE {
+        override {
       error_event_was_raised_ = true;
     }
     virtual void OnLogMessage(int host_id, AppCacheLogLevel log_level,
-                              const std::string& message) OVERRIDE {}
+                              const std::string& message) override {}
     virtual void OnContentBlocked(
-        int host_id, const GURL& manifest_url) OVERRIDE {}
+        int host_id, const GURL& manifest_url) override {}
 
     bool error_event_was_raised_;
   };
 
   enum ReinitTestCase {
      CORRUPT_CACHE_ON_INSTALL,
      CORRUPT_CACHE_ON_LOAD_EXISTING,
      CORRUPT_SQL_ON_INSTALL
   };
 
@@ skipping 372 matching lines @@
   RunTestOnIOThread(&AppCacheStorageImplTest::Reinitialize2);
 }
 
 TEST_F(AppCacheStorageImplTest, Reinitialize3) {
   RunTestOnIOThread(&AppCacheStorageImplTest::Reinitialize3);
 }
 
 // That's all folks!
 
 }  // namespace content