Initialize GPU shader disk cache on brower thread.

content/browser/gpu/browser_gpu_channel_host_factory.cc

 // Copyright (c) 2012 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/browser_gpu_channel_host_factory.h"
 
 #include "base/bind.h"
+#include "base/command_line.h"
 #include "base/location.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/browser/gpu/gpu_surface_tracker.h"
+#include "content/browser/gpu/shader_disk_cache.h"
 #include "content/common/child_process_host_impl.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/gpu_data_manager.h"
 #include "content/public/common/content_client.h"
+#include "gpu/command_buffer/service/gpu_switches.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/message_filter.h"
 
 namespace content {
 
 BrowserGpuChannelHostFactory* BrowserGpuChannelHostFactory::instance_ = NULL;
 
 struct BrowserGpuChannelHostFactory::CreateRequest {
   CreateRequest(int32 route_id)
       : event(true, false),
@@ skipping 102 matching lines @@
       // failure in ChannelEstablishedOnIO, but we ended up with the same
       // process ID, meaning the failure was not because of a channel error,
       // but another reason. So fail now.
       LOG(ERROR) << "Failed to create channel.";
       FinishOnIO();
       return;
     }
     reused_gpu_process_ = true;
   }
 
+  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kDisableGpuShaderDiskCache)) {
+    base::FilePath user_data_dir =
+        GetContentClient()->browser()->GetUserDataDirectory();
+    if (!user_data_dir.empty()) {
+      ShaderCacheFactory::GetInstance()->SetCacheInfo(gpu_client_id_,
+                                                      user_data_dir);

[Ken Russell (switch to Gerrit), 2015/08/06 01:01:01]

Something seems suspicious about this. GpuChannels mostly map 1:1 to renderer
processes. This is going to be called once per each renderer process that
attempts to communicate with the GPU process, which seems wrong.
RenderProcessHostImpl::RenderProcessHostImpl already sets up the shader cache
for every spawned renderer.

As far as I understand the problem, the GpuChannels that the browser compositor
creates are the ones that don't have the shader disk cache set up properly. I
think we need to track down the code path that initializes those GpuChannels
specifically.

[piman, 2015/08/06 19:53:13]

FYI, this code path is to setup the GpuChannelHost for the browser - it's the
equivalent of what RenderThreadImpl::EstablishGpuChannelSync does in the
renderer. gpu_client_id_ is the channel id for the browser.

This is going to be called once per GPU process restart though. It seems like an
odd place to put it. Maybe instead you could post a task to the IO thread from
the BrowserGpuChannelHostFactory constructor, only once?

+    } else {
+      LOG(ERROR) << "Failed to init browser shader cache.";
+    }
+  }
+
   host->EstablishGpuChannel(
       gpu_client_id_,
       gpu_client_tracing_id_,
       true,
       true,
       base::Bind(
           &BrowserGpuChannelHostFactory::EstablishRequest::OnEstablishedOnIO,
           this));
 }
 
@@ skipping 255 matching lines @@
     int host_id,
     scoped_refptr<IPC::MessageFilter> filter) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   GpuProcessHost* host = GpuProcessHost::FromID(host_id);
   if (host)
     host->AddFilter(filter.get());
 }
 
 }  // namespace content