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

gpu/ipc/host/shader_disk_cache.h

 // 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.
 
-#ifndef CONTENT_BROWSER_GPU_SHADER_DISK_CACHE_H_
-#define CONTENT_BROWSER_GPU_SHADER_DISK_CACHE_H_
+#ifndef GPU_IPC_HOST_SHADER_DISK_CACHE_H_
+#define GPU_IPC_HOST_SHADER_DISK_CACHE_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <queue>
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/threading/thread_checker.h"
-#include "content/common/content_export.h"
 #include "net/disk_cache/disk_cache.h"
 
-namespace content {
+namespace gpu {
 
 class ShaderCacheFactory;
 class ShaderDiskCacheEntry;
 class ShaderDiskReadHelper;
 class ShaderClearHelper;
 
 // ShaderDiskCache is the interface to the on disk cache for
 // GL shaders.
-class CONTENT_EXPORT ShaderDiskCache
-    : public base::RefCounted<ShaderDiskCache> {
+class ShaderDiskCache : public base::RefCounted<ShaderDiskCache> {
  public:
   using ShaderLoadedCallback =
       base::Callback<void(const std::string&, const std::string&)>;
 
   void set_shader_loaded_callback(const ShaderLoadedCallback& callback) {
     shader_loaded_callback_ = callback;
   }
 
   // Store the |shader| into the cache under |key|.
   void Cache(const std::string& key, const std::string& shader);
 
   // Clear a range of entries. This supports unbounded deletes in either
   // direction by using null Time values for either |begin_time| or |end_time|.
   // The return value is a net error code. If this method returns
   // ERR_IO_PENDING, the |completion_callback| will be invoked when the
   // operation completes.
-  int Clear(
-      const base::Time begin_time,
-      const base::Time end_time,
-      const net::CompletionCallback& completion_callback);
+  int Clear(const base::Time begin_time,
+            const base::Time end_time,
+            const net::CompletionCallback& completion_callback);
 
   // Sets a callback for when the cache is available. If the cache is
   // already available the callback will not be called and net::OK is returned.
   // If the callback is set net::ERR_IO_PENDING is returned and the callback
   // will be executed when the cache is available.
   int SetAvailableCallback(const net::CompletionCallback& callback);
 
   // Returns the number of elements currently in the cache.
   int32_t Size();
 
@@ skipping 35 matching lines @@
   std::unique_ptr<ShaderDiskReadHelper> helper_;
   std::unordered_map<ShaderDiskCacheEntry*,
                      std::unique_ptr<ShaderDiskCacheEntry>>
       entries_;
 
   DISALLOW_COPY_AND_ASSIGN(ShaderDiskCache);
 };
 
 // ShaderCacheFactory maintains a cache of ShaderDiskCache objects
 // so we only create one per profile directory.
-class CONTENT_EXPORT ShaderCacheFactory
-    : NON_EXPORTED_BASE(public base::ThreadChecker) {
+class ShaderCacheFactory : NON_EXPORTED_BASE(public base::ThreadChecker) {
  public:
   explicit ShaderCacheFactory(
       scoped_refptr<base::SingleThreadTaskRunner> cache_task_runner);
   ~ShaderCacheFactory();
 
   // Clear the shader disk cache for the given |path|. This supports unbounded
   // deletes in either direction by using null Time values for either
   // |begin_time| or |end_time|. The |callback| will be executed when the
   // clear is complete.
   void ClearByPath(const base::FilePath& path,
@@ skipping 30 matching lines @@
   using ClientIdToPathMap = std::map<int32_t, base::FilePath>;
   ClientIdToPathMap client_id_to_path_map_;
 
   using ShaderClearQueue = std::queue<std::unique_ptr<ShaderClearHelper>>;
   using ShaderClearMap = std::map<base::FilePath, ShaderClearQueue>;
   ShaderClearMap shader_clear_map_;
 
   DISALLOW_COPY_AND_ASSIGN(ShaderCacheFactory);
 };
 
-}  // namespace content
+}  // namespace gpu
 
-#endif  // CONTENT_BROWSER_GPU_SHADER_DISK_CACHE_H_
+#endif  // GPU_IPC_HOST_SHADER_DISK_CACHE_H_