VR Shell: Allow UI elements to determine hit testing.

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 68 matching lines @@
 static constexpr int kViewportListHeadlockedOffset = 2;
 
 // Buffer size large enough to handle the current backlog of poses which is
 // 2-3 frames.
 static constexpr unsigned kPoseRingBufferSize = 8;
 
 // Criteria for considering holding the app button in combination with
 // controller movement as a gesture.
 static constexpr float kMinAppButtonGestureAngleRad = 0.25;
 
+static constexpr gfx::PointF kInvalidTargetPoint =
+    gfx::PointF(std::numeric_limits<float>::max(),
+                std::numeric_limits<float>::max());
+
 // Generate a quaternion representing the rotation from the negative Z axis
 // (0, 0, -1) to a specified vector. This is an optimized version of a more
 // general vector-to-vector calculation.
 vr::Quatf GetRotationFromZAxis(gfx::Vector3dF vec) {
   vr::NormalizeVector(&vec);
   vr::Quatf quat;
   quat.qw = 1.0f - vec.z();
   if (quat.qw < 1e-6f) {
     // Degenerate case: vectors are exactly opposite. Replace by an
     // arbitrary 180 degree rotation to avoid invalid normalization.
@@ skipping 433 matching lines @@
 
   vr::Mat4f mat;
   QuatToMatrix(controller_quat_, &mat);
   gfx::Vector3dF controller_direction =
       vr::MatrixVectorMul(mat, ergo_neutral_pose);
 
   HandleControllerAppButtonActivity(controller_direction);
 
   if (ShouldDrawWebVr())
     return;
-  gfx::PointF target_local_point;
+  gfx::PointF target_local_point(kInvalidTargetPoint);
   gfx::Vector3dF eye_to_target;
   reticle_render_target_ = nullptr;
   GetVisualTargetElement(controller_direction, eye_to_target, target_point_,
                          &reticle_render_target_, target_local_point);
 
   UiElement* target_element = nullptr;
   if (input_locked_element_) {
     gfx::Point3F plane_intersection_point;
     float distance_to_plane;
-    GetTargetLocalPoint(eye_to_target, *input_locked_element_,
-                        2 * scene_->GetBackgroundDistance(), target_local_point,
-                        plane_intersection_point, distance_to_plane);
+    if (!GetTargetLocalPoint(eye_to_target, *input_locked_element_,
+                             2 * scene_->GetBackgroundDistance(),
+                             target_local_point, plane_intersection_point,
+                             distance_to_plane)) {
+      target_local_point = kInvalidTargetPoint;
+    }
     target_element = input_locked_element_;
   } else if (!in_scroll_ && !in_click_) {
     target_element = reticle_render_target_;
   }
 
   // Handle input targeting on the content quad, ignoring any other elements.
   // Content is treated specially to accomodate scrolling, flings, etc.
   gfx::Point local_point_pixels;
   if (target_element && (target_element->fill() == Fill::CONTENT)) {
-    gfx::RectF pixel_rect(0, 0, content_tex_css_width_,
-                          content_tex_css_height_);
-    local_point_pixels.set_x(pixel_rect.x() +
-                             pixel_rect.width() * target_local_point.x());
-    local_point_pixels.set_y(pixel_rect.y() +
-                             pixel_rect.height() * target_local_point.y());
+    local_point_pixels.set_x(content_tex_css_width_ * target_local_point.x());
+    local_point_pixels.set_y(content_tex_css_height_ * target_local_point.y());
   }
   std::unique_ptr<GestureList> gesture_list_ptr = controller_->DetectGestures();
   GestureList& gesture_list = *gesture_list_ptr;
   for (const std::unique_ptr<blink::WebGestureEvent>& gesture : gesture_list) {
     gesture->x = local_point_pixels.x();
     gesture->y = local_point_pixels.y();
   }
   SendFlingCancel(gesture_list);
   // For simplicity, don't allow scrolling while clicking until we need to.
   if (!in_click_) {
@@ skipping 157 matching lines @@
     return;
   target->OnButtonDown(target_point);
 }
 
 bool VrShellGl::SendButtonUp(UiElement* target,
                              const gfx::PointF& target_point) {
   if (!in_click_)
     return false;
   if (!controller_->ButtonUpHappened(gvr::kControllerButtonClick))
     return false;
+  in_click_ = false;
+  if (!input_locked_element_)
+    return true;
   DCHECK(input_locked_element_ == target);
   input_locked_element_ = nullptr;
-  in_click_ = false;
   // We don't support down/up for content yet.
   if (target->fill() == Fill::CONTENT)
     return false;
   target->OnButtonUp(target_point);
   return true;
 }
 
 void VrShellGl::SendTap(UiElement* target,
                         const gfx::PointF& target_point,
                         const gfx::Point& local_point_pixels) {
@@ skipping 52 matching lines @@
   for (auto& element : scene_->GetUiElements()) {
     if (!element->IsHitTestable())
       continue;
     gfx::PointF local_point;
     gfx::Point3F plane_intersection_point;
     float distance_to_plane;
     if (!GetTargetLocalPoint(eye_to_target, *element.get(),
                              closest_element_distance, local_point,
                              plane_intersection_point, distance_to_plane))
       continue;
-
-    if (local_point.x() < 0.0f || local_point.x() >= 1.0f ||
-        local_point.y() < 0.0f || local_point.y() >= 1.0f)
+    if (!element->HitTest(local_point))
       continue;
 
     closest_element_distance = distance_to_plane;
     target_point = plane_intersection_point;
     *target_element = element.get();
     target_local_point = local_point;
   }
 }
 
 bool VrShellGl::GetTargetLocalPoint(const gfx::Vector3dF& eye_to_target,
@@ skipping 641 matching lines @@
   // This assumes that the initial webvr_surface_size_ was set to the
   // appropriate recommended render resolution as the default size during
   // InitializeGl. Revisit if the initialization order changes.
   device::mojom::VRDisplayInfoPtr info =
       device::GvrDelegate::CreateVRDisplayInfo(gvr_api_.get(),
                                                webvr_surface_size_, device_id);
   browser_->RunVRDisplayInfoCallback(callback, &info);
 }
 
 }  // namespace vr_shell