Hook up insecure content warnings for http webVR presentation.

chrome/browser/android/vr_shell/vr_shell_renderer.cc

 // Copyright 2016 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 "chrome/browser/android/vr_shell/vr_shell_renderer.h"
 
 #include <math.h>
 #include <algorithm>
 #include <string>
 
@@ skipping 57 matching lines @@
 #define SHADER(Src) #Src
 #define OEIE_SHADER(Src) "#extension GL_OES_EGL_image_external : require\n" #Src
 #define VOID_OFFSET(x) reinterpret_cast<void*>(x)
 
 const char* GetShaderSource(vr_shell::ShaderID shader) {
   switch (shader) {
     case vr_shell::ShaderID::TEXTURE_QUAD_VERTEX_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;
           attribute vec4 a_Position;
           attribute vec2 a_TexCoordinate;
           varying vec2 v_TexCoordinate;
 
           void main() {
             v_TexCoordinate = a_TexCoordinate;
             gl_Position = u_ModelViewProjMatrix * a_Position;
@@ skipping 24 matching lines @@
           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::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 */
           attribute vec3 a_Position;
           attribute vec2 a_TexCoordinate;
           varying vec2 v_TexCoordinate;
 
           void main() {
             v_TexCoordinate = a_TexCoordinate;
             gl_Position = vec4(a_Position * 2.0, 1.0);
@@ skipping 171 matching lines @@
     : BaseQuadRenderer(TEXTURE_QUAD_VERTEX_SHADER,
                        TEXTURE_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 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(),
                     copy_rect.height()};
   quad.opacity = opacity;
   quad_queue_.push(quad);
 }
 
-void TexturedQuadRenderer::Flush() {
+void SkiaQuadRenderer::Flush() {
   if (quad_queue_.empty())
     return;
 
   int last_texture = 0;
   float last_opacity = -1.0f;
 
   // Set up GL state that doesn't change between draw calls.
   glUseProgram(program_handle_);
 
   glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_);
@@ skipping 14 matching lines @@
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
   // Link texture data with texture unit.
   glActiveTexture(GL_TEXTURE0);
   glUniform1i(tex_uniform_handle_, 0);
 
   // TODO(bajones): This should eventually be changed to use instancing so that
   // 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) {
       last_opacity = quad.opacity;
       glUniform1f(opacity_handle_, last_opacity);
     }
 
     // Pass in model view project matrix.
     glUniformMatrix4fv(model_view_proj_matrix_handle_, 1, false,
                        MatrixToGLArray(quad.view_proj_matrix).data());
 
     // Pass in the copy rect.
     glUniform4fv(copy_rect_uniform_handle_, 1,
                  reinterpret_cast<const float*>(&quad.copy_rect));
 
     glDrawArrays(GL_TRIANGLES, 0, kVerticesNumber);
 
     quad_queue_.pop();
   }
 
   glDisableVertexAttribArray(position_handle_);
   glDisableVertexAttribArray(tex_coord_handle_);
 }
 
-TexturedQuadRenderer::~TexturedQuadRenderer() = default;
+SkiaQuadRenderer::~SkiaQuadRenderer() = default;
 
 WebVrRenderer::WebVrRenderer()
     : BaseQuadRenderer(WEBVR_VERTEX_SHADER, WEBVR_FRAGMENT_SHADER) {
   tex_uniform_handle_ = glGetUniformLocation(program_handle_, "u_Texture");
 }
 
 // Draw the stereo WebVR frame
 void WebVrRenderer::Draw(int texture_handle) {
   glUseProgram(program_handle_);
 
@@ skipping 313 matching lines @@
   size_t vertex_buffer_size = sizeof(Line3d) * linesNumber;
 
   glGenBuffersARB(1, &vertex_buffer_);
   glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_);
   glBufferData(GL_ARRAY_BUFFER, vertex_buffer_size, grid_lines_.data(),
                GL_STATIC_DRAW);
 }
 
 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>()),
       controller_renderer_(base::MakeUnique<ControllerRenderer>()),
       gradient_quad_renderer_(base::MakeUnique<GradientQuadRenderer>()),
       gradient_grid_renderer_(base::MakeUnique<GradientGridRenderer>()) {
   BaseQuadRenderer::SetVertexBuffer();
 }
 
 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