The Shader class now support deferred shader compiling.

gpu/command_buffer/service/shader_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/service/shader_manager.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 
 namespace gpu {
 namespace gles2 {
 
 namespace {
 
 // Given a variable name | a[0].b.c[0] |, return |a|.
 std::string GetTopVariableName(const std::string& fullname) {
   size_t pos = fullname.find_first_of("[.");
   if (pos == std::string::npos)
     return fullname;
   return fullname.substr(0, pos);
 }
 
 }  // namespace anonymous
 
 Shader::Shader(GLuint service_id, GLenum shader_type)
       : use_count_(0),
+        shader_state_(kShaderStateWaiting),
         service_id_(service_id),
         shader_type_(shader_type),
         valid_(false) {
 }
 
 Shader::~Shader() {
 }
 
+void Shader::RequestCompile() {
+  shader_state_ = kShaderStateCompileRequested;
+  last_compiled_source_ = source_;
+}
+
 void Shader::DoCompile(ShaderTranslatorInterface* translator,
                        TranslatedShaderSourceType type) {
+  // If compile was not requested yet, we assume this is not a deferred compile.
+  // It is up to the caller of the function to check that the shader state
+  // is kShaderStateCompileRequested if they want to enforce deferred shader
+  // compiles. Otherwise calling DoCompile() will just compile the source that
+  // was last set. For deferred compiles we should compile
+  // |last_compiled_source_| instead of |source_| because they could have set a
+  // new shader source after requesting a compile, in which case the shader at
+  // the time of the compile request is the proper source.

[vmiura, 2015/02/04 21:18:56]

nit: DCHECK(shader_state_ != kShaderStateCompiled)

[David Yen, 2015/02/04 22:05:49]

After discussing in person, we decided to simplify the API to only support
Compile after RequestCompile.

+  if (shader_state_ != kShaderStateCompileRequested) {
+    last_compiled_source_ = source_;
+  }
+
+  // Signify the shader has been compiled, whether or not it is valid
+  // is dependent on the |valid_| member variable.
+  shader_state_ = kShaderStateCompiled;
+
   // Translate GL ES 2.0 shader to Desktop GL shader and pass that to
   // glShaderSource and then glCompileShader.
-  const char* source_for_driver = source_.c_str();
+  const char* source_for_driver = last_compiled_source_.c_str();
   if (translator) {
-    valid_ = translator->Translate(source_,
+    valid_ = translator->Translate(last_compiled_source_,
                                    &log_info_,
                                    &translated_source_,
                                    &attrib_map_,
                                    &uniform_map_,
                                    &varying_map_,
                                    &name_map_);
     if (!valid_) {
       return;
     }
-    signature_source_ = source_;
     source_for_driver = translated_source_.c_str();
   }
 
   glShaderSource(service_id_, 1, &source_for_driver, NULL);
   glCompileShader(service_id_);
   if (type == kANGLE) {
     GLint max_len = 0;
     glGetShaderiv(service_id_,
                   GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE,
                   &max_len);
@@ skipping 17 matching lines @@
     scoped_ptr<char[]> buffer(new char[max_len]);
     GLint len = 0;
     glGetShaderInfoLog(service_id_, max_len, &len, buffer.get());
     DCHECK(max_len == 0 || len < max_len);
     DCHECK(len == 0 || buffer[len] == '\0');
     valid_ = false;
     log_info_ = std::string(buffer.get(), len);
     LOG_IF(ERROR, translator)
         << "Shader translator allowed/produced an invalid shader "
         << "unless the driver is buggy:"
-        << "\n--original-shader--\n" << source_
+        << "\n--original-shader--\n" << last_compiled_source_
         << "\n--translated-shader--\n" << source_for_driver
         << "\n--info-log--\n" << log_info_;
   }
 }
 
 void Shader::IncUseCount() {
   ++use_count_;
 }
 
 void Shader::DecUseCount() {
@@ skipping 132 matching lines @@
   DCHECK(shader);
   DCHECK(IsOwned(shader));
   shader->DecUseCount();
   RemoveShader(shader);
 }
 
 }  // namespace gles2
 }  // namespace gpu