Change the ServiceWorkerCacheStorage's loader from a ref ptr to scoped.

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/file_util.h"
 #include "base/files/memory_mapped_file.h"
@@ skipping 21 matching lines @@
 struct ServiceWorkerCacheStorage::CacheContext {
   CacheContext(const std::string& name,
                CacheID id,
                scoped_ptr<ServiceWorkerCache> cache)
       : name(name), id(id), cache(cache.Pass()) {}
   std::string name;
   CacheID id;
   scoped_ptr<ServiceWorkerCache> cache;
 };
 
-// Handles the loading and clean up of ServiceWorkerCache objects.
-class ServiceWorkerCacheStorage::CacheLoader
-    : public base::RefCountedThreadSafe<
-          ServiceWorkerCacheStorage::CacheLoader> {
+// Handles the loading and clean up of ServiceWorkerCache objects. The
+// callback of every public method is guaranteed to be called.
+class ServiceWorkerCacheStorage::CacheLoader {
  public:
   typedef base::Callback<void(scoped_ptr<ServiceWorkerCache>)> CacheCallback;
   typedef base::Callback<void(bool)> BoolCallback;
   typedef base::Callback<void(scoped_ptr<std::vector<std::string> >)>
       StringsCallback;
 
   CacheLoader(base::SequencedTaskRunner* cache_task_runner,
               net::URLRequestContext* request_context,
               base::WeakPtr<storage::BlobStorageContext> blob_context)
       : cache_task_runner_(cache_task_runner),
         request_context_(request_context),
         blob_context_(blob_context) {}
 
+  virtual ~CacheLoader() {}
+
   // Loads the given cache_name, the cache is NULL if it fails. If the cache
   // doesn't exist a new one is created.
   virtual void LoadCache(const std::string& cache_name,
                          const CacheCallback& callback) = 0;
 
   // Deletes any pre-existing cache of the same name and then loads it.
   virtual void CreateCache(const std::string& cache_name,
                            const CacheCallback& callback) = 0;
 
   // After the backend has been deleted, do any extra house keeping such as
   // removing the cache's directory.
   virtual void CleanUpDeletedCache(const std::string& key,
                                    const BoolCallback& callback) = 0;
 
   // Writes the cache names (and sizes) to disk if applicable.
   virtual void WriteIndex(const CacheMap& caches,
                           const BoolCallback& callback) = 0;
 
   // Loads the cache names from disk if applicable.
   virtual void LoadIndex(scoped_ptr<std::vector<std::string> > cache_names,
                          const StringsCallback& callback) = 0;
 
  protected:
-  friend class base::RefCountedThreadSafe<
-      ServiceWorkerCacheStorage::CacheLoader>;
-
-  virtual ~CacheLoader() {}
   virtual void LoadCacheImpl(const std::string&) {}
 
   scoped_refptr<base::SequencedTaskRunner> cache_task_runner_;
   net::URLRequestContext* request_context_;
   base::WeakPtr<storage::BlobStorageContext> blob_context_;
 };
 
 class ServiceWorkerCacheStorage::MemoryLoader
     : public ServiceWorkerCacheStorage::CacheLoader {
  public:
@@ skipping 33 matching lines @@
 };
 
 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)
       : CacheLoader(cache_task_runner, request_context, blob_context),
-        origin_path_(origin_path) {}
+        origin_path_(origin_path),
+        weak_ptr_factory_(this) {}
 
   virtual void LoadCache(const std::string& cache_name,
                          const CacheCallback& callback) OVERRIDE {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     // 1. Create the cache's directory if necessary. (LoadCreateDirectoryInPool)
     // 2. Create the cache object. (LoadDidCreateDirectory)
 
     cache_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&SimpleCacheLoader::LoadCreateDirectoryInPool,
-                   this,
                    CreatePersistentCachePath(origin_path_, cache_name),
                    cache_name,
                    callback,
+                   weak_ptr_factory_.GetWeakPtr(),
                    base::MessageLoopProxy::current()));
   }
 
