Updated shader program caching to account for transform feedback varyings

gpu/command_buffer/service/program_cache.cc

Index: gpu/command_buffer/service/program_cache.cc
diff --git a/gpu/command_buffer/service/program_cache.cc b/gpu/command_buffer/service/program_cache.cc
index b219086c046c95e1c37d1315f8706a80daacfdd0..ae2962e25d189c20a2c768f059439ad698612b9d 100644
--- a/gpu/command_buffer/service/program_cache.cc
+++ b/gpu/command_buffer/service/program_cache.cc
@@ -22,7 +22,9 @@ void ProgramCache::Clear() {
 ProgramCache::LinkedProgramStatus ProgramCache::GetLinkedProgramStatus(
     const std::string& shader_signature_a,
     const std::string& shader_signature_b,
-    const std::map<std::string, GLint>* bind_attrib_location_map) const {
+    const std::map<std::string, GLint>* bind_attrib_location_map,
+    const std::vector<std::string>* transform_feedback_varyings,
+    GLenum transform_feedback_buffer_mode) const {
   char a_sha[kHashLength];
   char b_sha[kHashLength];
   ComputeShaderHash(shader_signature_a, a_sha);
@@ -32,6 +34,8 @@ ProgramCache::LinkedProgramStatus ProgramCache::GetLinkedProgramStatus(
   ComputeProgramHash(a_sha,
                      b_sha,
                      bind_attrib_location_map,
+                     transform_feedback_varyings,
+                     transform_feedback_buffer_mode,
                      sha);
   const std::string sha_string(sha, kHashLength);
 
@@ -46,7 +50,9 @@ ProgramCache::LinkedProgramStatus ProgramCache::GetLinkedProgramStatus(
 void ProgramCache::LinkedProgramCacheSuccess(
     const std::string& shader_signature_a,
     const std::string& shader_signature_b,
-    const LocationMap* bind_attrib_location_map) {
+    const LocationMap* bind_attrib_location_map,
+    const std::vector<std::string>* transform_feedback_varyings,
+    GLenum transform_feedback_buffer_mode) {
   char a_sha[kHashLength];
   char b_sha[kHashLength];
   ComputeShaderHash(shader_signature_a, a_sha);
@@ -55,6 +61,8 @@ void ProgramCache::LinkedProgramCacheSuccess(
   ComputeProgramHash(a_sha,
                      b_sha,
                      bind_attrib_location_map,
+                     transform_feedback_varyings,
+                     transform_feedback_buffer_mode,
                      sha);
   const std::string sha_string(sha, kHashLength);
 
@@ -88,24 +96,39 @@ size_t CalculateMapSize(const std::map<std::string, GLint>* map) {
   }
   return total;
 }
+size_t CalculateVaryingsSize(const std::vector<std::string>* varyings) {

[Zhenyao Mo, 2015/03/12 23:50:57]

nit: a line before this function.

+  if (!varyings) {
+    return 0;
+  }
+  std::vector<std::string>::const_iterator it;

[Zhenyao Mo, 2015/03/12 23:50:57]

No need to expose iterator outside for loop.

+  size_t total = 0;
+  for (it = varyings->begin(); it != varyings->end(); ++it) {
+    total += it->length();
+  }
+  return total;
+}
 }  // anonymous namespace
 
 void ProgramCache::ComputeProgramHash(
     const char* hashed_shader_0,
     const char* hashed_shader_1,
     const std::map<std::string, GLint>* bind_attrib_location_map,
+    const std::vector<std::string>* transform_feedback_varyings,
+    GLenum transform_feedback_buffer_mode,
     char* result) const {
   const size_t shader0_size = kHashLength;
   const size_t shader1_size = kHashLength;
   const size_t map_size = CalculateMapSize(bind_attrib_location_map);
-  const size_t total_size = shader0_size + shader1_size + map_size;
+  const size_t var_size = CalculateVaryingsSize(transform_feedback_varyings);
+  const size_t total_size = shader0_size + shader1_size + map_size + var_size
+      + sizeof(GLenum);

[Zhenyao Mo, 2015/03/12 23:50:57]

nit: sizeof(transform_feedback_buffer_mode)

 
   scoped_ptr<unsigned char[]> buffer(new unsigned char[total_size]);
   memcpy(buffer.get(), hashed_shader_0, shader0_size);
   memcpy(&buffer[shader0_size], hashed_shader_1, shader1_size);
+  size_t current_pos = shader0_size + shader1_size;
   if (map_size != 0) {
     // copy our map
-    size_t current_pos = shader0_size + shader1_size;
     std::map<std::string, GLint>::const_iterator it;
     for (it = bind_attrib_location_map->begin();
          it != bind_attrib_location_map->end();
@@ -120,6 +143,19 @@ void ProgramCache::ComputeProgramHash(
       buffer[current_pos++] = static_cast<unsigned char>(value);
     }
   }
+
+  if (var_size != 0) {
+    // copy transform feedback varyings
+    std::vector<std::string>::const_iterator it;

[Zhenyao Mo, 2015/03/12 23:50:57]

iterator should not be exposed outside the for loop here.  You could use c++11
auto& for simplicity.

+    for (it = transform_feedback_varyings->begin();
+         it != transform_feedback_varyings->end();
+         ++it) {
+      const size_t name_size = it->length();
+      memcpy(&buffer.get()[current_pos], it->c_str(), name_size);

[Zhenyao Mo, 2015/03/12 23:50:57]

You need to insert a ' ' in between two varyings.  Otherwise ["ax", "b"] will be
identified as a hit as ["a", "xb"].  You need to modify the
CalculateVaryingsSize() to count in such whitespaces.

+      current_pos += name_size;
+    }
+  }
+  memcpy(&buffer[current_pos], &transform_feedback_buffer_mode, sizeof(GLenum));
   base::SHA1HashBytes(buffer.get(),
                       total_size, reinterpret_cast<unsigned char*>(result));
 }