VR Shell Experimental work master

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 "chrome/browser/android/vr_shell/ui_scene.h"
 #include "chrome/browser/android/vr_shell/vr_compositor.h"
 #include "chrome/browser/android/vr_shell/vr_controller.h"
+#include "chrome/browser/android/vr_shell/vr_gesture.h"
 #include "chrome/browser/android/vr_shell/vr_gl_util.h"
 #include "chrome/browser/android/vr_shell/vr_input_manager.h"
 #include "chrome/browser/android/vr_shell/vr_math.h"
 #include "chrome/browser/android/vr_shell/vr_shell_delegate.h"
 #include "chrome/browser/android/vr_shell/vr_shell_renderer.h"
 #include "content/public/browser/android/content_view_core.h"
 #include "content/public/browser/navigation_controller.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 "content/public/common/screen_info.h"
 #include "jni/VrShell_jni.h"
+#include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/android/view_android.h"
 #include "ui/android/window_android.h"
 #include "ui/base/page_transition_types.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/init/gl_factory.h"
 
 using base::android::JavaParamRef;
 
 namespace {
 // Constant taken from treasure_hunt demo.
@@ skipping 113 matching lines @@
   ui_compositor_.reset(new VrCompositor(ui_window, true));
 
   float screen_width = kScreenWidthRatio * desktop_height_;
   float screen_height = kScreenHeightRatio * desktop_height_;
   std::unique_ptr<ContentRectangle> rect(new ContentRectangle());
   rect->id = kBrowserUiElementId;
   rect->size = {screen_width, screen_height, 1.0f};
   rect->translation = kDesktopPositionDefault;
   scene_.AddUiElement(rect);
 
-  desktop_plane_ = scene_.GetUiElementById(kBrowserUiElementId);
-
   LoadUIContent();
 }
 
 void VrShell::UpdateCompositorLayers(JNIEnv* env,
                                      const JavaParamRef<jobject>& obj) {
   content_compositor_->SetLayer(content_cvc_);
   ui_compositor_->SetLayer(ui_cvc_);
 }
 
 void VrShell::Destroy(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   delete this;
 }
 
 void VrShell::LoadUIContent() {
   GURL url(kVrShellUIURL);
   ui_cvc_->GetWebContents()->GetController().LoadURL(
       url, content::Referrer(),
       ui::PageTransition::PAGE_TRANSITION_AUTO_TOPLEVEL, std::string(""));
 }
 
 bool RegisterVrShell(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 VrShell::~VrShell() {
+  DCHECK(g_instance == this);
   g_instance = nullptr;
   gl::init::ClearGLBindings();
 }
 
 void VrShell::SetDelegate(JNIEnv* env,
     const base::android::JavaParamRef<jobject>& obj,
     const base::android::JavaParamRef<jobject>& delegate) {
   delegate_ = VrShellDelegate::getNativeDelegate(env, delegate);
 }
 
@@ skipping 52 matching lines @@
     controller_quat_ = GetRotationFromZAxis(forward_vector);
   } else {
     controller_quat_ = controller_->Orientation();
   }
 
   gvr::Mat4f mat = QuatToMatrix(controller_quat_);
   gvr::Vec3f forward = MatrixVectorMul(mat, kNeutralPose);
   gvr::Vec3f origin = kHandPosition;
 
   target_element_ = nullptr;
-  float distance = scene_.GetUiElementById(kBrowserUiElementId)
-      ->GetRayDistance(origin, forward);
+
+  ContentRectangle* content_plane =
+      scene_.GetUiElementById(kBrowserUiElementId);
+
+  float distance = content_plane->GetRayDistance(origin, forward);
 
   // If we place the reticle based on elements intersecting the controller beam,
   // we can end up with the reticle hiding behind elements, or jumping laterally
   // in the field of view. This is physically correct, but hard to use. For
   // usability, do the following instead:
   //
   // - Project the controller laser onto an outer surface, which is the
   //   closer of the desktop plane, or a distance-limiting sphere.
   // - Create a vector between the eyes and the outer surface point.
   // - If any UI elements intersect this vector, choose the closest to the eyes,
   //   and place the reticle at the intersection point.
 
   // Find distance to a corner of the content quad, and limit the cursor
   // distance to a multiple of that distance. This lets us keep the reticle on
   // the content plane near the content window, and on the surface of a sphere
   // in other directions. Note that this approach uses distance from controller,
   // rather than eye, for simplicity. This will make the sphere slightly
   // off-center.
   gvr::Vec3f corner = {0.5f, 0.5f, 0.0f};
-  corner = MatrixVectorMul(desktop_plane_->transform.to_world, corner);
+  corner = MatrixVectorMul(content_plane->transform.to_world, corner);
   float max_distance = Distance(origin, corner) * kReticleDistanceMultiplier;
   if (distance > max_distance || distance <= 0.0f) {
     distance = max_distance;
   }
   target_point_ = GetRayPoint(origin, forward, distance);
   gvr::Vec3f eye_to_target = target_point_;
   NormalizeVector(eye_to_target);
 
   // Determine which UI element (if any) intersects the line between the eyes
   // and the controller target position.
@@ skipping 505 matching lines @@
       content::WebContents::FromJavaWebContents(content_web_contents));
   content::ContentViewCore* ui_core = content::ContentViewCore::FromWebContents(
       content::WebContents::FromJavaWebContents(ui_web_contents));
   return reinterpret_cast<intptr_t>(new VrShell(
       env, obj, c_core,
       reinterpret_cast<ui::WindowAndroid*>(content_window_android), ui_core,
       reinterpret_cast<ui::WindowAndroid*>(ui_window_android)));
 }
 
 }  // namespace vr_shell