-  void LoadCreateDirectoryInPool(
+  static void LoadCreateDirectoryInPool(
       const base::FilePath& path,
       const std::string& cache_name,
       const CacheCallback& callback,
+      base::WeakPtr<SimpleCacheLoader> loader,
       const scoped_refptr<base::MessageLoopProxy>& original_loop) {
-    DCHECK(cache_task_runner_->RunsTasksOnCurrentThread());
-
     bool rv = base::CreateDirectory(path);
     original_loop->PostTask(
         FROM_HERE,
         base::Bind(&SimpleCacheLoader::LoadDidCreateDirectory,
-                   this,
                    cache_name,
                    callback,
+                   loader,
                    rv));
   }
 
-  void LoadDidCreateDirectory(const std::string& cache_name,
-                              const CacheCallback& callback,
-                              bool dir_rv) {
+  static void LoadDidCreateDirectory(const std::string& cache_name,
+                                     const CacheCallback& callback,
+                                     base::WeakPtr<SimpleCacheLoader> loader,
+                                     bool dir_rv) {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-    if (!dir_rv) {
+    if (!dir_rv || !loader) {
       callback.Run(scoped_ptr<ServiceWorkerCache>());
       return;
     }
 
     scoped_ptr<ServiceWorkerCache> cache =
         ServiceWorkerCache::CreatePersistentCache(
-            CreatePersistentCachePath(origin_path_, cache_name),
-            request_context_,
-            blob_context_);
+            CreatePersistentCachePath(loader->origin_path_, cache_name),
+            loader->request_context_,
+            loader->blob_context_);
     callback.Run(cache.Pass());
   }
 
   virtual 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);
 
     cache_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&SimpleCacheLoader::CreateCacheDeleteFilesInPool,
-                   this,
                    cache_path,
                    cache_name,
                    callback,
+                   weak_ptr_factory_.GetWeakPtr(),
                    base::MessageLoopProxy::current()));
   }
 
-  void CreateCacheDeleteFilesInPool(
+  static void CreateCacheDeleteFilesInPool(
       const base::FilePath& cache_path,
       const std::string& cache_name,
       const CacheCallback& callback,
+      base::WeakPtr<SimpleCacheLoader> loader,
       const scoped_refptr<base::MessageLoopProxy>& original_loop) {
-    DCHECK(cache_task_runner_->RunsTasksOnCurrentThread());
-
     base::FilePath path(cache_path);
     if (base::PathExists(path))
       base::DeleteFile(path, /* recursive */ true);
 
     // Jump straight into LoadCache on the same thread.
-    cache_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&SimpleCacheLoader::LoadCreateDirectoryInPool,
-                   this,
-                   cache_path,
-                   cache_name,
-                   callback,
-                   original_loop));
+    LoadCreateDirectoryInPool(
+        cache_path, cache_name, callback, loader, original_loop);
   }
 
   virtual 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,
-                   this,
                    cache_path,
                    callback,
                    base::MessageLoopProxy::current()));
   }
 
-  void CleanUpDeleteCacheDirInPool(
+  static void CleanUpDeleteCacheDirInPool(
       const base::FilePath& cache_path,
       const BoolCallback& callback,
       const scoped_refptr<base::MessageLoopProxy>& original_loop) {
-    DCHECK(cache_task_runner_->RunsTasksOnCurrentThread());
-
     bool rv = base::DeleteFile(cache_path, true);
     original_loop->PostTask(FROM_HERE, base::Bind(callback, rv));
   }
 
   virtual void WriteIndex(const CacheMap& caches,
                           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)
@@ skipping 11 matching lines @@
     std::string serialized;
     bool success = index.SerializeToString(&serialized);
     DCHECK(success);
 
     base::FilePath tmp_path = origin_path_.AppendASCII("index.txt.tmp");
     base::FilePath index_path = origin_path_.AppendASCII("index.txt");
 
     cache_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&SimpleCacheLoader::WriteIndexWriteToFileInPool,
-                   this,
                    tmp_path,
                    index_path,
                    serialized,
                    callback,
                    base::MessageLoopProxy::current()));
   }
 
