gpu: Pass key around on disk program load.

This will facilitate integration with the ANGLE-controlled program
cache that we will use with the passthrough command buffer.

Refactoring change only.

BUG=738513
R=piman@chromium.org

Change-Id: I10f0ccd05680496885467fd22ce9d1e1a486741f
Reviewed-on: https://chromium-review.googlesource.com/563610
Commit-Queue: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Antoine Labour <piman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#486028}

components/viz/host/server_gpu_memory_buffer_manager_unittest.cc

@@ -88,7 +88,7 @@ class TestGpuService : public ui::mojom::GpuService {
   void RequestCompleteGpuInfo(
       const RequestCompleteGpuInfoCallback& callback) override {}
 
-  void LoadedShader(const std::string& data) override {}
+  void LoadedShader(const std::string& key, const std::string& data) override {}
 
   void DestroyingVideoSurface(
       int32_t surface_id,

content/browser/gpu/gpu_process_host.cc

@@ -1217,8 +1217,11 @@ void GpuProcessHost::LoadedShader(const std::string& key,
   std::string prefix = GetShaderPrefixKey(data);
   bool prefix_ok = !key.compare(0, prefix.length(), prefix);
   UMA_HISTOGRAM_BOOLEAN("GPU.ShaderLoadPrefixOK", prefix_ok);
-  if (prefix_ok)
-    gpu_service_ptr_->LoadedShader(data);
+  if (prefix_ok) {
+    // Remove the prefix from the key before load.
+    std::string key_no_prefix = key.substr(prefix.length() + 1);
+    gpu_service_ptr_->LoadedShader(key_no_prefix, data);
+  }
 }
 
 ui::mojom::GpuService* GpuProcessHost::gpu_service() {

gpu/command_buffer/service/memory_program_cache.cc

@@ -395,7 +395,8 @@ void MemoryProgramCache::SaveLinkedProgram(
                        curr_size_bytes_ / 1024);
 }
 
-void MemoryProgramCache::LoadProgram(const std::string& program) {
+void MemoryProgramCache::LoadProgram(const std::string& key,
+                                     const std::string& program) {
   std::unique_ptr<GpuProgramProto> proto(
       GpuProgramProto::default_instance().New());
   if (proto->ParseFromString(program)) {

gpu/command_buffer/service/memory_program_cache.h

@@ -50,7 +50,7 @@ class GPU_EXPORT MemoryProgramCache : public ProgramCache {
       GLenum transform_feedback_buffer_mode,
       GLES2DecoderClient* client) override;
 
-  void LoadProgram(const std::string& program) override;
+  void LoadProgram(const std::string& key, const std::string& program) override;
 
   size_t Trim(size_t limit) override;
 

gpu/command_buffer/service/memory_program_cache_unittest.cc

@@ -248,7 +248,8 @@ TEST_F(MemoryProgramCacheTest, LoadProgram) {
 
   cache_->Clear();
 
-  cache_->LoadProgram(shader_cache_shader());
+  std::string blank;
+  cache_->LoadProgram(blank, shader_cache_shader());
   EXPECT_EQ(ProgramCache::LINK_SUCCEEDED, cache_->GetLinkedProgramStatus(
       vertex_shader_->last_compiled_signature(),
       fragment_shader_->last_compiled_signature(),
@@ -349,8 +350,9 @@ TEST_F(MemoryProgramCacheTest, LoadProgramMatchesSave) {
 
   SetExpectationsForLoadLinkedProgram(kProgramId, &emulator);
 
+  std::string blank;
   cache_->Clear();
-  cache_->LoadProgram(shader_cache_shader());
+  cache_->LoadProgram(blank, shader_cache_shader());
 
   EXPECT_EQ(
       ProgramCache::PROGRAM_LOAD_SUCCESS,

gpu/command_buffer/service/mocks.h

@@ -138,7 +138,7 @@ class MockProgramCache : public ProgramCache {
                     const std::vector<std::string>& transform_feedback_varyings,
                     GLenum transform_feedback_buffer_mode,
                     GLES2DecoderClient* client));
-  MOCK_METHOD1(LoadProgram, void(const std::string&));
+  MOCK_METHOD2(LoadProgram, void(const std::string&, const std::string&));
   MOCK_METHOD1(Trim, size_t(size_t));
 
  private:

gpu/command_buffer/service/program_cache.h

@@ -71,7 +71,8 @@ class GPU_EXPORT ProgramCache {
       GLenum transform_feedback_buffer_mode,
       GLES2DecoderClient* client) = 0;
 
-  virtual void LoadProgram(const std::string& program) = 0;
+  virtual void LoadProgram(const std::string& key,
+                           const std::string& program) = 0;
 
   // clears the cache
   void Clear();

gpu/command_buffer/service/program_cache_unittest.cc

@@ -35,7 +35,8 @@ class NoBackendProgramCache : public ProgramCache {
       GLenum /* transform_feedback_buffer_mode */,
       GLES2DecoderClient* /* client */) override {}
 
-  void LoadProgram(const std::string& /* program */) override {}
+  void LoadProgram(const std::string& /*key*/,
+                   const std::string& /* program */) override {}
 
   void ClearBackend() override {}
 

gpu/ipc/service/gpu_channel_manager.cc

@@ -167,9 +167,10 @@ void GpuChannelManager::DestroyGpuMemoryBuffer(gfx::GpuMemoryBufferId id,
   }
 }
 
-void GpuChannelManager::PopulateShaderCache(const std::string& program_proto) {
+void GpuChannelManager::PopulateShaderCache(const std::string& key,
+                                            const std::string& program) {
   if (program_cache())
-    program_cache()->LoadProgram(program_proto);
+    program_cache()->LoadProgram(key, program);
 }
 
 void GpuChannelManager::LoseAllContexts() {

gpu/ipc/service/gpu_channel_manager.h

@@ -85,7 +85,7 @@ class GPU_EXPORT GpuChannelManager {
                                uint64_t client_tracing_id,
                                bool is_gpu_host);
 
-  void PopulateShaderCache(const std::string& shader);
+  void PopulateShaderCache(const std::string& key, const std::string& program);
   void DestroyGpuMemoryBuffer(gfx::GpuMemoryBufferId id,
                               int client_id,
                               const SyncToken& sync_token);

services/ui/gpu/gpu_service.cc

@@ -429,13 +429,13 @@ void GpuService::CloseChannel(int32_t client_id) {
   gpu_channel_manager_->RemoveChannel(client_id);
 }
 
-void GpuService::LoadedShader(const std::string& data) {
+void GpuService::LoadedShader(const std::string& key, const std::string& data) {
   if (io_runner_->BelongsToCurrentThread()) {
     main_runner_->PostTask(
-        FROM_HERE, base::Bind(&GpuService::LoadedShader, weak_ptr_, data));
+        FROM_HERE, base::Bind(&GpuService::LoadedShader, weak_ptr_, key, data));
     return;
   }
-  gpu_channel_manager_->PopulateShaderCache(data);
+  gpu_channel_manager_->PopulateShaderCache(key, data);
 }
 
 void GpuService::DestroyingVideoSurface(

services/ui/gpu/gpu_service.h

@@ -153,7 +153,7 @@ class GpuService : public gpu::GpuChannelManagerDelegate,
       const GetVideoMemoryUsageStatsCallback& callback) override;
   void RequestCompleteGpuInfo(
       const RequestCompleteGpuInfoCallback& callback) override;
-  void LoadedShader(const std::string& data) override;
+  void LoadedShader(const std::string& key, const std::string& data) override;
   void DestroyingVideoSurface(
       int32_t surface_id,
       const DestroyingVideoSurfaceCallback& callback) override;

services/ui/gpu/interfaces/gpu_service.mojom

@@ -47,8 +47,10 @@ interface GpuService {
 
   RequestCompleteGpuInfo() => (gpu.mojom.GpuInfo gpu_info);
 
-  // Notify GPU that a shader was loaded from disk.
-  LoadedShader(string data);
+  // Notify GPU that a shader program was loaded from disk. Key is an
+  // SHA-1 hash, and data a binary blob with serialized program info.
+  // Note that this method is used only from a trusted process.
+  LoadedShader(string key, string data);
 
   // Tells GPU to release the surface because it's being destroyed.
   DestroyingVideoSurface(int32 surface_id) => ();