Refactor VR Shell Input. Locks input to click/scroll targets.

chrome/browser/android/vr_shell/vr_shell_gl.h

 // 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.
 
 #ifndef CHROME_BROWSER_ANDROID_VR_SHELL_VR_SHELL_GL_H_
 #define CHROME_BROWSER_ANDROID_VR_SHELL_VR_SHELL_GL_H_
 
 #include <memory>
 #include <queue>
 #include <utility>
 #include <vector>
 
 #include "base/cancelable_callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
+#include "chrome/browser/android/vr_shell/vr_controller.h"
 #include "chrome/browser/android/vr_shell/vr_controller_model.h"
 #include "device/vr/vr_service.mojom.h"
 #include "device/vr/vr_types.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "third_party/gvr-android-sdk/src/libraries/headers/vr/gvr/capi/include/gvr.h"
 #include "third_party/gvr-android-sdk/src/libraries/headers/vr/gvr/capi/include/gvr_types.h"
 #include "ui/gfx/native_widget_types.h"
 
 namespace blink {
 class WebInputEvent;
@@ skipping 28 matching lines @@
       : left_bounds(left), right_bounds(right), source_size(size) {}
   gfx::RectF left_bounds;
   gfx::RectF right_bounds;
   gfx::Size source_size;
 };
 
 // This class manages all GLThread owned objects and GL rendering for VrShell.
 // It is not threadsafe and must only be used on the GL thread.
 class VrShellGl : public device::mojom::VRVSyncProvider {
  public:
-  enum class InputTarget {
-    NONE = 0,
-    CONTENT,
-  };
-
   VrShellGl(VrBrowserInterface* browser,
             gvr_context* gvr_api,
             bool initially_web_vr,
             bool reprojected_rendering,
             UiScene* scene);
   ~VrShellGl() override;
 
   void Initialize();
   void InitializeGl(gfx::AcceleratedWidget window);
 
@@ skipping 47 matching lines @@
   std::vector<const UiElement*> GetElementsInDrawOrder(
       const vr::Mat4f& view_matrix,
       const std::vector<const UiElement*>& elements);
   void DrawCursor(const vr::Mat4f& render_matrix);
   void DrawController(const vr::Mat4f& view_proj_matrix);
   bool ShouldDrawWebVr();
   void DrawWebVr();
   bool WebVrPoseByteIsValid(int pose_index_byte);
 
   void UpdateController(const gfx::Vector3dF& head_direction);
+  void HandleWebVrCompatClick();
+  void SendFlingCancel(GestureList& gesture_list);
+  void SendScrollEnd(GestureList& gesture_list);
+  bool SendScrollBegin(UiElement* target, GestureList& gesture_list);
+  void SendScrollUpdate(GestureList& gesture_list);
+  void SendHoverLeave(UiElement* target);
+  bool SendHoverEnter(UiElement* target,
+                      const gfx::PointF& target_point,
+                      const gfx::Point& local_point_pixels);
+  void SendHoverMove(const gfx::PointF& target_point,
+                     const gfx::Point& local_point_pixels);
+  void SendButtonDown(UiElement* target, const gfx::PointF& target_point);
+  bool SendButtonUp(UiElement* target, const gfx::PointF& target_point);
+  void SendTap(UiElement* target,
+               const gfx::PointF& target_point,
+               const gfx::Point& local_point_pixels);
+  void GetVisualTargetElement(const gfx::Vector3dF& controller_direction,
+                              gfx::Vector3dF& eye_to_target,
+                              gfx::Point3F& target_point,
+                              UiElement** target_element,
+                              gfx::PointF& target_local_point) const;
+  bool GetTargetLocalPoint(const gfx::Vector3dF& eye_to_target,
+                           const UiElement& element,
+                           float max_distance_to_plane,
+                           gfx::PointF& target_local_point,
+                           gfx::Point3F& target_point,
+                           float& distance_to_plane) const;
   void HandleControllerInput(const gfx::Vector3dF& head_direction);
   void HandleControllerAppButtonActivity(
       const gfx::Vector3dF& controller_direction);
-  void SendInputToContent(InputTarget input_target, int pixel_x, int pixel_y);
-  void SendInputToUiElements(UiElement* target_element);
   void SendGestureToContent(std::unique_ptr<blink::WebInputEvent> event);
   void CreateUiSurface();
   void OnContentFrameAvailable();
   void OnWebVRFrameAvailable();
   bool GetPixelEncodedFrameIndex(uint16_t* frame_index);
 
   void OnVSync();
 
   // VRVSyncProvider
   void GetVSync(const GetVSyncCallback& callback) override;
@@ skipping 35 matching lines @@
   // can be restored after exiting WebVR mode.
   gfx::Size render_size_vrshell_;
 
   std::unique_ptr<VrShellRenderer> vr_shell_renderer_;
 
   bool touch_pending_ = false;
   vr::Quatf controller_quat_;
 
   gfx::Point3F target_point_;
 
-  // Input targeting for non-content elements.
-  UiElement* target_element_ = nullptr;
-  UiElement* previous_target_element_ = nullptr;
-  UiElement* click_target_element_ = nullptr;
-
-  // Input targeting for the content element.
-  InputTarget current_input_target_ = InputTarget::NONE;
-  InputTarget current_scroll_target_ = InputTarget::NONE;
-  InputTarget current_fling_target_ = InputTarget::NONE;
+  UiElement* cursor_render_target_ = nullptr;

[cjgrant, 2017/05/10 20:16:26]

Now might be a good time to TODO the fact that we should handle the deletion of
elements, eventually.

[mthiesse, 2017/05/10 21:09:08]

Done.

+  UiElement* hover_target_ = nullptr;
+  // TODO(mthiesse): Whether a target is flinging should be a property on the

[asimjour1, 2017/05/11 12:31:12]

I don't get this comment. If you mean "whether a target is flinging at this
moment", I think you are wrong. At least for the content we shouldn't need that
flag.

[mthiesse, 2017/05/11 14:12:00]

You're right, changed the TODO.

+  // element, so we can fling multiple things at once.
+  UiElement* fling_target_ = nullptr;
+  UiElement* input_locked_element_ = nullptr;
+  bool in_scroll_ = false;
+  bool in_click_ = false;
 
   int content_tex_css_width_ = 0;
   int content_tex_css_height_ = 0;
   gfx::Size content_tex_physical_size_ = {0, 0};
   gfx::Size webvr_surface_size_ = {0, 0};
 
   std::vector<vr::Mat4f> webvr_head_pose_;
   bool web_vr_mode_;
   bool ready_to_draw_ = false;
   bool surfaceless_rendering_;
@@ skipping 28 matching lines @@
   gfx::Point3F pointer_start_;
 
   base::WeakPtrFactory<VrShellGl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(VrShellGl);
 };
 
 }  // namespace vr_shell
 
 #endif  // CHROME_BROWSER_ANDROID_VR_SHELL_VR_SHELL_GL_H_