Re-land^2 WebVR compositor bypass via BrowserMain context + mailbox

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 <android/native_window_jni.h>
 
 #include <string>
 #include <utility>
@@ skipping 18 matching lines @@
 #include "chrome/browser/android/vr_shell/vr_web_contents_observer.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_features.h"
 #include "content/public/common/referrer.h"
 #include "device/vr/android/gvr/gvr_device.h"
 #include "device/vr/android/gvr/gvr_device_provider.h"
+#include "gpu/command_buffer/common/mailbox.h"
 #include "jni/VrShellImpl_jni.h"
 #include "third_party/WebKit/public/platform/WebInputEvent.h"
 #include "ui/android/view_android.h"
 #include "ui/android/window_android.h"
 #include "ui/base/page_transition_types.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/gfx/transform.h"
 #include "ui/gfx/transform_util.h"
 
 using base::android::JavaParamRef;
 using base::android::JavaRef;
 
 namespace vr_shell {
 
 namespace {
 vr_shell::VrShell* g_instance;
 
 static const char kVrShellUIURL[] = "chrome://vr-shell-ui";
 
+// Default downscale factor for computing the recommended WebVR
+// renderWidth/Height from the 1:1 pixel mapped size. Using a rather
+// aggressive downscale due to the high overhead of copying pixels
+// twice before handing off to GVR. For comparison, the polyfill
+// uses approximately 0.55 on a Pixel XL.
+static constexpr float kWebVrRecommendedResolutionScale = 0.5;
+
 void SetIsInVR(content::WebContents* contents, bool is_in_vr) {
   if (contents && contents->GetRenderWidgetHostView())
     contents->GetRenderWidgetHostView()->SetIsInVR(is_in_vr);
 }
 
 }  // namespace
 
 VrShell::VrShell(JNIEnv* env,
                  jobject obj,
                  ui::WindowAndroid* content_window,
@@ skipping 94 matching lines @@
   ui_contents_->GetController().LoadURL(
       url, content::Referrer(),
       ui::PageTransition::PAGE_TRANSITION_AUTO_TOPLEVEL, std::string(""));
 }
 
 bool RegisterVrShell(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 VrShell::~VrShell() {
+  delegate_provider_->RemoveDelegate();
   {
     // The GvrLayout is, and must always be, used only on the UI thread, and the
     // GvrApi used for rendering should only be used from the GL thread as it's
     // not thread safe. However, the GvrLayout owns the GvrApi instance, and
     // when it gets shut down it deletes the GvrApi instance with it. Therefore,
     // we need to block shutting down the GvrLayout on stopping our GL thread
     // from using the GvrApi instance.
     // base::Thread::Stop, which is called when destroying the thread, asserts
     // that IO is allowed to prevent jank, but there shouldn't be any concerns
     // regarding jank in this case, because we're switching from 3D to 2D,
     // adding/removing a bunch of Java views, and probably changing device
     // orientation here.
     base::ThreadRestrictions::ScopedAllowIO allow_io;
     gl_thread_.reset();
   }
-  delegate_provider_->RemoveDelegate();
   g_instance = nullptr;
 }
 
 void VrShell::PostToGlThreadWhenReady(const base::Closure& task) {
   // TODO(mthiesse): Remove this blocking wait. Queue up events if thread isn't
   // finished starting?
   gl_thread_->WaitUntilThreadStarted();
   gl_thread_->task_runner()->PostTask(FROM_HERE, task);
 }
 
@@ skipping 65 matching lines @@
 }
 
 void VrShell::SetWebVrMode(JNIEnv* env,
                            const base::android::JavaParamRef<jobject>& obj,
                            bool enabled) {
   webvr_mode_ = enabled;
   if (metrics_helper_)
     metrics_helper_->SetWebVREnabled(enabled);
   PostToGlThreadWhenReady(base::Bind(&VrShellGl::SetWebVrMode,
                                      gl_thread_->GetVrShellGl(), enabled));
+
   html_interface_->SetMode(enabled ? UiInterface::Mode::WEB_VR
                                    : UiInterface::Mode::STANDARD);
 }
 
 void VrShell::OnLoadProgressChanged(JNIEnv* env,
                                     const JavaParamRef<jobject>& obj,
                                     double progress) {
   html_interface_->SetLoadProgress(progress);
 }
 
@@ skipping 33 matching lines @@
                            jboolean incognito,
                            jint id) {
   html_interface_->RemoveTab(incognito, id);
 }
 
 void VrShell::SetWebVRSecureOrigin(bool secure_origin) {
   // TODO(cjgrant): Align this state with the logic that drives the omnibox.
   html_interface_->SetWebVRSecureOrigin(secure_origin);
 }
 
