Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 241 insertions, 0 deletions

diff --git a/layout/base/AccessibleCaretEventHub.h b/layout/base/AccessibleCaretEventHub.h
new file mode 100644
index 0000000000..5b1ed581c7
--- /dev/null
+++ b/layout/base/AccessibleCaretEventHub.h
@@ -0,0 +1,241 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_AccessibleCaretEventHub_h
+#define mozilla_AccessibleCaretEventHub_h
+
+#include "LayoutConstants.h"
+#include "mozilla/EventForwards.h"
+#include "mozilla/MouseEvents.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/WeakPtr.h"
+#include "nsCOMPtr.h"
+#include "nsDocShell.h"
+#include "nsIReflowObserver.h"
+#include "nsIScrollObserver.h"
+#include "nsPoint.h"
+#include "mozilla/RefPtr.h"
+#include "nsWeakReference.h"
+
+class nsITimer;
+
+namespace mozilla {
+class AccessibleCaretManager;
+class PresShell;
+class WidgetKeyboardEvent;
+class WidgetMouseEvent;
+class WidgetTouchEvent;
+
+// -----------------------------------------------------------------------------
+// Each PresShell holds a shared pointer to an AccessibleCaretEventHub; each
+// AccessibleCaretEventHub holds a unique pointer to an AccessibleCaretManager.
+// Thus, there's one AccessibleCaretManager per PresShell.
+//
+// AccessibleCaretEventHub implements a state pattern. It receives events from
+// PresShell and callbacks by observers and listeners, and then relays them to
+// the current concrete state which calls necessary event-handling methods in
+// AccessibleCaretManager.
+//
+// We separate AccessibleCaretEventHub from AccessibleCaretManager to make the
+// state transitions in AccessibleCaretEventHub testable. We put (nearly) all
+// the operations involving PresShell, Selection, and AccessibleCaret
+// manipulation in AccessibleCaretManager so that we can mock methods in
+// AccessibleCaretManager in gtest. We test the correctness of the state
+// transitions by giving events, callbacks, and the return values by mocked
+// methods of AccessibleCaretEventHub. See TestAccessibleCaretEventHub.cpp.
+//
+// Besides dealing with real events, AccessibleCaretEventHub could also
+// synthesize fake long-tap events and inject those events to itself on the
+// platform lacks eMouseLongTap. Turn on this preference
+// "layout.accessiblecaret.use_long_tap_injector" for the fake long-tap events.
+//
+// Please see the in-tree document for state transition diagram and more
+// information.
+// HTML: https://firefox-source-docs.mozilla.org/layout/AccessibleCaret.html
+// Source rst: layout/docs/AccessibleCaret.rst
+//
+class AccessibleCaretEventHub : public nsIReflowObserver,
+                                public nsIScrollObserver,
+                                public nsSupportsWeakReference {
+ public:
+  explicit AccessibleCaretEventHub(PresShell* aPresShell);
+  void Init();
+  void Terminate();
+
+  MOZ_CAN_RUN_SCRIPT
+  nsEventStatus HandleEvent(WidgetEvent* aEvent);
+
+  // Call this function to notify the blur event happened.
+  MOZ_CAN_RUN_SCRIPT
+  void NotifyBlur(bool aIsLeavingDocument);
+
+  NS_DECL_ISUPPORTS
+
+  // nsIReflowObserver
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY
+  NS_IMETHOD Reflow(DOMHighResTimeStamp start, DOMHighResTimeStamp end) final;
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY
+  NS_IMETHOD ReflowInterruptible(DOMHighResTimeStamp start,
+                                 DOMHighResTimeStamp end) final;
+
+  // Override nsIScrollObserver methods.
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY
+  virtual void ScrollPositionChanged() override;
+  MOZ_CAN_RUN_SCRIPT
+  virtual void AsyncPanZoomStarted() override;
+  MOZ_CAN_RUN_SCRIPT
+  virtual void AsyncPanZoomStopped() override;
+
+  // Base state
+  class State;
+  State* GetState() const;
+
+  MOZ_CAN_RUN_SCRIPT
+  void OnSelectionChange(dom::Document* aDocument, dom::Selection* aSelection,
+                         int16_t aReason);
+
+  bool ShouldDisableApz() const;
+
+ protected:
+  virtual ~AccessibleCaretEventHub() = default;
+
+#define MOZ_DECL_STATE_CLASS_GETTER(aClassName) \
+  class aClassName;                             \
+  static State* aClassName();
+
+#define MOZ_IMPL_STATE_CLASS_GETTER(aClassName)                           \
+  AccessibleCaretEventHub::State* AccessibleCaretEventHub::aClassName() { \
+    static class aClassName singleton;                                    \
+    return &singleton;                                                    \
+  }
+
+  // Concrete state getters
+  MOZ_DECL_STATE_CLASS_GETTER(NoActionState)
+  MOZ_DECL_STATE_CLASS_GETTER(PressCaretState)
+  MOZ_DECL_STATE_CLASS_GETTER(DragCaretState)
+  MOZ_DECL_STATE_CLASS_GETTER(PressNoCaretState)
+  MOZ_DECL_STATE_CLASS_GETTER(ScrollState)
+  MOZ_DECL_STATE_CLASS_GETTER(LongTapState)
+
+  void SetState(State* aState);
+
+  MOZ_CAN_RUN_SCRIPT
+  nsEventStatus HandleMouseEvent(WidgetMouseEvent* aEvent);
+  MOZ_CAN_RUN_SCRIPT
+  nsEventStatus HandleTouchEvent(WidgetTouchEvent* aEvent);
+  MOZ_CAN_RUN_SCRIPT
+  nsEventStatus HandleKeyboardEvent(WidgetKeyboardEvent* aEvent);
+
+  virtual nsPoint GetTouchEventPosition(WidgetTouchEvent* aEvent,
+                                        int32_t aIdentifier) const;
+  virtual nsPoint GetMouseEventPosition(WidgetMouseEvent* aEvent) const;
+
+  bool MoveDistanceIsLarge(const nsPoint& aPoint) const;
+
+  void LaunchLongTapInjector();
+  void CancelLongTapInjector();
+
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY
+  static void FireLongTap(nsITimer* aTimer, void* aAccessibleCaretEventHub);
+
+  void LaunchScrollEndInjector();
+  void CancelScrollEndInjector();
+
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY
+  static void FireScrollEnd(nsITimer* aTimer, void* aAccessibleCaretEventHub);
+
+  // Member variables
+  State* mState = NoActionState();
+
+  // Will be set to nullptr in Terminate().
+  PresShell* MOZ_NON_OWNING_REF mPresShell = nullptr;
+
+  UniquePtr<AccessibleCaretManager> mManager;
+
+  WeakPtr<nsDocShell> mDocShell;
+
+  // Use this timer for injecting a long tap event when APZ is disabled. If APZ
+  // is enabled, it will send long tap event to us.
+  nsCOMPtr<nsITimer> mLongTapInjectorTimer;
+
+  // Last mouse button down event or touch start event point.
+  nsPoint mPressPoint{NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE};
+
+  // For filter multitouch event
+  int32_t mActiveTouchId = kInvalidTouchId;
+
+  // Flag to indicate the class has been initialized.
+  bool mInitialized = false;
+
+  // Flag to avoid calling Reflow() callback recursively.
+  bool mIsInReflowCallback = false;
+
+  static const int32_t kMoveStartToleranceInPixel = 5;
+  static const int32_t kInvalidTouchId = -1;
+  static const int32_t kDefaultTouchId = 0;  // For mouse event
+};
+
+// -----------------------------------------------------------------------------
+// The base class for concrete states. A concrete state should inherit from this
+// class, and override the methods to handle the events or callbacks. A concrete
+// state is also responsible for transforming itself to the next concrete state.
+//
+class AccessibleCaretEventHub::State {
+ public:
+  virtual const char* Name() const { return ""; }
+
+  MOZ_CAN_RUN_SCRIPT
+  virtual nsEventStatus OnPress(AccessibleCaretEventHub* aContext,
+                                const nsPoint& aPoint, int32_t aTouchId,
+                                EventClassID aEventClass) {
+    return nsEventStatus_eIgnore;
+  }
+
+  MOZ_CAN_RUN_SCRIPT
+  virtual nsEventStatus OnMove(AccessibleCaretEventHub* aContext,
+                               const nsPoint& aPoint,
+                               WidgetMouseEvent::Reason aReason) {
+    return nsEventStatus_eIgnore;
+  }
+
+  MOZ_CAN_RUN_SCRIPT
+  virtual nsEventStatus OnRelease(AccessibleCaretEventHub* aContext) {
+    return nsEventStatus_eIgnore;
+  }
+
+  MOZ_CAN_RUN_SCRIPT
+  virtual nsEventStatus OnLongTap(AccessibleCaretEventHub* aContext,
+                                  const nsPoint& aPoint) {
+    return nsEventStatus_eIgnore;
+  }
+
+  MOZ_CAN_RUN_SCRIPT
+  virtual void OnScrollStart(AccessibleCaretEventHub* aContext) {}
+  MOZ_CAN_RUN_SCRIPT
+  virtual void OnScrollEnd(AccessibleCaretEventHub* aContext) {}
+  MOZ_CAN_RUN_SCRIPT
+  virtual void OnScrollPositionChanged(AccessibleCaretEventHub* aContext) {}
+  MOZ_CAN_RUN_SCRIPT
+  virtual void OnBlur(AccessibleCaretEventHub* aContext,
+                      bool aIsLeavingDocument) {}
+  MOZ_CAN_RUN_SCRIPT
+  virtual void OnSelectionChanged(AccessibleCaretEventHub* aContext,
+                                  dom::Document* aDoc, dom::Selection* aSel,
+                                  int16_t aReason) {}
+  MOZ_CAN_RUN_SCRIPT
+  virtual void OnReflow(AccessibleCaretEventHub* aContext) {}
+  virtual void Enter(AccessibleCaretEventHub* aContext) {}
+  virtual void Leave(AccessibleCaretEventHub* aContext) {}
+
+  explicit State() = default;
+  virtual ~State() = default;
+  State(const State&) = delete;
+  State& operator=(const State&) = delete;
+};
+
+}  // namespace mozilla
+
+#endif  // mozilla_AccessibleCaretEventHub_h