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

content/browser/service_worker/service_worker_cache_storage.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_storage.h"
 
 #include <string>
 
 #include "base/files/file_util.h"
 #include "base/files/memory_mapped_file.h"
@@ skipping 71 matching lines @@
 // cache is deleted.
 class ServiceWorkerCacheStorage::MemoryLoader
     : public ServiceWorkerCacheStorage::CacheLoader {
  public:
   MemoryLoader(base::SequencedTaskRunner* cache_task_runner,
                net::URLRequestContext* request_context,
                base::WeakPtr<storage::BlobStorageContext> blob_context,
                const GURL& origin)
       : CacheLoader(cache_task_runner, request_context, blob_context, origin) {}
 
-  virtual scoped_refptr<ServiceWorkerCache> CreateServiceWorkerCache(
+  scoped_refptr<ServiceWorkerCache> CreateServiceWorkerCache(
       const std::string& cache_name) override {
     return ServiceWorkerCache::CreateMemoryCache(request_context_,
                                                  blob_context_);
   }
 
-  virtual void CreateCache(const std::string& cache_name,
-                           const CacheCallback& callback) override {
+  void CreateCache(const std::string& cache_name,
+                   const CacheCallback& callback) override {
     scoped_refptr<ServiceWorkerCache> cache =
         ServiceWorkerCache::CreateMemoryCache(request_context_, blob_context_);
     cache_refs_.insert(std::make_pair(cache_name, cache));
     callback.Run(cache);
   }
 
-  virtual void CleanUpDeletedCache(const std::string& cache_name,
-                                   const BoolCallback& callback) override {
+  void CleanUpDeletedCache(const std::string& cache_name,
+                           const BoolCallback& callback) override {
     CacheRefMap::iterator it = cache_refs_.find(cache_name);
     DCHECK(it != cache_refs_.end());
     cache_refs_.erase(it);
     callback.Run(true);
   }
 
-  virtual void WriteIndex(const StringVector& cache_names,
-                          const BoolCallback& callback) override {
+  void WriteIndex(const StringVector& cache_names,
+                  const BoolCallback& callback) override {
     callback.Run(false);
   }
 
-  virtual void LoadIndex(scoped_ptr<std::vector<std::string> > cache_names,
-                         const StringVectorCallback& callback) override {
+  void LoadIndex(scoped_ptr<std::vector<std::string>> cache_names,
+                 const StringVectorCallback& callback) override {
     callback.Run(cache_names.Pass());
   }
 
  private:
   typedef std::map<std::string, scoped_refptr<ServiceWorkerCache> > CacheRefMap;
-  virtual ~MemoryLoader() {}
+  ~MemoryLoader() override {}
 
   // Keep a reference to each cache to ensure that it's not freed before the
   // client calls ServiceWorkerCacheStorage::Delete or the CacheStorage is
   // freed.
   CacheRefMap cache_refs_;
 };
 
 class ServiceWorkerCacheStorage::SimpleCacheLoader
     : public ServiceWorkerCacheStorage::CacheLoader {
  public:
   SimpleCacheLoader(const base::FilePath& origin_path,
                     base::SequencedTaskRunner* cache_task_runner,
                     net::URLRequestContext* request_context,
                     base::WeakPtr<storage::BlobStorageContext> blob_context,
                     const GURL& origin)
       : CacheLoader(cache_task_runner, request_context, blob_context, origin),
         origin_path_(origin_path),
         weak_ptr_factory_(this) {}
 
-  virtual scoped_refptr<ServiceWorkerCache> CreateServiceWorkerCache(
+  scoped_refptr<ServiceWorkerCache> CreateServiceWorkerCache(
       const std::string& cache_name) override {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     return ServiceWorkerCache::CreatePersistentCache(
         CreatePersistentCachePath(origin_path_, cache_name),
         request_context_,
         blob_context_);
   }
 
-  virtual void CreateCache(const std::string& cache_name,
-                           const CacheCallback& callback) override {
+  void CreateCache(const std::string& cache_name,
+                   const CacheCallback& callback) override {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     // 1. Delete the cache's directory if it exists.
     // (CreateCacheDeleteFilesInPool)
     // 2. Load the cache. (LoadCreateDirectoryInPool)
 
     base::FilePath cache_path =
         CreatePersistentCachePath(origin_path_, cache_name);
 
     PostTaskAndReplyWithResult(
@@ skipping 17 matching lines @@
                                     base::WeakPtr<SimpleCacheLoader> loader,
                                     bool success) {
     if (!success || !loader) {
       callback.Run(scoped_refptr<ServiceWorkerCache>());
       return;
     }
 
     callback.Run(loader->CreateServiceWorkerCache(cache_name));
   }
 
-  virtual void CleanUpDeletedCache(const std::string& cache_name,
-                                   const BoolCallback& callback) override {
+  void CleanUpDeletedCache(const std::string& cache_name,
+                           const BoolCallback& callback) override {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     // 1. Delete the cache's directory. (CleanUpDeleteCacheDirInPool)
 
     base::FilePath cache_path =
         CreatePersistentCachePath(origin_path_, cache_name);
     cache_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&SimpleCacheLoader::CleanUpDeleteCacheDirInPool,
                    cache_path,
                    callback,
                    base::MessageLoopProxy::current()));
   }
 
   static void CleanUpDeleteCacheDirInPool(
       const base::FilePath& cache_path,
       const BoolCallback& callback,
       const scoped_refptr<base::MessageLoopProxy>& original_loop) {
     bool rv = base::DeleteFile(cache_path, true);
     original_loop->PostTask(FROM_HERE, base::Bind(callback, rv));
   }
 
-  virtual void WriteIndex(const StringVector& cache_names,
-                          const BoolCallback& callback) override {
+  void WriteIndex(const StringVector& cache_names,
+                  const BoolCallback& callback) override {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     // 1. Create the index file as a string. (WriteIndex)
     // 2. Write the file to disk. (WriteIndexWriteToFileInPool)
 
     ServiceWorkerCacheStorageIndex index;
     index.set_origin(origin_.spec());
 
     for (size_t i = 0u, max = cache_names.size(); i < max; ++i) {
       ServiceWorkerCacheStorageIndex::Cache* index_cache = index.add_cache();
@@ skipping 29 matching lines @@
     if (bytes_written != implicit_cast<int>(data.size())) {
       base::DeleteFile(tmp_path, /* recursive */ false);
       original_loop->PostTask(FROM_HERE, base::Bind(callback, false));
     }
 
     // Atomically rename the temporary index file to become the real one.
     bool rv = base::ReplaceFile(tmp_path, index_path, NULL);
     original_loop->PostTask(FROM_HERE, base::Bind(callback, rv));
   }
 
-  virtual void LoadIndex(scoped_ptr<std::vector<std::string> > names,
-                         const StringVectorCallback& callback) override {
+  void LoadIndex(scoped_ptr<std::vector<std::string>> names,
+                 const StringVectorCallback& callback) override {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     // 1. Read the file from disk. (LoadIndexReadFileInPool)
     // 2. Parse file and return the names of the caches (LoadIndexDidReadFile)
 
     base::FilePath index_path =
         origin_path_.AppendASCII(ServiceWorkerCacheStorage::kIndexFileName);
 
     cache_task_runner_->PostTask(
         FROM_HERE,
@@ skipping 31 matching lines @@
         names->push_back(cache.name());
       }
     }
 
     // TODO(jkarlin): Delete caches that are in the directory and not returned
     // in LoadIndex.
     callback.Run(names.Pass());
   }
 
  private:
-  virtual ~SimpleCacheLoader() {}
+  ~SimpleCacheLoader() override {}
 
   static std::string HexedHash(const std::string& value) {
     std::string value_hash = base::SHA1HashString(value);
     std::string valued_hexed_hash = base::StringToLowerASCII(
         base::HexEncode(value_hash.c_str(), value_hash.length()));
     return valued_hexed_hash;
   }
 
   static base::FilePath CreatePersistentCachePath(
       const base::FilePath& origin_path,
@@ skipping 258 matching lines @@
     scoped_refptr<ServiceWorkerCache> new_cache =
         cache_loader_->CreateServiceWorkerCache(cache_name);
     map_iter->second = new_cache->AsWeakPtr();
     return new_cache;
   }
 
   return make_scoped_refptr(cache.get());
 }
 
 }  // namespace content