-void VrShell::SubmitWebVRFrame() {}
+void VrShell::SubmitWebVRFrame(int16_t frame_index,
+                               const gpu::MailboxHolder& mailbox) {
+  TRACE_EVENT1("gpu", "SubmitWebVRFrame", "frame", frame_index);
+
+  PostToGlThreadWhenReady(base::Bind(&VrShellGl::SubmitWebVRFrame,
+                                     gl_thread_->GetVrShellGl(), frame_index,
+                                     mailbox));
+}
 
 void VrShell::UpdateWebVRTextureBounds(int16_t frame_index,
                                        const gvr::Rectf& left_bounds,
-                                       const gvr::Rectf& right_bounds) {
+                                       const gvr::Rectf& right_bounds,
+                                       const gvr::Sizei& source_size) {
   PostToGlThreadWhenReady(base::Bind(&VrShellGl::UpdateWebVRTextureBounds,
                                      gl_thread_->GetVrShellGl(), frame_index,
-                                     left_bounds, right_bounds));
+                                     left_bounds, right_bounds, source_size));
 }
 
 bool VrShell::SupportsPresentation() {
   return true;
 }
 
 void VrShell::ResetPose() {
   gl_thread_->task_runner()->PostTask(
       FROM_HERE, base::Bind(&VrShellGl::ResetPose, gl_thread_->GetVrShellGl()));
 }
@@ skipping 33 matching lines @@
 }
 
 void VrShell::ContentSurfaceChanged(jobject surface) {
   content_surface_ = surface;
   content_compositor_->SurfaceChanged(surface);
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_VrShellImpl_contentSurfaceChanged(env, j_vr_shell_.obj());
 }
 
 void VrShell::GvrDelegateReady() {
+  PostToGlThreadWhenReady(base::Bind(
+      &VrShellGl::SetSubmitClient, gl_thread_->GetVrShellGl(),
+      base::Passed(
+          delegate_provider_->TakeSubmitFrameClient().PassInterface())));
   delegate_provider_->SetDelegate(this, gvr_api_);
 }
 
 void VrShell::AppButtonPressed() {
   if (vr_shell_enabled_)
     html_interface_->HandleAppButtonClicked();
 }
 
 void VrShell::ContentPhysicalBoundsChanged(JNIEnv* env,
                                            const JavaParamRef<jobject>& object,
@@ skipping 194 matching lines @@
 
 void VrShell::ProcessContentGesture(
     std::unique_ptr<blink::WebInputEvent> event) {
   if (content_input_manager_) {
     content_input_manager_->ProcessUpdatedGesture(std::move(event));
   } else if (android_ui_gesture_target_) {
     android_ui_gesture_target_->DispatchWebInputEvent(std::move(event));
   }
 }
 
+/* static */
 device::mojom::VRPosePtr VrShell::VRPosePtrFromGvrPose(gvr::Mat4f head_mat) {
   device::mojom::VRPosePtr pose = device::mojom::VRPose::New();
 
   pose->orientation.emplace(4);
 
   gfx::Transform inv_transform(
       head_mat.m[0][0], head_mat.m[0][1], head_mat.m[0][2], head_mat.m[0][3],
       head_mat.m[1][0], head_mat.m[1][1], head_mat.m[1][2], head_mat.m[1][3],
       head_mat.m[2][0], head_mat.m[2][1], head_mat.m[2][2], head_mat.m[2][3],
       head_mat.m[3][0], head_mat.m[3][1], head_mat.m[3][2], head_mat.m[3][3]);
@@ skipping 10 matching lines @@
 
     pose->position.emplace(3);
     pose->position.value()[0] = decomposed_transform.translate[0];
     pose->position.value()[1] = decomposed_transform.translate[1];
     pose->position.value()[2] = decomposed_transform.translate[2];
   }
 
   return pose;
 }
 
