Standardize usage of virtual/override/final in content/browser/

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 113 matching lines @@
 };
 
 class MockHttpServerJobFactory
     : public net::URLRequestJobFactory::ProtocolHandler {
  public:
   MockHttpServerJobFactory(
      scoped_ptr<net::URLRequestInterceptor> appcache_start_interceptor)
      : appcache_start_interceptor_(appcache_start_interceptor.Pass()) {
   }
 
-  virtual net::URLRequestJob* MaybeCreateJob(
+  net::URLRequestJob* MaybeCreateJob(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const override {
     net::URLRequestJob* appcache_job =
         appcache_start_interceptor_->MaybeInterceptRequest(
             request, network_delegate);
     if (appcache_job)
       return appcache_job;
     return MockHttpServer::CreateJob(request, network_delegate);
   }
  private:
   scoped_ptr<net::URLRequestInterceptor> appcache_start_interceptor_;
 };
 
 class IOThread : public base::Thread {
  public:
   explicit IOThread(const char* name)
       : base::Thread(name) {
   }
 
-  virtual ~IOThread() {
-    Stop();
-  }
+  ~IOThread() override { Stop(); }
 
   net::URLRequestContext* request_context() {
     return request_context_.get();
   }
 
-  virtual void Init() override {
+  void Init() override {
     scoped_ptr<net::URLRequestJobFactoryImpl> factory(
         new net::URLRequestJobFactoryImpl());
     factory->SetProtocolHandler(
         "http",
         new MockHttpServerJobFactory(
             AppCacheInterceptor::CreateStartInterceptor()));
     job_factory_ = factory.Pass();
     request_context_.reset(new net::TestURLRequestContext());
     request_context_->set_job_factory(job_factory_.get());
     AppCacheInterceptor::EnsureRegistered();
   }
 
-  virtual void CleanUp() override {
+  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 {
+    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 {
+    void OnGroupLoaded(AppCacheGroup* group,
+                       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 {
+    void OnGroupAndNewestCacheStored(AppCacheGroup* group,
+                                     AppCache* newest_cache,
+                                     bool success,
+                                     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 {
+    void OnGroupMadeObsolete(AppCacheGroup* group,
+                             bool success,
+                             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 {
+    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 {
       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 20 matching lines @@
   class MockQuotaManager : public storage::QuotaManager {
    public:
     MockQuotaManager()
         : 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 {
+    void GetUsageAndQuota(const GURL& origin,
+                          storage::StorageType type,
+                          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);
     }
 
     void CallCallback(const GetUsageAndQuotaCallback& callback) {
       callback.Run(storage::kQuotaStatusOk, 0, kMockQuota);
     }
 
     bool async_;
 
    protected:
-    virtual ~MockQuotaManager() {}
+    ~MockQuotaManager() override {}
   };
 
   class MockQuotaManagerProxy : public storage::QuotaManagerProxy {
    public:
     MockQuotaManagerProxy()
         : 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 {
+    void NotifyStorageAccessed(storage::QuotaClient::ID client_id,
+                               const GURL& origin,
+                               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 {
+    void NotifyStorageModified(storage::QuotaClient::ID client_id,
+                               const GURL& origin,
+                               storage::StorageType type,
+                               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 SetUsageCacheEnabled(storage::QuotaClient::ID client_id,
-                                      const GURL& origin,
-                                      storage::StorageType type,
-                                      bool enabled) override {}
-    virtual void GetUsageAndQuota(
-        base::SequencedTaskRunner* original_task_runner,
-        const GURL& origin,
-        storage::StorageType type,
-        const GetUsageAndQuotaCallback& callback) override {}
+    void RegisterClient(storage::QuotaClient* client) override {}
+    void NotifyOriginInUse(const GURL& origin) override {}
+    void NotifyOriginNoLongerInUse(const GURL& origin) override {}
+    void SetUsageCacheEnabled(storage::QuotaClient::ID client_id,
+                              const GURL& origin,
+                              storage::StorageType type,
+                              bool enabled) override {}
+    void GetUsageAndQuota(base::SequencedTaskRunner* original_task_runner,
+                          const GURL& origin,
+                          storage::StorageType type,
+                          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() {}
+    ~MockQuotaManagerProxy() override {}
   };
 
   template <class Method>
   void RunMethod(Method method) {
     (this->*method)();
   }
 
   // Helper callback to run a test on our io_thread. The io_thread is spun up
   // once and reused for all tests.
   template <class Method>
@@ skipping 1238 matching lines @@
   // These tests are somewhat of a system integration test.
   // 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(
+    void OnServiceReinitialized(
         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 {}
-    virtual void OnStatusChanged(const std::vector<int>& host_ids,
-                                 AppCacheStatus status) override {}
-    virtual void OnEventRaised(const std::vector<int>& host_ids,
-                               AppCacheEventID event_id) override {}
-    virtual void OnProgressEventRaised(
-        const std::vector<int>& host_ids,
-        const GURL& url,
-        int num_total, int num_complete) override {}
-    virtual void OnErrorEventRaised(const std::vector<int>& host_ids,
-                                    const AppCacheErrorDetails& details)
-        override {
+    void OnCacheSelected(int host_id, const AppCacheInfo& info) override {}
+    void OnStatusChanged(const std::vector<int>& host_ids,
+                         AppCacheStatus status) override {}
+    void OnEventRaised(const std::vector<int>& host_ids,
+                       AppCacheEventID event_id) override {}
+    void OnProgressEventRaised(const std::vector<int>& host_ids,
+                               const GURL& url,
+                               int num_total,
+                               int num_complete) override {}
+    void OnErrorEventRaised(const std::vector<int>& host_ids,
+                            const AppCacheErrorDetails& details) override {
       error_event_was_raised_ = true;
     }
-    virtual void OnLogMessage(int host_id, AppCacheLogLevel log_level,
-                              const std::string& message) override {}
-    virtual void OnContentBlocked(
-        int host_id, const GURL& manifest_url) override {}
+    void OnLogMessage(int host_id,
+                      AppCacheLogLevel log_level,
+                      const std::string& message) override {}
+    void OnContentBlocked(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