Add glGetFragDataLocation to gpu 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 <string>
 
 #include "base/compiler_specific.h"
+#include "base/containers/hash_tables.h"
 #include "base/synchronization/lock.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 
 namespace gpu {
 namespace gles2 {
 
 class NonCachedProgramInfoManager : public ProgramInfoManager {
  public:
   NonCachedProgramInfoManager();
   ~NonCachedProgramInfoManager() override;
 
   void CreateInfo(GLuint program) override;
 
   void DeleteInfo(GLuint program) override;
 
   bool GetProgramiv(GLES2Implementation* gl,
                     GLuint program,
                     GLenum pname,
                     GLint* params) override;
 
   GLint GetAttribLocation(GLES2Implementation* gl,
                           GLuint program,
                           const char* name) override;
 
   GLint GetUniformLocation(GLES2Implementation* gl,
                            GLuint program,
                            const char* name) override;
 
+  GLint GetFragDataLocation(GLES2Implementation* gl,
+                            GLuint program,
+                            const char* name) override;
+
   bool GetActiveAttrib(GLES2Implementation* gl,
                        GLuint program,
                        GLuint index,
                        GLsizei bufsize,
                        GLsizei* length,
                        GLint* size,
                        GLenum* type,
                        char* name) override;
 
   bool GetActiveUniform(GLES2Implementation* gl,
@@ skipping 29 matching lines @@
 GLint NonCachedProgramInfoManager::GetAttribLocation(
     GLES2Implementation* gl, GLuint program, const char* name) {
   return gl->GetAttribLocationHelper(program, name);
 }
 
 GLint NonCachedProgramInfoManager::GetUniformLocation(
     GLES2Implementation* gl, GLuint program, const char* name) {
   return gl->GetUniformLocationHelper(program, name);
 }
 
+GLint NonCachedProgramInfoManager::GetFragDataLocation(
+    GLES2Implementation* gl, GLuint program, const char* name) {
+  return gl->GetFragDataLocationHelper(program, name);
+}
+
 bool NonCachedProgramInfoManager::GetActiveAttrib(
     GLES2Implementation* gl,
     GLuint program, GLuint index, GLsizei bufsize, GLsizei* length,
     GLint* size, GLenum* type, char* name) {
   return gl->GetActiveAttribHelper(
       program, index, bufsize, length, size, type, name);
 }
 
 bool NonCachedProgramInfoManager::GetActiveUniform(
     GLES2Implementation* gl,
@@ skipping 18 matching lines @@
                     GLint* params) override;
 
   GLint GetAttribLocation(GLES2Implementation* gl,
                           GLuint program,
                           const char* name) override;
 
   GLint GetUniformLocation(GLES2Implementation* gl,
                            GLuint program,
                            const char* name) override;
 
+  GLint GetFragDataLocation(GLES2Implementation* gl,
+                            GLuint program,
+                            const char* name) override;
+
   bool GetActiveAttrib(GLES2Implementation* gl,
                        GLuint program,
                        GLuint index,
                        GLsizei bufsize,
                        GLsizei* length,
                        GLint* size,
                        GLenum* type,
                        char* name) override;
 
   bool GetActiveUniform(GLES2Implementation* gl,
@@ skipping 48 matching lines @@
     GLint GetAttribLocation(const std::string& name) const;
 
     const UniformInfo* GetUniformInfo(GLint index) const {
       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;
 
+    GLint GetFragDataLocation(const std::string& name) const;
+    void CacheFragDataLocation(const std::string& name, GLint loc);
+
     bool GetProgramiv(GLenum pname, GLint* params);
 
     // Updates the program info after a successful link.
     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_;
 
     // Uniform info by index.
     UniformInfoVector uniform_infos_;
 
+    base::hash_map<std::string, GLint> frag_data_locations_;
+
     // This is true if glLinkProgram was successful last time it was called.
     bool link_status_;
   };
 
   Program* GetProgramInfo(GLES2Implementation* gl, GLuint program);
 
   // TODO(gman): Switch to a faster container.

[bajones, 2015/01/26 23:38:57]

Does this change satisfy gman's TODO here? If so this comment should be removed.
Hash maps aren't always faster than a traditional map, but it seems to me that
in this use case it should be an improvement.

[Zhenyao Mo, 2015/01/26 23:47:30]

I am not what gman has in mind originally, but I switched to hash_map because
for frag_data_locations_ with std::string as keys, hash_map seems a better
choice.  For this one I don't think it's a big deal for the key to be sorted or
not, so I switch to hash_table to be consistent.

-  typedef std::map<GLuint, Program> ProgramInfoMap;
+  typedef base::hash_map<GLuint, Program> ProgramInfoMap;

[Ken Russell (switch to Gerrit), 2015/01/26 23:39:12]

Does this new container type have all the same guarantees that std::map does?

Is the TODO still necessary after this switch?

[Zhenyao Mo, 2015/01/27 00:48:38]

I think hash_map and map both work in this situation.  I'll delete the TODO here
because I can't think of a better container unless we write a customized one.

 
   ProgramInfoMap program_infos_;
 
   mutable base::Lock lock_;
 };
 
 CachedProgramInfoManager::Program::UniformInfo::UniformInfo(
     GLsizei _size, GLenum _type, const std::string& _name)
     : size(_size),
       type(_type),
@@ skipping 43 matching lines @@
           name.compare(0, open_pos, info.name, 0, open_pos) == 0) {
         if (index >= 0 && index < info.size) {
           return info.element_locations[index];
         }
       }
     }
   }
   return -1;
 }
 