+/* static */
+gvr::Sizei VrShell::GetRecommendedWebVrSize(gvr::GvrApi* gvr_api) {
+  // Pick a reasonable default size for the WebVR transfer surface
+  // based on a downscaled 1:1 render resolution. This size will also
+  // be reported to the client via CreateVRDisplayInfo as the
+  // client-recommended renderWidth/renderHeight and for the GVR
+  // framebuffer. If the client chooses a different size or resizes it
+  // while presenting, we'll resize the transfer surface and GVR
+  // framebuffer to match.
+  gvr::Sizei render_target_size =
+      gvr_api->GetMaximumEffectiveRenderTargetSize();
+  gvr::Sizei webvr_size = {static_cast<int>(render_target_size.width *
+                                            kWebVrRecommendedResolutionScale),
+                           static_cast<int>(render_target_size.height *
+                                            kWebVrRecommendedResolutionScale)};
+  // Ensure that the width is an even number so that the eyes each
+  // get the same size, the recommended renderWidth is per eye
+  // and the client will use the sum of the left and right width.
+  //
+  // TODO(klausw,crbug.com/699350): should we round the recommended
+  // size to a multiple of 2^N pixels to be friendlier to the GPU? The
+  // exact size doesn't matter, and it might be more efficient.
+  webvr_size.width &= ~1;
+
+  return webvr_size;
+}
+
+/* static */
 device::mojom::VRDisplayInfoPtr VrShell::CreateVRDisplayInfo(
     gvr::GvrApi* gvr_api,
-    gvr::Sizei compositor_size,
+    gvr::Sizei recommended_size,
     uint32_t device_id) {
   TRACE_EVENT0("input", "GvrDevice::GetVRDevice");
 
   device::mojom::VRDisplayInfoPtr device = device::mojom::VRDisplayInfo::New();
 
   device->index = device_id;
 
   device->capabilities = device::mojom::VRDisplayCapabilities::New();
   device->capabilities->hasOrientation = true;
   device->capabilities->hasPosition = false;
   device->capabilities->hasExternalDisplay = false;
   device->capabilities->canPresent = true;
 
   std::string vendor = gvr_api->GetViewerVendor();
   std::string model = gvr_api->GetViewerModel();
   device->displayName = vendor + " " + model;
 
   gvr::BufferViewportList gvr_buffer_viewports =
       gvr_api->CreateEmptyBufferViewportList();
   gvr_buffer_viewports.SetToRecommendedBufferViewports();
 
   device->leftEye = device::mojom::VREyeParameters::New();
   device->rightEye = device::mojom::VREyeParameters::New();
   for (auto eye : {GVR_LEFT_EYE, GVR_RIGHT_EYE}) {
     device::mojom::VREyeParametersPtr& eye_params =
         (eye == GVR_LEFT_EYE) ? device->leftEye : device->rightEye;
     eye_params->fieldOfView = device::mojom::VRFieldOfView::New();
     eye_params->offset.resize(3);
-    eye_params->renderWidth = compositor_size.width / 2;
-    eye_params->renderHeight = compositor_size.height;
+    eye_params->renderWidth = recommended_size.width / 2;
+    eye_params->renderHeight = recommended_size.height;
 
     gvr::BufferViewport eye_viewport = gvr_api->CreateBufferViewport();
     gvr_buffer_viewports.GetBufferViewport(eye, &eye_viewport);
     gvr::Rectf eye_fov = eye_viewport.GetSourceFov();
     eye_params->fieldOfView->upDegrees = eye_fov.top;
     eye_params->fieldOfView->downDegrees = eye_fov.bottom;
     eye_params->fieldOfView->leftDegrees = eye_fov.left;
     eye_params->fieldOfView->rightDegrees = eye_fov.right;
 
     gvr::Mat4f eye_mat = gvr_api->GetEyeFromHeadMatrix(eye);
@@ skipping 20 matching lines @@
            jboolean reprojected_rendering) {
   return reinterpret_cast<intptr_t>(new VrShell(
       env, obj, reinterpret_cast<ui::WindowAndroid*>(content_window_android),
       content::WebContents::FromJavaWebContents(ui_web_contents),
       reinterpret_cast<ui::WindowAndroid*>(ui_window_android), for_web_vr,
       VrShellDelegate::GetNativeVrShellDelegate(env, delegate),
       reinterpret_cast<gvr_context*>(gvr_api), reprojected_rendering));
 }
 
 }  // namespace vr_shell