Unbreak ppapi_example_video_decode for platforms that don't have ARB extensions.

ppapi/examples/video_decode/video_decode.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 <string.h>
 
 #include <iostream>
 #include <sstream>
 #include <list>
 #include <map>
@@ skipping 117 matching lines @@
     BitstreamBufferMap bitstream_buffers_by_id_;
   };
 
   // Initialize Video Decoders.
   void InitializeDecoders();
 
   // GL-related functions.
   void InitGL();
   GLuint CreateTexture(int32_t width, int32_t height, GLenum texture_target);
   void CreateGLObjects();
+  void Create2DProgramOnce();
+  void CreateARBProgramOnce();

[sail, 2012/08/10 17:45:45]

I think ARB isn't specific enough. Maybe Create2DRectProgramOnce?

[Ami GONE FROM CHROMIUM, 2012/08/10 17:56:19]

Changed to CreateRectangleARBProgramOnce to parallel shader_2d_ vs.
shader_rectangle_arb_.

   Shader CreateProgram(const char* vertex_shader,
                        const char* fragment_shader);
   void CreateShader(GLuint program, GLenum type, const char* source, int size);
   void DeleteTexture(GLuint id);
   void PaintFinished(int32_t result, PP_Resource decoder,
                      int picture_buffer_id);
 
   // Log an error to the developer console and stderr (though the latter may be
   // closed due to sandboxing or blackholed for other reasons) by creating a
   // temporary of this type and streaming to it.  Example usage:
@@ skipping 269 matching lines @@
   assert(!is_painting_);
   is_painting_ = true;
   int x = 0;
   int y = 0;
   if (client != video_decoders_.begin()->second) {
     x = plugin_size_.width() / kNumDecoders;
     y = plugin_size_.height() / kNumDecoders;
   }
 
   if (info.texture_target == GL_TEXTURE_2D) {
+    Create2DProgramOnce();
     gles2_if_->UseProgram(context_->pp_resource(), shader_2d_.program);
     gles2_if_->Uniform2f(
         context_->pp_resource(), shader_2d_.texcoord_scale_location, 1.0, 1.0);
   } else {
     assert(info.texture_target == GL_TEXTURE_RECTANGLE_ARB);
+    CreateARBProgramOnce();
     gles2_if_->UseProgram(
         context_->pp_resource(), shader_rectangle_arb_.program);
     gles2_if_->Uniform2f(context_->pp_resource(),
                          shader_rectangle_arb_.texcoord_scale_location,
                          info.buffer.size.width,
                          info.buffer.size.height);
   }
 
   gles2_if_->Viewport(context_->pp_resource(), x, y,
                       plugin_size_.width() / kNumDecoders,
@@ skipping 115 matching lines @@
   }
   assertNoGLError();
   return texture_id;
 }
 
 void VideoDecodeDemoInstance::DeleteTexture(GLuint id) {
   gles2_if_->DeleteTextures(context_->pp_resource(), 1, &id);
 }
 
 void VideoDecodeDemoInstance::CreateGLObjects() {
-  // Code and constants for shader.
-  static const char kVertexShader[] =
-      "varying vec2 v_texCoord;            \n"
-      "attribute vec4 a_position;          \n"
-      "attribute vec2 a_texCoord;          \n"
-      "uniform vec2 v_scale;               \n"
-      "void main()                         \n"
-      "{                                   \n"
-      "    v_texCoord = v_scale * a_texCoord; \n"
-      "    gl_Position = a_position;       \n"
-      "}";
+  // Assign vertex positions and texture coordinates to buffers for use in
+  // shader program.
+  static const float kVertices[] = {
+    -1, 1, -1, -1, 1, 1, 1, -1,  // Position coordinates.
+    0, 1, 0, 0, 1, 1, 1, 0,      // Texture coordinates.
+  };
 
+  GLuint buffer;
+  gles2_if_->GenBuffers(context_->pp_resource(), 1, &buffer);
+  gles2_if_->BindBuffer(context_->pp_resource(), GL_ARRAY_BUFFER, buffer);
+
+  gles2_if_->BufferData(context_->pp_resource(), GL_ARRAY_BUFFER,
+                        sizeof(kVertices), kVertices, GL_STATIC_DRAW);
+  assertNoGLError();
+}
+
+static const char kVertexShader[] =
+    "varying vec2 v_texCoord;            \n"
+    "attribute vec4 a_position;          \n"
+    "attribute vec2 a_texCoord;          \n"
+    "uniform vec2 v_scale;               \n"
+    "void main()                         \n"
+    "{                                   \n"
+    "    v_texCoord = v_scale * a_texCoord; \n"
+    "    gl_Position = a_position;       \n"
+    "}";
+
+void VideoDecodeDemoInstance::Create2DProgramOnce() {
+  if (shader_2d_.program)
+    return;
   static const char kFragmentShader2D[] =
       "precision mediump float;            \n"
       "varying vec2 v_texCoord;            \n"
       "uniform sampler2D s_texture;        \n"
       "void main()                         \n"
       "{"
       "    gl_FragColor = texture2D(s_texture, v_texCoord); \n"
       "}";
+  shader_2d_ = CreateProgram(kVertexShader, kFragmentShader2D);
+  assertNoGLError();
+}
 
+void VideoDecodeDemoInstance::CreateARBProgramOnce() {
+  if (shader_rectangle_arb_.program)
+    return;
   static const char kFragmentShaderRectangle[] =
       "#extension GL_ARB_texture_rectangle : require\n"
       "precision mediump float;            \n"
       "varying vec2 v_texCoord;            \n"
       "uniform sampler2DRect s_texture;    \n"
       "void main()                         \n"
       "{"
       "    gl_FragColor = texture2DRect(s_texture, v_texCoord).rgba; \n"
       "}";
-
-  // Assign vertex positions and texture coordinates to buffers for use in
-  // shader program.
-  static const float kVertices[] = {
-    -1, 1, -1, -1, 1, 1, 1, -1,  // Position coordinates.
-    0, 1, 0, 0, 1, 1, 1, 0,      // Texture coordinates.
-  };
-
-  GLuint buffer;
-  gles2_if_->GenBuffers(context_->pp_resource(), 1, &buffer);
-  gles2_if_->BindBuffer(context_->pp_resource(), GL_ARRAY_BUFFER, buffer);
-
-  gles2_if_->BufferData(context_->pp_resource(), GL_ARRAY_BUFFER,
-                        sizeof(kVertices), kVertices, GL_STATIC_DRAW);
-  assertNoGLError();
-
-  shader_2d_ = CreateProgram(kVertexShader, kFragmentShader2D);
   shader_rectangle_arb_ =
       CreateProgram(kVertexShader, kFragmentShaderRectangle);
 }
 
 Shader VideoDecodeDemoInstance::CreateProgram(const char* vertex_shader,
                                               const char* fragment_shader) {
   Shader shader;
 
   // Create shader program.
   shader.program = gles2_if_->CreateProgram(context_->pp_resource());
@@ skipping 40 matching lines @@
   gles2_if_->DeleteShader(context_->pp_resource(), shader);
 }
 }  // anonymous namespace
 
 namespace pp {
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new VideoDecodeDemoModule();
 }
 }  // namespace pp