diff options
Diffstat (limited to 'layout/base/AccessibleCaretManager.cpp')
| -rw-r--r-- | layout/base/AccessibleCaretManager.cpp | 1474 |
1 files changed, 1474 insertions, 0 deletions
diff --git a/layout/base/AccessibleCaretManager.cpp b/layout/base/AccessibleCaretManager.cpp new file mode 100644 index 000000000..ac3f36bea --- /dev/null +++ b/layout/base/AccessibleCaretManager.cpp @@ -0,0 +1,1474 @@ +/* -*- 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 "AccessibleCaretManager.h" + +#include "AccessibleCaret.h" +#include "AccessibleCaretEventHub.h" +#include "AccessibleCaretLogger.h" +#include "mozilla/AsyncEventDispatcher.h" +#include "mozilla/dom/Element.h" +#include "mozilla/dom/Selection.h" +#include "mozilla/dom/TreeWalker.h" +#include "mozilla/IMEStateManager.h" +#include "mozilla/Preferences.h" +#include "nsCaret.h" +#include "nsContainerFrame.h" +#include "nsContentUtils.h" +#include "nsFocusManager.h" +#include "nsFrame.h" +#include "nsFrameSelection.h" +#include "nsGenericHTMLElement.h" +#include "nsIHapticFeedback.h" +#ifdef MOZ_WIDGET_ANDROID +#include "nsWindow.h" +#endif + +namespace mozilla { + +#undef AC_LOG +#define AC_LOG(message, ...) \ + AC_LOG_BASE("AccessibleCaretManager (%p): " message, this, ##__VA_ARGS__); + +#undef AC_LOGV +#define AC_LOGV(message, ...) \ + AC_LOGV_BASE("AccessibleCaretManager (%p): " message, this, ##__VA_ARGS__); + +using namespace dom; +using Appearance = AccessibleCaret::Appearance; +using PositionChangedResult = AccessibleCaret::PositionChangedResult; + +#define AC_PROCESS_ENUM_TO_STREAM(e) case(e): aStream << #e; break; +std::ostream& +operator<<(std::ostream& aStream, + const AccessibleCaretManager::CaretMode& aCaretMode) +{ + using CaretMode = AccessibleCaretManager::CaretMode; + switch (aCaretMode) { + AC_PROCESS_ENUM_TO_STREAM(CaretMode::None); + AC_PROCESS_ENUM_TO_STREAM(CaretMode::Cursor); + AC_PROCESS_ENUM_TO_STREAM(CaretMode::Selection); + } + return aStream; +} + +std::ostream& operator<<(std::ostream& aStream, + const AccessibleCaretManager::UpdateCaretsHint& aHint) +{ + using UpdateCaretsHint = AccessibleCaretManager::UpdateCaretsHint; + switch (aHint) { + AC_PROCESS_ENUM_TO_STREAM(UpdateCaretsHint::Default); + AC_PROCESS_ENUM_TO_STREAM(UpdateCaretsHint::RespectOldAppearance); + } + return aStream; +} +#undef AC_PROCESS_ENUM_TO_STREAM + +/*static*/ bool +AccessibleCaretManager::sSelectionBarEnabled = false; +/*static*/ bool +AccessibleCaretManager::sCaretShownWhenLongTappingOnEmptyContent = false; +/*static*/ bool +AccessibleCaretManager::sCaretsAlwaysTilt = false; +/*static*/ bool +AccessibleCaretManager::sCaretsAlwaysShowWhenScrolling = true; +/*static*/ bool +AccessibleCaretManager::sCaretsScriptUpdates = false; +/*static*/ bool +AccessibleCaretManager::sCaretsAllowDraggingAcrossOtherCaret = true; +/*static*/ bool +AccessibleCaretManager::sHapticFeedback = false; +/*static*/ bool +AccessibleCaretManager::sExtendSelectionForPhoneNumber = false; +/*static*/ bool +AccessibleCaretManager::sHideCaretsForMouseInput = true; + +AccessibleCaretManager::AccessibleCaretManager(nsIPresShell* aPresShell) + : mPresShell(aPresShell) +{ + if (!mPresShell) { + return; + } + + mFirstCaret = MakeUnique<AccessibleCaret>(mPresShell); + mSecondCaret = MakeUnique<AccessibleCaret>(mPresShell); + + mCaretTimeoutTimer = do_CreateInstance("@mozilla.org/timer;1"); + + static bool addedPrefs = false; + if (!addedPrefs) { + Preferences::AddBoolVarCache(&sSelectionBarEnabled, + "layout.accessiblecaret.bar.enabled"); + Preferences::AddBoolVarCache(&sCaretShownWhenLongTappingOnEmptyContent, + "layout.accessiblecaret.caret_shown_when_long_tapping_on_empty_content"); + Preferences::AddBoolVarCache(&sCaretsAlwaysTilt, + "layout.accessiblecaret.always_tilt"); + Preferences::AddBoolVarCache(&sCaretsAlwaysShowWhenScrolling, + "layout.accessiblecaret.always_show_when_scrolling", true); + Preferences::AddBoolVarCache(&sCaretsScriptUpdates, + "layout.accessiblecaret.allow_script_change_updates"); + Preferences::AddBoolVarCache(&sCaretsAllowDraggingAcrossOtherCaret, + "layout.accessiblecaret.allow_dragging_across_other_caret", true); + Preferences::AddBoolVarCache(&sHapticFeedback, + "layout.accessiblecaret.hapticfeedback"); + Preferences::AddBoolVarCache(&sExtendSelectionForPhoneNumber, + "layout.accessiblecaret.extend_selection_for_phone_number"); + Preferences::AddBoolVarCache(&sHideCaretsForMouseInput, + "layout.accessiblecaret.hide_carets_for_mouse_input"); + addedPrefs = true; + } +} + +AccessibleCaretManager::~AccessibleCaretManager() +{ +} + +void +AccessibleCaretManager::Terminate() +{ + CancelCaretTimeoutTimer(); + mCaretTimeoutTimer = nullptr; + mFirstCaret = nullptr; + mSecondCaret = nullptr; + mActiveCaret = nullptr; + mPresShell = nullptr; +} + +nsresult +AccessibleCaretManager::OnSelectionChanged(nsIDOMDocument* aDoc, + nsISelection* aSel, int16_t aReason) +{ + Selection* selection = GetSelection(); + AC_LOG("%s: aSel: %p, GetSelection(): %p, aReason: %d", __FUNCTION__, + aSel, selection, aReason); + if (aSel != selection) { + return NS_OK; + } + + // eSetSelection events from the Fennec widget IME can be generated + // by autoSuggest / autoCorrect composition changes, or by TYPE_REPLACE_TEXT + // actions, either positioning cursor for text insert, or selecting + // text-to-be-replaced. None should affect AccessibleCaret visibility. + if (aReason & nsISelectionListener::IME_REASON) { + return NS_OK; + } + + // Move the cursor by Javascript / or unknown internal. + if (aReason == nsISelectionListener::NO_REASON) { + // Update visible carets, if javascript changes are allowed. + if (sCaretsScriptUpdates && + (mFirstCaret->IsLogicallyVisible() || mSecondCaret->IsLogicallyVisible())) { + UpdateCarets(); + return NS_OK; + } + // Default for NO_REASON is to make hidden. + HideCarets(); + return NS_OK; + } + + // Move cursor by keyboard. + if (aReason & nsISelectionListener::KEYPRESS_REASON) { + HideCarets(); + return NS_OK; + } + + // OnBlur() might be called between mouse down and mouse up, so we hide carets + // upon mouse down anyway, and update carets upon mouse up. + if (aReason & nsISelectionListener::MOUSEDOWN_REASON) { + HideCarets(); + return NS_OK; + } + + // Range will collapse after cutting or copying text. + if (aReason & (nsISelectionListener::COLLAPSETOSTART_REASON | + nsISelectionListener::COLLAPSETOEND_REASON)) { + HideCarets(); + return NS_OK; + } + + // For mouse input we don't want to show the carets. + if (sHideCaretsForMouseInput && + mLastInputSource == nsIDOMMouseEvent::MOZ_SOURCE_MOUSE) { + HideCarets(); + return NS_OK; + } + + // When we want to hide the carets for mouse input, hide them for select + // all action fired by keyboard as well. + if (sHideCaretsForMouseInput && + mLastInputSource == nsIDOMMouseEvent::MOZ_SOURCE_KEYBOARD && + (aReason & nsISelectionListener::SELECTALL_REASON)) { + HideCarets(); + return NS_OK; + } + + UpdateCarets(); + return NS_OK; +} + +void +AccessibleCaretManager::HideCarets() +{ + if (mFirstCaret->IsLogicallyVisible() || mSecondCaret->IsLogicallyVisible()) { + AC_LOG("%s", __FUNCTION__); + mFirstCaret->SetAppearance(Appearance::None); + mSecondCaret->SetAppearance(Appearance::None); + DispatchCaretStateChangedEvent(CaretChangedReason::Visibilitychange); + CancelCaretTimeoutTimer(); + } +} + +void +AccessibleCaretManager::UpdateCarets(UpdateCaretsHint aHint) +{ + FlushLayout(); + if (IsTerminated()) { + return; + } + + mLastUpdateCaretMode = GetCaretMode(); + + switch (mLastUpdateCaretMode) { + case CaretMode::None: + HideCarets(); + break; + case CaretMode::Cursor: + UpdateCaretsForCursorMode(aHint); + break; + case CaretMode::Selection: + UpdateCaretsForSelectionMode(aHint); + break; + } +} + +bool +AccessibleCaretManager::IsCaretDisplayableInCursorMode(nsIFrame** aOutFrame, + int32_t* aOutOffset) const +{ + RefPtr<nsCaret> caret = mPresShell->GetCaret(); + if (!caret || !caret->IsVisible()) { + return false; + } + + int32_t offset = 0; + nsIFrame* frame = nsCaret::GetFrameAndOffset(GetSelection(), nullptr, 0, &offset); + + if (!frame) { + return false; + } + + if (!GetEditingHostForFrame(frame)) { + return false; + } + + if (aOutFrame) { + *aOutFrame = frame; + } + + if (aOutOffset) { + *aOutOffset = offset; + } + + return true; +} + +bool +AccessibleCaretManager::HasNonEmptyTextContent(nsINode* aNode) const +{ + return nsContentUtils::HasNonEmptyTextContent( + aNode, nsContentUtils::eRecurseIntoChildren); +} + +void +AccessibleCaretManager::UpdateCaretsForCursorMode(UpdateCaretsHint aHint) +{ + AC_LOG("%s, selection: %p", __FUNCTION__, GetSelection()); + + int32_t offset = 0; + nsIFrame* frame = nullptr; + if (!IsCaretDisplayableInCursorMode(&frame, &offset)) { + HideCarets(); + return; + } + + bool oldSecondCaretVisible = mSecondCaret->IsLogicallyVisible(); + PositionChangedResult result = mFirstCaret->SetPosition(frame, offset); + + switch (result) { + case PositionChangedResult::NotChanged: + // Do nothing + break; + + case PositionChangedResult::Changed: + switch (aHint) { + case UpdateCaretsHint::Default: + if (HasNonEmptyTextContent(GetEditingHostForFrame(frame))) { + mFirstCaret->SetAppearance(Appearance::Normal); + } else if (sCaretShownWhenLongTappingOnEmptyContent) { + if (mFirstCaret->IsLogicallyVisible()) { + // Possible cases are: 1) SelectWordOrShortcut() sets the + // appearance to Normal. 2) When the caret is out of viewport and + // now scrolling into viewport, it has appearance NormalNotShown. + mFirstCaret->SetAppearance(Appearance::Normal); + } else { + // Possible cases are: a) Single tap on current empty content; + // OnSelectionChanged() sets the appearance to None due to + // MOUSEDOWN_REASON. b) Single tap on other empty content; + // OnBlur() sets the appearance to None. + // + // Do nothing to make the appearance remains None so that it can + // be distinguished from case 2). Also do not set the appearance + // to NormalNotShown here like the default update behavior. + } + } else { + mFirstCaret->SetAppearance(Appearance::NormalNotShown); + } + break; + + case UpdateCaretsHint::RespectOldAppearance: + // Do nothing to preserve the appearance of the caret set by the + // caller. + break; + } + break; + + case PositionChangedResult::Invisible: + mFirstCaret->SetAppearance(Appearance::NormalNotShown); + break; + } + + mFirstCaret->SetSelectionBarEnabled(false); + mSecondCaret->SetAppearance(Appearance::None); + + LaunchCaretTimeoutTimer(); + + if ((result != PositionChangedResult::NotChanged || oldSecondCaretVisible) && + !mActiveCaret) { + DispatchCaretStateChangedEvent(CaretChangedReason::Updateposition); + } +} + +void +AccessibleCaretManager::UpdateCaretsForSelectionMode(UpdateCaretsHint aHint) +{ + AC_LOG("%s: selection: %p", __FUNCTION__, GetSelection()); + + int32_t startOffset = 0; + nsIFrame* startFrame = + GetFrameForFirstRangeStartOrLastRangeEnd(eDirNext, &startOffset); + + int32_t endOffset = 0; + nsIFrame* endFrame = + GetFrameForFirstRangeStartOrLastRangeEnd(eDirPrevious, &endOffset); + + if (!CompareTreePosition(startFrame, endFrame)) { + // XXX: Do we really have to hide carets if this condition isn't satisfied? + HideCarets(); + return; + } + + auto updateSingleCaret = [aHint](AccessibleCaret* aCaret, nsIFrame* aFrame, + int32_t aOffset) -> PositionChangedResult + { + PositionChangedResult result = aCaret->SetPosition(aFrame, aOffset); + aCaret->SetSelectionBarEnabled(sSelectionBarEnabled); + + switch (result) { + case PositionChangedResult::NotChanged: + // Do nothing + break; + + case PositionChangedResult::Changed: + switch (aHint) { + case UpdateCaretsHint::Default: + aCaret->SetAppearance(Appearance::Normal); + break; + + case UpdateCaretsHint::RespectOldAppearance: + // Do nothing to preserve the appearance of the caret set by the + // caller. + break; + } + break; + + case PositionChangedResult::Invisible: + aCaret->SetAppearance(Appearance::NormalNotShown); + break; + } + return result; + }; + + PositionChangedResult firstCaretResult = + updateSingleCaret(mFirstCaret.get(), startFrame, startOffset); + PositionChangedResult secondCaretResult = + updateSingleCaret(mSecondCaret.get(), endFrame, endOffset); + + if (firstCaretResult == PositionChangedResult::Changed || + secondCaretResult == PositionChangedResult::Changed) { + // Flush layout to make the carets intersection correct. + FlushLayout(); + if (IsTerminated()) { + return; + } + } + + if (aHint == UpdateCaretsHint::Default) { + // Only check for tilt carets with default update hint. Otherwise we might + // override the appearance set by the caller. + if (sCaretsAlwaysTilt) { + UpdateCaretsForAlwaysTilt(startFrame, endFrame); + } else { + UpdateCaretsForOverlappingTilt(); + } + } + + if (!mActiveCaret) { + DispatchCaretStateChangedEvent(CaretChangedReason::Updateposition); + } +} + +void +AccessibleCaretManager::UpdateCaretsForOverlappingTilt() +{ + if (mFirstCaret->IsVisuallyVisible() && mSecondCaret->IsVisuallyVisible()) { + if (mFirstCaret->Intersects(*mSecondCaret)) { + if (mFirstCaret->LogicalPosition().x <= + mSecondCaret->LogicalPosition().x) { + mFirstCaret->SetAppearance(Appearance::Left); + mSecondCaret->SetAppearance(Appearance::Right); + } else { + mFirstCaret->SetAppearance(Appearance::Right); + mSecondCaret->SetAppearance(Appearance::Left); + } + } else { + mFirstCaret->SetAppearance(Appearance::Normal); + mSecondCaret->SetAppearance(Appearance::Normal); + } + } +} + +void +AccessibleCaretManager::UpdateCaretsForAlwaysTilt(nsIFrame* aStartFrame, + nsIFrame* aEndFrame) +{ + if (mFirstCaret->IsVisuallyVisible()) { + auto startFrameWritingMode = aStartFrame->GetWritingMode(); + mFirstCaret->SetAppearance(startFrameWritingMode.IsBidiLTR() ? + Appearance::Left : Appearance::Right); + } + if (mSecondCaret->IsVisuallyVisible()) { + auto endFrameWritingMode = aEndFrame->GetWritingMode(); + mSecondCaret->SetAppearance(endFrameWritingMode.IsBidiLTR() ? + Appearance::Right : Appearance::Left); + } +} + +void +AccessibleCaretManager::ProvideHapticFeedback() +{ + if (sHapticFeedback) { + nsCOMPtr<nsIHapticFeedback> haptic = + do_GetService("@mozilla.org/widget/hapticfeedback;1"); + haptic->PerformSimpleAction(haptic->LongPress); + } +} + +nsresult +AccessibleCaretManager::PressCaret(const nsPoint& aPoint, + EventClassID aEventClass) +{ + nsresult rv = NS_ERROR_FAILURE; + + MOZ_ASSERT(aEventClass == eMouseEventClass || aEventClass == eTouchEventClass, + "Unexpected event class!"); + + using TouchArea = AccessibleCaret::TouchArea; + TouchArea touchArea = + aEventClass == eMouseEventClass ? TouchArea::CaretImage : TouchArea::Full; + + if (mFirstCaret->Contains(aPoint, touchArea)) { + mActiveCaret = mFirstCaret.get(); + SetSelectionDirection(eDirPrevious); + } else if (mSecondCaret->Contains(aPoint, touchArea)) { + mActiveCaret = mSecondCaret.get(); + SetSelectionDirection(eDirNext); + } + + if (mActiveCaret) { + mOffsetYToCaretLogicalPosition = + mActiveCaret->LogicalPosition().y - aPoint.y; + SetSelectionDragState(true); + DispatchCaretStateChangedEvent(CaretChangedReason::Presscaret); + CancelCaretTimeoutTimer(); + rv = NS_OK; + } + + return rv; +} + +nsresult +AccessibleCaretManager::DragCaret(const nsPoint& aPoint) +{ + MOZ_ASSERT(mActiveCaret); + MOZ_ASSERT(GetCaretMode() != CaretMode::None); + + nsPoint point(aPoint.x, aPoint.y + mOffsetYToCaretLogicalPosition); + DragCaretInternal(point); + UpdateCarets(); + return NS_OK; +} + +nsresult +AccessibleCaretManager::ReleaseCaret() +{ + MOZ_ASSERT(mActiveCaret); + + mActiveCaret = nullptr; + SetSelectionDragState(false); + DispatchCaretStateChangedEvent(CaretChangedReason::Releasecaret); + LaunchCaretTimeoutTimer(); + return NS_OK; +} + +nsresult +AccessibleCaretManager::TapCaret(const nsPoint& aPoint) +{ + MOZ_ASSERT(GetCaretMode() != CaretMode::None); + + nsresult rv = NS_ERROR_FAILURE; + + if (GetCaretMode() == CaretMode::Cursor) { + DispatchCaretStateChangedEvent(CaretChangedReason::Taponcaret); + rv = NS_OK; + } + + return rv; +} + +nsresult +AccessibleCaretManager::SelectWordOrShortcut(const nsPoint& aPoint) +{ + auto UpdateCaretsWithHapticFeedback = [this] { + UpdateCarets(); + ProvideHapticFeedback(); + }; + + // If the long-tap is landing on a pre-existing selection, don't replace + // it with a new one. Instead just return and let the context menu pop up + // on the pre-existing selection. + if (GetCaretMode() == CaretMode::Selection && + GetSelection()->ContainsPoint(aPoint)) { + AC_LOG("%s: UpdateCarets() for current selection", __FUNCTION__); + UpdateCaretsWithHapticFeedback(); + return NS_OK; + } + + if (!mPresShell) { + return NS_ERROR_UNEXPECTED; + } + + nsIFrame* rootFrame = mPresShell->GetRootFrame(); + if (!rootFrame) { + return NS_ERROR_NOT_AVAILABLE; + } + + // Find the frame under point. + nsWeakFrame ptFrame = nsLayoutUtils::GetFrameForPoint(rootFrame, aPoint, + nsLayoutUtils::IGNORE_PAINT_SUPPRESSION | nsLayoutUtils::IGNORE_CROSS_DOC); + if (!ptFrame.IsAlive()) { + return NS_ERROR_FAILURE; + } + + nsIFrame* focusableFrame = GetFocusableFrame(ptFrame); + +#ifdef DEBUG_FRAME_DUMP + AC_LOG("%s: Found %s under (%d, %d)", __FUNCTION__, ptFrame->ListTag().get(), + aPoint.x, aPoint.y); + AC_LOG("%s: Found %s focusable", __FUNCTION__, + focusableFrame ? focusableFrame->ListTag().get() : "no frame"); +#endif + + // Get ptInFrame here so that we don't need to check whether rootFrame is + // alive later. Note that if ptFrame is being moved by + // IMEStateManager::NotifyIME() or ChangeFocusToOrClearOldFocus() below, + // something under the original point will be selected, which may not be the + // original text the user wants to select. + nsPoint ptInFrame = aPoint; + nsLayoutUtils::TransformPoint(rootFrame, ptFrame, ptInFrame); + + // Firstly check long press on an empty editable content. + Element* newFocusEditingHost = GetEditingHostForFrame(ptFrame); + if (focusableFrame && newFocusEditingHost && + !HasNonEmptyTextContent(newFocusEditingHost)) { + ChangeFocusToOrClearOldFocus(focusableFrame); + + if (sCaretShownWhenLongTappingOnEmptyContent) { + mFirstCaret->SetAppearance(Appearance::Normal); + } + // We need to update carets to get correct information before dispatching + // CaretStateChangedEvent. + UpdateCaretsWithHapticFeedback(); + DispatchCaretStateChangedEvent(CaretChangedReason::Longpressonemptycontent); + return NS_OK; + } + + bool selectable = false; + ptFrame->IsSelectable(&selectable, nullptr); + +#ifdef DEBUG_FRAME_DUMP + AC_LOG("%s: %s %s selectable.", __FUNCTION__, ptFrame->ListTag().get(), + selectable ? "is" : "is NOT"); +#endif + + if (!selectable) { + return NS_ERROR_FAILURE; + } + + // Commit the composition string of the old editable focus element (if there + // is any) before changing the focus. + IMEStateManager::NotifyIME(widget::REQUEST_TO_COMMIT_COMPOSITION, + mPresShell->GetPresContext()); + if (!ptFrame.IsAlive()) { + // Cannot continue because ptFrame died. + return NS_ERROR_FAILURE; + } + + // ptFrame is selectable. Now change the focus. + ChangeFocusToOrClearOldFocus(focusableFrame); + if (!ptFrame.IsAlive()) { + // Cannot continue because ptFrame died. + return NS_ERROR_FAILURE; + } + + // Then try select a word under point. + nsresult rv = SelectWord(ptFrame, ptInFrame); + UpdateCaretsWithHapticFeedback(); + + return rv; +} + +void +AccessibleCaretManager::OnScrollStart() +{ + AC_LOG("%s", __FUNCTION__); + + if (!sCaretsAlwaysShowWhenScrolling) { + // Backup the appearance so that we can restore them after the scrolling + // ends. + mFirstCaretAppearanceOnScrollStart = mFirstCaret->GetAppearance(); + mSecondCaretAppearanceOnScrollStart = mSecondCaret->GetAppearance(); + HideCarets(); + return; + } + + if (mFirstCaret->IsLogicallyVisible() || mSecondCaret->IsLogicallyVisible()) { + // Dispatch the event only if one of the carets is logically visible like in + // HideCarets(). + DispatchCaretStateChangedEvent(CaretChangedReason::Scroll); + } +} + +void +AccessibleCaretManager::OnScrollEnd() +{ + if (mLastUpdateCaretMode != GetCaretMode()) { + return; + } + + if (!sCaretsAlwaysShowWhenScrolling) { + // Restore the appearance which is saved before the scrolling is started. + mFirstCaret->SetAppearance(mFirstCaretAppearanceOnScrollStart); + mSecondCaret->SetAppearance(mSecondCaretAppearanceOnScrollStart); + } + + if (GetCaretMode() == CaretMode::Cursor) { + if (!mFirstCaret->IsLogicallyVisible()) { + // If the caret is hidden (Appearance::None) due to timeout or blur, no + // need to update it. + return; + } + } + + // For mouse input we don't want to show the carets. + if (sHideCaretsForMouseInput && + mLastInputSource == nsIDOMMouseEvent::MOZ_SOURCE_MOUSE) { + AC_LOG("%s: HideCarets()", __FUNCTION__); + HideCarets(); + return; + } + + AC_LOG("%s: UpdateCarets()", __FUNCTION__); + UpdateCarets(); +} + +void +AccessibleCaretManager::OnScrollPositionChanged() +{ + if (mLastUpdateCaretMode != GetCaretMode()) { + return; + } + + if (mFirstCaret->IsLogicallyVisible() || mSecondCaret->IsLogicallyVisible()) { + AC_LOG("%s: UpdateCarets(RespectOldAppearance)", __FUNCTION__); + UpdateCarets(UpdateCaretsHint::RespectOldAppearance); + } +} + +void +AccessibleCaretManager::OnReflow() +{ + if (mLastUpdateCaretMode != GetCaretMode()) { + return; + } + + if (mFirstCaret->IsLogicallyVisible() || mSecondCaret->IsLogicallyVisible()) { + AC_LOG("%s: UpdateCarets(RespectOldAppearance)", __FUNCTION__); + UpdateCarets(UpdateCaretsHint::RespectOldAppearance); + } +} + +void +AccessibleCaretManager::OnBlur() +{ + AC_LOG("%s: HideCarets()", __FUNCTION__); + HideCarets(); +} + +void +AccessibleCaretManager::OnKeyboardEvent() +{ + if (GetCaretMode() == CaretMode::Cursor) { + AC_LOG("%s: HideCarets()", __FUNCTION__); + HideCarets(); + } +} + +void +AccessibleCaretManager::OnFrameReconstruction() +{ + mFirstCaret->EnsureApzAware(); + mSecondCaret->EnsureApzAware(); +} + +void +AccessibleCaretManager::SetLastInputSource(uint16_t aInputSource) +{ + mLastInputSource = aInputSource; +} + +Selection* +AccessibleCaretManager::GetSelection() const +{ + RefPtr<nsFrameSelection> fs = GetFrameSelection(); + if (!fs) { + return nullptr; + } + return fs->GetSelection(SelectionType::eNormal); +} + +already_AddRefed<nsFrameSelection> +AccessibleCaretManager::GetFrameSelection() const +{ + if (!mPresShell) { + return nullptr; + } + + nsFocusManager* fm = nsFocusManager::GetFocusManager(); + MOZ_ASSERT(fm); + + nsIContent* focusedContent = fm->GetFocusedContent(); + if (focusedContent) { + nsIFrame* focusFrame = focusedContent->GetPrimaryFrame(); + if (!focusFrame) { + return nullptr; + } + + // Prevent us from touching the nsFrameSelection associated with other + // PresShell. + RefPtr<nsFrameSelection> fs = focusFrame->GetFrameSelection(); + if (!fs || fs->GetShell() != mPresShell) { + return nullptr; + } + + return fs.forget(); + } else { + // For non-editable content + return mPresShell->FrameSelection(); + } +} + +Element* +AccessibleCaretManager::GetEditingHostForFrame(nsIFrame* aFrame) const +{ + if (!aFrame) { + return nullptr; + } + + auto content = aFrame->GetContent(); + if (!content) { + return nullptr; + } + + return content->GetEditingHost(); +} + + +AccessibleCaretManager::CaretMode +AccessibleCaretManager::GetCaretMode() const +{ + Selection* selection = GetSelection(); + if (!selection) { + return CaretMode::None; + } + + uint32_t rangeCount = selection->RangeCount(); + if (rangeCount <= 0) { + return CaretMode::None; + } + + if (selection->IsCollapsed()) { + return CaretMode::Cursor; + } + + return CaretMode::Selection; +} + +nsIFrame* +AccessibleCaretManager::GetFocusableFrame(nsIFrame* aFrame) const +{ + // This implementation is similar to EventStateManager::PostHandleEvent(). + // Look for the nearest enclosing focusable frame. + nsIFrame* focusableFrame = aFrame; + while (focusableFrame) { + if (focusableFrame->IsFocusable(nullptr, true)) { + break; + } + focusableFrame = focusableFrame->GetParent(); + } + return focusableFrame; +} + +void +AccessibleCaretManager::ChangeFocusToOrClearOldFocus(nsIFrame* aFrame) const +{ + nsFocusManager* fm = nsFocusManager::GetFocusManager(); + MOZ_ASSERT(fm); + + if (aFrame) { + nsIContent* focusableContent = aFrame->GetContent(); + MOZ_ASSERT(focusableContent, "Focusable frame must have content!"); + nsCOMPtr<nsIDOMElement> focusableElement = do_QueryInterface(focusableContent); + fm->SetFocus(focusableElement, nsIFocusManager::FLAG_BYMOUSE); + } else { + nsPIDOMWindowOuter* win = mPresShell->GetDocument()->GetWindow(); + if (win) { + fm->ClearFocus(win); + fm->SetFocusedWindow(win); + } + } +} + +nsresult +AccessibleCaretManager::SelectWord(nsIFrame* aFrame, const nsPoint& aPoint) const +{ + SetSelectionDragState(true); + nsFrame* frame = static_cast<nsFrame*>(aFrame); + nsresult rs = frame->SelectByTypeAtPoint(mPresShell->GetPresContext(), aPoint, + eSelectWord, eSelectWord, 0); + + SetSelectionDragState(false); + ClearMaintainedSelection(); + + // Smart-select phone numbers if possible. + if (sExtendSelectionForPhoneNumber) { + SelectMoreIfPhoneNumber(); + } + + return rs; +} + +void +AccessibleCaretManager::SetSelectionDragState(bool aState) const +{ + RefPtr<nsFrameSelection> fs = GetFrameSelection(); + if (fs) { + fs->SetDragState(aState); + } + + // Pin Fennecs DynamicToolbarAnimator in place before/after dragging, + // to avoid co-incident screen scrolling. + #ifdef MOZ_WIDGET_ANDROID + nsIDocument* doc = mPresShell->GetDocument(); + MOZ_ASSERT(doc); + nsIWidget* widget = nsContentUtils::WidgetForDocument(doc); + static_cast<nsWindow*>(widget)->SetSelectionDragState(aState); + #endif +} + +void +AccessibleCaretManager::SelectMoreIfPhoneNumber() const +{ + SetSelectionDirection(eDirNext); + ExtendPhoneNumberSelection(NS_LITERAL_STRING("forward")); + + SetSelectionDirection(eDirPrevious); + ExtendPhoneNumberSelection(NS_LITERAL_STRING("backward")); + + SetSelectionDirection(eDirNext); +} + +void +AccessibleCaretManager::ExtendPhoneNumberSelection(const nsAString& aDirection) const +{ + if (!mPresShell) { + return; + } + + RefPtr<nsIDocument> doc = mPresShell->GetDocument(); + + // Extend the phone number selection until we find a boundary. + RefPtr<Selection> selection = GetSelection(); + + while (selection) { + const nsRange* anchorFocusRange = selection->GetAnchorFocusRange(); + if (!anchorFocusRange) { + return; + } + + // Backup the anchor focus range since both anchor node and focus node might + // be changed after calling Selection::Modify(). + RefPtr<nsRange> oldAnchorFocusRange = anchorFocusRange->CloneRange(); + + // Save current Focus position, and extend the selection one char. + nsINode* focusNode = selection->GetFocusNode(); + uint32_t focusOffset = selection->FocusOffset(); + selection->Modify(NS_LITERAL_STRING("extend"), + aDirection, + NS_LITERAL_STRING("character")); + if (IsTerminated()) { + return; + } + + // If the selection didn't change, (can't extend further), we're done. + if (selection->GetFocusNode() == focusNode && + selection->FocusOffset() == focusOffset) { + return; + } + + // If the changed selection isn't a valid phone number, we're done. + nsAutoString selectedText; + selection->Stringify(selectedText); + nsAutoString phoneRegex(NS_LITERAL_STRING("(^\\+)?[0-9\\s,\\-.()*#pw]{1,30}$")); + + if (!nsContentUtils::IsPatternMatching(selectedText, phoneRegex, doc)) { + // Backout the undesired selection extend, restore the old anchor focus + // range before exit. + selection->SetAnchorFocusToRange(oldAnchorFocusRange); + return; + } + } +} + +void +AccessibleCaretManager::SetSelectionDirection(nsDirection aDir) const +{ + Selection* selection = GetSelection(); + if (selection) { + selection->AdjustAnchorFocusForMultiRange(aDir); + } +} + +void +AccessibleCaretManager::ClearMaintainedSelection() const +{ + // Selection made by double-clicking for example will maintain the original + // word selection. We should clear it so that we can drag caret freely. + RefPtr<nsFrameSelection> fs = GetFrameSelection(); + if (fs) { + fs->MaintainSelection(eSelectNoAmount); + } +} + +void +AccessibleCaretManager::FlushLayout() const +{ + if (mPresShell) { + mPresShell->FlushPendingNotifications(Flush_Layout); + } +} + +nsIFrame* +AccessibleCaretManager::GetFrameForFirstRangeStartOrLastRangeEnd( + nsDirection aDirection, int32_t* aOutOffset, nsINode** aOutNode, + int32_t* aOutNodeOffset) const +{ + if (!mPresShell) { + return nullptr; + } + + MOZ_ASSERT(GetCaretMode() == CaretMode::Selection); + MOZ_ASSERT(aOutOffset, "aOutOffset shouldn't be nullptr!"); + + nsRange* range = nullptr; + RefPtr<nsINode> startNode; + RefPtr<nsINode> endNode; + int32_t nodeOffset = 0; + CaretAssociationHint hint; + + RefPtr<Selection> selection = GetSelection(); + bool findInFirstRangeStart = aDirection == eDirNext; + + if (findInFirstRangeStart) { + range = selection->GetRangeAt(0); + startNode = range->GetStartParent(); + endNode = range->GetEndParent(); + nodeOffset = range->StartOffset(); + hint = CARET_ASSOCIATE_AFTER; + } else { + range = selection->GetRangeAt(selection->RangeCount() - 1); + startNode = range->GetEndParent(); + endNode = range->GetStartParent(); + nodeOffset = range->EndOffset(); + hint = CARET_ASSOCIATE_BEFORE; + } + + nsCOMPtr<nsIContent> startContent = do_QueryInterface(startNode); + RefPtr<nsFrameSelection> fs = GetFrameSelection(); + nsIFrame* startFrame = + fs->GetFrameForNodeOffset(startContent, nodeOffset, hint, aOutOffset); + + if (!startFrame) { + ErrorResult err; + RefPtr<TreeWalker> walker = mPresShell->GetDocument()->CreateTreeWalker( + *startNode, nsIDOMNodeFilter::SHOW_ALL, nullptr, err); + + if (!walker) { + return nullptr; + } + + startFrame = startContent ? startContent->GetPrimaryFrame() : nullptr; + while (!startFrame && startNode != endNode) { + startNode = findInFirstRangeStart ? walker->NextNode(err) + : walker->PreviousNode(err); + + if (!startNode) { + break; + } + + startContent = startNode->AsContent(); + startFrame = startContent ? startContent->GetPrimaryFrame() : nullptr; + } + + // We are walking among the nodes in the content tree, so the node offset + // relative to startNode should be set to 0. + nodeOffset = 0; + *aOutOffset = 0; + } + + if (startFrame) { + if (aOutNode) { + *aOutNode = startNode.get(); + } + if (aOutNodeOffset) { + *aOutNodeOffset = nodeOffset; + } + } + + return startFrame; +} + +bool +AccessibleCaretManager::RestrictCaretDraggingOffsets( + nsIFrame::ContentOffsets& aOffsets) +{ + if (!mPresShell) { + return false; + } + + MOZ_ASSERT(GetCaretMode() == CaretMode::Selection); + + nsDirection dir = mActiveCaret == mFirstCaret.get() ? eDirPrevious : eDirNext; + int32_t offset = 0; + nsINode* node = nullptr; + int32_t contentOffset = 0; + nsIFrame* frame = + GetFrameForFirstRangeStartOrLastRangeEnd(dir, &offset, &node, &contentOffset); + + if (!frame) { + return false; + } + + nsCOMPtr<nsIContent> content = do_QueryInterface(node); + + // Compare the active caret's new position (aOffsets) to the inactive caret's + // position. + int32_t cmpToInactiveCaretPos = + nsContentUtils::ComparePoints(aOffsets.content, aOffsets.StartOffset(), + content, contentOffset); + + // Move one character (in the direction of dir) from the inactive caret's + // position. This is the limit for the active caret's new position. + nsPeekOffsetStruct limit(eSelectCluster, dir, offset, nsPoint(0, 0), true, true, + false, false, false); + nsresult rv = frame->PeekOffset(&limit); + if (NS_FAILED(rv)) { + limit.mResultContent = content; + limit.mContentOffset = contentOffset; + } + + // Compare the active caret's new position (aOffsets) to the limit. + int32_t cmpToLimit = + nsContentUtils::ComparePoints(aOffsets.content, aOffsets.StartOffset(), + limit.mResultContent, limit.mContentOffset); + + auto SetOffsetsToLimit = [&aOffsets, &limit] () { + aOffsets.content = limit.mResultContent; + aOffsets.offset = limit.mContentOffset; + aOffsets.secondaryOffset = limit.mContentOffset; + }; + + if (!sCaretsAllowDraggingAcrossOtherCaret) { + if ((mActiveCaret == mFirstCaret.get() && cmpToLimit == 1) || + (mActiveCaret == mSecondCaret.get() && cmpToLimit == -1)) { + // The active caret's position is past the limit, which we don't allow + // here. So set it to the limit, resulting in one character being + // selected. + SetOffsetsToLimit(); + } + } else { + switch (cmpToInactiveCaretPos) { + case 0: + // The active caret's position is the same as the position of the + // inactive caret. So set it to the limit to prevent the selection from + // being collapsed, resulting in one character being selected. + SetOffsetsToLimit(); + break; + case 1: + if (mActiveCaret == mFirstCaret.get()) { + // First caret was moved across the second caret. After making change + // to the selection, the user will drag the second caret. + mActiveCaret = mSecondCaret.get(); + } + break; + case -1: + if (mActiveCaret == mSecondCaret.get()) { + // Second caret was moved across the first caret. After making change + // to the selection, the user will drag the first caret. + mActiveCaret = mFirstCaret.get(); + } + break; + } + } + + return true; +} + +bool +AccessibleCaretManager::CompareTreePosition(nsIFrame* aStartFrame, + nsIFrame* aEndFrame) const +{ + return (aStartFrame && aEndFrame && + nsLayoutUtils::CompareTreePosition(aStartFrame, aEndFrame) <= 0); +} + +nsresult +AccessibleCaretManager::DragCaretInternal(const nsPoint& aPoint) +{ + if (!mPresShell) { + return NS_ERROR_NULL_POINTER; + } + + nsIFrame* rootFrame = mPresShell->GetRootFrame(); + if (!rootFrame) { + return NS_ERROR_NULL_POINTER; + } + + nsPoint point = AdjustDragBoundary(aPoint); + + // Find out which content we point to + nsIFrame* ptFrame = nsLayoutUtils::GetFrameForPoint( + rootFrame, point, + nsLayoutUtils::IGNORE_PAINT_SUPPRESSION | nsLayoutUtils::IGNORE_CROSS_DOC); + if (!ptFrame) { + return NS_ERROR_FAILURE; + } + + RefPtr<nsFrameSelection> fs = GetFrameSelection(); + if (!fs) { + return NS_ERROR_NULL_POINTER; + } + + nsresult result; + nsIFrame* newFrame = nullptr; + nsPoint newPoint; + nsPoint ptInFrame = point; + nsLayoutUtils::TransformPoint(rootFrame, ptFrame, ptInFrame); + result = fs->ConstrainFrameAndPointToAnchorSubtree(ptFrame, ptInFrame, + &newFrame, newPoint); + if (NS_FAILED(result) || !newFrame) { + return NS_ERROR_FAILURE; + } + + bool selectable; + newFrame->IsSelectable(&selectable, nullptr); + if (!selectable) { + return NS_ERROR_FAILURE; + } + + nsIFrame::ContentOffsets offsets = + newFrame->GetContentOffsetsFromPoint(newPoint); + if (offsets.IsNull()) { + return NS_ERROR_FAILURE; + } + + Selection* selection = GetSelection(); + if (!selection) { + return NS_ERROR_NULL_POINTER; + } + + if (GetCaretMode() == CaretMode::Selection && + !RestrictCaretDraggingOffsets(offsets)) { + return NS_ERROR_FAILURE; + } + + ClearMaintainedSelection(); + + nsIFrame* anchorFrame = nullptr; + selection->GetPrimaryFrameForAnchorNode(&anchorFrame); + + nsIFrame* scrollable = + nsLayoutUtils::GetClosestFrameOfType(anchorFrame, nsGkAtoms::scrollFrame); + nsWeakFrame weakScrollable = scrollable; + fs->HandleClick(offsets.content, offsets.StartOffset(), offsets.EndOffset(), + GetCaretMode() == CaretMode::Selection, false, + offsets.associate); + if (!weakScrollable.IsAlive()) { + return NS_OK; + } + + // Scroll scrolled frame. + nsIScrollableFrame* saf = do_QueryFrame(scrollable); + nsIFrame* capturingFrame = saf->GetScrolledFrame(); + nsPoint ptInScrolled = point; + nsLayoutUtils::TransformPoint(rootFrame, capturingFrame, ptInScrolled); + fs->StartAutoScrollTimer(capturingFrame, ptInScrolled, kAutoScrollTimerDelay); + return NS_OK; +} + +nsRect +AccessibleCaretManager::GetAllChildFrameRectsUnion(nsIFrame* aFrame) const +{ + nsRect unionRect; + + // Drill through scroll frames, we don't want to include scrollbar child + // frames below. + for (nsIFrame* frame = aFrame->GetContentInsertionFrame(); + frame; + frame = frame->GetNextContinuation()) { + nsRect frameRect; + + for (nsIFrame::ChildListIterator lists(frame); !lists.IsDone(); lists.Next()) { + // Loop all children to union their scrollable overflow rect. + for (nsIFrame* child : lists.CurrentList()) { + nsRect childRect = child->GetScrollableOverflowRectRelativeToSelf(); + nsLayoutUtils::TransformRect(child, frame, childRect); + + // A TextFrame containing only '\n' has positive height and width 0, or + // positive width and height 0 if it's vertical. Need to use UnionEdges + // to add its rect. BRFrame rect should be non-empty. + if (childRect.IsEmpty()) { + frameRect = frameRect.UnionEdges(childRect); + } else { + frameRect = frameRect.Union(childRect); + } + } + } + + MOZ_ASSERT(!frameRect.IsEmpty(), + "Editable frames should have at least one BRFrame child to make " + "frameRect non-empty!"); + if (frame != aFrame) { + nsLayoutUtils::TransformRect(frame, aFrame, frameRect); + } + unionRect = unionRect.Union(frameRect); + } + + return unionRect; +} + +nsPoint +AccessibleCaretManager::AdjustDragBoundary(const nsPoint& aPoint) const +{ + nsPoint adjustedPoint = aPoint; + + int32_t focusOffset = 0; + nsIFrame* focusFrame = + nsCaret::GetFrameAndOffset(GetSelection(), nullptr, 0, &focusOffset); + Element* editingHost = GetEditingHostForFrame(focusFrame); + + if (editingHost) { + nsIFrame* editingHostFrame = editingHost->GetPrimaryFrame(); + if (editingHostFrame) { + nsRect boundary = GetAllChildFrameRectsUnion(editingHostFrame); + nsLayoutUtils::TransformRect(editingHostFrame, mPresShell->GetRootFrame(), + boundary); + + // Shrink the rect to make sure we never hit the boundary. + boundary.Deflate(kBoundaryAppUnits); + + adjustedPoint = boundary.ClampPoint(adjustedPoint); + } + } + + if (GetCaretMode() == CaretMode::Selection && + !sCaretsAllowDraggingAcrossOtherCaret) { + // Bug 1068474: Adjust the Y-coordinate so that the carets won't be in tilt + // mode when a caret is being dragged surpass the other caret. + // + // For example, when dragging the second caret, the horizontal boundary (lower + // bound) of its Y-coordinate is the logical position of the first caret. + // Likewise, when dragging the first caret, the horizontal boundary (upper + // bound) of its Y-coordinate is the logical position of the second caret. + if (mActiveCaret == mFirstCaret.get()) { + nscoord dragDownBoundaryY = mSecondCaret->LogicalPosition().y; + if (dragDownBoundaryY > 0 && adjustedPoint.y > dragDownBoundaryY) { + adjustedPoint.y = dragDownBoundaryY; + } + } else { + nscoord dragUpBoundaryY = mFirstCaret->LogicalPosition().y; + if (adjustedPoint.y < dragUpBoundaryY) { + adjustedPoint.y = dragUpBoundaryY; + } + } + } + + return adjustedPoint; +} + +uint32_t +AccessibleCaretManager::CaretTimeoutMs() const +{ + static bool added = false; + static uint32_t caretTimeoutMs = 0; + + if (!added) { + Preferences::AddUintVarCache(&caretTimeoutMs, + "layout.accessiblecaret.timeout_ms"); + added = true; + } + + return caretTimeoutMs; +} + +void +AccessibleCaretManager::LaunchCaretTimeoutTimer() +{ + if (!mPresShell || !mCaretTimeoutTimer || CaretTimeoutMs() == 0 || + GetCaretMode() != CaretMode::Cursor || mActiveCaret) { + return; + } + + nsTimerCallbackFunc callback = [](nsITimer* aTimer, void* aClosure) { + auto self = static_cast<AccessibleCaretManager*>(aClosure); + if (self->GetCaretMode() == CaretMode::Cursor) { + self->HideCarets(); + } + }; + + mCaretTimeoutTimer->InitWithFuncCallback(callback, this, CaretTimeoutMs(), + nsITimer::TYPE_ONE_SHOT); +} + +void +AccessibleCaretManager::CancelCaretTimeoutTimer() +{ + if (mCaretTimeoutTimer) { + mCaretTimeoutTimer->Cancel(); + } +} + +void +AccessibleCaretManager::DispatchCaretStateChangedEvent(CaretChangedReason aReason) const +{ + if (!mPresShell) { + return; + } + + FlushLayout(); + if (IsTerminated()) { + return; + } + + Selection* sel = GetSelection(); + if (!sel) { + return; + } + + nsIDocument* doc = mPresShell->GetDocument(); + MOZ_ASSERT(doc); + + CaretStateChangedEventInit init; + init.mBubbles = true; + + const nsRange* range = sel->GetAnchorFocusRange(); + nsINode* commonAncestorNode = nullptr; + if (range) { + commonAncestorNode = range->GetCommonAncestor(); + } + + if (!commonAncestorNode) { + commonAncestorNode = sel->GetFrameSelection()->GetAncestorLimiter(); + } + + RefPtr<DOMRect> domRect = new DOMRect(ToSupports(doc)); + nsRect rect = nsLayoutUtils::GetSelectionBoundingRect(sel); + + nsIFrame* commonAncestorFrame = nullptr; + nsIFrame* rootFrame = mPresShell->GetRootFrame(); + + if (commonAncestorNode && commonAncestorNode->IsContent()) { + commonAncestorFrame = commonAncestorNode->AsContent()->GetPrimaryFrame(); + } + + if (commonAncestorFrame && rootFrame) { + nsLayoutUtils::TransformRect(rootFrame, commonAncestorFrame, rect); + nsRect clampedRect = nsLayoutUtils::ClampRectToScrollFrames(commonAncestorFrame, + rect); + nsLayoutUtils::TransformRect(commonAncestorFrame, rootFrame, clampedRect); + domRect->SetLayoutRect(clampedRect); + init.mSelectionVisible = !clampedRect.IsEmpty(); + } else { + domRect->SetLayoutRect(rect); + init.mSelectionVisible = true; + } + + // Send isEditable info w/ event detail. This info can help determine + // whether to show cut command on selection dialog or not. + init.mSelectionEditable = commonAncestorFrame && + GetEditingHostForFrame(commonAncestorFrame); + + init.mBoundingClientRect = domRect; + init.mReason = aReason; + init.mCollapsed = sel->IsCollapsed(); + init.mCaretVisible = mFirstCaret->IsLogicallyVisible() || + mSecondCaret->IsLogicallyVisible(); + init.mCaretVisuallyVisible = mFirstCaret->IsVisuallyVisible() || + mSecondCaret->IsVisuallyVisible(); + sel->Stringify(init.mSelectedTextContent); + + RefPtr<CaretStateChangedEvent> event = + CaretStateChangedEvent::Constructor(doc, NS_LITERAL_STRING("mozcaretstatechanged"), init); + + event->SetTrusted(true); + event->WidgetEventPtr()->mFlags.mOnlyChromeDispatch = true; + + AC_LOG("%s: reason %d, collapsed %d, caretVisible %d", __FUNCTION__, + init.mReason, init.mCollapsed, init.mCaretVisible); + + (new AsyncEventDispatcher(doc, event))->RunDOMEventWhenSafe(); +} + +} // namespace mozilla |