Remove Sync GetPose VRService call, implement VRVSyncProvider

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/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_provider.h"
 #include "jni/VrShellImpl_jni.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";
 
-class GLThread : public base::Thread {
- public:
-  GLThread(const base::WeakPtr<VrShell>& weak_vr_shell,
-           const base::WeakPtr<VrInputManager>& content_input_manager,
-           const base::WeakPtr<VrInputManager>& ui_input_manager,
-           scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner,
-           gvr_context* gvr_api,
-           bool initially_web_vr,
-           bool reprojected_rendering)
-      : base::Thread("VrShellGL"),
-        weak_vr_shell_(weak_vr_shell),
-        content_input_manager_(content_input_manager),
-        ui_input_manager_(ui_input_manager),
-        main_thread_task_runner_(std::move(main_thread_task_runner)),
-        gvr_api_(gvr_api),
-        initially_web_vr_(initially_web_vr),
-        reprojected_rendering_(reprojected_rendering) {}
-
-  ~GLThread() override {
-    Stop();
-  }
-  base::WeakPtr<VrShellGl> GetVrShellGl() { return weak_vr_shell_gl_; }
-  VrShellGl* GetVrShellGlUnsafe() { return vr_shell_gl_.get(); }
-
- protected:
-  void Init() override {
-    vr_shell_gl_.reset(new VrShellGl(std::move(weak_vr_shell_),
-                                     std::move(content_input_manager_),
-                                     std::move(ui_input_manager_),
-                                     std::move(main_thread_task_runner_),
-                                     gvr_api_,
-                                     initially_web_vr_,
-                                     reprojected_rendering_));
-    weak_vr_shell_gl_ = vr_shell_gl_->GetWeakPtr();
-    vr_shell_gl_->Initialize();
-  }
-  void CleanUp() override {
-    vr_shell_gl_.reset();
-  }
-
- private:
-  // Created on GL thread.
-  std::unique_ptr<VrShellGl> vr_shell_gl_;
-  base::WeakPtr<VrShellGl> weak_vr_shell_gl_;
-
-  base::WeakPtr<VrShell> weak_vr_shell_;
-  base::WeakPtr<VrInputManager> content_input_manager_;
-  base::WeakPtr<VrInputManager> ui_input_manager_;
-  scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner_;
-  gvr_context* gvr_api_;
-  bool initially_web_vr_;
-  bool reprojected_rendering_;
-};
-
 }  // namespace
 
 VrShell::VrShell(JNIEnv* env,
                  jobject obj,
                  content::WebContents* main_contents,
                  ui::WindowAndroid* content_window,
                  content::WebContents* ui_contents,
                  ui::WindowAndroid* ui_window,
                  bool for_web_vr,
                  VrShellDelegate* delegate,
                  gvr_context* gvr_api,
                  bool reprojected_rendering)
     : WebContentsObserver(ui_contents),
       main_contents_(main_contents),
       content_compositor_(new VrCompositor(content_window, false)),
       ui_contents_(ui_contents),
       ui_compositor_(new VrCompositor(ui_window, true)),
