author Mike Hommey <>
Wed, 16 Jan 2019 21:44:54 +0000
changeset 514172 e0fd6ca971ae522dd9398d49f564fe3f7263112b
parent 512431 f0a91d36587266d7454a450c6044d573664fbed5
child 524385 005ab4b76f8c43b8a9a1dd792786b65d4dd4d05a
permissions -rw-r--r--
Bug 1520377 - Replace/Inline subconfigure.{prefix_lines,execute_and_prefix}. r=nalexander Use an I/O wrapper on the configure output handler to add the "js/src>" prefix. Depends on D16643 Differential Revision:

/* -*- 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 */

#ifndef mozilla_AccessibleCaretEventHub_h
#define mozilla_AccessibleCaretEventHub_h

#include "mozilla/EventForwards.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/WeakPtr.h"
#include "nsCOMPtr.h"
#include "nsDocShell.h"
#include "nsIFrame.h"
#include "nsIReflowObserver.h"
#include "nsIScrollObserver.h"
#include "nsPoint.h"
#include "mozilla/RefPtr.h"
#include "nsWeakReference.h"

class nsIPresShell;
class nsITimer;

namespace mozilla {
class AccessibleCaretManager;
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.
// State transition diagram:
// Source code of the diagram:
// Please see the wiki page for more information.
class AccessibleCaretEventHub : public nsIReflowObserver,
                                public nsIScrollObserver,
                                public nsSupportsWeakReference {
  explicit AccessibleCaretEventHub(nsIPresShell* aPresShell);
  void Init();
  void Terminate();

  nsEventStatus HandleEvent(WidgetEvent* aEvent);

  // Call this function to notify the blur event happened.
  void NotifyBlur(bool aIsLeavingDocument);


  // nsIReflowObserver
  NS_IMETHOD Reflow(DOMHighResTimeStamp start, DOMHighResTimeStamp end) final;
  NS_IMETHOD ReflowInterruptible(DOMHighResTimeStamp start,
                                 DOMHighResTimeStamp end) final;

  // Override nsIScrollObserver methods.
  virtual void ScrollPositionChanged() override;
  virtual void AsyncPanZoomStarted() override;
  virtual void AsyncPanZoomStopped() override;

  // Base state
  class State;
  State* GetState() const;

  void OnSelectionChange(dom::Document* aDocument, dom::Selection* aSelection,
                         int16_t aReason);

  virtual ~AccessibleCaretEventHub() = default;

  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

  void SetState(State* aState);

  nsEventStatus HandleMouseEvent(WidgetMouseEvent* aEvent);
  nsEventStatus HandleTouchEvent(WidgetTouchEvent* aEvent);
  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();

  static void FireLongTap(nsITimer* aTimer, void* aAccessibleCaretEventHub);

  void LaunchScrollEndInjector();
  void CancelScrollEndInjector();

  static void FireScrollEnd(nsITimer* aTimer, void* aAccessibleCaretEventHub);

  // Member variables
  State* mState = NoActionState();

  // Will be set to nullptr in Terminate().
  nsIPresShell* 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.

  // 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 {
  virtual const char* Name() const { return ""; }

  virtual nsEventStatus OnPress(AccessibleCaretEventHub* aContext,
                                const nsPoint& aPoint, int32_t aTouchId,
                                EventClassID aEventClass) {
    return nsEventStatus_eIgnore;

  virtual nsEventStatus OnMove(AccessibleCaretEventHub* aContext,
                               const nsPoint& aPoint) {
    return nsEventStatus_eIgnore;

  virtual nsEventStatus OnRelease(AccessibleCaretEventHub* aContext) {
    return nsEventStatus_eIgnore;

  virtual nsEventStatus OnLongTap(AccessibleCaretEventHub* aContext,
                                  const nsPoint& aPoint) {
    return nsEventStatus_eIgnore;

  virtual void OnScrollStart(AccessibleCaretEventHub* aContext) {}
  virtual void OnScrollEnd(AccessibleCaretEventHub* aContext) {}
  virtual void OnScrollPositionChanged(AccessibleCaretEventHub* aContext) {}
  virtual void OnBlur(AccessibleCaretEventHub* aContext,
                      bool aIsLeavingDocument) {}
  virtual void OnSelectionChanged(AccessibleCaretEventHub* aContext,
                                  dom::Document* aDoc, dom::Selection* aSel,
                                  int16_t aReason) {}
  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