Update from https://crrev.com/316786

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"
@@ skipping 11 matching lines @@
   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),
+        source_type_(kANGLE),
         valid_(false) {
 }
 
 Shader::~Shader() {
 }
 
-void Shader::RequestCompile() {
+void Shader::RequestCompile(scoped_refptr<ShaderTranslatorInterface> translator,
+                            TranslatedShaderSourceType type) {
   shader_state_ = kShaderStateCompileRequested;
+  translator_ = translator;
+  source_type_ = type;
   last_compiled_source_ = source_;
 }
 
-void Shader::DoCompile(ShaderTranslatorInterface* translator,
-                       TranslatedShaderSourceType type) {
+void Shader::DoCompile() {
   // We require that RequestCompile() must be called before DoCompile(),
   // so we can return early if the shader state is not what we expect.
   if (shader_state_ != kShaderStateCompileRequested) {
     return;
   }
 
   // Signify the shader has been compiled, whether or not it is valid
   // is dependent on the |valid_| member variable.
   shader_state_ = kShaderStateCompiled;
+  valid_ = false;
 
   // Translate GL ES 2.0 shader to Desktop GL shader and pass that to
   // glShaderSource and then glCompileShader.
   const char* source_for_driver = last_compiled_source_.c_str();
+  ShaderTranslatorInterface* translator = translator_.get();
   if (translator) {
-    valid_ = translator->Translate(last_compiled_source_,
-                                   &log_info_,
-                                   &translated_source_,
-                                   &attrib_map_,
-                                   &uniform_map_,
-                                   &varying_map_,
-                                   &name_map_);
-    if (!valid_) {
+    bool success = translator->Translate(last_compiled_source_,
+                                         &log_info_,
+                                         &translated_source_,
+                                         &attrib_map_,
+                                         &uniform_map_,
+                                         &varying_map_,
+                                         &name_map_);
+    if (!success) {
       return;
     }
     source_for_driver = translated_source_.c_str();
   }
 
   glShaderSource(service_id_, 1, &source_for_driver, NULL);
   glCompileShader(service_id_);
-  if (type == kANGLE) {
+  if (source_type_ == kANGLE) {
     GLint max_len = 0;
     glGetShaderiv(service_id_,
                   GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE,
                   &max_len);
     translated_source_.resize(max_len);
     GLint len = 0;
     glGetTranslatedShaderSourceANGLE(
         service_id_, translated_source_.size(),
         &len, &translated_source_.at(0));
     DCHECK(max_len == 0 || len < max_len);
     DCHECK(len == 0 || translated_source_[len] == '\0');
     translated_source_.resize(len);
+    source_for_driver = translated_source_.c_str();
   }
 
   GLint status = GL_FALSE;
   glGetShaderiv(service_id_, GL_COMPILE_STATUS, &status);
-  if (status != GL_TRUE) {
+  if (status == GL_TRUE) {
+    valid_ = true;
+  } else {
     // We cannot reach here if we are using the shader translator.
     // All invalid shaders must be rejected by the translator.
     // All translated shaders must compile.
     GLint max_len = 0;
     glGetShaderiv(service_id_, GL_INFO_LOG_LENGTH, &max_len);
     log_info_.resize(max_len);
     GLint len = 0;
     glGetShaderInfoLog(service_id_, log_info_.size(), &len, &log_info_.at(0));
     DCHECK(max_len == 0 || len < max_len);
     DCHECK(len == 0 || log_info_[len] == '\0');
@@ skipping 148 matching lines @@
   DCHECK(shader);
   DCHECK(IsOwned(shader));
   shader->DecUseCount();
   RemoveShader(shader);
 }
 
 }  // namespace gles2
 }  // namespace gpu