Avoid holding locks across sync IPCs in command buffer

gpu/command_buffer/client/program_info_manager.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 "gpu/command_buffer/client/program_info_manager.h"
 
 #include <map>
 
 #include "base/compiler_specific.h"
 #include "base/synchronization/lock.h"
@@ skipping 177 matching lines @@
       return (static_cast<size_t>(index) < uniform_infos_.size()) ?
          &uniform_infos_[index] : NULL;
     }
 
     // Gets the location of a uniform by name.
     GLint GetUniformLocation(const std::string& name) const;
 
     bool GetProgramiv(GLenum pname, GLint* params);
 
     // Updates the program info after a successful link.
-    void Update(GLES2Implementation* gl, GLuint program);
+    void Update(GLES2Implementation* gl,
+                GLuint program,
+                const std::vector<int8>& result);
+
+    bool cached() const { return cached_; }
 
    private:
     bool cached_;
 
     GLsizei max_attrib_name_length_;
 
     // Attrib by index.
     AttribInfoVector attrib_infos_;
 
     GLsizei max_uniform_name_length_;
@@ skipping 100 matching lines @@
     const std::vector<int8>& data, uint32 offset, size_t size) {
   const int8* p = &data[0] + offset;
   if (offset + size > data.size()) {
     NOTREACHED();
     return NULL;
   }
   return static_cast<T>(static_cast<const void*>(p));
 }
 
 void CachedProgramInfoManager::Program::Update(
-    GLES2Implementation* gl, GLuint program) {
+    GLES2Implementation* gl,
+    GLuint program,
+    const std::vector<int8>& result) {
   if (cached_) {
     return;
   }
-  std::vector<int8> result;
-  gl->GetProgramInfoCHROMIUMHelper(program, &result);
   if (result.empty()) {
     // This should only happen on a lost context.
     return;
   }
   DCHECK_GE(result.size(), sizeof(ProgramInfoHeader));
   const ProgramInfoHeader* header = LocalGetAs<const ProgramInfoHeader*>(
       result, 0, sizeof(header));
   link_status_ = header->link_status != 0;
   if (!link_status_) {
     return;
@@ skipping 47 matching lines @@
 
 CachedProgramInfoManager::Program*
     CachedProgramInfoManager::GetProgramInfo(
         GLES2Implementation* gl, GLuint program) {
   lock_.AssertAcquired();
   ProgramInfoMap::iterator it = program_infos_.find(program);
   if (it == program_infos_.end()) {
     return NULL;
   }
   Program* info = &it->second;
-  info->Update(gl, program);
+  if (info->cached())
+    return info;
+  std::vector<int8> result;
+  {
+    base::AutoUnlock unlock(lock_);
+    // lock_ can't be held across IPC call or else it may deadlock in pepper.
+    // http://crbug.com/418651
+    gl->GetProgramInfoCHROMIUMHelper(program, &result);
+  }
+
+  it = program_infos_.find(program);
+  if (it == program_infos_.end()) {
+    return NULL;
+  }
+  info = &it->second;
+  info->Update(gl, program, result);
   return info;
 }
 
 void CachedProgramInfoManager::CreateInfo(GLuint program) {
   base::AutoLock auto_lock(lock_);
   program_infos_.erase(program);
   std::pair<ProgramInfoMap::iterator, bool> result =
       program_infos_.insert(std::make_pair(program, Program()));
 
   DCHECK(result.second);
@@ skipping 24 matching lines @@
   return gl->GetAttribLocationHelper(program, name);
 }
 
 GLint CachedProgramInfoManager::GetUniformLocation(
     GLES2Implementation* gl, GLuint program, const char* name) {
   base::AutoLock auto_lock(lock_);
   Program* info = GetProgramInfo(gl, program);
   if (info) {
     return info->GetUniformLocation(name);
   }
   return gl->GetUniformLocationHelper(program, name);

[Peng, 2014/09/29 23:28:59]

Does this gl call use sync IPC?

 }
 
 bool CachedProgramInfoManager::GetActiveAttrib(
     GLES2Implementation* gl,
     GLuint program, GLuint index, GLsizei bufsize, GLsizei* length,
     GLint* size, GLenum* type, char* name) {
   base::AutoLock auto_lock(lock_);
   Program* info = GetProgramInfo(gl, program);
   if (info) {
     const Program::VertexAttrib* attrib_info =
@@ skipping 13 matching lines @@
           *length = max_size;
         }
         if (name && bufsize > 0) {
           memcpy(name, attrib_info->name.c_str(), max_size);
           name[max_size] = '\0';
         }
       }
       return true;
     }
   }
   return gl->GetActiveAttribHelper(

[Peng, 2014/09/29 23:28:59]

Same here?

       program, index, bufsize, length, size, type, name);
 }
 
 bool CachedProgramInfoManager::GetActiveUniform(
     GLES2Implementation* gl,
     GLuint program, GLuint index, GLsizei bufsize, GLsizei* length,
     GLint* size, GLenum* type, char* name) {
   base::AutoLock auto_lock(lock_);
   Program* info = GetProgramInfo(gl, program);
   if (info) {
@@ skipping 13 matching lines @@
           *length = max_size;
         }
         if (name && bufsize > 0) {
           memcpy(name, uniform_info->name.c_str(), max_size);
           name[max_size] = '\0';
         }
       }
       return true;
     }
   }
   return gl->GetActiveUniformHelper(

[Peng, 2014/09/29 23:28:59]

same?

       program, index, bufsize, length, size, type, name);
 }
 
 ProgramInfoManager::ProgramInfoManager() {
 }
 
 ProgramInfoManager::~ProgramInfoManager() {
 }
 
 ProgramInfoManager* ProgramInfoManager::Create(
     bool shared_resources_across_processes) {
   if (shared_resources_across_processes) {
     return new NonCachedProgramInfoManager();
   } else {
     return new CachedProgramInfoManager();
   }
 }
 
 }  // namespace gles2
 }  // namespace gpu