Implement controller handling in vr_shell.cc

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 <thread>
 
 #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_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 "jni/VrShell_jni.h"
@@ skipping 152 matching lines @@
 }
 
 void VrShell::GvrInit(JNIEnv* env,
                       const JavaParamRef<jobject>& obj,
                       jlong native_gvr_api) {
   gvr_api_ =
       gvr::GvrApi::WrapNonOwned(reinterpret_cast<gvr_context*>(native_gvr_api));
 
   if (delegate_)
     delegate_->OnVrShellReady(this);
+  controller_.reset(
+      new VrController(reinterpret_cast<gvr_context*>(native_gvr_api)));
+  content_input_manager_ = new VrInputManager(content_cvc_->GetWebContents());
+  ui_input_manager_ = new VrInputManager(ui_cvc_->GetWebContents());
 }
 
 void VrShell::InitializeGl(JNIEnv* env,
                            const JavaParamRef<jobject>& obj,
                            jint content_texture_handle,
                            jint ui_texture_handle) {
   CHECK(gl::GetGLImplementation() != gl::kGLImplementationNone ||
         gl::init::InitializeGLOneOff());
 
   content_texture_id_ = content_texture_handle;
   ui_texture_id_ = ui_texture_handle;
 
   gvr_api_->InitializeGl();
   std::vector<gvr::BufferSpec> specs;
   specs.push_back(gvr_api_->CreateBufferSpec());
   render_size_ = specs[0].GetSize();
   swap_chain_.reset(new gvr::SwapChain(gvr_api_->CreateSwapchain(specs)));
 
   vr_shell_renderer_.reset(new VrShellRenderer());
   buffer_viewport_list_.reset(
       new gvr::BufferViewportList(gvr_api_->CreateEmptyBufferViewportList()));
   buffer_viewport_.reset(
       new gvr::BufferViewport(gvr_api_->CreateBufferViewport()));
 }
 
 void VrShell::UpdateController(const gvr::Vec3f& forward_vector) {
-  if (!controller_active_) {
+  controller_->UpdateState();
+  std::unique_ptr<VrGesture> gesture = controller_->DetectGesture();
+
+  // TODO(asimjour) for now, scroll is sent to the main content.
+  if (gesture->type == WebInputEvent::GestureScrollBegin ||
+      gesture->type == WebInputEvent::GestureScrollUpdate ||
+      gesture->type == WebInputEvent::GestureScrollEnd) {
+    content_input_manager_->ProcessUpdatedGesture(*gesture.get());
+  }
+
+  WebInputEvent::Type original_type = gesture->type;
+  if (!controller_->IsConnected()) {
     // No controller detected, set up a gaze cursor that tracks the
     // forward direction.
     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;;
+  target_element_ = nullptr;
   float distance = scene_.GetUiElementById(kBrowserUiElementId)
       ->GetRayDistance(origin, forward);
 
   // 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.
   // TODO(cjgrant): 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);
   float max_distance = Distance(origin, corner) * kReticleDistanceMultiplier;
   if (distance > max_distance || distance <= 0.0f) {
     distance = max_distance;
   }
   target_point_ = GetRayPoint(origin, forward, distance);
 
   // Determine which UI element (if any) the cursor is pointing to.
-  float closest_element = std::numeric_limits<float>::infinity();
+  float closest_element_distance = std::numeric_limits<float>::infinity();
+  int pixel_x = 0;
+  int pixel_y = 0;
+  VrInputManager* input_target = nullptr;
+
   for (std::size_t i = 0; i < scene_.GetUiElements().size(); ++i) {
     const ContentRectangle& plane = *scene_.GetUiElements()[i].get();
+    if (!plane.visible) {
+      continue;
+    }
     float distance_to_plane = plane.GetRayDistance(origin, forward);
     gvr::Vec3f plane_intersection_point =
         GetRayPoint(origin, forward, distance_to_plane);
 
     gvr::Vec3f rect_2d_point =
         MatrixVectorMul(plane.transform.from_world, plane_intersection_point);
     float x = rect_2d_point.x + 0.5f;
     float y = 0.5f - rect_2d_point.y;
-    if (distance_to_plane > 0 && distance_to_plane < closest_element) {
+    if (distance_to_plane > 0 && distance_to_plane < closest_element_distance) {
       bool is_inside = x >= 0.0f && x < 1.0f && y >= 0.0f && y < 1.0f;
       if (is_inside) {
-        closest_element = distance_to_plane;
+        closest_element_distance = distance_to_plane;
+        pixel_x =
+            static_cast<int>(plane.copy_rect.width * x + plane.copy_rect.x);
+        pixel_y =
+            static_cast<int>(plane.copy_rect.height * y + plane.copy_rect.y);
+
         target_point_ = plane_intersection_point;
         target_element_ = &plane;
+        input_target = (plane.id == kBrowserUiElementId)
+            ? content_input_manager_.get() : ui_input_manager_.get();
       }
     }
   }
+  bool new_target = input_target != current_input_target_;
+  if (new_target && current_input_target_ != nullptr) {
+    // Send a move event indicating that the pointer moved off of an element.
+    gesture->type = WebInputEvent::MouseLeave;
+    gesture->details.move.delta.x = 0;
+    gesture->details.move.delta.y = 0;
+    current_input_target_->ProcessUpdatedGesture(*gesture.get());
+  }
+  current_input_target_ = input_target;
+  if (current_input_target_ == nullptr) {
+    return;
+  }
+
+  gesture->type = new_target ? WebInputEvent::MouseEnter
+                             : WebInputEvent::MouseMove;
+  gesture->details.move.delta.x = pixel_x;
+  gesture->details.move.delta.y = pixel_y;
+  current_input_target_->ProcessUpdatedGesture(*gesture.get());
+
+  if (original_type == WebInputEvent::GestureTap) {
+    gesture->type = WebInputEvent::GestureTap;
+    gesture->details.buttons.pos.x = pixel_x;
+    gesture->details.buttons.pos.y = pixel_y;
+    current_input_target_->ProcessUpdatedGesture(*gesture.get());
+  }
 }
 
 void ApplyNeckModel(gvr::Mat4f& mat_forward) {
   // This assumes that the input matrix is a pure rotation matrix. The
   // input object_from_reference matrix has the inverse rotation of
   // the head rotation. Invert it (this is just a transpose).
   gvr::Mat4f mat = MatrixTranspose(mat_forward);
 
   // Position of the point between the eyes, relative to the neck pivot:
   const float kNeckHorizontalOffset = -0.080f;  // meters in Z
@@ skipping 200 matching lines @@
   vr_shell_renderer_->GetWebVrRenderer()->Draw(content_texture_id_);
 
   if (!webvr_secure_origin_) {
     // TODO(klausw): Draw the insecure origin warning here.
   }
 }
 
 void VrShell::OnPause(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   if (gvr_api_ == nullptr)
     return;
+  controller_->OnPause();
   gvr_api_->PauseTracking();
 }
 
 void VrShell::OnResume(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   if (gvr_api_ == nullptr)
     return;
 
   gvr_api_->RefreshViewerProfile();
   gvr_api_->ResumeTracking();
+  controller_->OnResume();
 }
 
 base::WeakPtr<VrShell> VrShell::GetWeakPtr() {
   // TODO: Ensure that only ui webcontents can request this weak ptr.
   if (g_instance != nullptr)
     return g_instance->weak_ptr_factory_.GetWeakPtr();
   return base::WeakPtr<VrShell>(nullptr);
 }
 
 void VrShell::OnDomContentsLoaded() {
@@ skipping 94 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