Hook up insecure content warnings for http webVR presentation.

chrome/browser/android/vr_shell/vr_shell_renderer.cc

Index: chrome/browser/android/vr_shell/vr_shell_renderer.cc
diff --git a/chrome/browser/android/vr_shell/vr_shell_renderer.cc b/chrome/browser/android/vr_shell/vr_shell_renderer.cc
index 7951074d0453fedd5f9c2eba49fefdeb4030a37e..01ecdd0f64ac6b047d65fec7291263a80b3086b4 100644
--- a/chrome/browser/android/vr_shell/vr_shell_renderer.cc
+++ b/chrome/browser/android/vr_shell/vr_shell_renderer.cc
@@ -75,6 +75,7 @@ const char* GetShaderSource(vr_shell::ShaderID shader) {
     case vr_shell::ShaderID::RETICLE_VERTEX_SHADER:
     case vr_shell::ShaderID::LASER_VERTEX_SHADER:
     case vr_shell::ShaderID::CONTROLLER_VERTEX_SHADER:
+    case vr_shell::ShaderID::SKIA_QUAD_VERTEX_SHADER:
       return SHADER(
           /* clang-format off */
           uniform mat4 u_ModelViewProjMatrix;
@@ -119,6 +120,24 @@ const char* GetShaderSource(vr_shell::ShaderID shader) {
             gl_FragColor = vec4(color.xyz, color.w * opacity);
           }
           /* clang-format on */);
+    case vr_shell::ShaderID::SKIA_QUAD_FRAGMENT_SHADER:
+      return OEIE_SHADER(
+          /* clang-format off */
+          precision highp float;
+          uniform sampler2D u_Texture;
+          uniform vec4 u_CopyRect;  // rectangle
+          varying vec2 v_TexCoordinate;
+          uniform lowp vec4 color;
+          uniform mediump float opacity;
+
+          void main() {
+            vec2 scaledTex =
+                vec2(u_CopyRect[0] + v_TexCoordinate.x * u_CopyRect[2],
+                     u_CopyRect[1] + v_TexCoordinate.y * u_CopyRect[3]);
+            lowp vec4 color = texture2D(u_Texture, scaledTex);
+            gl_FragColor = vec4(color.xyz, color.w * opacity);
+          }
+          /* clang-format on */);
     case vr_shell::ShaderID::WEBVR_VERTEX_SHADER:
       return SHADER(
           /* clang-format off */
@@ -310,11 +329,48 @@ TexturedQuadRenderer::TexturedQuadRenderer()
   opacity_handle_ = glGetUniformLocation(program_handle_, "opacity");
 }
 
-void TexturedQuadRenderer::AddQuad(int texture_data_handle,
-                                   const vr::Mat4f& view_proj_matrix,
-                                   const gfx::RectF& copy_rect,
-                                   float opacity) {
-  TexturedQuad quad;
+void TexturedQuadRenderer::Draw(int texture_data_handle,
+                                const vr::Mat4f& view_proj_matrix,
+                                const gfx::RectF& copy_rect,
+                                float opacity) {
+  PrepareToDraw(model_view_proj_matrix_handle_, view_proj_matrix);
+
+  // Link texture data with texture unit.
+  glActiveTexture(GL_TEXTURE0);
+  glBindTexture(GL_TEXTURE_EXTERNAL_OES, texture_data_handle);
+  glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+  glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+  glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+  glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+
+  glUniform1i(tex_uniform_handle_, 0);
+  glUniform4fv(copy_rect_uniform_handle_, 1,
+               reinterpret_cast<const float*>(&copy_rect));
+  glUniform1f(opacity_handle_, opacity);
+
+  glDrawArrays(GL_TRIANGLES, 0, kVerticesNumber);
+
+  glDisableVertexAttribArray(position_handle_);
+  glDisableVertexAttribArray(tex_coord_handle_);
+}
+
+TexturedQuadRenderer::~TexturedQuadRenderer() = default;
+
+SkiaQuadRenderer::SkiaQuadRenderer()
+    : BaseQuadRenderer(SKIA_QUAD_VERTEX_SHADER, SKIA_QUAD_FRAGMENT_SHADER) {
+  model_view_proj_matrix_handle_ =
+      glGetUniformLocation(program_handle_, "u_ModelViewProjMatrix");
+  tex_uniform_handle_ = glGetUniformLocation(program_handle_, "u_Texture");
+  copy_rect_uniform_handle_ =
+      glGetUniformLocation(program_handle_, "u_CopyRect");
+  opacity_handle_ = glGetUniformLocation(program_handle_, "opacity");
+}
+
+void SkiaQuadRenderer::AddQuad(int texture_data_handle,
+                               const vr::Mat4f& view_proj_matrix,
+                               const gfx::RectF& copy_rect,
+                               float opacity) {
+  SkiaQuad quad;
   quad.texture_data_handle = texture_data_handle;
   quad.view_proj_matrix = view_proj_matrix;
   quad.copy_rect = {copy_rect.x(), copy_rect.y(), copy_rect.width(),
@@ -323,7 +379,7 @@ void TexturedQuadRenderer::AddQuad(int texture_data_handle,
   quad_queue_.push(quad);
 }
 
-void TexturedQuadRenderer::Flush() {
+void SkiaQuadRenderer::Flush() {
   if (quad_queue_.empty())
     return;
 
@@ -358,20 +414,16 @@ void TexturedQuadRenderer::Flush() {
   // the entire queue can be processed in one draw call. For now this still
   // significantly reduces the amount of state changes made per draw.
   while (!quad_queue_.empty()) {
-    const TexturedQuad& quad = quad_queue_.front();
+    const SkiaQuad& quad = quad_queue_.front();
 
     // Only change texture ID or opacity when they differ between quads.
     if (last_texture != quad.texture_data_handle) {
       last_texture = quad.texture_data_handle;
-      glBindTexture(GL_TEXTURE_EXTERNAL_OES, last_texture);
-      glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S,
-                      GL_CLAMP_TO_EDGE);
-      glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T,
-                      GL_CLAMP_TO_EDGE);
-      glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER,
-                      GL_LINEAR);
-      glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER,
-                      GL_NEAREST);
+      glBindTexture(GL_TEXTURE_2D, last_texture);
+      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     }
 
     if (last_opacity != quad.opacity) {
@@ -396,7 +448,7 @@ void TexturedQuadRenderer::Flush() {
   glDisableVertexAttribArray(tex_coord_handle_);
 }
 
-TexturedQuadRenderer::~TexturedQuadRenderer() = default;
+SkiaQuadRenderer::~SkiaQuadRenderer() = default;
 
 WebVrRenderer::WebVrRenderer()
     : BaseQuadRenderer(WEBVR_VERTEX_SHADER, WEBVR_FRAGMENT_SHADER) {
@@ -730,6 +782,7 @@ void GradientGridRenderer::MakeGridLines(int gridline_count) {
 
 VrShellRenderer::VrShellRenderer()
     : textured_quad_renderer_(base::MakeUnique<TexturedQuadRenderer>()),
+      skia_quad_renderer_(base::MakeUnique<SkiaQuadRenderer>()),
       webvr_renderer_(base::MakeUnique<WebVrRenderer>()),
       reticle_renderer_(base::MakeUnique<ReticleRenderer>()),
       laser_renderer_(base::MakeUnique<LaserRenderer>()),
@@ -741,4 +794,47 @@ VrShellRenderer::VrShellRenderer()
 
 VrShellRenderer::~VrShellRenderer() = default;
 
+TexturedQuadRenderer* VrShellRenderer::GetTexturedQuadRenderer() {
+  Flush();
+  return textured_quad_renderer_.get();
+}
+
+SkiaQuadRenderer* VrShellRenderer::GetSkiaQuadRenderer() {
+  return skia_quad_renderer_.get();
+}
+
+WebVrRenderer* VrShellRenderer::GetWebVrRenderer() {
+  Flush();
+  return webvr_renderer_.get();
+}
+
+ReticleRenderer* VrShellRenderer::GetReticleRenderer() {
+  Flush();
+  return reticle_renderer_.get();
+}
+
+LaserRenderer* VrShellRenderer::GetLaserRenderer() {
+  Flush();
+  return laser_renderer_.get();
+}
+
+ControllerRenderer* VrShellRenderer::GetControllerRenderer() {
+  Flush();
+  return controller_renderer_.get();
+}
+
+GradientQuadRenderer* VrShellRenderer::GetGradientQuadRenderer() {
+  Flush();
+  return gradient_quad_renderer_.get();
+}
+
+GradientGridRenderer* VrShellRenderer::GetGradientGridRenderer() {
+  Flush();
+  return gradient_grid_renderer_.get();
+}
+
+void VrShellRenderer::Flush() {
+  skia_quad_renderer_->Flush();
+}
+
 }  // namespace vr_shell