Enable 2D Canvas painting for Chrome on Android.

gpu/command_buffer/service/gles2_cmd_copy_texture_chromium.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/gles2_cmd_copy_texture_chromium.h"
 
 #include <string.h>
 #include "base/basictypes.h"
 #include "gpu/command_buffer/common/types.h"
 #include "gpu/command_buffer/service/gl_utils.h"
@@ skipping 36 matching lines @@
 };
 
 struct ShaderInfo {
   bool needs_egl_image_external;
   const char* source;
 };
 
 const ShaderInfo shader_infos[] = {
   // VERTEX_SHADER_POS_TEX
   SHADER(
+    uniform mat4 u_matrix;
     attribute vec4 a_position;
     varying vec2 v_uv;
     void main(void) {
-      gl_Position = a_position;
+      gl_Position = u_matrix * a_position;
       v_uv = a_position.xy * 0.5 + vec2(0.5, 0.5);
     }),
   // FRAGMENT_SHADER_TEX
   SHADER(
     uniform sampler2D u_texSampler;
     varying vec2 v_uv;
     void main(void) {
       gl_FragColor = texture2D(u_texSampler, v_uv.st);
     }),
   // FRAGMENT_SHADER_TEX_FLIP_Y
@@ skipping 201 matching lines @@
     glLinkProgram(programs_[program]);
 #ifndef NDEBUG
     GLint linked;
     glGetProgramiv(programs_[program], GL_LINK_STATUS, &linked);
     if (!linked)
       DLOG(ERROR) << "CopyTextureCHROMIUM: program link failure.";
 #endif
 
     sampler_locations_[program] = glGetUniformLocation(programs_[program],
                                                       "u_texSampler");
+
+    matrix_handle_[program] = glGetUniformLocation(programs_[program],
+                                                   "u_matrix");
   }
 
   for (int shader = 0; shader < kNumShaders; ++shader)
     glDeleteShader(shaders[shader]);
 
   decoder->RestoreBufferBindings();
 
   initialized_ = true;
 }
 
@@ skipping 14 matching lines @@
     GLenum source_target,
     GLenum dest_target,
     GLuint source_id,
     GLuint dest_id,
     GLint level,
     GLsizei width,
     GLsizei height,
     bool flip_y,
     bool premultiply_alpha,
     bool unpremultiply_alpha) {
+  // Use default transform matrix if no transform passed in.
+  const static GLfloat default_matrix[16] = {1.0f, 0.0f, 0.0f, 0.0f,
+                                             0.0f, 1.0f, 0.0f, 0.0f,
+                                             0.0f, 0.0f, 1.0f, 0.0f,
+                                             0.0f, 0.0f, 0.0f, 1.0f};
+  DoCopyTextureWithTransform(decoder, source_target, dest_target, source_id,
+      dest_id, level, width, height, flip_y, premultiply_alpha,
+      unpremultiply_alpha, default_matrix);
+}
+
+void CopyTextureCHROMIUMResourceManager::DoCopyTextureWithTransform(
+    const gles2::GLES2Decoder* decoder,
+    GLenum source_target,
+    GLenum dest_target,
+    GLuint source_id,
+    GLuint dest_id,
+    GLint level,
+    GLsizei width,
+    GLsizei height,
+    bool flip_y,
+    bool premultiply_alpha,
+    bool unpremultiply_alpha,
+    const GLfloat transform_matrix[16]) {
   DCHECK(source_target == GL_TEXTURE_2D ||
          source_target == GL_TEXTURE_EXTERNAL_OES);
   if (!initialized_) {
     DLOG(ERROR) << "CopyTextureCHROMIUM: Uninitialized manager.";
     return;
   }
 
   GLuint program = GetProgram(
       flip_y, premultiply_alpha, unpremultiply_alpha,
       source_target == GL_TEXTURE_EXTERNAL_OES);
   glUseProgram(programs_[program]);
 
 #ifndef NDEBUG
   glValidateProgram(programs_[program]);
   GLint validation_status;
   glGetProgramiv(programs_[program], GL_VALIDATE_STATUS, &validation_status);
   if (GL_TRUE != validation_status) {
     DLOG(ERROR) << "CopyTextureCHROMIUM: Invalid shader.";
     return;
   }
 #endif
 
+  glUniformMatrix4fv(matrix_handle_[program], 1, GL_FALSE, transform_matrix);
   glActiveTexture(GL_TEXTURE0);
   glBindTexture(GL_TEXTURE_2D, dest_id);
   // NVidia drivers require texture settings to be a certain way
   // or they won't report FRAMEBUFFER_COMPLETE.
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, framebuffer_);
   glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, dest_target,
@@ skipping 38 matching lines @@
   decoder->RestoreTextureState(dest_id);
   decoder->RestoreActiveTexture();
   decoder->RestoreProgramBindings();
   decoder->RestoreBufferBindings();
   decoder->RestoreFramebufferBindings();
   decoder->RestoreGlobalState();
 }
 
 }  // namespace