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_controller.h"

[cjgrant, 2016/09/30 20:26:39]

Duplicate include.

[mthiesse, 2016/10/03 16:30:13]

Done.

 #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) {
+  controller_->UpdateState();
+  std::unique_ptr<VrGesture> gesture = controller_->DetectGesture();
+
+  // TODO (asimjour) for now, scroll is sent to the main content.

[bshe, 2016/10/03 12:23:21]

nit: s/TODO (asimjour)/TODO(asimjour): 

[mthiesse, 2016/10/03 16:30:13]

Done.

+  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;
+  controller_active_ = controller_->IsConnected();

[cjgrant, 2016/09/30 20:26:39]

Rebase needed.

[asimjour1, 2016/10/03 15:54:38]

It looks that controller_active_ is not needed. you can replace it with
controller_->IsConnected();

[mthiesse, 2016/10/03 16:30:13]

Acknowledged.

[mthiesse, 2016/10/03 16:30:13]

Done.

   if (!controller_active_) {
     // 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;;
   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.
+  int closest_element_index = -1;
   float closest_element = std::numeric_limits<float>::infinity();

[bshe, 2016/10/03 12:23:21]

nit: s/closest_element/closest_element_distance ?

[mthiesse, 2016/10/03 16:30:13]

Done.

+  int pixel_x = 0;
+  int pixel_y = 0;
   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) {
       bool is_inside = x >= 0.0f && x < 1.0f && y >= 0.0f && y < 1.0f;
       if (is_inside) {
+        closest_element_index = i;
         closest_element = 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;
       }
     }
   }
+  if (closest_element_index != current_ui_rect_ && current_ui_rect_ >= 0) {
+    // Send a move event indicating that the pointer moved off of an element.
+    gesture->type = WebInputEvent::MouseMove;
+    gesture->details.move.delta.x = 0;
+    gesture->details.move.delta.y = 0;
+    gesture->details.move.type = 2;

[cjgrant, 2016/09/30 20:26:39]

Type should be an enum.

[mthiesse, 2016/10/03 16:30:13]

Done.

+    if (current_ui_rect_ == 0) {

[cjgrant, 2016/09/30 20:26:39]

kBrowserUiElementId

[mthiesse, 2016/10/03 16:30:13]

Done.

+      content_input_manager_->ProcessUpdatedGesture(*gesture.get());
+    } else {
+      ui_input_manager_->ProcessUpdatedGesture(*gesture.get());
+    }
+    current_ui_rect_ = 1;

[bshe, 2016/10/03 12:23:21]

why 1?

[mthiesse, 2016/10/03 16:30:12]

Removed.

+  }
+
+  if (closest_element_index >= 0) {
+    if (current_ui_rect_ != closest_element_index) {
+      gesture->type = WebInputEvent::MouseMove;
+      gesture->details.move.delta.x = pixel_x;
+      gesture->details.move.delta.y = pixel_y;
+      gesture->details.move.type = 1;

[cjgrant, 2016/09/30 20:26:39]

Enum here as well, and elsewhere.

[mthiesse, 2016/10/03 16:30:12]

Done.

+      if (closest_element_index > 0) {

[cjgrant, 2016/09/30 20:26:39]

!= kBrowserUiElementId, here and elsewhere.

[mthiesse, 2016/10/03 16:30:13]

Done.

+        ui_input_manager_->ProcessUpdatedGesture(*gesture.get());
+      } else {
+        content_input_manager_->ProcessUpdatedGesture(*gesture.get());
+      }
+    }
+    if (closest_element_index > 0) {
+      if (original_type == WebInputEvent::GestureTap) {
+        gesture->type = WebInputEvent::GestureTap;
+        gesture->details.buttons.pos.x = pixel_x;
+        gesture->details.buttons.pos.y = pixel_y;
+        ui_input_manager_->ProcessUpdatedGesture(*gesture.get());
+      }
+      gesture->type = WebInputEvent::MouseMove;
+      gesture->details.move.delta.x = pixel_x;
+      gesture->details.move.delta.y = pixel_y;
+      gesture->details.move.type = 0;
+      ui_input_manager_->ProcessUpdatedGesture(*gesture.get());

[bshe, 2016/10/03 12:23:21]

it looks like line 320 - 330 is very similar to line 332 to 342. Perhaps create
a private function to reduce the code size?

[mthiesse, 2016/10/03 16:30:13]

Done.

+    } else {
+      if (original_type == WebInputEvent::GestureTap) {
+        gesture->type = WebInputEvent::GestureTap;
+        gesture->details.buttons.pos.x = pixel_x;
+        gesture->details.buttons.pos.y = pixel_y;
+        content_input_manager_->ProcessUpdatedGesture(*gesture.get());
+      }
+      gesture->type = WebInputEvent::MouseMove;
+      gesture->details.move.delta.x = pixel_x;
+      gesture->details.move.delta.y = pixel_y;
+      gesture->details.move.type = 0;
+      content_input_manager_->ProcessUpdatedGesture(*gesture.get());
+    }
+    current_ui_rect_ = closest_element_index;
+  }
 }
 
 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