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..fabab8da3c09f8d97efd8f6087ab3a77c6b14fde 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(

[acondor_, 2017/04/21 15:04:23]

No need for OEIE

[mthiesse, 2017/04/21 17:17:30]

Good catch

+          /* 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);

[cjgrant, 2017/04/21 14:30:13]

I recall Aldo saying we didn't need these values set here, but I could be wrong.
 Aldo?

[acondor_, 2017/04/21 15:04:23]

We don't :)

[mthiesse, 2017/04/21 17:17:30]

Done.

+      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,43 @@ VrShellRenderer::VrShellRenderer()
 
 VrShellRenderer::~VrShellRenderer() = default;
 
+TexturedQuadRenderer* VrShellRenderer::GetTexturedQuadRenderer() {
+  skia_quad_renderer_->Flush();

[cjgrant, 2017/04/21 14:30:13]

I'm not sure this approach is much better than before.  A user of the renderer
could hold a pointer to their desired renderer type to save fetching it every
time.  Another option is to have VrShellRenderer track the last drawn type, and
if the type changes, have VrShellRenderer ratchet through all renderers and
flush each (if supported).  Can chat offline, and it doesn't matter much for
this particular CL.

[mthiesse, 2017/04/21 15:05:12]

Yeah, right now we don't hold onto pointers, and we could return const
references to ensure that, but we should rethink this whole class and do some
refactoring for M60 instead.

[cjgrant, 2017/04/21 15:19:33]

Agreed.

+  return textured_quad_renderer_.get();
+}
+
+SkiaQuadRenderer* VrShellRenderer::GetSkiaQuadRenderer() {
+  return skia_quad_renderer_.get();
+}
+
+WebVrRenderer* VrShellRenderer::GetWebVrRenderer() {
+  skia_quad_renderer_->Flush();
+  return webvr_renderer_.get();
+}
+
+ReticleRenderer* VrShellRenderer::GetReticleRenderer() {
+  skia_quad_renderer_->Flush();
+  return reticle_renderer_.get();
+}
+
+LaserRenderer* VrShellRenderer::GetLaserRenderer() {
+  skia_quad_renderer_->Flush();
+  return laser_renderer_.get();
+}
+
+ControllerRenderer* VrShellRenderer::GetControllerRenderer() {
+  skia_quad_renderer_->Flush();
+  return controller_renderer_.get();
+}
+
+GradientQuadRenderer* VrShellRenderer::GetGradientQuadRenderer() {
+  skia_quad_renderer_->Flush();
+  return gradient_quad_renderer_.get();
+}
+
+GradientGridRenderer* VrShellRenderer::GetGradientGridRenderer() {
+  skia_quad_renderer_->Flush();
+  return gradient_grid_renderer_.get();
+}
+
 }  // namespace vr_shell