DCHECK if shader compilation fails that it's due to context loss.

content/common/gpu/client/gl_helper_scaling.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 "content/common/gpu/client/gl_helper_scaling.h"
 
 #include <deque>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
+#include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 
 using gpu::gles2::GLES2Interface;
 
 namespace content {
 
-GLHelperScaling::GLHelperScaling(GLES2Interface* gl, GLHelper* helper)
-    : gl_(gl), helper_(helper), vertex_attributes_buffer_(gl_) {
+GLHelperScaling::GLHelperScaling(GLES2Interface* gl,
+                                 gpu::ContextSupport* context_support,
+                                 GLHelper* helper)
+    : gl_(gl),
+      context_support_(context_support),
+      helper_(helper),
+      vertex_attributes_buffer_(gl_) {
   InitBuffer();
 }
 
 GLHelperScaling::~GLHelperScaling() {}
 
 // Used to keep track of a generated shader program. The program
 // is passed in as text through Setup and is used by calling
 // UseProgram() with the right parameters. Note that |gl_|
 // and |helper_| are assumed to live longer than this program.
 class ShaderProgram : public base::RefCounted<ShaderProgram> {
  public:
   ShaderProgram(GLES2Interface* gl, GLHelper* helper)
       : gl_(gl),
         helper_(helper),
         program_(gl_->CreateProgram()),
         position_location_(-1),
         texcoord_location_(-1),
         src_subrect_location_(-1),
         src_pixelsize_location_(-1),
         dst_pixelsize_location_(-1),
         scaling_vector_location_(-1),
         color_weights_location_(-1) {}
 
   // Compile shader program.
-  void Setup(const GLchar* vertex_shader_text,
+  void Setup(gpu::ContextSupport* context_support,
+             const GLchar* vertex_shader_text,
              const GLchar* fragment_shader_text);
 
   // UseProgram must be called with GL_TEXTURE_2D bound to the
   // source texture and GL_ARRAY_BUFFER bound to a vertex
   // attribute buffer.
   void UseProgram(const gfx::Size& src_size,
                   const gfx::Rect& src_subrect,
                   const gfx::Size& dst_size,
                   bool scale_x,
                   bool flip_y,
@@ skipping 757 matching lines @@
       }
     }
 
     vertex_program = vertex_header + shared_variables + "void main() {\n" +
                      vertex_program + "}\n";
 
     fragment_program = fragment_directives + fragment_header +
                        shared_variables + "void main() {\n" + fragment_program +
                        "}\n";
 
-    cache_entry->Setup(vertex_program.c_str(), fragment_program.c_str());
+    cache_entry->Setup(context_support_, vertex_program.c_str(),
+                       fragment_program.c_str());
   }
   return cache_entry;
 }
 
-void ShaderProgram::Setup(const GLchar* vertex_shader_text,
+void ShaderProgram::Setup(gpu::ContextSupport* context_support,
+                          const GLchar* vertex_shader_text,
                           const GLchar* fragment_shader_text) {
   // Shaders to map the source texture to |dst_texture_|.
   GLuint vertex_shader =
       helper_->CompileShaderFromSource(vertex_shader_text, GL_VERTEX_SHADER);
   if (vertex_shader == 0)
     return;
 
   gl_->AttachShader(program_, vertex_shader);
   gl_->DeleteShader(vertex_shader);
 
@@ skipping 16 matching lines @@
   texture_location_ = gl_->GetUniformLocation(program_, "s_texture");
   src_subrect_location_ = gl_->GetUniformLocation(program_, "src_subrect");
   src_pixelsize_location_ = gl_->GetUniformLocation(program_, "src_pixelsize");
   dst_pixelsize_location_ = gl_->GetUniformLocation(program_, "dst_pixelsize");
   scaling_vector_location_ =
       gl_->GetUniformLocation(program_, "scaling_vector");
   color_weights_location_ = gl_->GetUniformLocation(program_, "color_weights");
   // The only reason fetching these attribute locations should fail is
   // if the context was spontaneously lost (i.e., because the GPU
   // process crashed, perhaps deliberately for testing).
   // Unfortunately, the only way to reliably detect context loss from

[Ken Russell (switch to Gerrit), 2015/05/29 17:47:05]

The sentence starting with "Unfortunately" should probably be removed now.

[danakj, 2015/05/29 18:30:14]

Done.

[Ken Russell (switch to Gerrit), 2015/05/29 19:13:09]

Was the current patch set updated to include this change?

   // GLES2Interface would be to repeatedly call GetError(), and this
   // seems fragile. Most of the APIs in GLHelper should be updated to
   // be able to return an error. Fortunately, many users of this code
   // check for context loss at a higher level.
   if (!Initialized()) {
-    LOG(ERROR) << "ShaderProgram::Setup: initialization failed (context lost?)";
+    // Should only fail due to context loss, anything else is a bug.
+    DCHECK(context_support->IsContextLost());

[Ken Russell (switch to Gerrit), 2015/05/29 17:47:05]

To be closer to the previous code, should this be phrased as
DCHECK(Initialized() || context_support->IsContextLost())?

[danakj, 2015/05/29 18:30:14]

Sure ya.

   }
   return;
 }
 
 void ShaderProgram::UseProgram(const gfx::Size& src_size,
                                const gfx::Rect& src_subrect,
                                const gfx::Size& dst_size,
                                bool scale_x,
                                bool flip_y,
                                GLfloat color_weights[4]) {
@@ skipping 40 matching lines @@
   gl_->Uniform2f(dst_pixelsize_location_,
                  static_cast<float>(dst_size.width()),
                  static_cast<float>(dst_size.height()));
 
   gl_->Uniform2f(
       scaling_vector_location_, scale_x ? 1.0 : 0.0, scale_x ? 0.0 : 1.0);
   gl_->Uniform4fv(color_weights_location_, 1, color_weights);
 }
 
 }  // namespace content