-  void WriteIndexWriteToFileInPool(
+  static void WriteIndexWriteToFileInPool(
       const base::FilePath& tmp_path,
       const base::FilePath& index_path,
       const std::string& data,
       const BoolCallback& callback,
       const scoped_refptr<base::MessageLoopProxy>& original_loop) {
-    DCHECK(cache_task_runner_->RunsTasksOnCurrentThread());
-
     int bytes_written = base::WriteFile(tmp_path, data.c_str(), data.size());
     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 StringsCallback& 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("index.txt");
 
     cache_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&SimpleCacheLoader::LoadIndexReadFileInPool,
-                   this,
                    index_path,
                    base::Passed(names.Pass()),
                    callback,
                    base::MessageLoopProxy::current()));
   }
 
-  void LoadIndexReadFileInPool(
+  static void LoadIndexReadFileInPool(
       const base::FilePath& index_path,
       scoped_ptr<std::vector<std::string> > names,
       const StringsCallback& callback,
       const scoped_refptr<base::MessageLoopProxy>& original_loop) {
-    DCHECK(cache_task_runner_->RunsTasksOnCurrentThread());
-
     std::string body;
     base::ReadFileToString(index_path, &body);
 
     original_loop->PostTask(FROM_HERE,
                             base::Bind(&SimpleCacheLoader::LoadIndexDidReadFile,
-                                       this,
                                        base::Passed(names.Pass()),
                                        callback,
                                        body));
   }
 
-  void LoadIndexDidReadFile(scoped_ptr<std::vector<std::string> > names,
-                            const StringsCallback& callback,
-                            const std::string& serialized) {
+  static void LoadIndexDidReadFile(scoped_ptr<std::vector<std::string> > names,
+                                   const StringsCallback& callback,
+                                   const std::string& serialized) {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     ServiceWorkerCacheStorageIndex index;
     if (index.ParseFromString(serialized)) {
       for (int i = 0, max = index.cache_size(); i < max; ++i) {
         const ServiceWorkerCacheStorageIndex::Cache& cache = index.cache(i);
         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() {}
 
-  std::string HexedHash(const std::string& value) {
+  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;
   }
 
-  base::FilePath CreatePersistentCachePath(const base::FilePath& origin_path,
-                                           const std::string& cache_name) {
+  static base::FilePath CreatePersistentCachePath(
+      const base::FilePath& origin_path,
+      const std::string& cache_name) {
     return origin_path.AppendASCII(HexedHash(cache_name));
   }
 
   const base::FilePath origin_path_;
+
+  base::WeakPtrFactory<SimpleCacheLoader> weak_ptr_factory_;
 };
 
 ServiceWorkerCacheStorage::ServiceWorkerCacheStorage(
     const base::FilePath& path,
     bool memory_only,
     base::SequencedTaskRunner* cache_task_runner,
     net::URLRequestContext* request_context,
     base::WeakPtr<storage::BlobStorageContext> blob_context)
     : initialized_(false),
       next_cache_id_(0),
       origin_path_(path),
       cache_task_runner_(cache_task_runner),
       weak_factory_(this) {
   if (memory_only)
-    cache_loader_ = new MemoryLoader(
-        cache_task_runner_.get(), request_context, blob_context);
+    cache_loader_.reset(new MemoryLoader(
+        cache_task_runner_.get(), request_context, blob_context));
   else
-    cache_loader_ = new SimpleCacheLoader(
-        origin_path_, cache_task_runner_.get(), request_context, blob_context);
+    cache_loader_.reset(new SimpleCacheLoader(
+        origin_path_, cache_task_runner_.get(), request_context, blob_context));
 }
 
 ServiceWorkerCacheStorage::~ServiceWorkerCacheStorage() {
   STLDeleteContainerPairSecondPointers(cache_map_.begin(), cache_map_.end());
 }
 
 void ServiceWorkerCacheStorage::CreateCache(
     const std::string& cache_name,
     const CacheAndErrorCallback& callback) {
   if (!initialized_) {
@@ skipping 323 matching lines @@
   NameMap::const_iterator name_iter = name_map_.find(cache_name);
   if (name_iter == name_map_.end())
     return NULL;
 
   CacheMap::const_iterator map_iter = cache_map_.find(name_iter->second);
   DCHECK(map_iter != cache_map_.end());
   return map_iter->second;
 }
 
 }  // namespace content