summaryrefslogtreecommitdiffstats
path: root/layout/base/AccessibleCaretEventHub.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'layout/base/AccessibleCaretEventHub.cpp')
-rw-r--r--layout/base/AccessibleCaretEventHub.cpp706
1 files changed, 706 insertions, 0 deletions
diff --git a/layout/base/AccessibleCaretEventHub.cpp b/layout/base/AccessibleCaretEventHub.cpp
new file mode 100644
index 0000000000..45887d1716
--- /dev/null
+++ b/layout/base/AccessibleCaretEventHub.cpp
@@ -0,0 +1,706 @@
+/* -*- 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/. */
+
+#include "AccessibleCaretEventHub.h"
+
+#include "AccessibleCaretLogger.h"
+#include "AccessibleCaretManager.h"
+
+#include "mozilla/AutoRestore.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/StaticPrefs_layout.h"
+#include "mozilla/StaticPrefs_ui.h"
+#include "mozilla/TextEvents.h"
+#include "mozilla/TouchEvents.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/dom/MouseEventBinding.h"
+#include "mozilla/dom/Selection.h"
+#include "nsCanvasFrame.h"
+#include "nsDocShell.h"
+#include "nsFocusManager.h"
+#include "nsFrameSelection.h"
+#include "nsITimer.h"
+#include "nsLayoutUtils.h"
+#include "nsPresContext.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+namespace mozilla {
+
+#undef AC_LOG
+#define AC_LOG(message, ...) \
+ AC_LOG_BASE("AccessibleCaretEventHub (%p): " message, this, ##__VA_ARGS__);
+
+#undef AC_LOGV
+#define AC_LOGV(message, ...) \
+ AC_LOGV_BASE("AccessibleCaretEventHub (%p): " message, this, ##__VA_ARGS__);
+
+NS_IMPL_ISUPPORTS(AccessibleCaretEventHub, nsIReflowObserver, nsIScrollObserver,
+ nsISupportsWeakReference);
+
+// -----------------------------------------------------------------------------
+// NoActionState
+//
+class AccessibleCaretEventHub::NoActionState
+ : public AccessibleCaretEventHub::State {
+ public:
+ const char* Name() const override { return "NoActionState"; }
+
+ MOZ_CAN_RUN_SCRIPT
+ nsEventStatus OnPress(AccessibleCaretEventHub* aContext,
+ const nsPoint& aPoint, int32_t aTouchId,
+ EventClassID aEventClass) override {
+ nsEventStatus rv = nsEventStatus_eIgnore;
+
+ if (NS_SUCCEEDED(aContext->mManager->PressCaret(aPoint, aEventClass))) {
+ aContext->SetState(AccessibleCaretEventHub::PressCaretState());
+ rv = nsEventStatus_eConsumeNoDefault;
+ } else {
+ aContext->SetState(AccessibleCaretEventHub::PressNoCaretState());
+ }
+
+ aContext->mPressPoint = aPoint;
+ aContext->mActiveTouchId = aTouchId;
+
+ return rv;
+ }
+
+ MOZ_CAN_RUN_SCRIPT
+ void OnScrollStart(AccessibleCaretEventHub* aContext) override {
+ aContext->mManager->OnScrollStart();
+ aContext->SetState(AccessibleCaretEventHub::ScrollState());
+ }
+
+ MOZ_CAN_RUN_SCRIPT
+ void OnScrollPositionChanged(AccessibleCaretEventHub* aContext) override {
+ aContext->mManager->OnScrollPositionChanged();
+ }
+
+ MOZ_CAN_RUN_SCRIPT
+ void OnSelectionChanged(AccessibleCaretEventHub* aContext, Document* aDoc,
+ dom::Selection* aSel, int16_t aReason) override {
+ aContext->mManager->OnSelectionChanged(aDoc, aSel, aReason);
+ }
+
+ MOZ_CAN_RUN_SCRIPT
+ void OnBlur(AccessibleCaretEventHub* aContext,
+ bool aIsLeavingDocument) override {
+ aContext->mManager->OnBlur();
+ }
+
+ MOZ_CAN_RUN_SCRIPT
+ void OnReflow(AccessibleCaretEventHub* aContext) override {
+ aContext->mManager->OnReflow();
+ }
+
+ void Enter(AccessibleCaretEventHub* aContext) override {
+ aContext->mPressPoint = nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
+ aContext->mActiveTouchId = kInvalidTouchId;
+ }
+};
+
+// -----------------------------------------------------------------------------
+// PressCaretState: Because we've pressed on the caret, always consume the
+// event, both real and synthesized, so that other event handling code won't
+// have a chance to do something else to interrupt caret dragging.
+//
+class AccessibleCaretEventHub::PressCaretState
+ : public AccessibleCaretEventHub::State {
+ public:
+ const char* Name() const override { return "PressCaretState"; }
+
+ MOZ_CAN_RUN_SCRIPT
+ nsEventStatus OnMove(AccessibleCaretEventHub* aContext, const nsPoint& aPoint,
+ WidgetMouseEvent::Reason aReason) override {
+ if (aReason == WidgetMouseEvent::eReal &&
+ aContext->MoveDistanceIsLarge(aPoint)) {
+ if (NS_SUCCEEDED(aContext->mManager->DragCaret(aPoint))) {
+ aContext->SetState(AccessibleCaretEventHub::DragCaretState());
+ }
+ }
+
+ return nsEventStatus_eConsumeNoDefault;
+ }
+
+ MOZ_CAN_RUN_SCRIPT
+ nsEventStatus OnRelease(AccessibleCaretEventHub* aContext) override {
+ aContext->mManager->ReleaseCaret();
+ aContext->mManager->TapCaret(aContext->mPressPoint);
+ aContext->SetState(AccessibleCaretEventHub::NoActionState());
+
+ return nsEventStatus_eConsumeNoDefault;
+ }
+
+ nsEventStatus OnLongTap(AccessibleCaretEventHub* aContext,
+ const nsPoint& aPoint) override {
+ return nsEventStatus_eConsumeNoDefault;
+ }
+};
+
+// -----------------------------------------------------------------------------
+// DragCaretState: Because we've pressed on the caret, always consume the event,
+// both real and synthesized, so that other event handling code won't have a
+// chance to do something else to interrupt caret dragging.
+//
+class AccessibleCaretEventHub::DragCaretState
+ : public AccessibleCaretEventHub::State {
+ public:
+ const char* Name() const override { return "DragCaretState"; }
+
+ MOZ_CAN_RUN_SCRIPT
+ nsEventStatus OnMove(AccessibleCaretEventHub* aContext, const nsPoint& aPoint,
+ WidgetMouseEvent::Reason aReason) override {
+ if (aReason == WidgetMouseEvent::eReal) {
+ aContext->mManager->DragCaret(aPoint);
+ }
+
+ return nsEventStatus_eConsumeNoDefault;
+ }
+
+ MOZ_CAN_RUN_SCRIPT
+ nsEventStatus OnRelease(AccessibleCaretEventHub* aContext) override {
+ aContext->mManager->ReleaseCaret();
+ aContext->SetState(AccessibleCaretEventHub::NoActionState());
+
+ return nsEventStatus_eConsumeNoDefault;
+ }
+};
+
+// -----------------------------------------------------------------------------
+// PressNoCaretState
+//
+class AccessibleCaretEventHub::PressNoCaretState
+ : public AccessibleCaretEventHub::State {
+ public:
+ const char* Name() const override { return "PressNoCaretState"; }
+
+ nsEventStatus OnMove(AccessibleCaretEventHub* aContext, const nsPoint& aPoint,
+ WidgetMouseEvent::Reason aReason) override {
+ if (aContext->MoveDistanceIsLarge(aPoint)) {
+ aContext->SetState(AccessibleCaretEventHub::NoActionState());
+ }
+
+ return nsEventStatus_eIgnore;
+ }
+
+ nsEventStatus OnRelease(AccessibleCaretEventHub* aContext) override {
+ aContext->SetState(AccessibleCaretEventHub::NoActionState());
+
+ return nsEventStatus_eIgnore;
+ }
+
+ MOZ_CAN_RUN_SCRIPT
+ nsEventStatus OnLongTap(AccessibleCaretEventHub* aContext,
+ const nsPoint& aPoint) override {
+ aContext->SetState(AccessibleCaretEventHub::LongTapState());
+
+ return aContext->GetState()->OnLongTap(aContext, aPoint);
+ }
+
+ MOZ_CAN_RUN_SCRIPT
+ void OnScrollStart(AccessibleCaretEventHub* aContext) override {
+ aContext->mManager->OnScrollStart();
+ aContext->SetState(AccessibleCaretEventHub::ScrollState());
+ }
+
+ MOZ_CAN_RUN_SCRIPT
+ void OnBlur(AccessibleCaretEventHub* aContext,
+ bool aIsLeavingDocument) override {
+ aContext->mManager->OnBlur();
+ if (aIsLeavingDocument) {
+ aContext->SetState(AccessibleCaretEventHub::NoActionState());
+ }
+ }
+
+ MOZ_CAN_RUN_SCRIPT
+ void OnSelectionChanged(AccessibleCaretEventHub* aContext, Document* aDoc,
+ dom::Selection* aSel, int16_t aReason) override {
+ aContext->mManager->OnSelectionChanged(aDoc, aSel, aReason);
+ }
+
+ MOZ_CAN_RUN_SCRIPT
+ void OnReflow(AccessibleCaretEventHub* aContext) override {
+ aContext->mManager->OnReflow();
+ }
+
+ void Enter(AccessibleCaretEventHub* aContext) override {
+ aContext->LaunchLongTapInjector();
+ }
+
+ void Leave(AccessibleCaretEventHub* aContext) override {
+ aContext->CancelLongTapInjector();
+ }
+};
+
+// -----------------------------------------------------------------------------
+// ScrollState
+//
+class AccessibleCaretEventHub::ScrollState
+ : public AccessibleCaretEventHub::State {
+ public:
+ const char* Name() const override { return "ScrollState"; }
+
+ MOZ_CAN_RUN_SCRIPT
+ void OnScrollEnd(AccessibleCaretEventHub* aContext) override {
+ aContext->mManager->OnScrollEnd();
+ aContext->SetState(AccessibleCaretEventHub::NoActionState());
+ }
+
+ MOZ_CAN_RUN_SCRIPT
+ void OnScrollPositionChanged(AccessibleCaretEventHub* aContext) override {
+ aContext->mManager->OnScrollPositionChanged();
+ }
+
+ MOZ_CAN_RUN_SCRIPT
+ void OnBlur(AccessibleCaretEventHub* aContext,
+ bool aIsLeavingDocument) override {
+ aContext->mManager->OnBlur();
+ if (aIsLeavingDocument) {
+ aContext->SetState(AccessibleCaretEventHub::NoActionState());
+ }
+ }
+};
+
+// -----------------------------------------------------------------------------
+// LongTapState
+//
+class AccessibleCaretEventHub::LongTapState
+ : public AccessibleCaretEventHub::State {
+ public:
+ const char* Name() const override { return "LongTapState"; }
+
+ MOZ_CAN_RUN_SCRIPT
+ nsEventStatus OnLongTap(AccessibleCaretEventHub* aContext,
+ const nsPoint& aPoint) override {
+ // In general text selection is lower-priority than the context menu. If
+ // we consume this long-press event, then it prevents the context menu from
+ // showing up on desktop Firefox (because that happens on long-tap-up, if
+ // the long-tap was not cancelled). So we return eIgnore instead.
+ aContext->mManager->SelectWordOrShortcut(aPoint);
+ return nsEventStatus_eIgnore;
+ }
+
+ nsEventStatus OnRelease(AccessibleCaretEventHub* aContext) override {
+ aContext->SetState(AccessibleCaretEventHub::NoActionState());
+
+ // Do not consume the release since the press is not consumed in
+ // PressNoCaretState either.
+ return nsEventStatus_eIgnore;
+ }
+
+ MOZ_CAN_RUN_SCRIPT
+ void OnScrollStart(AccessibleCaretEventHub* aContext) override {
+ aContext->mManager->OnScrollStart();
+ aContext->SetState(AccessibleCaretEventHub::ScrollState());
+ }
+
+ MOZ_CAN_RUN_SCRIPT
+ void OnReflow(AccessibleCaretEventHub* aContext) override {
+ aContext->mManager->OnReflow();
+ }
+};
+
+// -----------------------------------------------------------------------------
+// Implementation of AccessibleCaretEventHub methods
+//
+AccessibleCaretEventHub::State* AccessibleCaretEventHub::GetState() const {
+ return mState;
+}
+
+void AccessibleCaretEventHub::SetState(State* aState) {
+ MOZ_ASSERT(aState);
+
+ AC_LOG("%s -> %s", mState->Name(), aState->Name());
+
+ mState->Leave(this);
+ mState = aState;
+ mState->Enter(this);
+}
+
+MOZ_IMPL_STATE_CLASS_GETTER(NoActionState)
+MOZ_IMPL_STATE_CLASS_GETTER(PressCaretState)
+MOZ_IMPL_STATE_CLASS_GETTER(DragCaretState)
+MOZ_IMPL_STATE_CLASS_GETTER(PressNoCaretState)
+MOZ_IMPL_STATE_CLASS_GETTER(ScrollState)
+MOZ_IMPL_STATE_CLASS_GETTER(LongTapState)
+
+AccessibleCaretEventHub::AccessibleCaretEventHub(PresShell* aPresShell)
+ : mPresShell(aPresShell) {}
+
+void AccessibleCaretEventHub::Init() {
+ if (mInitialized && mManager) {
+ mManager->OnFrameReconstruction();
+ }
+
+ if (mInitialized || !mPresShell || !mPresShell->GetCanvasFrame()) {
+ return;
+ }
+
+ // Without nsAutoScriptBlocker, the script might be run after constructing
+ // mFirstCaret in AccessibleCaretManager's constructor, which might destructs
+ // the whole frame tree. Therefore we'll fail to construct mSecondCaret
+ // because we cannot get root frame or canvas frame from mPresShell to inject
+ // anonymous content. To avoid that, we protect Init() by nsAutoScriptBlocker.
+ // To reproduce, run "./mach crashtest layout/base/crashtests/897852.html"
+ // without the following scriptBlocker.
+ nsAutoScriptBlocker scriptBlocker;
+
+ nsPresContext* presContext = mPresShell->GetPresContext();
+ MOZ_ASSERT(presContext, "PresContext should be given in PresShell::Init()");
+
+ nsDocShell* docShell = presContext->GetDocShell();
+ if (!docShell) {
+ return;
+ }
+
+ docShell->AddWeakReflowObserver(this);
+ docShell->AddWeakScrollObserver(this);
+
+ mDocShell = static_cast<nsDocShell*>(docShell);
+
+ if (StaticPrefs::layout_accessiblecaret_use_long_tap_injector()) {
+ mLongTapInjectorTimer = NS_NewTimer();
+ }
+
+ mManager = MakeUnique<AccessibleCaretManager>(mPresShell);
+
+ mInitialized = true;
+}
+
+void AccessibleCaretEventHub::Terminate() {
+ if (!mInitialized) {
+ return;
+ }
+
+ if (mDocShell) {
+ mDocShell->RemoveWeakReflowObserver(this);
+ mDocShell->RemoveWeakScrollObserver(this);
+ }
+
+ if (mLongTapInjectorTimer) {
+ mLongTapInjectorTimer->Cancel();
+ }
+
+ mManager->Terminate();
+ mPresShell = nullptr;
+ mInitialized = false;
+}
+
+nsEventStatus AccessibleCaretEventHub::HandleEvent(WidgetEvent* aEvent) {
+ nsEventStatus status = nsEventStatus_eIgnore;
+
+ if (!mInitialized) {
+ return status;
+ }
+
+ MOZ_ASSERT(mRefCnt.get() > 1, "Expect caller holds us as well!");
+
+ switch (aEvent->mClass) {
+ case eMouseEventClass:
+ status = HandleMouseEvent(aEvent->AsMouseEvent());
+ break;
+
+ case eTouchEventClass:
+ status = HandleTouchEvent(aEvent->AsTouchEvent());
+ break;
+
+ case eKeyboardEventClass:
+ status = HandleKeyboardEvent(aEvent->AsKeyboardEvent());
+ break;
+
+ default:
+ MOZ_ASSERT_UNREACHABLE(
+ "PresShell should've filtered unwanted event classes!");
+ break;
+ }
+
+ return status;
+}
+
+nsEventStatus AccessibleCaretEventHub::HandleMouseEvent(
+ WidgetMouseEvent* aEvent) {
+ nsEventStatus rv = nsEventStatus_eIgnore;
+
+ if (aEvent->mButton != MouseButton::ePrimary) {
+ return rv;
+ }
+
+ int32_t id =
+ (mActiveTouchId == kInvalidTouchId ? kDefaultTouchId : mActiveTouchId);
+ nsPoint point = GetMouseEventPosition(aEvent);
+
+ if (aEvent->mMessage == eMouseDown || aEvent->mMessage == eMouseUp ||
+ aEvent->mMessage == eMouseClick ||
+ aEvent->mMessage == eMouseDoubleClick ||
+ aEvent->mMessage == eMouseLongTap) {
+ // Don't reset the source on mouse movement since that can
+ // happen anytime, even randomly during a touch sequence.
+ mManager->SetLastInputSource(aEvent->mInputSource);
+ }
+
+ switch (aEvent->mMessage) {
+ case eMouseDown:
+ AC_LOGV("Before eMouseDown, state: %s", mState->Name());
+ rv = mState->OnPress(this, point, id, eMouseEventClass);
+ AC_LOGV("After eMouseDown, state: %s, consume: %d", mState->Name(), rv);
+ break;
+
+ case eMouseMove:
+ AC_LOGV("Before eMouseMove, state: %s", mState->Name());
+ // The mouse move events synthesized from the touch move events can have
+ // wrong point (bug 1549355). Workaround it by ignoring the events when
+ // dragging the caret because the caret doesn't really need them.
+ rv = mState->OnMove(this, point, aEvent->mReason);
+ AC_LOGV("After eMouseMove, state: %s, consume: %d", mState->Name(), rv);
+ break;
+
+ case eMouseUp:
+ AC_LOGV("Before eMouseUp, state: %s", mState->Name());
+ rv = mState->OnRelease(this);
+ AC_LOGV("After eMouseUp, state: %s, consume: %d", mState->Name(), rv);
+ break;
+
+ case eMouseLongTap:
+ AC_LOGV("Before eMouseLongTap, state: %s", mState->Name());
+ rv = mState->OnLongTap(this, point);
+ AC_LOGV("After eMouseLongTap, state: %s, consume: %d", mState->Name(),
+ rv);
+ break;
+
+ default:
+ break;
+ }
+
+ return rv;
+}
+
+nsEventStatus AccessibleCaretEventHub::HandleTouchEvent(
+ WidgetTouchEvent* aEvent) {
+ if (aEvent->mTouches.IsEmpty()) {
+ AC_LOG("%s: Receive a touch event without any touch data!", __FUNCTION__);
+ return nsEventStatus_eIgnore;
+ }
+
+ nsEventStatus rv = nsEventStatus_eIgnore;
+
+ int32_t id =
+ (mActiveTouchId == kInvalidTouchId ? aEvent->mTouches[0]->Identifier()
+ : mActiveTouchId);
+ nsPoint point = GetTouchEventPosition(aEvent, id);
+
+ mManager->SetLastInputSource(MouseEvent_Binding::MOZ_SOURCE_TOUCH);
+
+ switch (aEvent->mMessage) {
+ case eTouchStart:
+ AC_LOGV("Before eTouchStart, state: %s", mState->Name());
+ rv = mState->OnPress(this, point, id, eTouchEventClass);
+ AC_LOGV("After eTouchStart, state: %s, consume: %d", mState->Name(), rv);
+ break;
+
+ case eTouchMove:
+ AC_LOGV("Before eTouchMove, state: %s", mState->Name());
+ // There is no synthesized touch move event.
+ rv = mState->OnMove(this, point, WidgetMouseEvent::eReal);
+ AC_LOGV("After eTouchMove, state: %s, consume: %d", mState->Name(), rv);
+ break;
+
+ case eTouchEnd:
+ AC_LOGV("Before eTouchEnd, state: %s", mState->Name());
+ rv = mState->OnRelease(this);
+ AC_LOGV("After eTouchEnd, state: %s, consume: %d", mState->Name(), rv);
+ break;
+
+ case eTouchCancel:
+ AC_LOGV("Got eTouchCancel, state: %s", mState->Name());
+ // Do nothing since we don't really care eTouchCancel anyway.
+ break;
+
+ default:
+ break;
+ }
+
+ return rv;
+}
+
+nsEventStatus AccessibleCaretEventHub::HandleKeyboardEvent(
+ WidgetKeyboardEvent* aEvent) {
+ mManager->SetLastInputSource(MouseEvent_Binding::MOZ_SOURCE_KEYBOARD);
+
+ switch (aEvent->mMessage) {
+ case eKeyUp:
+ AC_LOGV("eKeyUp, state: %s", mState->Name());
+ mManager->OnKeyboardEvent();
+ break;
+
+ case eKeyDown:
+ AC_LOGV("eKeyDown, state: %s", mState->Name());
+ mManager->OnKeyboardEvent();
+ break;
+
+ case eKeyPress:
+ AC_LOGV("eKeyPress, state: %s", mState->Name());
+ mManager->OnKeyboardEvent();
+ break;
+
+ default:
+ break;
+ }
+
+ return nsEventStatus_eIgnore;
+}
+
+bool AccessibleCaretEventHub::MoveDistanceIsLarge(const nsPoint& aPoint) const {
+ nsPoint delta = aPoint - mPressPoint;
+ return NS_hypot(delta.x, delta.y) >
+ AppUnitsPerCSSPixel() * kMoveStartToleranceInPixel;
+}
+
+void AccessibleCaretEventHub::LaunchLongTapInjector() {
+ if (!mLongTapInjectorTimer) {
+ return;
+ }
+
+ int32_t longTapDelay = StaticPrefs::ui_click_hold_context_menus_delay();
+ mLongTapInjectorTimer->InitWithNamedFuncCallback(
+ FireLongTap, this, longTapDelay, nsITimer::TYPE_ONE_SHOT,
+ "AccessibleCaretEventHub::LaunchLongTapInjector");
+}
+
+void AccessibleCaretEventHub::CancelLongTapInjector() {
+ if (!mLongTapInjectorTimer) {
+ return;
+ }
+
+ mLongTapInjectorTimer->Cancel();
+}
+
+/* static */
+void AccessibleCaretEventHub::FireLongTap(nsITimer* aTimer,
+ void* aAccessibleCaretEventHub) {
+ RefPtr<AccessibleCaretEventHub> self =
+ static_cast<AccessibleCaretEventHub*>(aAccessibleCaretEventHub);
+ self->mState->OnLongTap(self, self->mPressPoint);
+}
+
+NS_IMETHODIMP
+AccessibleCaretEventHub::Reflow(DOMHighResTimeStamp aStart,
+ DOMHighResTimeStamp aEnd) {
+ if (!mInitialized) {
+ return NS_OK;
+ }
+
+ MOZ_ASSERT(mRefCnt.get() > 1, "Expect caller holds us as well!");
+
+ if (mIsInReflowCallback) {
+ return NS_OK;
+ }
+
+ AutoRestore<bool> autoRestoreIsInReflowCallback(mIsInReflowCallback);
+ mIsInReflowCallback = true;
+
+ AC_LOG("%s, state: %s", __FUNCTION__, mState->Name());
+ mState->OnReflow(this);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+AccessibleCaretEventHub::ReflowInterruptible(DOMHighResTimeStamp aStart,
+ DOMHighResTimeStamp aEnd) {
+ // Defer the error checking to Reflow().
+ return Reflow(aStart, aEnd);
+}
+
+void AccessibleCaretEventHub::AsyncPanZoomStarted() {
+ if (!mInitialized) {
+ return;
+ }
+
+ MOZ_ASSERT(mRefCnt.get() > 1, "Expect caller holds us as well!");
+
+ AC_LOG("%s, state: %s", __FUNCTION__, mState->Name());
+ mState->OnScrollStart(this);
+}
+
+void AccessibleCaretEventHub::AsyncPanZoomStopped() {
+ if (!mInitialized) {
+ return;
+ }
+
+ MOZ_ASSERT(mRefCnt.get() > 1, "Expect caller holds us as well!");
+
+ AC_LOG("%s, state: %s", __FUNCTION__, mState->Name());
+ mState->OnScrollEnd(this);
+}
+
+void AccessibleCaretEventHub::ScrollPositionChanged() {
+ if (!mInitialized) {
+ return;
+ }
+
+ MOZ_ASSERT(mRefCnt.get() > 1, "Expect caller holds us as well!");
+
+ AC_LOG("%s, state: %s", __FUNCTION__, mState->Name());
+ mState->OnScrollPositionChanged(this);
+}
+
+void AccessibleCaretEventHub::OnSelectionChange(Document* aDoc,
+ dom::Selection* aSel,
+ int16_t aReason) {
+ if (!mInitialized) {
+ return;
+ }
+
+ MOZ_ASSERT(mRefCnt.get() > 1, "Expect caller holds us as well!");
+
+ AC_LOG("%s, state: %s, reason: %d", __FUNCTION__, mState->Name(), aReason);
+
+ // XXX Here we may be in a hot path. So, if we could avoid this virtual call,
+ // we should do so.
+ mState->OnSelectionChanged(this, aDoc, aSel, aReason);
+}
+
+bool AccessibleCaretEventHub::ShouldDisableApz() const {
+ return mManager && mManager->ShouldDisableApz();
+}
+
+void AccessibleCaretEventHub::NotifyBlur(bool aIsLeavingDocument) {
+ if (!mInitialized) {
+ return;
+ }
+
+ MOZ_ASSERT(mRefCnt.get() > 1, "Expect caller holds us as well!");
+
+ AC_LOG("%s, state: %s", __FUNCTION__, mState->Name());
+ mState->OnBlur(this, aIsLeavingDocument);
+}
+
+nsPoint AccessibleCaretEventHub::GetTouchEventPosition(
+ WidgetTouchEvent* aEvent, int32_t aIdentifier) const {
+ for (dom::Touch* touch : aEvent->mTouches) {
+ if (touch->Identifier() == aIdentifier) {
+ LayoutDeviceIntPoint touchIntPoint = touch->mRefPoint;
+
+ // Get event coordinate relative to root frame.
+ nsIFrame* rootFrame = mPresShell->GetRootFrame();
+ return nsLayoutUtils::GetEventCoordinatesRelativeTo(
+ aEvent, touchIntPoint, RelativeTo{rootFrame});
+ }
+ }
+ return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
+}
+
+nsPoint AccessibleCaretEventHub::GetMouseEventPosition(
+ WidgetMouseEvent* aEvent) const {
+ LayoutDeviceIntPoint mouseIntPoint = aEvent->AsGUIEvent()->mRefPoint;
+
+ // Get event coordinate relative to root frame.
+ nsIFrame* rootFrame = mPresShell->GetRootFrame();
+ return nsLayoutUtils::GetEventCoordinatesRelativeTo(aEvent, mouseIntPoint,
+ RelativeTo{rootFrame});
+}
+
+} // namespace mozilla