content: Move shader cache factory singleton into a separate file.

content/browser/gpu/shader_disk_cache.cc

 // Copyright (c) 2013 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/gpu/shader_disk_cache.h"
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_checker.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "net/base/cache_type.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 
 namespace content {
 
 namespace {
 
 static const base::FilePath::CharType kGpuCachePath[] =
     FILE_PATH_LITERAL("GPUCache");
 
-static ShaderCacheFactory* factory_instance = nullptr;
-
 }  // namespace
 
 // ShaderDiskCacheEntry handles the work of caching/updating the cached
 // shaders.
 class ShaderDiskCacheEntry : public base::ThreadChecker {
  public:
   ShaderDiskCacheEntry(ShaderDiskCache* cache,
                        const std::string& key,
                        const std::string& shader);
   ~ShaderDiskCacheEntry();
@@ skipping 58 matching lines @@
   std::unique_ptr<disk_cache::Backend::Iterator> iter_;
   scoped_refptr<net::IOBufferWithSize> buf_;
   disk_cache::Entry* entry_;
   base::WeakPtrFactory<ShaderDiskReadHelper> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ShaderDiskReadHelper);
 };
 
 class ShaderClearHelper : public base::ThreadChecker {
  public:
-  ShaderClearHelper(scoped_refptr<ShaderDiskCache> cache,
+  ShaderClearHelper(ShaderCacheFactory* factory,
+                    scoped_refptr<ShaderDiskCache> cache,
                     const base::FilePath& path,
                     const base::Time& delete_begin,
                     const base::Time& delete_end,
                     const base::Closure& callback);
   ~ShaderClearHelper();
 
   void Clear();
 
  private:
   enum OpType {
     TERMINATE,
     VERIFY_CACHE_SETUP,
     DELETE_CACHE
   };
 
   void DoClearShaderCache(int rv);
 
+  ShaderCacheFactory* factory_;
   scoped_refptr<ShaderDiskCache> cache_;
   OpType op_type_;
   base::FilePath path_;
   base::Time delete_begin_;
   base::Time delete_end_;
   base::Closure callback_;
   base::WeakPtrFactory<ShaderClearHelper> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ShaderClearHelper);
 };
