Refactor GvrDelegate ownership into GvrDelegateProvider and fix more threading violations.

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 "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "chrome/browser/android/vr_shell/ui_interface.h"
 #include "chrome/browser/android/vr_shell/vr_compositor.h"
 #include "chrome/browser/android/vr_shell/vr_gl_thread.h"
 #include "chrome/browser/android/vr_shell/vr_input_manager.h"
 #include "chrome/browser/android/vr_shell/vr_shell_delegate.h"
 #include "chrome/browser/android/vr_shell/vr_shell_gl.h"
 #include "chrome/browser/android/vr_shell/vr_usage_monitor.h"
 #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/referrer.h"
+#include "device/vr/android/gvr/gvr_device.h"
 #include "device/vr/android/gvr/gvr_device_provider.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"
@@ skipping 28 matching lines @@
     : WebContentsObserver(ui_contents),
       main_contents_(main_contents),
       content_compositor_(
           base::MakeUnique<VrCompositor>(content_window, false)),
       ui_contents_(ui_contents),
       ui_compositor_(base::MakeUnique<VrCompositor>(ui_window, true)),
       delegate_provider_(delegate),
       metrics_helper_(base::MakeUnique<VrMetricsHelper>(main_contents_)),
       main_thread_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       reprojected_rendering_(reprojected_rendering),
+      gvr_api_(gvr_api),
       weak_ptr_factory_(this) {
   DCHECK(g_instance == nullptr);
   g_instance = this;
   j_vr_shell_.Reset(env, obj);
 
   content_input_manager_ = base::MakeUnique<VrInputManager>(main_contents_);
   ui_input_manager_ = base::MakeUnique<VrInputManager>(ui_contents_);
 
   content_compositor_->SetLayer(main_contents_);
   ui_compositor_->SetLayer(ui_contents_);
@@ skipping 142 matching lines @@
   }
 }
 
 void VrShell::OnLoadProgressChanged(
     JNIEnv* env,
     const base::android::JavaParamRef<jobject>& obj,
     double progress) {
   html_interface_->SetLoadProgress(progress);
 }
 
-void VrShell::SetWebVRRenderSurfaceSize(int width, int height) {
-  // TODO(klausw,crbug.com/655722): Change the GVR render size and set the WebVR
-  // render surface size.
-}
-
-gvr::Sizei VrShell::GetWebVRCompositorSurfaceSize() {
-  const gfx::Size& size = content_compositor_->GetWindowBounds();
-  return {size.width(), size.height()};
-}
-
 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::UpdateWebVRTextureBounds(int16_t frame_index,
                                        const gvr::Rectf& left_bounds,
                                        const gvr::Rectf& right_bounds) {
   PostToGlThreadWhenReady(base::Bind(&VrShellGl::UpdateWebVRTextureBounds,
                                      gl_thread_->GetVrShellGl(), frame_index,
                                      left_bounds, right_bounds));
 }
 
-// TODO(mthiesse): Do not expose GVR API outside of GL thread.
-// It's not thread-safe.
-gvr::GvrApi* VrShell::gvr_api() {
-  if (gl_thread_->GetVrShellGlUnsafe()) {
-    return gl_thread_->GetVrShellGlUnsafe()->gvr_api();
-  }
-  CHECK(false);
-  return nullptr;
+bool VrShell::SupportsPresentation() {
+  return true;
+}
+
+void VrShell::ResetPose() {
+  gl_thread_->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&VrShellGl::ResetPose, gl_thread_->GetVrShellGl()));
+}
+
+void VrShell::CreateVRDisplayInfo(
+    const base::Callback<void(device::mojom::VRDisplayInfoPtr)>& callback,
+    uint32_t device_id) {
+  PostToGlThreadWhenReady(base::Bind(&VrShellGl::CreateVRDisplayInfo,
+                                     gl_thread_->GetVrShellGl(),
+                                     callback, device_id));
 }
 
 void VrShell::SurfacesChanged(jobject content_surface, jobject ui_surface) {
   content_compositor_->SurfaceChanged(content_surface);
   ui_compositor_->SurfaceChanged(ui_surface);
 }
 
 void VrShell::GvrDelegateReady() {
-  delegate_provider_->SetDelegate(this);
+  delegate_provider_->SetDelegate(this, gvr_api_);
 }
 
 void VrShell::AppButtonPressed() {
 #if defined(ENABLE_VR_SHELL)
   html_interface_->SetMenuMode(!html_interface_->GetMenuMode());
 
   // TODO(mthiesse): The page is no longer visible when in menu mode. We
   // should unfocus or otherwise let it know it's hidden.
   if (html_interface_->GetMode() == UiInterface::Mode::WEB_VR) {
     if (delegate_provider_->device_provider()) {
       if (html_interface_->GetMenuMode()) {
-        delegate_provider_->device_provider()->OnDisplayBlur();
+        delegate_provider_->device_provider()->Device()->OnBlur();
       } else {
-        delegate_provider_->device_provider()->OnDisplayFocus();
+        delegate_provider_->device_provider()->Device()->OnFocus();
       }
     }
   }
 #endif
 }
 
 void VrShell::ContentPhysicalBoundsChanged(JNIEnv* env,
                                            const JavaParamRef<jobject>& object,
                                            jint width, jint height,
                                            jfloat dpr) {
@@ skipping 167 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;
 }
 
+device::mojom::VRDisplayInfoPtr VrShell::CreateVRDisplayInfo(
+    gvr::GvrApi* gvr_api, gvr::Sizei compositor_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;
+
+    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);
+    eye_params->offset[0] = -eye_mat.m[0][3];
+    eye_params->offset[1] = -eye_mat.m[1][3];
+    eye_params->offset[2] = -eye_mat.m[2][3];
+  }
+
+  return device;
+}
+
 // ----------------------------------------------------------------------------
 // Native JNI methods
 // ----------------------------------------------------------------------------
 
 jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj,
            const JavaParamRef<jobject>& content_web_contents,
            jlong content_window_android,
            const JavaParamRef<jobject>& ui_web_contents,
            jlong ui_window_android, jboolean for_web_vr,
            const base::android::JavaParamRef<jobject>& delegate,
            jlong gvr_api, jboolean reprojected_rendering) {
   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),
-      for_web_vr, VrShellDelegate::GetNativeDelegate(env, delegate),
+      for_web_vr, VrShellDelegate::GetNativeVrShellDelegate(env, delegate),
       reinterpret_cast<gvr_context*>(gvr_api), reprojected_rendering));
 }
 
 }  // namespace vr_shell