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"
@@ skipping 14 matching lines @@
 #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";
@@ skipping 216 matching lines @@
   GLThread* thread = static_cast<GLThread*>(gl_thread_.get());
   PostToGlThreadWhenReady(
       base::Bind(&VrShellGl::SetWebVrMode, thread->GetVrShellGl(), enabled));
   if (enabled) {
     html_interface_->SetMode(UiInterface::Mode::WEB_VR);
   } else {
     html_interface_->SetMode(UiInterface::Mode::STANDARD);
   }
 }
 
-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()};
 }
 
@@ skipping 155 matching lines @@
   // 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();
 }
 
+void VrShell::OnVRVsyncProviderRequest(
+    device::mojom::VRVSyncProviderRequest request) {
+  GLThread* thread = static_cast<GLThread*>(gl_thread_.get());
+  PostToGlThreadWhenReady(base::Bind(
+      &VrShellGl::OnRequest, thread->GetVrShellGl(), base::Passed(&request)));
+}
+
+void VrShell::UpdateVSyncInterval(long timebase_nanos,
+                                  double interval_seconds) {
+  GLThread* thread = static_cast<GLThread*>(gl_thread_.get());
+  PostToGlThreadWhenReady(
+      base::Bind(&VrShellGl::UpdateVSyncInterval,
+                 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();
+
+  // Increment pose frame counter always, even if it's a faked pose.
+  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