@@ skipping 181 matching lines @@
 int ShaderDiskReadHelper::IterationComplete(int rv) {
   DCHECK(CalledOnValidThread());
   iter_.reset();
   op_type_ = TERMINATE;
   return net::OK;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShaderClearHelper
 
-ShaderClearHelper::ShaderClearHelper(scoped_refptr<ShaderDiskCache> cache,
+ShaderClearHelper::ShaderClearHelper(ShaderCacheFactory* factory,
+                                     scoped_refptr<ShaderDiskCache> cache,
                                      const base::FilePath& path,
                                      const base::Time& delete_begin,
                                      const base::Time& delete_end,
                                      const base::Closure& callback)
-    : cache_(std::move(cache)),
+    : factory_(factory),
+      cache_(std::move(cache)),
       op_type_(VERIFY_CACHE_SETUP),
       path_(path),
       delete_begin_(delete_begin),
       delete_end_(delete_end),
       callback_(callback),
       weak_ptr_factory_(this) {}
 
 ShaderClearHelper::~ShaderClearHelper() {
   DCHECK(CalledOnValidThread());
 }
@@ skipping 15 matching lines @@
         break;
       case DELETE_CACHE:
         rv = cache_->Clear(delete_begin_, delete_end_,
                            base::Bind(&ShaderClearHelper::DoClearShaderCache,
                                       weak_ptr_factory_.GetWeakPtr()));
         op_type_ = TERMINATE;
         break;
       case TERMINATE:
         callback_.Run();
         // Calling CacheCleared() destroys |this|.
-        ShaderCacheFactory::GetInstance()->CacheCleared(path_);
+        factory_->CacheCleared(path_);
         rv = net::ERR_IO_PENDING;  // Break the loop.
         break;
     }
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShaderCacheFactory
 
-// static
-void ShaderCacheFactory::InitInstance(
-    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-    scoped_refptr<base::SingleThreadTaskRunner> cache_task_runner) {
-  if (task_runner->BelongsToCurrentThread()) {
-    CreateFactoryInstance(std::move(cache_task_runner));
-  } else {
-    task_runner->PostTask(FROM_HERE,
-                          base::Bind(&ShaderCacheFactory::CreateFactoryInstance,
-                                     std::move(cache_task_runner)));
-  }
-}
-
-// static
-ShaderCacheFactory* ShaderCacheFactory::GetInstance() {
-  DCHECK(!factory_instance || factory_instance->CalledOnValidThread());
-  return factory_instance;
-}
-
 ShaderCacheFactory::ShaderCacheFactory(
     scoped_refptr<base::SingleThreadTaskRunner> cache_task_runner)
     : cache_task_runner_(std::move(cache_task_runner)) {}
 
 ShaderCacheFactory::~ShaderCacheFactory() {
 }
 
-// static
-void ShaderCacheFactory::CreateFactoryInstance(
-    scoped_refptr<base::SingleThreadTaskRunner> cache_task_runner) {
-  DCHECK(!factory_instance);
-  factory_instance = new ShaderCacheFactory(std::move(cache_task_runner));
-}
-
 void ShaderCacheFactory::SetCacheInfo(int32_t client_id,
                                       const base::FilePath& path) {
   DCHECK(CalledOnValidThread());
   client_id_to_path_map_[client_id] = path;
 }
 
 void ShaderCacheFactory::RemoveCacheInfo(int32_t client_id) {
   DCHECK(CalledOnValidThread());
   client_id_to_path_map_.erase(client_id);
 }
 
 scoped_refptr<ShaderDiskCache> ShaderCacheFactory::Get(int32_t client_id) {
   DCHECK(CalledOnValidThread());
   ClientIdToPathMap::iterator iter = client_id_to_path_map_.find(client_id);
   if (iter == client_id_to_path_map_.end())
     return NULL;
   return ShaderCacheFactory::GetByPath(iter->second);
 }
 
 scoped_refptr<ShaderDiskCache> ShaderCacheFactory::GetByPath(
     const base::FilePath& path) {
   DCHECK(CalledOnValidThread());
   ShaderCacheMap::iterator iter = shader_cache_map_.find(path);
   if (iter != shader_cache_map_.end())
     return iter->second;
 
-  ShaderDiskCache* cache = new ShaderDiskCache(path);
+  ShaderDiskCache* cache = new ShaderDiskCache(this, path);
   cache->Init(cache_task_runner_);
   return cache;
 }
 
 void ShaderCacheFactory::AddToCache(const base::FilePath& key,
                                     ShaderDiskCache* cache) {
   DCHECK(CalledOnValidThread());
   shader_cache_map_[key] = cache;
 }
 
 void ShaderCacheFactory::RemoveFromCache(const base::FilePath& key) {
   DCHECK(CalledOnValidThread());
   shader_cache_map_.erase(key);
 }
 
 void ShaderCacheFactory::ClearByPath(const base::FilePath& path,
                                      const base::Time& delete_begin,
                                      const base::Time& delete_end,
                                      const base::Closure& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   auto helper = base::MakeUnique<ShaderClearHelper>(
-      GetByPath(path), path, delete_begin, delete_end, callback);
+      this, GetByPath(path), path, delete_begin, delete_end, callback);
 
   // We could receive requests to clear the same path with different
   // begin/end times. So, we keep a list of requests. If we haven't seen this
   // path before we kick off the clear and add it to the list. If we have see it
   // already, then we already have a clear running. We add this clear to the
   // list and wait for any previous clears to finish.
   ShaderClearMap::iterator iter = shader_clear_map_.find(path);
   if (iter != shader_clear_map_.end()) {
     iter->second.push(std::move(helper));
     return;
@@ skipping 25 matching lines @@
     iter->second.front()->Clear();
     return;
   }
 
   shader_clear_map_.erase(iter);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShaderDiskCache
 
-ShaderDiskCache::ShaderDiskCache(const base::FilePath& cache_path)
-    : cache_available_(false),
+ShaderDiskCache::ShaderDiskCache(ShaderCacheFactory* factory,
+                                 const base::FilePath& cache_path)
+    : factory_(factory),
+      cache_available_(false),
       cache_path_(cache_path),
       is_initialized_(false) {
-  ShaderCacheFactory::GetInstance()->AddToCache(cache_path_, this);
+  factory_->AddToCache(cache_path_, this);
 }
 
 ShaderDiskCache::~ShaderDiskCache() {
-  ShaderCacheFactory::GetInstance()->RemoveFromCache(cache_path_);
+  factory_->RemoveFromCache(cache_path_);
 }
 
 void ShaderDiskCache::Init(
     scoped_refptr<base::SingleThreadTaskRunner> cache_task_runner) {
   if (is_initialized_) {
     NOTREACHED();  // can't initialize disk cache twice.
     return;
   }
   is_initialized_ = true;
 
@@ skipping 76 matching lines @@
 int ShaderDiskCache::SetCacheCompleteCallback(
     const net::CompletionCallback& callback) {
   if (entries_.empty()) {
     return net::OK;
   }
   cache_complete_callback_ = callback;
   return net::ERR_IO_PENDING;
 }
 
 }  // namespace content
-