Draw WebVR security overlay with a non-reprojected viewport

chrome/browser/android/vr_shell/vr_shell.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.h"
 
 #include "base/metrics/histogram_macros.h"
 #include "chrome/browser/android/vr_shell/ui_elements.h"
 #include "chrome/browser/android/vr_shell/ui_scene.h"
 #include "chrome/browser/android/vr_shell/vr_compositor.h"
@@ skipping 64 matching lines @@
 // Positions and sizes of statically placed UI elements in the UI texture.
 // TODO(klausw): replace the hardcoded positions with JS position/offset
 // retrieval once the infrastructure for that is hooked up.
 //
 // UI is designed with 1 pixel = 1mm at 1m distance. It's rescaled to
 // maintain the same angular resolution if placed closer or further.
 // The warning overlays should be fairly close since they cut holes
 // into geometry (they ignore the Z buffer), leading to odd effects
 // if they are far away.
 static constexpr vr_shell::Recti kWebVrWarningTransientRect = {
-  0, 128, 512, 256};
+  0, 128, 512, 250};
 static constexpr vr_shell::Recti kWebVrWarningPermanentRect = {0, 0, 512, 128};
 static constexpr float kWebVrWarningDistance = 0.7f;  // meters
 static constexpr float kWebVrWarningPermanentAngle = 16.3f;  // degrees up
 // How long the transient warning needs to be displayed.
 static constexpr int64_t kWebVrWarningSeconds = 30;
 
+static constexpr int kFramePrimaryBuffer = 0;
+static constexpr int kFrameOverlayBuffer = 1;

[klausw, 2016/10/21 18:32:42]

rename to kFrameHeadLockedBuffer ?

