VR: Route hover and click events to UI elements.

chrome/browser/android/vr_shell/vr_shell_gl.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_gl.h"
 
 #include <chrono>
 #include <limits>
 #include <utility>
 
@@ skipping 518 matching lines @@
     if (touch_pending_ ||
         controller_->ButtonUpHappened(
             gvr::ControllerButton::GVR_CONTROLLER_BUTTON_CLICK)) {
       touch_pending_ = false;
       std::unique_ptr<WebGestureEvent> gesture(new WebGestureEvent(
           WebInputEvent::kGestureTapDown, WebInputEvent::kNoModifiers,
           (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF()));
       gesture->source_device = blink::kWebGestureDeviceTouchpad;
       gesture->x = 0;
       gesture->y = 0;
-      SendGesture(InputTarget::CONTENT, std::move(gesture));
+      SendGestureToContent(std::move(gesture));
       DVLOG(1) << __FUNCTION__ << ": sent CLICK gesture";
     }
   }
 
   gfx::Vector3dF ergo_neutral_pose;
   if (!controller_->IsConnected()) {
     // No controller detected, set up a gaze cursor that tracks the
     // forward direction.
     ergo_neutral_pose = {0.0f, 0.0f, -1.0f};
     controller_quat_ = GetRotationFromZAxis(forward_vector);
@@ skipping 29 matching lines @@
   // simplicity.
   float distance = scene_->GetBackgroundDistance();
   target_point_ =
       vr::GetRayPoint(kHandPosition, controller_direction, distance);
   gfx::Vector3dF eye_to_target = target_point_ - kOrigin;
   vr::NormalizeVector(&eye_to_target);
 
   // Determine which UI element (if any) intersects the line between the eyes
   // and the controller target position.
   float closest_element_distance = (target_point_ - kOrigin).Length();
+  previous_target_element_ = target_element_;
   target_element_ = nullptr;
   float target_x;
   float target_y;
 
-  for (const auto& plane : scene_->GetUiElements()) {
+  for (auto& plane : scene_->GetUiElements()) {
     if (!plane->IsHitTestable())
       continue;
 
     float distance_to_plane;
     if (!plane->GetRayDistance(kOrigin, eye_to_target, &distance_to_plane))
       continue;
 
     if (distance_to_plane < 0 || distance_to_plane >= closest_element_distance)
       continue;
 
     gfx::Point3F plane_intersection_point =
         vr::GetRayPoint(kOrigin, eye_to_target, distance_to_plane);
     gfx::PointF unit_xy_point =
         plane->GetUnitRectangleCoordinates(plane_intersection_point);
 
     float x = 0.5f + unit_xy_point.x();
     float y = 0.5f - unit_xy_point.y();
     if (x < 0.0f || x >= 1.0f || y < 0.0f || y >= 1.0f)
       continue;
 
     closest_element_distance = distance_to_plane;
     target_point_ = plane_intersection_point;
     target_element_ = plane.get();
     target_x = x;
     target_y = y;
   }
 
-  // Treat UI elements, which do not show web content, as NONE input
-  // targets since they cannot make use of the input anyway.
+  // Handle input targeting on the content quad, ignoring any other elements.
+  // Content is treated specially to accomodate scrolling, flings, etc.
   InputTarget input_target = InputTarget::NONE;
   int pixel_x = 0;
   int pixel_y = 0;
-
   if (target_element_ != nullptr && target_element_->fill == Fill::CONTENT) {
     input_target = InputTarget::CONTENT;
     gfx::RectF pixel_rect(0, 0, content_tex_css_width_,
                           content_tex_css_height_);
     pixel_x = pixel_rect.x() + pixel_rect.width() * target_x;
     pixel_y = pixel_rect.y() + pixel_rect.height() * target_y;
   }
-  SendEventsToTarget(input_target, pixel_x, pixel_y);
+  SendInputToContent(input_target, pixel_x, pixel_y);
+
+  // Handle input targeting on all non-content elements.
+  SendInputToUiElements(target_element_);
 }
 
 void VrShellGl::HandleControllerAppButtonActivity(
     const gfx::Vector3dF& controller_direction) {
   // Note that button up/down state is transient, so ButtonDownHappened only
   // returns true for a single frame (and we're guaranteed not to miss it).
   if (controller_->ButtonDownHappened(
           gvr::ControllerButton::GVR_CONTROLLER_BUTTON_APP)) {
     controller_start_direction_ = controller_direction;
   }
@@ skipping 16 matching lines @@
                                   weak_vr_shell_, direction));
       }
     }
     if (direction == UiInterface::NONE) {
       main_thread_task_runner_->PostTask(
           FROM_HERE, base::Bind(&VrShell::AppButtonPressed, weak_vr_shell_));
     }
   }
 }
 
