Bug fixes for getTranslatedShader

Fixed the following bugs:
 * Getting the length of translated shader source failed on pending compilation
 * Getting the translated shader source failed on pending compilation
 * Getting the translated shader source after a new source is set

Small refactoring:
 * Put an enum in ShaderInfo for storing the compilation state

BUG=137758


Review URL: https://chromiumcodereview.appspot.com/10812002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@147997 0039d316-1c4b-4281-b951-d872f2087c98

gpu/command_buffer/service/gles2_cmd_decoder.cc

@@ -1361,6 +1361,8 @@ class GLES2DecoderImpl : public base::SupportsWeakPtr<GLES2DecoderImpl>,
            surface_->DeferDraws();
   }
 
+  void ForceCompileShaderIfPending(ShaderManager::ShaderInfo* info);
+
   // Generate a member function prototype for each command in an automated and
   // typesafe way.
   #define GLES2_CMD_OP(name) \
@@ -5125,6 +5127,25 @@ void GLES2DecoderImpl::PerformanceWarning(const std::string& msg) {
   LogMessage(std::string("PERFORMANCE WARNING: ") + msg);
 }
 
+void GLES2DecoderImpl::ForceCompileShaderIfPending(
+    ShaderManager::ShaderInfo* info) {
+  if (info->compilation_status() ==
+      ShaderManager::ShaderInfo::PENDING_DEFERRED_COMPILE) {
+
+    ShaderTranslator* translator = NULL;
+    if (use_shader_translator_) {
+      translator = info->shader_type() == GL_VERTEX_SHADER ?
+          vertex_translator_.get() : fragment_translator_.get();
+    }
+    // We know there will be no errors, because we only defer compilation on
+    // shaders that were previously compiled successfully.
+    program_manager()->ForceCompileShader(info->deferred_compilation_source(),
+                                          info,
+                                          translator,
+                                          feature_info_);
+  }
+}
+
 void GLES2DecoderImpl::CopyRealGLErrorsToWrapper() {
   GLenum error;
   while ((error = glGetError()) != GL_NO_ERROR) {
@@ -5848,6 +5869,7 @@ void GLES2DecoderImpl::DoGetShaderiv(
       *params = info->log_info() ? info->log_info()->size() + 1 : 0;
       return;
     case GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE:
+      ForceCompileShaderIfPending(info);
       *params = info->translated_source() ?
           info->translated_source()->size() + 1 : 0;
       return;
@@ -5885,6 +5907,7 @@ error::Error GLES2DecoderImpl::HandleGetTranslatedShaderSourceANGLE(
     bucket->SetSize(0);
     return error::kNoError;
   }
+  ForceCompileShaderIfPending(info);
 
   bucket->SetFromString(info->translated_source() ?
       info->translated_source()->c_str() : NULL);

gpu/command_buffer/service/program_manager.cc

@@ -489,7 +489,8 @@ bool ProgramManager::ProgramInfo::Link(ShaderManager* manager,
       const int kShaders = ProgramManager::ProgramInfo::kMaxAttachedShaders;
       for (int i = 0; i < kShaders; ++i) {
         ShaderManager::ShaderInfo* info = attached_shaders_[i].get();
-        if (!info->source_compiled()) {
+        if (info->compilation_status() ==
+            ShaderManager::ShaderInfo::PENDING_DEFERRED_COMPILE) {
           ShaderTranslator* translator = ShaderIndexToTranslator(
               i,
               vertex_translator,

gpu/command_buffer/service/program_manager.h

@@ -352,13 +352,13 @@ class GPU_EXPORT ProgramManager {
                        ShaderTranslator* translator,
                        FeatureInfo* feature_info);
 
- private:
   // Actually compiles the shader
   void ForceCompileShader(const std::string* source,
                           ShaderManager::ShaderInfo* info,
                           ShaderTranslator* translator,
                           FeatureInfo* feature_info);
 
+ private:
   void StartTracking(ProgramInfo* info);
   void StopTracking(ProgramInfo* info);
 

gpu/command_buffer/service/program_manager_unittest.cc

@@ -1383,13 +1383,17 @@ TEST_F(ProgramManagerWithCacheTest, CorrectCompileOnSourceChangeNoCompile) {
   SetExpectationsForNoCompile(new_vertex_shader);
 
   manager_.DoCompileShader(new_vertex_shader, NULL, NULL);
+  EXPECT_EQ(ShaderManager::ShaderInfo::PENDING_DEFERRED_COMPILE,
+            new_vertex_shader->compilation_status());
 
   new_vertex_shader->UpdateSource("different!");
   EXPECT_EQ(original_source,
             *new_vertex_shader->deferred_compilation_source());
 
-  EXPECT_FALSE(new_vertex_shader->source_compiled());
-  EXPECT_FALSE(fragment_shader_->source_compiled());
+  EXPECT_EQ(ShaderManager::ShaderInfo::PENDING_DEFERRED_COMPILE,
+            new_vertex_shader->compilation_status());
+  EXPECT_EQ(ShaderManager::ShaderInfo::PENDING_DEFERRED_COMPILE,
+            fragment_shader_->compilation_status());
 
   SetExpectationsForNoCompile(fragment_shader_);
   SetExpectationsForNotCachingProgram(program_info,
@@ -1441,8 +1445,10 @@ TEST_F(ProgramManagerWithCacheTest, CorrectCompileOnSourceChangeWithCompile) {
   EXPECT_EQ(differentSource,
             *new_vertex_shader->deferred_compilation_source());
 
-  EXPECT_TRUE(new_vertex_shader->source_compiled());
-  EXPECT_FALSE(fragment_shader_->source_compiled());
+  EXPECT_EQ(ShaderManager::ShaderInfo::COMPILED,
+            new_vertex_shader->compilation_status());
+  EXPECT_EQ(ShaderManager::ShaderInfo::PENDING_DEFERRED_COMPILE,
+            fragment_shader_->compilation_status());
 
   // so we don't recompile because we were pending originally
   SetExpectationsForNoCompile(new_vertex_shader);

gpu/command_buffer/service/shader_manager.cc

@@ -17,7 +17,7 @@ ShaderManager::ShaderInfo::ShaderInfo(GLuint service_id, GLenum shader_type)
         service_id_(service_id),
         shader_type_(shader_type),
         valid_(false),
-        source_compiled_(false) {
+        compilation_status_(NOT_COMPILED) {
 }
 
 ShaderManager::ShaderInfo::~ShaderInfo() {

gpu/command_buffer/service/shader_manager.h

@@ -33,6 +33,13 @@ class GPU_EXPORT ShaderManager {
     typedef scoped_refptr<ShaderInfo> Ref;
     typedef ShaderTranslator::VariableInfo VariableInfo;
 
+    enum CompilationStatus {
+      NOT_COMPILED,
+      // We're pending compilation for a cache hit with the program cache.
+      PENDING_DEFERRED_COMPILE,
+      COMPILED
+    };
+
     void UpdateSource(const char* source) {
       // If the source is flagged as compiled, then store our previous source
       // for deferred compile and caching.
@@ -40,7 +47,6 @@ class GPU_EXPORT ShaderManager {
         deferred_compilation_source_.reset(source_.release());
       }
       source_.reset(source ? new std::string(source) : NULL);
-      translated_source_.reset(NULL);
     }
 
     void UpdateTranslatedSource(const char* translated_source) {
@@ -68,9 +74,8 @@ class GPU_EXPORT ShaderManager {
         bool valid, const char* log,
         ShaderTranslatorInterface* translator);
 
-    // If the source was actually compiled (compilation wasn't deferred)
-    bool source_compiled() const {
-      return source_compiled_;
+    CompilationStatus compilation_status() const {
+      return compilation_status_;
     }
 
     // The source that was used when the user called CompileShader.
@@ -84,7 +89,9 @@ class GPU_EXPORT ShaderManager {
     // Resets our deferred compilation source and stores if the source was
     // actually compiled, or if we're expecting a cache hit
     void FlagSourceAsCompiled(bool actually_compiled) {
-      source_compiled_ = actually_compiled;
+      compilation_status_ = actually_compiled ?
+          COMPILED :
+          PENDING_DEFERRED_COMPILE;
       deferred_compilation_source_.reset();
     }
 
@@ -170,9 +177,8 @@ class GPU_EXPORT ShaderManager {
     VariableMap attrib_map_;
     VariableMap uniform_map_;
 
-    // If the source was actually compiled (otherwise we're deferring
-    // compilation because of a possible cache hit)
-    bool source_compiled_;
+    // The current compilation status of the shader
+    CompilationStatus compilation_status_;
 
     // Holds on to the source for a deferred compile.
     scoped_ptr<std::string> deferred_compilation_source_;

gpu/command_buffer/service/shader_manager_unittest.cc

@@ -253,11 +253,17 @@ TEST_F(ShaderManagerTest, ShaderInfoStoreCompilationStatus) {
       kClientId, kServiceId, kShaderType);
   ASSERT_TRUE(info != NULL);
 
+  EXPECT_EQ(ShaderManager::ShaderInfo::NOT_COMPILED,
+            info->compilation_status());
   info->UpdateSource("original source");
+  EXPECT_EQ(ShaderManager::ShaderInfo::NOT_COMPILED,
+            info->compilation_status());
   info->FlagSourceAsCompiled(false);
-  EXPECT_FALSE(info->source_compiled());
+  EXPECT_EQ(ShaderManager::ShaderInfo::PENDING_DEFERRED_COMPILE,
+            info->compilation_status());
   info->FlagSourceAsCompiled(true);
-  EXPECT_TRUE(info->source_compiled());
+  EXPECT_EQ(ShaderManager::ShaderInfo::COMPILED,
+            info->compilation_status());
 }
 
 TEST_F(ShaderManagerTest, ShaderInfoStoreDeferredSource) {