Revert "[vr] Enable 2x MSAA"

This reverts commit 9f6b2091.

Reason for revert: The timing of the swap_chain_ destruction appears to be wrong. Reverting this until I can sort it out.

Original change's description:
> [vr] Enable 2x MSAA
> 
> This increases the number of samples used in the primary framebuffer.
> 
> Bug: 752085
> Change-Id: I869ae41943db925aff845b3d1da15e8130b14e45
> Reviewed-on: https://chromium-review.googlesource.com/680374
> Reviewed-by: Michael Thiessen <mthiesse@chromium.org>
> Reviewed-by: Tibor Goldschwendt <tiborg@chromium.org>
> Commit-Queue: Ian Vollick <vollick@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#505811}

TBR=vollick@chromium.org,mthiesse@chromium.org,tiborg@chromium.org

# Not skipping CQ checks because original CL landed > 1 day ago.

Bug: 752085, 771663
Change-Id: I6150abf5840fa81cc9ce135c0746d3fd4f8bca7a
Reviewed-on: https://chromium-review.googlesource.com/702517
Commit-Queue: Ian Vollick <vollick@chromium.org>
Reviewed-by: Tibor Goldschwendt <tiborg@chromium.org>
Reviewed-by: Ian Vollick <vollick@chromium.org>
Cr-Commit-Position: refs/heads/master@{#506807}

chrome/browser/android/vr_shell/vr_shell_gl.cc

@@ -95,9 +95,6 @@ static constexpr int kWebVrInitialFrameTimeoutSeconds = 5;
 
 static constexpr gfx::PointF kOutOfBoundsPoint = {-0.5f, -0.5f};
 
-static constexpr int kNumSamplesPerPixelBrowserUi = 2;
-static constexpr int kNumSamplesPerPixelWebVr = 1;
-
 // Provides the direction the head is looking towards as a 3x1 unit vector.
 gfx::Vector3dF GetForwardVector(const gfx::Transform& head_pose) {
   // Same as multiplying the inverse of the rotation component of the matrix by
@@ -185,7 +182,6 @@ VrShellGl::VrShellGl(GlBrowserInterface* browser_interface,
                      bool reprojected_rendering,
                      bool daydream_support)
     : ui_(base::MakeUnique<vr::Ui>(ui_host_interface, this, ui_initial_state)),
-      web_vr_mode_(ui_initial_state.in_web_vr),
       surfaceless_rendering_(reprojected_rendering),
       daydream_support_(daydream_support),
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
@@ -444,26 +440,24 @@ void VrShellGl::InitializeRenderer() {
   webvr_frame_oustanding_.assign(kPoseRingBufferSize, false);
   webvr_time_js_submit_.assign(kPoseRingBufferSize, base::TimeTicks());
 
+  std::vector<gvr::BufferSpec> specs;
   // For kFramePrimaryBuffer (primary VrShell and WebVR content)
-  specs_.push_back(gvr_api_->CreateBufferSpec());
-  specs_.push_back(gvr_api_->CreateBufferSpec());
+  specs.push_back(gvr_api_->CreateBufferSpec());
+  specs.push_back(gvr_api_->CreateBufferSpec());
 
-  gvr::Sizei render_size_default = specs_[kFramePrimaryBuffer].GetSize();
+  gvr::Sizei render_size_default = specs[kFramePrimaryBuffer].GetSize();
   render_size_default_ = {render_size_default.width,
                           render_size_default.height};
 
-  specs_[kFramePrimaryBuffer].SetSamples(
-      web_vr_mode_ ? kNumSamplesPerPixelWebVr : kNumSamplesPerPixelBrowserUi);
-  specs_[kFrameWebVrBrowserUiBuffer].SetSize(
+  specs[kFrameWebVrBrowserUiBuffer].SetSize(
       {render_size_default.width / kWebVrBrowserUiSizeFactor,
        render_size_default.height / kWebVrBrowserUiSizeFactor});
-  specs_[kFrameWebVrBrowserUiBuffer].SetSamples(2);
   render_size_webvr_ui_ = {
       render_size_default.width / kWebVrBrowserUiSizeFactor,
       render_size_default.height / kWebVrBrowserUiSizeFactor};
 
   swap_chain_ =
-      base::MakeUnique<gvr::SwapChain>(gvr_api_->CreateSwapChain(specs_));
+      base::MakeUnique<gvr::SwapChain>(gvr_api_->CreateSwapChain(specs));
 
   // Allocate a buffer viewport for use in UI drawing. This isn't
   // initialized at this point, it'll be set from other viewport list
@@ -1083,12 +1077,6 @@ void VrShellGl::OnResume() {
 }
 
 void VrShellGl::SetWebVrMode(bool enabled) {
-  if (web_vr_mode_ != enabled) {
-    specs_[kFramePrimaryBuffer].SetSamples(
-        enabled ? kNumSamplesPerPixelWebVr : kNumSamplesPerPixelBrowserUi);
-    swap_chain_ =
-        base::MakeUnique<gvr::SwapChain>(gvr_api_->CreateSwapChain(specs_));
-  }
   web_vr_mode_ = enabled;
 
   if (web_vr_mode_ && submit_client_) {

chrome/browser/android/vr_shell/vr_shell_gl.h

@@ -236,7 +236,7 @@ class VrShellGl : public device::mojom::VRPresentationProvider,
 
   std::unique_ptr<vr::Ui> ui_;
 
-  bool web_vr_mode_ = false;
+  bool web_vr_mode_;
   bool ready_to_draw_ = false;
   bool paused_ = true;
   bool surfaceless_rendering_;
@@ -278,8 +278,6 @@ class VrShellGl : public device::mojom::VRPresentationProvider,
 
   base::CancelableCallback<void()> webvr_frame_timeout_;
 
-  std::vector<gvr::BufferSpec> specs_;
-
   base::WeakPtrFactory<VrShellGl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(VrShellGl);

chrome/browser/vr/ui_renderer.cc

@@ -147,6 +147,8 @@ void UiRenderer::DrawElements(const gfx::Transform& view_proj_matrix,
   if (elements.empty()) {
     return;
   }
+  vr_shell_renderer_->set_surface_texture_size(
+      render_info.surface_texture_size);
   bool drawn_reticle = false;
   for (const auto* element : elements) {
     // If we have no element to draw the reticle on, draw it after the

chrome/browser/vr/vr_shell_renderer.cc

@@ -170,6 +170,28 @@ static const unsigned char kLaserData[] =
     "\xd2\x11\xd8\xd8\xd8\x0d\xcc\xcc\xcc\x0a\xdb\xdb\xdb\x07\xcc\xcc\xcc\x05"
     "\xbf\xbf\xbf\x04\xff\xff\xff\x02\xff\xff\xff\x01";
 
+// This is used to help with antialiasing rounded rects and is a heuristic. We
+// implement antialiasing via a smooth-step in the rrect shader (we smoothly
+// transition from being inside the rrect to being outside of it). We need to
+// compute the size of that step, and the size is related to physical pixels.
+// This function aims to compute the width of the quad in physical pixels for
+// this purpose. This heuristic will produce worse values when the quad is
+// heavily distorted in perspective, but in practice, the error in smooth-step
+// ramp size is not noticeable, even in those cases.
+float ComputePhysicalPixelWidth(const gfx::Transform& model_view_proj_matrix,
+                                float corner_radius,
+                                const gfx::SizeF element_size,
+                                const gfx::Size surface_texture_size) {
+  gfx::Point3F top_left(-0.5, 0.5, 0.0);
+  gfx::Point3F top_right(0.5, 0.5, 0.0);
+  model_view_proj_matrix.TransformPoint(&top_left);
+  model_view_proj_matrix.TransformPoint(&top_right);
+  gfx::Vector3dF top_vector = top_right - top_left;
+  float physical_width = top_vector.Length();
+  physical_width *= corner_radius / element_size.width();
+  return 0.5 * physical_width * surface_texture_size.width();
+}
+
 #define SHADER(Src) "#version 100\n" #Src
 #define OEIE_SHADER(Src) \
   "#version 100\n#extension GL_OES_EGL_image_external : require\n" #Src
@@ -302,6 +324,7 @@ static constexpr char const* kGradientQuadFragmentShader = SHADER(
   precision highp float;
   varying vec2 v_CornerPosition;
   varying vec2 v_Position;
+  uniform float u_CornerScale;
   uniform mediump float u_Opacity;
   uniform vec4 u_CenterColor;
   uniform vec4 u_EdgeColor;
@@ -314,7 +337,9 @@ static constexpr char const* kGradientQuadFragmentShader = SHADER(
     float center_color_weight = 1.0 - edge_color_weight;
     vec4 color = u_CenterColor * center_color_weight + u_EdgeColor *
         edge_color_weight;
-    float mask = 1.0 - step(1.0, length(v_CornerPosition));
+    float mask = smoothstep(1.0 + u_CornerScale,
+        1.0 - u_CornerScale,
+        length(v_CornerPosition));
     gl_FragColor = color * u_Opacity * mask;
   }
 );
@@ -392,13 +417,16 @@ static constexpr char const* kTexturedQuadVertexShader = SHADER(
   "uniform vec4 u_CopyRect;"                                          \
   "varying vec2 v_TexCoordinate;"                                     \
   "varying vec2 v_CornerPosition;"                                    \
+  "uniform float u_CornerScale;"                                      \
   "uniform mediump float u_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);"              \
-    "float mask = 1.0 - step(1.0, length(v_CornerPosition));"         \
+    "float mask = smoothstep(1.0 + u_CornerScale,"                    \
+        "1.0 - u_CornerScale,"                                        \
+        "length(v_CornerPosition));"                                  \
     "gl_FragColor = color * u_Opacity * mask;"                        \
   "}"
 
@@ -539,6 +567,7 @@ TexturedQuadRenderer::TexturedQuadRenderer(const char* vertex_src,
 
   copy_rect_handler_ = glGetUniformLocation(program_handle_, "u_CopyRect");
 
+  corner_scale_handle_ = glGetUniformLocation(program_handle_, "u_CornerScale");
   opacity_handle_ = glGetUniformLocation(program_handle_, "u_Opacity");
   texture_handle_ = glGetUniformLocation(program_handle_, "u_Texture");
 }
@@ -549,6 +578,7 @@ void TexturedQuadRenderer::AddQuad(int texture_data_handle,
                                    const gfx::Transform& model_view_proj_matrix,
                                    const gfx::RectF& copy_rect,
                                    float opacity,
+                                   const gfx::Size& surface_texture_size,
                                    const gfx::SizeF& element_size,
                                    float corner_radius) {
   QuadData quad;
@@ -556,6 +586,7 @@ void TexturedQuadRenderer::AddQuad(int texture_data_handle,
   quad.model_view_proj_matrix = model_view_proj_matrix;
   quad.copy_rect = copy_rect;
   quad.opacity = opacity;
+  quad.surface_texture_size = surface_texture_size;
   quad.element_size = element_size;
   quad.corner_radius = corner_radius;
   quad_queue_.push(quad);
@@ -626,8 +657,13 @@ void TexturedQuadRenderer::Flush() {
       last_corner_radius = quad.corner_radius;
       last_element_size = quad.element_size;
       if (quad.corner_radius == 0.0f) {
+        glUniform1f(corner_scale_handle_, 0.5);
         glUniform2f(corner_offset_handle_, 0.0, 0.0);
       } else {
+        glUniform1f(corner_scale_handle_,
+                    1.0f / ComputePhysicalPixelWidth(
+                               quad.model_view_proj_matrix, quad.corner_radius,
+                               quad.element_size, quad.surface_texture_size));
         glUniform2f(corner_offset_handle_,
                     quad.corner_radius / quad.element_size.width(),
                     quad.corner_radius / quad.element_size.height());
@@ -908,6 +944,7 @@ GradientQuadRenderer::GradientQuadRenderer()
   corner_position_handle_ =
       glGetAttribLocation(program_handle_, "a_CornerPosition");
   offset_scale_handle_ = glGetAttribLocation(program_handle_, "a_OffsetScale");
+  corner_scale_handle_ = glGetUniformLocation(program_handle_, "u_CornerScale");
   opacity_handle_ = glGetUniformLocation(program_handle_, "u_Opacity");
   center_color_handle_ = glGetUniformLocation(program_handle_, "u_CenterColor");
   edge_color_handle_ = glGetUniformLocation(program_handle_, "u_EdgeColor");
@@ -919,6 +956,7 @@ void GradientQuadRenderer::Draw(const gfx::Transform& model_view_proj_matrix,
                                 SkColor edge_color,
                                 SkColor center_color,
                                 float opacity,
+                                const gfx::Size& surface_texture_size,
                                 const gfx::SizeF& element_size,
                                 float corner_radius) {
   glUseProgram(program_handle_);
@@ -947,8 +985,14 @@ void GradientQuadRenderer::Draw(const gfx::Transform& model_view_proj_matrix,
   glEnableVertexAttribArray(corner_position_handle_);
 
   if (corner_radius == 0.0f) {
+    glUniform1f(corner_scale_handle_, 0.5);
     glUniform2f(corner_offset_handle_, 0.0, 0.0);
   } else {
+    glUniform1f(
+        corner_scale_handle_,
+        1.0f / ComputePhysicalPixelWidth(model_view_proj_matrix, corner_radius,
+                                         element_size, surface_texture_size));
+
     glUniform2f(corner_offset_handle_, corner_radius / element_size.width(),
                 corner_radius / element_size.height());
   }
@@ -1066,7 +1110,8 @@ void VrShellRenderer::DrawTexturedQuad(
                                        ? GetExternalTexturedQuadRenderer()
                                        : GetTexturedQuadRenderer();
   renderer->AddQuad(texture_data_handle, model_view_proj_matrix, copy_rect,
-                    opacity, element_size, corner_radius);
+                    opacity, surface_texture_size_, element_size,
+                    corner_radius);
 }
 
 void VrShellRenderer::DrawGradientQuad(
@@ -1077,8 +1122,8 @@ void VrShellRenderer::DrawGradientQuad(
     gfx::SizeF element_size,
     float corner_radius) {
   GetGradientQuadRenderer()->Draw(model_view_proj_matrix, edge_color,
-                                  center_color, opacity, element_size,
-                                  corner_radius);
+                                  center_color, opacity, surface_texture_size_,
+                                  element_size, corner_radius);
 }
 
 void VrShellRenderer::DrawGradientGridQuad(

chrome/browser/vr/vr_shell_renderer.h

@@ -69,6 +69,11 @@ class VrShellRenderer : public vr::UiElementRenderer {
 
   void Flush();
 
+  gfx::Size surface_texture_size() const { return surface_texture_size_; }
+  void set_surface_texture_size(const gfx::Size& surface_texture_size) {
+    surface_texture_size_ = surface_texture_size;
+  }
+
  private:
   void FlushIfNecessary(BaseRenderer* renderer);
 
@@ -84,6 +89,8 @@ class VrShellRenderer : public vr::UiElementRenderer {
   std::unique_ptr<GradientQuadRenderer> gradient_quad_renderer_;
   std::unique_ptr<GradientGridRenderer> gradient_grid_renderer_;
 
+  gfx::Size surface_texture_size_;
+
   DISALLOW_COPY_AND_ASSIGN(VrShellRenderer);
 };
 
@@ -132,6 +139,7 @@ class TexturedQuadRenderer : public BaseRenderer {
                const gfx::Transform& model_view_proj_matrix,
                const gfx::RectF& copy_rect,
                float opacity,
+               const gfx::Size& surface_texture_size,
                const gfx::SizeF& element_size,
                float corner_radius);
 
@@ -148,6 +156,7 @@ class TexturedQuadRenderer : public BaseRenderer {
     gfx::Transform model_view_proj_matrix;
     gfx::RectF copy_rect;
     float opacity;
+    gfx::Size surface_texture_size;
     gfx::SizeF element_size;
     float corner_radius;
   };
@@ -158,6 +167,7 @@ class TexturedQuadRenderer : public BaseRenderer {
   // Uniforms
   GLuint model_view_proj_matrix_handle_;
   GLuint corner_offset_handle_;
+  GLuint corner_scale_handle_;
   GLuint opacity_handle_;
   GLuint texture_handle_;
   GLuint copy_rect_handler_;
@@ -280,6 +290,7 @@ class GradientQuadRenderer : public BaseRenderer {
             SkColor edge_color,
             SkColor center_color,
             float opacity,
+            const gfx::Size& surface_texture_size,
             const gfx::SizeF& element_size,
             float corner_radius);
 
@@ -293,6 +304,7 @@ class GradientQuadRenderer : public BaseRenderer {
   GLuint corner_offset_handle_;
   GLuint corner_position_handle_;
   GLuint offset_scale_handle_;
+  GLuint corner_scale_handle_;
   GLuint opacity_handle_;
   GLuint center_color_handle_;
   GLuint edge_color_handle_;