-      delegate_(delegate),
+      delegate_provider_(delegate),
       metrics_helper_(new VrMetricsHelper(main_contents_)),
       main_thread_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       reprojected_rendering_(reprojected_rendering),
       weak_ptr_factory_(this) {
   DCHECK(g_instance == nullptr);
   g_instance = this;
   j_vr_shell_.Reset(env, obj);
 
   content_input_manager_.reset(new VrInputManager(main_contents_));
   ui_input_manager_.reset(new VrInputManager(ui_contents_));
 
   content_compositor_->SetLayer(main_contents_);
   ui_compositor_->SetLayer(ui_contents_);
 
-  gl_thread_.reset(new GLThread(weak_ptr_factory_.GetWeakPtr(),
-                                content_input_manager_->GetWeakPtr(),
-                                ui_input_manager_->GetWeakPtr(),
-                                main_thread_task_runner_,
-                                gvr_api,
-                                for_web_vr,
-                                reprojected_rendering_));
+  gl_thread_.reset(new VrGLThread(
+      weak_ptr_factory_.GetWeakPtr(), content_input_manager_->GetWeakPtr(),
+      ui_input_manager_->GetWeakPtr(), delegate_provider_->GetWeakPtr(),
+      main_thread_task_runner_, gvr_api,
+      for_web_vr, reprojected_rendering_));
 
   base::Thread::Options options(base::MessageLoop::TYPE_DEFAULT, 0);
   options.priority = base::ThreadPriority::DISPLAY;
   gl_thread_->StartWithOptions(options);
 
   if (for_web_vr)
     metrics_helper_->SetWebVREnabled(true);
   html_interface_.reset(new UiInterface(
       for_web_vr ? UiInterface::Mode::WEB_VR : UiInterface::Mode::STANDARD,
       main_contents_->IsFullscreen()));
@@ skipping 27 matching lines @@
     // 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_->RemoveDelegate();
+  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);
 }
 
 void VrShell::OnTriggerEvent(JNIEnv* env,
                              const JavaParamRef<jobject>& obj) {
-  GLThread* thread = static_cast<GLThread*>(gl_thread_.get());
-  thread->task_runner()->PostTask(FROM_HERE,
-                                  base::Bind(&VrShellGl::OnTriggerEvent,
-                                             thread->GetVrShellGl()));
+  gl_thread_->task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&VrShellGl::OnTriggerEvent, gl_thread_->GetVrShellGl()));
 }
 
 void VrShell::OnPause(JNIEnv* env, const JavaParamRef<jobject>& obj) {
-  GLThread* thread = static_cast<GLThread*>(gl_thread_.get());
-  thread->task_runner()->PostTask(
-      FROM_HERE, base::Bind(&VrShellGl::OnPause, thread->GetVrShellGl()));
+  gl_thread_->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&VrShellGl::OnPause, gl_thread_->GetVrShellGl()));
 
   // exit vr session
   metrics_helper_->SetVRActive(false);
   SetIsInVR(false);
 }
 
 void VrShell::OnResume(JNIEnv* env, const JavaParamRef<jobject>& obj) {
-  GLThread* thread = static_cast<GLThread*>(gl_thread_.get());
-  thread->task_runner()->PostTask(
-      FROM_HERE, base::Bind(&VrShellGl::OnResume, thread->GetVrShellGl()));
+  gl_thread_->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&VrShellGl::OnResume, gl_thread_->GetVrShellGl()));
 
   metrics_helper_->SetVRActive(true);
   SetIsInVR(true);
 }
 
 void VrShell::SetSurface(JNIEnv* env,
                          const JavaParamRef<jobject>& obj,
                          const JavaParamRef<jobject>& surface) {
   CHECK(!reprojected_rendering_);
-  GLThread* thread = static_cast<GLThread*>(gl_thread_.get());
   gfx::AcceleratedWidget window =
       ANativeWindow_fromSurface(base::android::AttachCurrentThread(), surface);
   PostToGlThreadWhenReady(base::Bind(&VrShellGl::InitializeGl,
-                                     thread->GetVrShellGl(),
+                                     gl_thread_->GetVrShellGl(),
                                      base::Unretained(window)));
 }
 
 void VrShell::SetIsInVR(bool is_in_vr) {
   main_contents_->GetRenderWidgetHostView()->SetIsInVR(is_in_vr);
 }
 
 base::WeakPtr<VrShell> VrShell::GetWeakPtr(
     const content::WebContents* web_contents) {
   // Ensure that the WebContents requesting the VrShell instance is the one
   // we created.
   if (g_instance != nullptr && g_instance->ui_contents_ == web_contents)
     return g_instance->weak_ptr_factory_.GetWeakPtr();
   return base::WeakPtr<VrShell>(nullptr);
 }
 
 void VrShell::OnDomContentsLoaded() {
   html_interface_->SetURL(main_contents_->GetVisibleURL());
   html_interface_->SetLoading(main_contents_->IsLoading());
   html_interface_->OnDomContentsLoaded();
 }
 
 void VrShell::SetWebVrMode(JNIEnv* env,
                            const base::android::JavaParamRef<jobject>& obj,
                            bool enabled) {
   metrics_helper_->SetWebVREnabled(enabled);
-  GLThread* thread = static_cast<GLThread*>(gl_thread_.get());
-  PostToGlThreadWhenReady(
-      base::Bind(&VrShellGl::SetWebVrMode, thread->GetVrShellGl(), enabled));
+  PostToGlThreadWhenReady(base::Bind(&VrShellGl::SetWebVrMode,
+                                     gl_thread_->GetVrShellGl(), enabled));
   if (enabled) {
     html_interface_->SetMode(UiInterface::Mode::WEB_VR);
   } else {
     html_interface_->SetMode(UiInterface::Mode::STANDARD);
   }
 }
 
 void VrShell::OnLoadProgressChanged(
     JNIEnv* env,
     const base::android::JavaParamRef<jobject>& obj,
     double progress) {
   html_interface_->SetLoadProgress(progress);
 }
 
