gpu: Remove some GpuProcessHost dependency from shader cache.

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/threading/thread_checker.h"
-#include "content/browser/gpu/gpu_process_host.h"
 #include "content/public/browser/browser_thread.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 {
 
@@ skipping 46 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ShaderDiskCacheEntry);
 };
 
 // ShaderDiskReadHelper is used to load all of the cached shaders from the
 // disk cache and send to the memory cache.
 class ShaderDiskReadHelper
     : public base::ThreadChecker,
       public base::RefCounted<ShaderDiskReadHelper> {
  public:
-  ShaderDiskReadHelper(base::WeakPtr<ShaderDiskCache> cache, int host_id);
+  using ShaderLoadedCallback = ShaderDiskCache::ShaderLoadedCallback;
+  ShaderDiskReadHelper(base::WeakPtr<ShaderDiskCache> cache,
+                       const ShaderLoadedCallback& callback);
   void LoadCache();
 
  private:
   friend class base::RefCounted<ShaderDiskReadHelper>;
 
   enum OpType {
     TERMINATE,
     OPEN_NEXT,
     OPEN_NEXT_COMPLETE,
     READ_COMPLETE,
     ITERATION_FINISHED
   };
 
 
   ~ShaderDiskReadHelper();
 
   void OnOpComplete(int rv);
 
   int OpenNextEntry();
   int OpenNextEntryComplete(int rv);
   int ReadComplete(int rv);
   int IterationComplete(int rv);
 
   base::WeakPtr<ShaderDiskCache> cache_;
+  ShaderLoadedCallback shader_loaded_callback_;
   OpType op_type_;
   std::unique_ptr<disk_cache::Backend::Iterator> iter_;
   scoped_refptr<net::IOBufferWithSize> buf_;
-  int host_id_;
   disk_cache::Entry* entry_;
 
   DISALLOW_COPY_AND_ASSIGN(ShaderDiskReadHelper);
 };
 
 class ShaderClearHelper
     : public base::RefCounted<ShaderClearHelper>,
       public base::SupportsWeakPtr<ShaderClearHelper> {
  public:
   ShaderClearHelper(scoped_refptr<ShaderDiskCache> cache,
@@ skipping 120 matching lines @@
 }
 
 int ShaderDiskCacheEntry::IOComplete(int rv) {
   DCHECK(CalledOnValidThread());
   // Called through OnOpComplete, so we know |cache_| is valid.
   cache_->EntryComplete(this);
   op_type_ = TERMINATE;
   return rv;
 }
 
-ShaderDiskReadHelper::ShaderDiskReadHelper(
-    base::WeakPtr<ShaderDiskCache> cache,
-    int host_id)
+ShaderDiskReadHelper::ShaderDiskReadHelper(base::WeakPtr<ShaderDiskCache> cache,
+                                           const ShaderLoadedCallback& callback)
     : cache_(cache),
+      shader_loaded_callback_(callback),
       op_type_(OPEN_NEXT),
       buf_(NULL),
-      host_id_(host_id),
-      entry_(NULL) {
-}
+      entry_(NULL) {}
 
 void ShaderDiskReadHelper::LoadCache() {
   DCHECK(CalledOnValidThread());
   if (!cache_.get())
     return;
   OnOpComplete(net::OK);
 }
 
 void ShaderDiskReadHelper::OnOpComplete(int rv) {
   DCHECK(CalledOnValidThread());
@@ skipping 54 matching lines @@
       1,
       0,
       buf_.get(),
       buf_->size(),
       base::Bind(&ShaderDiskReadHelper::OnOpComplete, this));
 }
 
 int ShaderDiskReadHelper::ReadComplete(int rv) {
   DCHECK(CalledOnValidThread());
   // Called through OnOpComplete, so we know |cache_| is valid.
-  if (rv && rv == buf_->size()) {
-    GpuProcessHost* host = GpuProcessHost::FromID(host_id_);
-    if (host)
-      host->LoadedShader(entry_->GetKey(), std::string(buf_->data(),
-                                                       buf_->size()));
+  if (rv && rv == buf_->size() && !shader_loaded_callback_.is_null()) {
+    shader_loaded_callback_.Run(entry_->GetKey(),
+                                std::string(buf_->data(), buf_->size()));
   }
 
   buf_ = NULL;
   entry_->Close();
   entry_ = NULL;
 
   op_type_ = OPEN_NEXT;
   return net::OK;
 }
 
@@ skipping 164 matching lines @@
   if (!iter->second.empty()) {
     iter->second.front()->Clear();
     return;
   }
 
   shader_clear_map_.erase(path);
 }
 
 ShaderDiskCache::ShaderDiskCache(const base::FilePath& cache_path)
     : cache_available_(false),
-      host_id_(0),
       cache_path_(cache_path),
       is_initialized_(false) {
   ShaderCacheFactory::GetInstance()->AddToCache(cache_path_, this);
 }
 
 ShaderDiskCache::~ShaderDiskCache() {
   ShaderCacheFactory::GetInstance()->RemoveFromCache(cache_path_);
 }
 
 void ShaderDiskCache::Init() {
@@ skipping 50 matching lines @@
     return net::OK;
   available_callback_ = callback;
   return net::ERR_IO_PENDING;
 }
 
 void ShaderDiskCache::CacheCreatedCallback(int rv) {
   if (rv != net::OK) {
     LOG(ERROR) << "Shader Cache Creation failed: " << rv;
     return;
   }
-  helper_ = new ShaderDiskReadHelper(AsWeakPtr(), host_id_);
+  helper_ = new ShaderDiskReadHelper(AsWeakPtr(), shader_loaded_callback_);
   helper_->LoadCache();
 }
 
 void ShaderDiskCache::EntryComplete(void* entry) {
   entry_map_.erase(entry);
 
   if (entry_map_.empty() && !cache_complete_callback_.is_null())
     cache_complete_callback_.Run(net::OK);
 }
 
@@ skipping 14 matching lines @@
     const net::CompletionCallback& callback) {
   if (entry_map_.empty()) {
     return net::OK;
   }
   cache_complete_callback_ = callback;
   return net::ERR_IO_PENDING;
 }
 
 }  // namespace content