-void VrShellGl::SendEventsToTarget(InputTarget input_target,
+void VrShellGl::SendInputToContent(InputTarget input_target,
                                    int pixel_x,
                                    int pixel_y) {
   std::vector<std::unique_ptr<WebGestureEvent>> gesture_list =
       controller_->DetectGestures();
   double timestamp = gesture_list.front()->TimeStampSeconds();
 
   if (touch_pending_) {
     touch_pending_ = false;
     std::unique_ptr<WebGestureEvent> event(
         new WebGestureEvent(WebInputEvent::kGestureTapDown,
                             WebInputEvent::kNoModifiers, timestamp));
     event->source_device = blink::kWebGestureDeviceTouchpad;
     event->x = pixel_x;
     event->y = pixel_y;
     gesture_list.push_back(std::move(event));
   }
 
   for (auto& gesture : gesture_list) {
     gesture->x = pixel_x;
     gesture->y = pixel_y;
     auto movableGesture = base::MakeUnique<WebGestureEvent>(*gesture);
 
     switch (gesture->GetType()) {
       // Once the user starts scrolling send all the scroll events to this
       // element until the scrolling stops.
       case WebInputEvent::kGestureScrollBegin:
         current_scroll_target_ = input_target;
         if (current_scroll_target_ != InputTarget::NONE) {
-          SendGesture(current_scroll_target_, std::move(movableGesture));
+          SendGestureToContent(std::move(movableGesture));
         }
         break;
       case WebInputEvent::kGestureScrollEnd:
         if (current_scroll_target_ != InputTarget::NONE) {
-          SendGesture(current_scroll_target_, std::move(movableGesture));
+          SendGestureToContent(std::move(movableGesture));
         }
         current_fling_target_ = current_scroll_target_;
         current_scroll_target_ = InputTarget::NONE;
         break;
       case WebInputEvent::kGestureScrollUpdate:
         if (current_scroll_target_ != InputTarget::NONE) {
-          SendGesture(current_scroll_target_, std::move(movableGesture));
+          SendGestureToContent(std::move(movableGesture));
         }
         break;
       case WebInputEvent::kGestureFlingStart:
         if (current_fling_target_ != InputTarget::NONE) {
-          SendGesture(current_fling_target_, std::move(movableGesture));
+          SendGestureToContent(std::move(movableGesture));
         }
         current_fling_target_ = InputTarget::NONE;
         break;
       case WebInputEvent::kGestureFlingCancel:
         current_fling_target_ = InputTarget::NONE;
         if (input_target != InputTarget::NONE) {
-          SendGesture(input_target, std::move(movableGesture));
+          SendGestureToContent(std::move(movableGesture));
         }
         break;
       case WebInputEvent::kGestureTapDown:
         current_fling_target_ = InputTarget::NONE;
         if (input_target != InputTarget::NONE) {
-          SendGesture(input_target, std::move(movableGesture));
+          SendGestureToContent(std::move(movableGesture));
         }
         break;
       case WebInputEvent::kUndefined:
         break;
       default:
         NOTREACHED();
     }
   }
 
   // Hover support
   bool new_target = input_target != current_input_target_;
   if (new_target && current_input_target_ != InputTarget::NONE) {
     // Send a move event indicating that the pointer moved off of an element.
-    SendGesture(current_input_target_,
-                MakeMouseEvent(WebInputEvent::kMouseLeave, timestamp, 0, 0));
+    SendGestureToContent(
+        MakeMouseEvent(WebInputEvent::kMouseLeave, timestamp, 0, 0));
   }
   current_input_target_ = input_target;
   if (current_input_target_ != InputTarget::NONE) {
     WebInputEvent::Type type =
         new_target ? WebInputEvent::kMouseEnter : WebInputEvent::kMouseMove;
-    SendGesture(input_target,
-                MakeMouseEvent(type, timestamp, pixel_x, pixel_y));
+    SendGestureToContent(MakeMouseEvent(type, timestamp, pixel_x, pixel_y));
   }
 }
 
-void VrShellGl::SendGesture(InputTarget input_target,
-                            std::unique_ptr<blink::WebInputEvent> event) {
-  DCHECK(input_target != InputTarget::NONE);
+void VrShellGl::SendInputToUiElements(UiElement* target_element) {
+  if (target_element != previous_target_element_) {
+    if (previous_target_element_ &&
+        previous_target_element_->fill != Fill::CONTENT) {
+      task_runner_->PostTask(
+          FROM_HERE, base::Bind(&UiElement::OnHoverLeave,
+                                base::Unretained(previous_target_element_)));
+    }
+    if (target_element && target_element->fill != Fill::CONTENT) {
+      task_runner_->PostTask(FROM_HERE,
+                             base::Bind(&UiElement::OnHoverEnter,
+                                        base::Unretained(target_element)));
+    }
+    click_target_element_ = nullptr;
+  }
+  if (target_element && target_element->fill != Fill::CONTENT) {
+    if (controller_->ButtonDownHappened(
+            gvr::ControllerButton::GVR_CONTROLLER_BUTTON_CLICK)) {
+      task_runner_->PostTask(FROM_HERE,
+                             base::Bind(&UiElement::OnButtonDown,
+                                        base::Unretained(target_element)));
+      click_target_element_ = target_element;
+    }
+    if (controller_->ButtonUpHappened(
+            gvr::ControllerButton::GVR_CONTROLLER_BUTTON_CLICK)) {
+      if (click_target_element_ == target_element) {
+        task_runner_->PostTask(FROM_HERE,
+                               base::Bind(&UiElement::OnButtonUp,
+                                          base::Unretained(target_element)));
+      }
+      click_target_element_ = nullptr;
+    }
+  }
+}
+
+void VrShellGl::SendGestureToContent(
+    std::unique_ptr<blink::WebInputEvent> event) {
   main_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VrShell::ProcessContentGesture, weak_vr_shell_,
                             base::Passed(std::move(event))));
 }
 
 void VrShellGl::DrawFrame(int16_t frame_index) {
   TRACE_EVENT1("gpu", "VrShellGl::DrawFrame", "frame", frame_index);
 
   base::TimeTicks current_time = base::TimeTicks::Now();
 
@@ skipping 556 matching lines @@
   // InitializeGl. Revisit if the initialization order changes.
   device::mojom::VRDisplayInfoPtr info =
       device::GvrDelegate::CreateVRDisplayInfo(gvr_api_.get(),
                                                webvr_surface_size_, device_id);
   main_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&RunVRDisplayInfoCallback, callback, base::Passed(&info)));
 }
 
 }  // namespace vr_shell