-void VrShell::SetGvrPoseForWebVr(const gvr::Mat4f& pose, uint32_t pose_num) {
-  GLThread* thread = static_cast<GLThread*>(gl_thread_.get());
-  if (thread->IsRunning()) {
-    thread->task_runner()->PostTask(
-        FROM_HERE, base::Bind(&VrShellGl::SetGvrPoseForWebVr,
-                              thread->GetVrShellGl(), pose, pose_num));
-  }
-}
-
 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(const gvr::Rectf& left_bounds,
                                        const gvr::Rectf& right_bounds) {
-  GLThread* thread = static_cast<GLThread*>(gl_thread_.get());
   PostToGlThreadWhenReady(base::Bind(&VrShellGl::UpdateWebVRTextureBounds,
-                                     thread->GetVrShellGl(), left_bounds,
+                                     gl_thread_->GetVrShellGl(), 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() {
-  GLThread* thread = static_cast<GLThread*>(gl_thread_.get());
-  if (thread->GetVrShellGlUnsafe()) {
-    return thread->GetVrShellGlUnsafe()->gvr_api();
+  if (gl_thread_->GetVrShellGlUnsafe()) {
+    return gl_thread_->GetVrShellGlUnsafe()->gvr_api();
   }
   CHECK(false);
   return nullptr;
 }
 
 void VrShell::SurfacesChanged(jobject content_surface, jobject ui_surface) {
   content_compositor_->SurfaceChanged(content_surface);
   ui_compositor_->SurfaceChanged(ui_surface);
 }
 
 void VrShell::GvrDelegateReady() {
-  delegate_->SetDelegate(this);
+  delegate_provider_->SetDelegate(this);
 }
 
 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_->device_provider()) {
+    if (delegate_provider_->device_provider()) {
       if (html_interface_->GetMenuMode()) {
-        delegate_->device_provider()->OnDisplayBlur();
+        delegate_provider_->device_provider()->OnDisplayBlur();
       } else {
-        delegate_->device_provider()->OnDisplayFocus();
+        delegate_provider_->device_provider()->OnDisplayFocus();
       }
     }
   }
 #endif
 }
 
 void VrShell::ContentPhysicalBoundsChanged(JNIEnv* env,
                                            const JavaParamRef<jobject>& object,
                                            jint width, jint height,
                                            jfloat dpr) {
   TRACE_EVENT0("gpu", "VrShell::ContentPhysicalBoundsChanged");
-  GLThread* thread = static_cast<GLThread*>(gl_thread_.get());
   PostToGlThreadWhenReady(base::Bind(&VrShellGl::ContentPhysicalBoundsChanged,
-                                     thread->GetVrShellGl(), width, height));
+                                     gl_thread_->GetVrShellGl(), width,
+                                     height));
   content_compositor_->SetWindowBounds(gfx::Size(width, height));
 }
 
 void VrShell::UIPhysicalBoundsChanged(JNIEnv* env,
                                       const JavaParamRef<jobject>& object,
                                       jint width, jint height, jfloat dpr) {
-  GLThread* thread = static_cast<GLThread*>(gl_thread_.get());
   PostToGlThreadWhenReady(base::Bind(&VrShellGl::UIPhysicalBoundsChanged,
-                                     thread->GetVrShellGl(), width, height));
+                                     gl_thread_->GetVrShellGl(), width,
+                                     height));
   ui_compositor_->SetWindowBounds(gfx::Size(width, height));
 }
 
 UiInterface* VrShell::GetUiInterface() {
   return html_interface_.get();
 }
 
 void VrShell::UpdateScene(const base::ListValue* args) {
-  GLThread* thread = static_cast<GLThread*>(gl_thread_.get());
   PostToGlThreadWhenReady(base::Bind(&VrShellGl::UpdateScene,
-                                     thread->GetVrShellGl(),
+                                     gl_thread_->GetVrShellGl(),
                                      base::Passed(args->CreateDeepCopy())));
 }
 
 void VrShell::DoUiAction(const UiAction action) {
   content::NavigationController& controller = main_contents_->GetController();
   switch (action) {
     case HISTORY_BACK:
       if (main_contents_->IsFullscreen()) {
         main_contents_->ExitFullscreen(false);
       } else if (controller.CanGoBack()) {
@@ skipping 24 matching lines @@
 }
 
 void VrShell::RenderViewHostChanged(content::RenderViewHost* old_host,
                                     content::RenderViewHost* new_host) {
   new_host->GetWidget()->GetView()->SetBackgroundColor(SK_ColorTRANSPARENT);
 }
 
 void VrShell::MainFrameWasResized(bool width_changed) {
   display::Display display = display::Screen::GetScreen()
       ->GetDisplayNearestWindow(ui_contents_->GetNativeView());
-  GLThread* thread = static_cast<GLThread*>(gl_thread_.get());
   PostToGlThreadWhenReady(
-      base::Bind(&VrShellGl::UIBoundsChanged, thread->GetVrShellGl(),
+      base::Bind(&VrShellGl::UIBoundsChanged, gl_thread_->GetVrShellGl(),
                  display.size().width(), display.size().height()));
 }
 
 void VrShell::ContentFrameWasResized(bool width_changed) {
   display::Display display = display::Screen::GetScreen()
       ->GetDisplayNearestWindow(main_contents_->GetNativeView());
-  GLThread* thread = static_cast<GLThread*>(gl_thread_.get());
   PostToGlThreadWhenReady(
-      base::Bind(&VrShellGl::ContentBoundsChanged, thread->GetVrShellGl(),
+      base::Bind(&VrShellGl::ContentBoundsChanged, gl_thread_->GetVrShellGl(),
                  display.size().width(), display.size().height()));
 }
 
 void VrShell::WebContentsDestroyed() {
   ui_input_manager_.reset();
   ui_contents_ = nullptr;
   // TODO(mthiesse): Handle web contents being destroyed.
   ForceExitVr();
 }
 
 void VrShell::ContentWebContentsDestroyed() {
   content_input_manager_.reset();
   main_contents_ = nullptr;
   // TODO(mthiesse): Handle web contents being destroyed.
   ForceExitVr();
 }
 
 void VrShell::ContentWasHidden() {
   // Ensure we don't continue sending input to it.
   content_input_manager_.reset();
   // TODO(mthiesse): Handle web contents being hidden.
   ForceExitVr();
 }
 
 void VrShell::ForceExitVr() {
-  delegate_->ForceExitVr();
+  delegate_provider_->ForceExitVr();
+}
+
+void VrShell::OnVRVsyncProviderRequest(
+    device::mojom::VRVSyncProviderRequest request) {
+  PostToGlThreadWhenReady(base::Bind(&VrShellGl::OnRequest,
+                                     gl_thread_->GetVrShellGl(),
+                                     base::Passed(&request)));
+}
+
+void VrShell::UpdateVSyncInterval(long timebase_nanos,
+                                  double interval_seconds) {
+  PostToGlThreadWhenReady(
+      base::Bind(&VrShellGl::UpdateVSyncInterval,
+                 gl_thread_->GetVrShellGl(), timebase_nanos, interval_seconds));
 }
 
 void VrShell::SetContentCssSize(float width, float height, float dpr) {
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_VrShellImpl_setContentCssSize(env, j_vr_shell_.obj(), width, height,
                                      dpr);
 }
 
 void VrShell::SetUiCssSize(float width, float height, float dpr) {
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_VrShellImpl_setUiCssSize(env, j_vr_shell_.obj(), width, height, dpr);
 }
 
+device::mojom::VRPosePtr VrShell::VRPosePtrFromGvrPose(gvr::Mat4f head_mat,
+                                                       uint32_t pose_index) {
+  device::mojom::VRPosePtr pose = device::mojom::VRPose::New();
+
+  pose->timestamp = base::Time::Now().ToJsTime();
+
+  pose->poseIndex = pose_index;
+  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]);
+
+  gfx::Transform transform;
+  if (inv_transform.GetInverse(&transform)) {
+    gfx::DecomposedTransform decomposed_transform;
+    gfx::DecomposeTransform(&decomposed_transform, transform);
+
+    pose->orientation.value()[0] = decomposed_transform.quaternion[0];
+    pose->orientation.value()[1] = decomposed_transform.quaternion[1];
+    pose->orientation.value()[2] = decomposed_transform.quaternion[2];
+    pose->orientation.value()[3] = decomposed_transform.quaternion[3];
+
+    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;
+}
+
 // ----------------------------------------------------------------------------
 // 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),
       reinterpret_cast<gvr_context*>(gvr_api), reprojected_rendering));
 }
 
 }  // namespace vr_shell