Update from https://crrev.com/320343

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),
+        marked_for_deletion_(false),
         service_id_(service_id),
         shader_type_(shader_type),
         source_type_(kANGLE),
         valid_(false) {
 }
 
 Shader::~Shader() {
 }
 
+void Shader::Destroy() {
+  if (service_id_) {
+    DeleteServiceID();
+  }
+}
+
 void Shader::RequestCompile(scoped_refptr<ShaderTranslatorInterface> translator,
                             TranslatedShaderSourceType type) {
   shader_state_ = kShaderStateCompileRequested;
   translator_ = translator;
   source_type_ = type;
   last_compiled_source_ = source_;
 }
 
 void Shader::DoCompile() {
   // We require that RequestCompile() must be called before DoCompile(),
@@ skipping 49 matching lines @@
   GLint status = GL_FALSE;
   glGetShaderiv(service_id_, GL_COMPILE_STATUS, &status);
   if (status == GL_TRUE) {
     valid_ = true;
   } else {
     valid_ = false;
 
     // 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.
+    std::string translator_log = log_info_;
+
     GLint max_len = 0;
     glGetShaderiv(service_id_, GL_INFO_LOG_LENGTH, &max_len);
     log_info_.resize(max_len);
     if (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');
       log_info_.resize(len);
     }
+
     LOG_IF(ERROR, translator)
         << "Shader translator allowed/produced an invalid shader "
         << "unless the driver is buggy:"
+        << "\n--Log from shader translator--\n" << translator_log
         << "\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() {
   --use_count_;
   DCHECK_GE(use_count_, 0);
+  if (service_id_ && use_count_ == 0 && marked_for_deletion_) {
+    DeleteServiceID();
+  }
 }
 
-void Shader::Delete() {
-  if (use_count_ > 0) {
-    // If attached, compile the shader before we delete it.
-    DoCompile();
+void Shader::MarkForDeletion() {
+  DCHECK(!marked_for_deletion_);
+  DCHECK_NE(service_id_, 0u);
+
+  marked_for_deletion_ = true;
+  if (use_count_ == 0) {
+    DeleteServiceID();
   }
+}
+
+void Shader::DeleteServiceID() {
   DCHECK_NE(service_id_, 0u);
   glDeleteShader(service_id_);
   service_id_ = 0;
 }
 
 const sh::Attribute* Shader::GetAttribInfo(const std::string& name) const {
   // Vertex attributes can't be arrays or structs (GLSL ES 3.00.4, section
   // 4.3.4, "Input Variables"), so |name| is the top level name used as
   // the AttributeMap key.
   AttributeMap::const_iterator it = attrib_map_.find(name);
@@ skipping 31 matching lines @@
 ShaderManager::ShaderManager() {}
 
 ShaderManager::~ShaderManager() {
   DCHECK(shaders_.empty());
 }
 
 void ShaderManager::Destroy(bool have_context) {
   while (!shaders_.empty()) {
     if (have_context) {
       Shader* shader = shaders_.begin()->second.get();
-      if (!shader->IsDeleted()) {
-        shader->Delete();
-      }
+      shader->Destroy();
     }
     shaders_.erase(shaders_.begin());
   }
 }
 
 Shader* ShaderManager::CreateShader(
     GLuint client_id,
     GLuint service_id,
     GLenum shader_type) {
   std::pair<ShaderMap::iterator, bool> result =
@@ skipping 42 matching lines @@
         return;
       }
     }
     NOTREACHED();
   }
 }
 
 void ShaderManager::Delete(Shader* shader) {
   DCHECK(shader);
   DCHECK(IsOwned(shader));
-  shader->Delete();
+  shader->MarkForDeletion();
   RemoveShader(shader);
 }
 
 void ShaderManager::UseShader(Shader* shader) {
   DCHECK(shader);
   DCHECK(IsOwned(shader));
   shader->IncUseCount();
 }
 
 void ShaderManager::UnuseShader(Shader* shader) {
   DCHECK(shader);
   DCHECK(IsOwned(shader));
   shader->DecUseCount();
   RemoveShader(shader);
 }
 
 }  // namespace gles2
 }  // namespace gpu