+GLint CachedProgramInfoManager::Program::GetFragDataLocation(
+    const std::string& name) const {
+  base::hash_map<std::string, GLint>::const_iterator iter =
+      frag_data_locations_.find(name);
+  if (iter == frag_data_locations_.end())
+    return -1;
+  return iter->second;
+}
+
+void CachedProgramInfoManager::Program::CacheFragDataLocation(
+    const std::string& name, GLint loc) {
+  frag_data_locations_[name] = loc;
+}
+
 bool CachedProgramInfoManager::Program::GetProgramiv(
     GLenum pname, GLint* params) {
   switch (pname) {
     case GL_LINK_STATUS:
       *params = link_status_;
       return true;
     case GL_ACTIVE_ATTRIBUTES:
       *params = attrib_infos_.size();
       return true;
     case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
@@ skipping 34 matching lines @@
   }
   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;
   }
   attrib_infos_.clear();
   uniform_infos_.clear();
+  frag_data_locations_.clear();
   max_attrib_name_length_ = 0;
   max_uniform_name_length_ = 0;
   const ProgramInput* inputs = LocalGetAs<const ProgramInput*>(
       result, sizeof(*header),
       sizeof(ProgramInput) * (header->num_attribs + header->num_uniforms));
   const ProgramInput* input = inputs;
   for (uint32 ii = 0; ii < header->num_attribs; ++ii) {
     const int32* location = LocalGetAs<const int32*>(
         result, input->location_offset, sizeof(int32));
     const char* name_buf = LocalGetAs<const char*>(
@@ skipping 101 matching lines @@
   {
     base::AutoLock auto_lock(lock_);
     Program* info = GetProgramInfo(gl, program);
     if (info) {
       return info->GetUniformLocation(name);
     }
   }
   return gl->GetUniformLocationHelper(program, name);
 }
 
+GLint CachedProgramInfoManager::GetFragDataLocation(
+    GLES2Implementation* gl, GLuint program, const char* name) {
+  // TODO(zmo): make FragData locations part of the ProgramInfo that are
+  // fetched altogether from the service side.  See crbug.com/452104.
+  {
+    base::AutoLock auto_lock(lock_);
+    Program* info = GetProgramInfo(gl, program);
+    if (info) {
+      GLint possible_loc = info->GetFragDataLocation(name);
+      if (possible_loc != -1)
+        return possible_loc;
+    }
+  }
+  GLint loc = gl->GetFragDataLocationHelper(program, name);
+  if (loc != -1) {
+    base::AutoLock auto_lock(lock_);
+    Program* info = GetProgramInfo(gl, program);
+    if (info) {
+      info->CacheFragDataLocation(name, loc);
+    }
+  }
+  return loc;
+}
+
 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 = info->GetAttribInfo(index);
       if (attrib_info) {
@@ skipping 70 matching lines @@
   if (shared_resources_across_processes) {
     return new NonCachedProgramInfoManager();
   } else {
     return new CachedProgramInfoManager();
   }
 }
 
 }  // namespace gles2
 }  // namespace gpu