gpu: Move ShaderDiskCache into //gpu/ipc/host component.

gpu/ipc/host/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 "gpu/ipc/host/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 gpu {
 
 namespace {
 
 static const base::FilePath::CharType kGpuCachePath[] =
     FILE_PATH_LITERAL("GPUCache");
 
 }  // namespace
 
 // ShaderDiskCacheEntry handles the work of caching/updating the cached
 // shaders.
@@ skipping 43 matching lines @@
 
  private:
   enum OpType {
     TERMINATE,
     OPEN_NEXT,
     OPEN_NEXT_COMPLETE,
     READ_COMPLETE,
     ITERATION_FINISHED
   };
 
-
   void OnOpComplete(int rv);
 
   int OpenNextEntry();
   int OpenNextEntryComplete(int rv);
   int ReadComplete(int rv);
   int IterationComplete(int rv);
 
   ShaderDiskCache* cache_;
   ShaderLoadedCallback shader_loaded_callback_;
   OpType op_type_;
@@ skipping 11 matching lines @@
                     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
-  };
+  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_;
@@ skipping 242 matching lines @@
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShaderCacheFactory
 
 ShaderCacheFactory::ShaderCacheFactory(
     scoped_refptr<base::SingleThreadTaskRunner> cache_task_runner)
     : cache_task_runner_(std::move(cache_task_runner)) {}
 
-ShaderCacheFactory::~ShaderCacheFactory() {
-}
+ShaderCacheFactory::~ShaderCacheFactory() {}
 
 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);
@@ skipping 118 matching lines @@
 void ShaderDiskCache::Cache(const std::string& key, const std::string& shader) {
   if (!cache_available_)
     return;
 
   auto shim = base::MakeUnique<ShaderDiskCacheEntry>(this, key, shader);
   shim->Cache();
   auto* raw_ptr = shim.get();
   entries_.insert(std::make_pair(raw_ptr, std::move(shim)));
 }
 
-int ShaderDiskCache::Clear(
-    const base::Time begin_time, const base::Time end_time,
-    const net::CompletionCallback& completion_callback) {
+int ShaderDiskCache::Clear(const base::Time begin_time,
+                           const base::Time end_time,
+                           const net::CompletionCallback& completion_callback) {
   int rv;
   if (begin_time.is_null()) {
     rv = backend_->DoomAllEntries(completion_callback);
   } else {
-    rv = backend_->DoomEntriesBetween(begin_time, end_time,
-                                      completion_callback);
+    rv =
+        backend_->DoomEntriesBetween(begin_time, end_time, completion_callback);
   }
   return rv;
 }
 
 int32_t ShaderDiskCache::Size() {
   if (!cache_available_)
     return -1;
   return backend_->GetEntryCount();
 }
 
@@ skipping 36 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
+}  // namespace gpu