VR: handle content quad drawing in Ui

Also renaming WebVrRenderer to TextureCopyRenderer, given that it is not
only being used for rendering WebXR.

Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel;luci.chromium.try:linux_optional_gpu_tests_rel;luci.chromium.try:linux_vr;luci.chromium.try:mac_optional_gpu_tests_rel;luci.chromium.try:win_optional_gpu_tests_rel
Change-Id: Ib6ba330bde972b4d87b8e4b897957f5f37bb7364
Reviewed-on: https://chromium-review.googlesource.com/1168469Reviewed-by: Michael Thiessen <mthiesse@chromium.org>
Commit-Queue: Aldo Culquicondor <acondor@chromium.org>
Cr-Commit-Position: refs/heads/master@{#582762}

chrome/browser/android/vr/arcore_device/arcore_gl.cc

@@ -55,7 +55,7 @@ gfx::Transform ConvertUvsToTransformMatrix(const std::vector<float>& uvs) {
   // a Y flip because ARCore's "normalized screen space" coordinates have the
   // origin at the top left to match 2D Android APIs, so it needs a Y flip to
   // get an origin at bottom left as used for textures.
-  DCHECK(uvs.size() == 6);
+  DCHECK_EQ(uvs.size(), 6U);
   float u00 = uvs[0];
   float v00 = uvs[1];
   float u10 = uvs[2];

chrome/browser/android/vr/vr_shell_gl.cc

@@ -1272,7 +1272,7 @@ void VrShellGl::DrawIntoAcquiredFrame(int16_t frame_index,
 
     glClear(GL_COLOR_BUFFER_BIT);
 
-    DrawContentQuad(!ui_->IsContentOverlayTextureEmpty());
+    DrawContentQuad();
 
     acquired_frame_.Unbind();
   }
@@ -1617,18 +1617,17 @@ void VrShellGl::DrawWebVr() {
     CHECK(buffer);
 
     // Use an identity UV transform, the image is already oriented correctly.
-    ui_->DrawWebVr(buffer->local_texture, kWebVrIdentityUvTransform, 0, 0);
+    ui_->DrawWebXr(buffer->local_texture, kWebVrIdentityUvTransform);
   } else {
     // Apply the UV transform from the SurfaceTexture, that's usually a Y flip.
-    ui_->DrawWebVr(webvr_texture_id_, webvr_surface_texture_uv_transform_, 0,
-                   0);
+    ui_->DrawWebXr(webvr_texture_id_, webvr_surface_texture_uv_transform_);
   }
 }
 
-void VrShellGl::DrawContentQuad(bool draw_overlay_texture) {
+void VrShellGl::DrawContentQuad() {
   // Add a 2 pixel border to avoid aliasing issues at the edge of the texture.
   constexpr float kBorder = 2;
-  TRACE_EVENT0("gpu", "VrShellGl::DrawContentQuad");
+  TRACE_EVENT0("gpu", __func__);
   // Don't need face culling, depth testing, blending, etc. Turn it all off.
   glDisable(GL_CULL_FACE);
   glDisable(GL_SCISSOR_TEST);
@@ -1641,16 +1640,10 @@ void VrShellGl::DrawContentQuad(bool draw_overlay_texture) {
       content_tex_buffer_size_.height() * kContentVignetteBorder - kBorder,
       content_tex_buffer_size_.width() + 2 * kBorder,
       content_tex_buffer_size_.height() + 2 * kBorder);
-  ui_->DrawWebVr(content_texture_id_, kContentUvTransform,
-                 kBorder / content_tex_buffer_size_.width(),
-                 kBorder / content_tex_buffer_size_.height());
-  if (draw_overlay_texture) {
-    glEnable(GL_BLEND);
-    glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
-    ui_->DrawWebVr(content_overlay_texture_id_, kContentUvTransform,
+
+  ui_->DrawContent(kContentUvTransform,
                    kBorder / content_tex_buffer_size_.width(),
                    kBorder / content_tex_buffer_size_.height());
-  }
 }
 
 void VrShellGl::OnPause() {

chrome/browser/android/vr/vr_shell_gl.h

@@ -187,7 +187,7 @@ class VrShellGl : public RenderLoop,
   void DrawFrameSubmitNow(int16_t frame_index, const gfx::Transform& head_pose);
   bool ShouldDrawWebVr();
   void DrawWebVr();
-  void DrawContentQuad(bool draw_overlay_texture);
+  void DrawContentQuad();
   bool WebVrPoseByteIsValid(int pose_index_byte);
 
   void OnContentFrameAvailable();

chrome/browser/vr/BUILD.gn

@@ -156,12 +156,12 @@ source_set("vr_ui") {
     "renderers/external_textured_quad_renderer.h",
     "renderers/radial_gradient_quad_renderer.cc",
     "renderers/radial_gradient_quad_renderer.h",
+    "renderers/texture_copy_renderer.cc",
+    "renderers/texture_copy_renderer.h",
     "renderers/textured_quad_renderer.cc",
     "renderers/textured_quad_renderer.h",
     "renderers/transparent_quad_renderer.cc",
     "renderers/transparent_quad_renderer.h",
-    "renderers/web_vr_renderer.cc",
-    "renderers/web_vr_renderer.h",
     "sequence.cc",
     "sequence.h",
     "target_property.cc",

chrome/browser/vr/renderers/web_vr_renderer.cc → chrome/browser/vr/renderers/texture_copy_renderer.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "chrome/browser/vr/renderers/web_vr_renderer.h"
+#include "chrome/browser/vr/renderers/texture_copy_renderer.h"
 
 #include "chrome/browser/vr/vr_gl_util.h"
 
@@ -47,7 +47,7 @@ static constexpr char const* kWebVrFragmentShader = OEIE_SHADER(
 
 }  // namespace
 
-WebVrRenderer::WebVrRenderer()
+TextureCopyRenderer::TextureCopyRenderer()
     : BaseQuadRenderer(kWebVrVertexShader, kWebVrFragmentShader) {
   texture_handle_ = glGetUniformLocation(program_handle_, "u_Texture");
   uv_transform_ = glGetUniformLocation(program_handle_, "u_UvTransform");
@@ -56,10 +56,10 @@ WebVrRenderer::WebVrRenderer()
 }
 
 // Draw the stereo WebVR frame
-void WebVrRenderer::Draw(int texture_handle,
-                         const float (&uv_transform)[16],
-                         float xborder,
-                         float yborder) {
+void TextureCopyRenderer::Draw(int texture_handle,
+                               const float (&uv_transform)[16],
+                               float xborder,
+                               float yborder) {
   glUseProgram(program_handle_);
 
   // Bind vertex attributes
@@ -93,6 +93,6 @@ void WebVrRenderer::Draw(int texture_handle,
 // Note that we don't explicitly delete gl objects here, they're deleted
 // automatically when we call ShutdownGL, and deleting them here leads to
 // segfaults.
-WebVrRenderer::~WebVrRenderer() = default;
+TextureCopyRenderer::~TextureCopyRenderer() = default;
 
 }  // namespace vr

chrome/browser/vr/renderers/web_vr_renderer.h → chrome/browser/vr/renderers/texture_copy_renderer.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CHROME_BROWSER_VR_RENDERERS_WEB_VR_RENDERER_H_
-#define CHROME_BROWSER_VR_RENDERERS_WEB_VR_RENDERER_H_
+#ifndef CHROME_BROWSER_VR_RENDERERS_TEXTURE_COPY_RENDERER_H_
+#define CHROME_BROWSER_VR_RENDERERS_TEXTURE_COPY_RENDERER_H_
 
 #include "base/macros.h"
 #include "chrome/browser/vr/renderers/base_quad_renderer.h"
@@ -12,10 +12,10 @@
 namespace vr {
 
 // Renders a page-generated stereo VR view.
-class VR_UI_EXPORT WebVrRenderer : public BaseQuadRenderer {
+class VR_UI_EXPORT TextureCopyRenderer : public BaseQuadRenderer {
  public:
-  WebVrRenderer();
-  ~WebVrRenderer() override;
+  TextureCopyRenderer();
+  ~TextureCopyRenderer() override;
 
   void Draw(int texture_handle,
             const float (&uv_transform)[16],
@@ -28,9 +28,9 @@ class VR_UI_EXPORT WebVrRenderer : public BaseQuadRenderer {
   GLuint x_border_handle_;
   GLuint y_border_handle_;
 
-  DISALLOW_COPY_AND_ASSIGN(WebVrRenderer);
+  DISALLOW_COPY_AND_ASSIGN(TextureCopyRenderer);
 };
 
 }  // namespace vr
 
-#endif  // CHROME_BROWSER_VR_RENDERERS_WEB_VR_RENDERER_H_
+#endif  // CHROME_BROWSER_VR_RENDERERS_TEXTURE_COPY_RENDERER_H_

chrome/browser/vr/ui.cc

@@ -2,9 +2,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <algorithm>
 #include <iomanip>
 #include <queue>
 #include <sstream>
+#include <string>
+#include <utility>
 
 #include "chrome/browser/vr/ui.h"
 
@@ -615,10 +618,6 @@ bool Ui::IsContentVisibleAndOpaque() {
   return GetContentElement()->IsVisibleAndOpaque();
 }
 
-bool Ui::IsContentOverlayTextureEmpty() {
-  return GetContentElement()->GetOverlayTextureEmpty();
-}
-
 void Ui::SetContentUsesQuadLayer(bool uses_quad_layer) {
   return GetContentElement()->SetUsesQuadLayer(uses_quad_layer);
 }
@@ -650,12 +649,24 @@ void Ui::Draw(const vr::RenderInfo& info) {
   ui_renderer_->Draw(info);
 }
 
-void Ui::DrawWebVr(int texture_data_handle,
-                   const float (&uv_transform)[16],
-                   float xborder,
-                   float yborder) {
-  ui_element_renderer_->DrawWebVr(texture_data_handle, uv_transform, xborder,
-                                  yborder);
+void Ui::DrawContent(const float (&uv_transform)[16],
+                     float xborder,
+                     float yborder) {
+  if (!model_->content_texture_id || !model_->content_overlay_texture_id)
+    return;
+  ui_element_renderer_->DrawTextureCopy(model_->content_texture_id,
+                                        uv_transform, xborder, yborder);
+  if (!GetContentElement()->GetOverlayTextureEmpty()) {
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+    ui_element_renderer_->DrawTextureCopy(model_->content_overlay_texture_id,
+                                          uv_transform, xborder, yborder);
+  }
+}
+
+void Ui::DrawWebXr(int texture_data_handle, const float (&uv_transform)[16]) {
+  ui_element_renderer_->DrawTextureCopy(texture_data_handle, uv_transform, 0,
+                                        0);
 }
 
 void Ui::DrawWebVrOverlayForeground(const vr::RenderInfo& info) {

chrome/browser/vr/ui.h

@@ -159,7 +159,6 @@ class VR_EXPORT Ui : public UiInterface {
   gfx::Point3F GetTargetPointForTesting(UserFriendlyElementName element_name,
                                         const gfx::PointF& position) override;
   bool IsContentVisibleAndOpaque() override;
-  bool IsContentOverlayTextureEmpty() override;
   void SetContentUsesQuadLayer(bool uses_quad_buffers) override;
   gfx::Transform GetContentWorldSpaceTransform() override;
 
@@ -167,10 +166,11 @@ class VR_EXPORT Ui : public UiInterface {
   bool SceneHasDirtyTextures() const override;
   void UpdateSceneTextures() override;
   void Draw(const RenderInfo& render_info) override;
-  void DrawWebVr(int texture_data_handle,
-                 const float (&uv_transform)[16],
-                 float xborder,
-                 float yborder) override;
+  void DrawContent(const float (&uv_transform)[16],
+                   float xborder,
+                   float yborder) override;
+  void DrawWebXr(int texture_data_handle,
+                 const float (&uv_transform)[16]) override;
   void DrawWebVrOverlayForeground(const RenderInfo& render_info) override;
   bool HasWebXrOverlayElementsToDraw() override;
 

chrome/browser/vr/ui_element_renderer.cc

@@ -14,9 +14,9 @@
 #include "chrome/browser/vr/renderers/base_renderer.h"
 #include "chrome/browser/vr/renderers/external_textured_quad_renderer.h"
 #include "chrome/browser/vr/renderers/radial_gradient_quad_renderer.h"
+#include "chrome/browser/vr/renderers/texture_copy_renderer.h"
 #include "chrome/browser/vr/renderers/textured_quad_renderer.h"
 #include "chrome/browser/vr/renderers/transparent_quad_renderer.h"
-#include "chrome/browser/vr/renderers/web_vr_renderer.h"
 #include "chrome/browser/vr/vr_gl_util.h"
 #include "ui/gfx/geometry/point3_f.h"
 #include "ui/gfx/geometry/vector3d_f.h"
@@ -43,7 +43,7 @@ void UiElementRenderer::Init() {
   textured_quad_renderer_ = std::make_unique<TexturedQuadRenderer>();
   radial_gradient_quad_renderer_ =
       std::make_unique<RadialGradientQuadRenderer>();
-  webvr_renderer_ = std::make_unique<WebVrRenderer>();
+  texture_copy_renderer_ = std::make_unique<TextureCopyRenderer>();
   reticle_renderer_ = std::make_unique<Reticle::Renderer>();
   laser_renderer_ = std::make_unique<Laser::Renderer>();
   controller_renderer_ = std::make_unique<Controller::Renderer>();
@@ -135,12 +135,13 @@ void UiElementRenderer::DrawReticle(
   reticle_renderer_->Draw(opacity, model_view_proj_matrix);
 }
 
-void UiElementRenderer::DrawWebVr(int texture_data_handle,
-                                  const float (&uv_transform)[16],
-                                  float xborder,
-                                  float yborder) {
-  FlushIfNecessary(webvr_renderer_.get());
-  webvr_renderer_->Draw(texture_data_handle, uv_transform, xborder, yborder);
+void UiElementRenderer::DrawTextureCopy(int texture_data_handle,
+                                        const float (&uv_transform)[16],
+                                        float xborder,
+                                        float yborder) {
+  FlushIfNecessary(texture_copy_renderer_.get());
+  texture_copy_renderer_->Draw(texture_data_handle, uv_transform, xborder,
+                               yborder);
 }
 
 void UiElementRenderer::DrawShadow(const gfx::Transform& model_view_proj_matrix,

chrome/browser/vr/ui_element_renderer.h

@@ -37,9 +37,9 @@ namespace vr {
 class BaseRenderer;
 class ExternalTexturedQuadRenderer;
 class RadialGradientQuadRenderer;
+class TextureCopyRenderer;
 class TexturedQuadRenderer;
 class TransparentQuadRenderer;
-class WebVrRenderer;
 
 // An instance of this class is passed to UiElements by the UiRenderer in order
 // to issue the GL commands for drawing the frame. In some ways, this class is a
@@ -90,10 +90,10 @@ class UiElementRenderer {
       float opacity,
       const gfx::Transform& model_view_proj_matrix);
 
-  VIRTUAL_FOR_MOCKS void DrawWebVr(int texture_data_handle,
-                                   const float (&uv_transform)[16],
-                                   float xborder,
-                                   float yborder);
+  VIRTUAL_FOR_MOCKS void DrawTextureCopy(int texture_data_handle,
+                                         const float (&uv_transform)[16],
+                                         float xborder,
+                                         float yborder);
 
   VIRTUAL_FOR_MOCKS void DrawShadow(
       const gfx::Transform& model_view_proj_matrix,
@@ -138,7 +138,7 @@ class UiElementRenderer {
   std::unique_ptr<TransparentQuadRenderer> transparent_quad_renderer_;
   std::unique_ptr<TexturedQuadRenderer> textured_quad_renderer_;
   std::unique_ptr<RadialGradientQuadRenderer> radial_gradient_quad_renderer_;
-  std::unique_ptr<WebVrRenderer> webvr_renderer_;
+  std::unique_ptr<TextureCopyRenderer> texture_copy_renderer_;
   std::unique_ptr<Reticle::Renderer> reticle_renderer_;
   std::unique_ptr<Laser::Renderer> laser_renderer_;
   std::unique_ptr<Controller::Renderer> controller_renderer_;

chrome/browser/vr/ui_interface.h

@@ -86,17 +86,17 @@ class UiInterface : public BrowserUiInterface, public KeyboardUiInterface {
       UserFriendlyElementName element_name,
       const gfx::PointF& position) = 0;
   virtual bool IsContentVisibleAndOpaque() = 0;
-  virtual bool IsContentOverlayTextureEmpty() = 0;
   virtual void SetContentUsesQuadLayer(bool uses_quad_buffers) = 0;
   virtual gfx::Transform GetContentWorldSpaceTransform() = 0;
   virtual bool OnBeginFrame(const base::TimeTicks&, const gfx::Transform&) = 0;
   virtual bool SceneHasDirtyTextures() const = 0;
   virtual void UpdateSceneTextures() = 0;
   virtual void Draw(const RenderInfo&) = 0;
-  virtual void DrawWebVr(int texture_data_handle,
-                         const float (&uv_transform)[16],
-                         float xborder,
-                         float yborder) = 0;
+  virtual void DrawContent(const float (&uv_transform)[16],
+                           float xborder,
+                           float yborder) = 0;
+  virtual void DrawWebXr(int texture_data_handle,
+                         const float (&uv_transform)[16]) = 0;
   virtual void DrawWebVrOverlayForeground(const RenderInfo&) = 0;
   virtual bool HasWebXrOverlayElementsToDraw() = 0;
   virtual void HandleInput(base::TimeTicks current_time,