+
 vr_shell::VrShell* g_instance;
 
 static const char kVrShellUIURL[] = "chrome://vr-shell-ui";
 
 float Distance(const gvr::Vec3f& vec1, const gvr::Vec3f& vec2) {
   float xdiff = (vec1.x - vec2.x);
   float ydiff = (vec1.y - vec2.y);
   float zdiff = (vec1.z - vec2.z);
   float scale = xdiff * xdiff + ydiff * ydiff + zdiff * zdiff;
   return std::sqrt(scale);
@@ skipping 136 matching lines @@
   CHECK(gl::GetGLImplementation() != gl::kGLImplementationNone ||
         gl::init::InitializeGLOneOff());
 
   content_texture_id_ = content_texture_handle;
   ui_texture_id_ = ui_texture_handle;
 
   gvr_api_->InitializeGl();
   std::vector<gvr::BufferSpec> specs;
   specs.push_back(gvr_api_->CreateBufferSpec());
   render_size_ = specs[0].GetSize();
+
+  // For WebVR content
+  specs.push_back(gvr_api_->CreateBufferSpec());
+
   swap_chain_.reset(new gvr::SwapChain(gvr_api_->CreateSwapChain(specs)));
 
   vr_shell_renderer_.reset(new VrShellRenderer());
   buffer_viewport_list_.reset(
       new gvr::BufferViewportList(gvr_api_->CreateEmptyBufferViewportList()));
+  buffer_viewport_list_->SetToRecommendedBufferViewports();
+
   buffer_viewport_.reset(
       new gvr::BufferViewport(gvr_api_->CreateBufferViewport()));
+
+  overlay_left_viewport_.reset(

[bshe, 2016/10/21 19:00:04]

nit: if you rename the above constexpr to HeadLocked, rename this overlay to
head_lock too.

+      new gvr::BufferViewport(gvr_api_->CreateBufferViewport()));
+  buffer_viewport_list_->GetBufferViewport(GVR_LEFT_EYE,
+                                           overlay_left_viewport_.get());
+  overlay_left_viewport_->SetSourceBufferIndex(kFrameOverlayBuffer);
+  overlay_left_viewport_->SetReprojection(GVR_REPROJECTION_NONE);
+
+  overlay_right_viewport_.reset(
+      new gvr::BufferViewport(gvr_api_->CreateBufferViewport()));
+  buffer_viewport_list_->GetBufferViewport(GVR_RIGHT_EYE,
+                                           overlay_right_viewport_.get());
+  overlay_right_viewport_->SetSourceBufferIndex(kFrameOverlayBuffer);
+  overlay_right_viewport_->SetReprojection(GVR_REPROJECTION_NONE);
 }
 
 void VrShell::UpdateController(const gvr::Vec3f& forward_vector) {
   controller_->UpdateState();
   std::unique_ptr<VrGesture> gesture = controller_->DetectGesture();
 
   // TODO(asimjour) for now, scroll is sent to the main content.
   if (gesture->type == WebInputEvent::GestureScrollBegin ||
       gesture->type == WebInputEvent::GestureScrollUpdate ||
       gesture->type == WebInputEvent::GestureScrollEnd) {
@@ skipping 144 matching lines @@
   gvr::Vec3f position = GetTranslation(head_pose);
   if (position.x == 0.0f && position.y == 0.0f && position.z == 0.0f) {
     // This appears to be a 3DOF pose without a neck model. Add one.
     // The head pose has redundant data. Assume we're only using the
     // object_from_reference_matrix, we're not updating position_external.
     // TODO: Not sure what object_from_reference_matrix is. The new api removed
     // it. For now, removing it seems working fine.
     gvr_api_->ApplyNeckModel(head_pose, 1.0f);
   }
 
-  // Bind back to the default framebuffer.
-  frame.BindBuffer(0);
+  // Bind the primary framebuffer.
+  frame.BindBuffer(kFramePrimaryBuffer);
 
   if (webvr_mode_) {
     DrawWebVr();
-    if (!webvr_secure_origin_) {
+    // Wait for the DOM contents to be loaded before rendering to avoid drawing
+    // white rectangles with no content.
+    if (!webvr_secure_origin_ && IsUiTextureReady()) {
+      size_t last_viewport = buffer_viewport_list_->GetSize();
+      buffer_viewport_list_->SetBufferViewport(last_viewport++,
+          *overlay_left_viewport_);
+      buffer_viewport_list_->SetBufferViewport(last_viewport++,
+          *overlay_right_viewport_);
+
+      // Bind the non-reprojected overlay framebuffer.
+      frame.BindBuffer(kFrameOverlayBuffer);
       DrawWebVrOverlay(target_time.monotonic_system_time_nanos);
     }
 
     // When using async reprojection, we need to know which pose was used in
     // the WebVR app for drawing this frame. Due to unknown amounts of
     // buffering in the compositor and SurfaceTexture, we read the pose number
     // from a corner pixel. There's no point in doing this for legacy
     // distortion rendering since that doesn't need a pose, and reading back
     // pixels is an expensive operation. TODO(klausw): stop doing this once we
     // have working no-compositor rendering for WebVR.
@@ skipping 58 matching lines @@
       view_matrix);
 
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
   // TODO(mthiesse): Draw order for transparency.
   DrawUI(render_matrix);
   DrawCursor(render_matrix);
 }
 
 bool VrShell::IsUiTextureReady() {
-  return ui_tex_width_ > 0 && ui_tex_height_ > 0;
+  return ui_tex_width_ > 0 && ui_tex_height_ > 0 && dom_contents_loaded_;
 }
 
 Rectf VrShell::MakeUiGlCopyRect(Recti pixel_rect) {
   CHECK(IsUiTextureReady());
   return Rectf({
       static_cast<float>(pixel_rect.x) / ui_tex_width_,
       static_cast<float>(pixel_rect.y) / ui_tex_height_,
       static_cast<float>(pixel_rect.width) / ui_tex_width_,
       static_cast<float>(pixel_rect.height) / ui_tex_height_});
 }
@@ skipping 118 matching lines @@
 void VrShell::DrawWebVrOverlay(int64_t present_time_nanos) {
   // Draw WebVR security warning overlays for each eye. This uses the
   // eye-from-head matrices but not the pose, goal is to place the icons in an
   // eye-relative position so that they follow along with head rotations.
 
   gvr::Mat4f left_eye_view_matrix =
       gvr_api_->GetEyeFromHeadMatrix(GVR_LEFT_EYE);
   gvr::Mat4f right_eye_view_matrix =
       gvr_api_->GetEyeFromHeadMatrix(GVR_RIGHT_EYE);
 
+  glClear(GL_COLOR_BUFFER_BIT);
+
   buffer_viewport_list_->GetBufferViewport(GVR_LEFT_EYE,
                                            buffer_viewport_.get());
   DrawWebVrEye(left_eye_view_matrix, *buffer_viewport_, present_time_nanos);
   buffer_viewport_list_->GetBufferViewport(GVR_RIGHT_EYE,
                                            buffer_viewport_.get());
   DrawWebVrEye(right_eye_view_matrix, *buffer_viewport_, present_time_nanos);
 }
 
 void VrShell::DrawWebVrEye(const gvr::Mat4f& view_matrix,
                            const gvr::BufferViewport& params,
@@ skipping 90 matching lines @@
 void VrShell::OnDomContentsLoaded() {
   // TODO(mthiesse): Setting the background to transparent after the DOM content
   // has loaded is a hack to work around the background not updating when we set
   // it to transparent unless we perform a very specific sequence of events.
   // First the page background must load as not transparent, then we set the
   // background of the renderer to transparent, then we update the page
   // background to be transparent. This is probably a bug in blink that we
   // should fix.
   ui_contents_->GetRenderWidgetHostView()->SetBackgroundColor(
       SK_ColorTRANSPARENT);
+
+  dom_contents_loaded_ = true;

[klausw, 2016/10/21 17:50:47]

I'm a bit fuzzy about how the life cycle works, does this need to be set back to
false on exiting VR mode, or does that happen implicitly when/if the VrShell
object gets destroyed and recreated? Sounds like the latter.

[cjgrant, 2016/10/21 18:29:02]

See previous comments.  Native state changes (like WebVR mode and secure origin)
will be propagated to the HTML UI, and the HTML UI will trigger the
appearance/disappearance of warnings as it would any other UI element.

 }
 
 void VrShell::SetWebVrMode(JNIEnv* env,
                            const base::android::JavaParamRef<jobject>& obj,
                            bool enabled) {
   webvr_mode_ = enabled;
   if (enabled) {
     int64_t now = gvr::GvrApi::GetTimePointNow().monotonic_system_time_nanos;
     constexpr int64_t seconds_to_nanos = 1000 * 1000 * 1000;
     webvr_warning_end_nanos_ = now + kWebVrWarningSeconds * seconds_to_nanos;
@@ skipping 105 matching lines @@
            const JavaParamRef<jobject>& ui_web_contents,
            jlong ui_window_android) {
   return reinterpret_cast<intptr_t>(new VrShell(
       env, obj, content::WebContents::FromJavaWebContents(content_web_contents),
       reinterpret_cast<ui::WindowAndroid*>(content_window_android),
       content::WebContents::FromJavaWebContents(ui_web_contents),
       reinterpret_cast<ui::WindowAndroid*>(ui_window_android)));
 }
 
 }  // namespace vr_shell