Standardize usage of virtual/override/final specifiers in content/.

content/browser/service_worker/service_worker_cache_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 "content/browser/service_worker/service_worker_cache.h"
 
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/run_loop.h"
@@ skipping 29 matching lines @@
       blob_storage_context, NULL, base::MessageLoopProxy::current().get());
 }
 
 // A disk_cache::Backend wrapper that can delay operations.
 class DelayableBackend : public disk_cache::Backend {
  public:
   DelayableBackend(scoped_ptr<disk_cache::Backend> backend)
       : backend_(backend.Pass()), delay_open_(false) {}
 
   // disk_cache::Backend overrides
-  virtual net::CacheType GetCacheType() const override {
+  net::CacheType GetCacheType() const override {
     return backend_->GetCacheType();
   }
-  virtual int32 GetEntryCount() const override {
-    return backend_->GetEntryCount();
-  }
-  virtual int OpenEntry(const std::string& key,
-                        disk_cache::Entry** entry,
-                        const CompletionCallback& callback) override {
+  int32 GetEntryCount() const override { return backend_->GetEntryCount(); }
+  int OpenEntry(const std::string& key,
+                disk_cache::Entry** entry,
+                const CompletionCallback& callback) override {
     if (delay_open_) {
       open_entry_callback_ =
           base::Bind(&DelayableBackend::OpenEntryDelayedImpl,
                      base::Unretained(this), key, entry, callback);
       return net::ERR_IO_PENDING;
     }
 
     return backend_->OpenEntry(key, entry, callback);
   }
-  virtual int CreateEntry(const std::string& key,
-                          disk_cache::Entry** entry,
-                          const CompletionCallback& callback) override {
+  int CreateEntry(const std::string& key,
+                  disk_cache::Entry** entry,
+                  const CompletionCallback& callback) override {
     return backend_->CreateEntry(key, entry, callback);
   }
-  virtual int DoomEntry(const std::string& key,
-                        const CompletionCallback& callback) override {
+  int DoomEntry(const std::string& key,
+                const CompletionCallback& callback) override {
     return backend_->DoomEntry(key, callback);
   }
-  virtual int DoomAllEntries(const CompletionCallback& callback) override {
+  int DoomAllEntries(const CompletionCallback& callback) override {
     return backend_->DoomAllEntries(callback);
   }
-  virtual int DoomEntriesBetween(base::Time initial_time,
-                                 base::Time end_time,
-                                 const CompletionCallback& callback) override {
+  int DoomEntriesBetween(base::Time initial_time,
+                         base::Time end_time,
+                         const CompletionCallback& callback) override {
     return backend_->DoomEntriesBetween(initial_time, end_time, callback);
   }
-  virtual int DoomEntriesSince(base::Time initial_time,
-                               const CompletionCallback& callback) override {
+  int DoomEntriesSince(base::Time initial_time,
+                       const CompletionCallback& callback) override {
     return backend_->DoomEntriesSince(initial_time, callback);
   }
-  virtual scoped_ptr<Iterator> CreateIterator() override {
+  scoped_ptr<Iterator> CreateIterator() override {
     return backend_->CreateIterator();
   }
-  virtual void GetStats(
+  void GetStats(
       std::vector<std::pair<std::string, std::string>>* stats) override {
     return backend_->GetStats(stats);
   }
-  virtual void OnExternalCacheHit(const std::string& key) override {
+  void OnExternalCacheHit(const std::string& key) override {
     return backend_->OnExternalCacheHit(key);
   }
 
   // Call to continue a delayed open.
   void OpenEntryContinue() {
     EXPECT_FALSE(open_entry_callback_.is_null());
     open_entry_callback_.Run();
   }
 
   void set_delay_open(bool value) { delay_open_ = value; }
@@ skipping 23 matching lines @@
       net::URLRequestContext* request_context,
       const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
       base::WeakPtr<storage::BlobStorageContext> blob_context)
       : ServiceWorkerCache(origin,
                            path,
                            request_context,
                            quota_manager_proxy,
                            blob_context),
         delay_backend_creation_(false) {}
 
-  virtual void CreateBackend(const ErrorCallback& callback) override {
+  void CreateBackend(const ErrorCallback& callback) override {
     backend_creation_callback_ = callback;
     if (delay_backend_creation_)
       return;
     ContinueCreateBackend();
   }
 
   void ContinueCreateBackend() {
     ServiceWorkerCache::CreateBackend(backend_creation_callback_);
   }
 
   void set_delay_backend_creation(bool delay) {
     delay_backend_creation_ = delay;
   }
 
   // Swap the existing backend with a delayable one. The backend must have been
   // created before calling this.
   DelayableBackend* UseDelayableBackend() {
     EXPECT_TRUE(backend_);
     DelayableBackend* delayable_backend = new DelayableBackend(backend_.Pass());
     backend_.reset(delayable_backend);
     return delayable_backend;
   }
 
  private:
-  virtual ~TestServiceWorkerCache() override {}
+  ~TestServiceWorkerCache() override {}
 
   bool delay_backend_creation_;
   ErrorCallback backend_creation_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(TestServiceWorkerCache);
 };
 
 class ServiceWorkerCacheTest : public testing::Test {
  public:
   ServiceWorkerCacheTest()
@@ skipping 732 matching lines @@
   EXPECT_TRUE(callback_closed_);
 
   VerifyAllOpsFail();
 }
 
 INSTANTIATE_TEST_CASE_P(ServiceWorkerCacheTest,
                         ServiceWorkerCacheTestP,
                         ::testing::Values(false, true));
 
 }  // namespace content