Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-10 20:05:49 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge mozilla-central to fx-team

Browse Source
This commit is contained in:
Carsten "Tomcat" Book 2016-02-17 14:38:01 +01:00
commit 2b6503e6a2
6 changed files with 47 additions and 211 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
layout/base/AccessibleCaret.h
View File

@ -199,9 +199,9 @@ protected:
bool mSelectionBarEnabled = false;
// AccessibleCaretManager owns us by a UniquePtr. When it's terminated by
// AccessibleCaretManager owns us. When it's destroyed by
// AccessibleCaretEventHub::Terminate() which is called in
// PresShell::Destroy(), it frees us automatically. No need to worry if we
// PresShell::Destroy(), it frees us automatically. No need to worry we
// outlive mPresShell.
nsIPresShell* MOZ_NON_OWNING_REF const mPresShell = nullptr;

2
layout/base/AccessibleCaretEventHub.cpp
View File

@ -459,7 +459,7 @@ AccessibleCaretEventHub::Terminate()
mScrollEndInjectorTimer->Cancel();
}
mManager->Terminate();
mManager = nullptr;
mPresShell = nullptr;
mInitialized = false;
}

66
layout/base/AccessibleCaretManager.cpp
View File

@ -104,18 +104,8 @@ AccessibleCaretManager::AccessibleCaretManager(nsIPresShell* aPresShell)
}
AccessibleCaretManager::~AccessibleCaretManager()
{
}
void
AccessibleCaretManager::Terminate()
{
CancelCaretTimeoutTimer();
mCaretTimeoutTimer = nullptr;
mFirstCaret = nullptr;
mSecondCaret = nullptr;
mActiveCaret = nullptr;
mPresShell = nullptr;
}
nsresult
@ -142,6 +132,7 @@ AccessibleCaretManager::OnSelectionChanged(nsIDOMDocument* aDoc,
// Update visible carets, if javascript changes are allowed.
if (sCaretsScriptUpdates &&
(mFirstCaret->IsLogicallyVisible() || mSecondCaret->IsLogicallyVisible())) {
FlushLayout();
UpdateCarets();
return NS_OK;
}
@ -201,11 +192,6 @@ AccessibleCaretManager::DoNotShowCarets()
void
AccessibleCaretManager::UpdateCarets(UpdateCaretsHint aHint)
{
FlushLayout();
if (IsTerminated()) {
return;
}
mLastUpdateCaretMode = GetCaretMode();
switch (mLastUpdateCaretMode) {
@ -216,7 +202,7 @@ AccessibleCaretManager::UpdateCarets(UpdateCaretsHint aHint)
UpdateCaretsForCursorMode(aHint);
break;
case CaretMode::Selection:
UpdateCaretsForSelectionMode(aHint);
UpdateCaretsForSelectionMode();
break;
}
}
@ -330,7 +316,7 @@ AccessibleCaretManager::UpdateCaretsForCursorMode(UpdateCaretsHint aHint)
}
void
AccessibleCaretManager::UpdateCaretsForSelectionMode(UpdateCaretsHint aHint)
AccessibleCaretManager::UpdateCaretsForSelectionMode()
{
AC_LOG("%s: selection: %p", __FUNCTION__, GetSelection());
@ -346,8 +332,8 @@ AccessibleCaretManager::UpdateCaretsForSelectionMode(UpdateCaretsHint aHint)
return;
}
auto updateSingleCaret = [aHint](AccessibleCaret* aCaret, nsIFrame* aFrame,
int32_t aOffset) -> PositionChangedResult
auto updateSingleCaret = [](AccessibleCaret* aCaret, nsIFrame* aFrame,
int32_t aOffset) -> PositionChangedResult
{
PositionChangedResult result = aCaret->SetPosition(aFrame, aOffset);
aCaret->SetSelectionBarEnabled(sSelectionBarEnabled);
@ -358,16 +344,7 @@ AccessibleCaretManager::UpdateCaretsForSelectionMode(UpdateCaretsHint aHint)
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;
}
aCaret->SetAppearance(Appearance::Normal);
break;
case PositionChangedResult::Invisible:
@ -386,16 +363,9 @@ AccessibleCaretManager::UpdateCaretsForSelectionMode(UpdateCaretsHint aHint)
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.
UpdateCaretsForTilt();
}
UpdateCaretsForTilt();
if (!mActiveCaret) {
DispatchCaretStateChangedEvent(CaretChangedReason::Updateposition);
@ -590,8 +560,9 @@ AccessibleCaretManager::OnScrollStart()
{
AC_LOG("%s", __FUNCTION__);
mFirstCaretAppearanceOnScrollStart = mFirstCaret->GetAppearance();
mSecondCaretAppearanceOnScrollStart = mSecondCaret->GetAppearance();
if (GetCaretMode() == CaretMode::Cursor) {
mFirstCaretAppearanceOnScrollStart = mFirstCaret->GetAppearance();
}
// Hide the carets. (Extended visibility makes them "NormalNotShown").
if (sCaretsExtendedVisibility) {
@ -608,13 +579,11 @@ AccessibleCaretManager::OnScrollEnd()
return;
}
mFirstCaret->SetAppearance(mFirstCaretAppearanceOnScrollStart);
mSecondCaret->SetAppearance(mSecondCaretAppearanceOnScrollStart);
if (GetCaretMode() == CaretMode::Cursor) {
mFirstCaret->SetAppearance(mFirstCaretAppearanceOnScrollStart);
if (!mFirstCaret->IsLogicallyVisible()) {
// If the caret is hidden (Appearance::None) due to timeout or blur, no
// need to update it.
// If the caret is hide (Appearance::None) due to timeout or blur, no need
// to update it.
return;
}
}
@ -1144,7 +1113,7 @@ AccessibleCaretManager::CaretTimeoutMs() const
void
AccessibleCaretManager::LaunchCaretTimeoutTimer()
{
if (!mPresShell || !mCaretTimeoutTimer || CaretTimeoutMs() == 0 ||
if (!mCaretTimeoutTimer || CaretTimeoutMs() == 0 ||
GetCaretMode() != CaretMode::Cursor || mActiveCaret) {
return;
}
@ -1171,12 +1140,11 @@ AccessibleCaretManager::CancelCaretTimeoutTimer()
void
AccessibleCaretManager::DispatchCaretStateChangedEvent(CaretChangedReason aReason) const
{
if (!mPresShell) {
return;
}
// Holding PresShell to prevent AccessibleCaretManager to be destroyed.
nsCOMPtr<nsIPresShell> presShell = mPresShell;
FlushLayout();
if (IsTerminated()) {
if (presShell->IsDestroying()) {
return;
}

38
layout/base/AccessibleCaretManager.h
View File

@ -50,9 +50,6 @@ public:
explicit AccessibleCaretManager(nsIPresShell* aPresShell);
virtual ~AccessibleCaretManager();
// Called by AccessibleCaretEventHub to inform us that PresShell is destroyed.
void Terminate();
// The aPoint in the following public methods should be relative to root
// frame.
@ -127,9 +124,7 @@ protected:
friend std::ostream& operator<<(std::ostream& aStream,
const UpdateCaretsHint& aResult);
// Update carets based on current selection status. This function will flush
// layout, so caller must ensure the PresShell is still valid after calling
// this method.
// Update carets based on current selection status.
void UpdateCarets(UpdateCaretsHint aHint = UpdateCaretsHint::Default);
// Force hiding all carets regardless of the current selection status.
@ -140,7 +135,7 @@ protected:
void DoNotShowCarets();
void UpdateCaretsForCursorMode(UpdateCaretsHint aHint);
void UpdateCaretsForSelectionMode(UpdateCaretsHint aHint);
void UpdateCaretsForSelectionMode();
// Provide haptic / touch feedback, primarily for select on longpress.
void ProvideHapticFeedback();
@ -165,11 +160,7 @@ protected:
nsresult DragCaretInternal(const nsPoint& aPoint);
nsPoint AdjustDragBoundary(const nsPoint& aPoint) const;
void ClearMaintainedSelection() const;
// Caller is responsible to use IsTerminated() to check whether PresShell is
// still valid.
void FlushLayout() const;
dom::Element* GetEditingHostForFrame(nsIFrame* aFrame) const;
dom::Selection* GetSelection() const;
already_AddRefed<nsFrameSelection> GetFrameSelection() const;
@ -193,9 +184,6 @@ protected:
// ---------------------------------------------------------------------------
// The following functions are made virtual for stubbing or mocking in gtest.
//
// @return true if Terminate() had been called.
virtual bool IsTerminated() const { return !mPresShell; }
// Get caret mode based on current selection.
virtual CaretMode GetCaretMode() const;
@ -214,8 +202,8 @@ protected:
virtual bool HasNonEmptyTextContent(nsINode* aNode) const;
// This function will flush layout, so caller must ensure the PresShell is
// still valid after calling this method.
// This function will call FlushPendingNotifications. So caller must ensure
// everything exists after calling this method.
virtual void DispatchCaretStateChangedEvent(dom::CaretChangedReason aReason) const;
// ---------------------------------------------------------------------------
@ -223,12 +211,10 @@ protected:
//
nscoord mOffsetYToCaretLogicalPosition = NS_UNCONSTRAINEDSIZE;
// AccessibleCaretEventHub owns us by a UniquePtr. When it's destroyed, we'll
// also be destroyed. No need to worry if we outlive mPresShell.
//
// mPresShell will be set to nullptr in Terminate(). Therefore mPresShell is
// nullptr either we are in gtest or PresShell::IsDestroying() is true.
nsIPresShell* MOZ_NON_OWNING_REF mPresShell = nullptr;
// AccessibleCaretEventHub owns us. When it's Terminate() called by
// PresShell::Destroy(), we will be destroyed. No need to worry we outlive
// mPresShell.
nsIPresShell* MOZ_NON_OWNING_REF const mPresShell = nullptr;
// First caret is attached to nsCaret in cursor mode, and is attached to
// selection highlight as the left caret in selection mode.
@ -248,12 +234,10 @@ protected:
// The caret mode since last update carets.
CaretMode mLastUpdateCaretMode = CaretMode::None;
// Store the appearance of the carets when calling OnScrollStart() so that it
// can be restored in OnScrollEnd().
// Store the appearance of the first caret when calling OnScrollStart so that
// it can be restored in OnScrollEnd.
AccessibleCaret::Appearance mFirstCaretAppearanceOnScrollStart =
AccessibleCaret::Appearance::None;
AccessibleCaret::Appearance mSecondCaretAppearanceOnScrollStart =
AccessibleCaret::Appearance::None;
static const int32_t kAutoScrollTimerDelay = 30;
@ -274,7 +258,7 @@ protected:
static bool sCaretShownWhenLongTappingOnEmptyContent;
// Android specific visibility extensions correct compatibility issues
// with ActionBar visibility during page scroll.
// with caret-drag and ActionBar visibility during page scroll.
static bool sCaretsExtendedVisibility;
// By default, javascript content selection changes closes AccessibleCarets and

144
layout/base/gtest/TestAccessibleCaretManager.cpp
View File

@ -60,7 +60,6 @@ public:
using AccessibleCaretManager::UpdateCarets;
using AccessibleCaretManager::HideCarets;
using AccessibleCaretManager::sCaretShownWhenLongTappingOnEmptyContent;
using AccessibleCaretManager::sCaretsExtendedVisibility;
MockAccessibleCaretManager()
: AccessibleCaretManager(nullptr)
@ -93,8 +92,6 @@ public:
virtual void UpdateCaretsForTilt() override {}
virtual bool IsTerminated() const override { return false; }
MOCK_CONST_METHOD0(GetCaretMode, CaretMode());
MOCK_CONST_METHOD1(DispatchCaretStateChangedEvent,
void(CaretChangedReason aReason));
@ -347,156 +344,42 @@ TEST_F(AccessibleCaretManagerTester, TestScrollInSelectionMode)
// Initially, first caret is out of scrollport, and second caret is visible.
EXPECT_CALL(mManager.FirstCaret(), SetPosition(_, _))
.WillOnce(Return(PositionChangedResult::Invisible));
.WillRepeatedly(Return(PositionChangedResult::Invisible));
EXPECT_CALL(mManager.SecondCaret(), SetPosition(_, _))
.WillRepeatedly(Return(PositionChangedResult::Changed));
EXPECT_CALL(mManager, DispatchCaretStateChangedEvent(
CaretChangedReason::Updateposition));
CaretChangedReason::Updateposition)).Times(1);
EXPECT_CALL(check, Call("updatecarets"));
EXPECT_CALL(mManager, DispatchCaretStateChangedEvent(
CaretChangedReason::Visibilitychange));
EXPECT_CALL(check, Call("scrollstart1"));
CaretChangedReason::Visibilitychange)).Times(1);
EXPECT_CALL(check, Call("scrollstart"));
// After scroll ended, first caret is visible and second caret is out of
// scroll port.
EXPECT_CALL(mManager.SecondCaret(), SetPosition(_, _))
.WillOnce(Return(PositionChangedResult::Invisible));
EXPECT_CALL(mManager, DispatchCaretStateChangedEvent(
CaretChangedReason::Updateposition));
EXPECT_CALL(check, Call("scrollend1"));
EXPECT_CALL(mManager, DispatchCaretStateChangedEvent(
CaretChangedReason::Visibilitychange));
EXPECT_CALL(check, Call("scrollstart2"));
// After the scroll ended, both carets are visible.
EXPECT_CALL(mManager, DispatchCaretStateChangedEvent(
CaretChangedReason::Updateposition));
EXPECT_CALL(check, Call("scrollend2"));
}
mManager.UpdateCarets();
EXPECT_EQ(FirstCaretAppearance(), Appearance::NormalNotShown);
EXPECT_EQ(SecondCaretAppearance(), Appearance::Normal);
check.Call("updatecarets");
mManager.OnScrollStart();
EXPECT_EQ(FirstCaretAppearance(), Appearance::None);
EXPECT_EQ(SecondCaretAppearance(), Appearance::None);
check.Call("scrollstart1");
mManager.OnReflow();
EXPECT_EQ(FirstCaretAppearance(), Appearance::None);
EXPECT_EQ(SecondCaretAppearance(), Appearance::None);
mManager.OnScrollEnd();
EXPECT_EQ(FirstCaretAppearance(), Appearance::Normal);
EXPECT_EQ(SecondCaretAppearance(), Appearance::NormalNotShown);
check.Call("scrollend1");
mManager.OnScrollStart();
EXPECT_EQ(FirstCaretAppearance(), Appearance::None);
EXPECT_EQ(SecondCaretAppearance(), Appearance::None);
check.Call("scrollstart2");
mManager.OnReflow();
EXPECT_EQ(FirstCaretAppearance(), Appearance::None);
EXPECT_EQ(SecondCaretAppearance(), Appearance::None);
mManager.OnScrollEnd();
EXPECT_EQ(FirstCaretAppearance(), Appearance::Normal);
EXPECT_EQ(SecondCaretAppearance(), Appearance::Normal);
check.Call("scrollend2");
}
TEST_F(AccessibleCaretManagerTester,
TestScrollInSelectionModeWithExtendedVisibility)
{
EXPECT_CALL(mManager, GetCaretMode())
.WillRepeatedly(Return(CaretMode::Selection));
MockFunction<void(std::string aCheckPointName)> check;
{
InSequence dummy;
// Initially, first caret is out of scrollport, and second caret is visible.
EXPECT_CALL(mManager.FirstCaret(), SetPosition(_, _))
.WillOnce(Return(PositionChangedResult::Invisible));
EXPECT_CALL(mManager, DispatchCaretStateChangedEvent(
CaretChangedReason::Updateposition));
EXPECT_CALL(check, Call("updatecarets"));
EXPECT_CALL(mManager, DispatchCaretStateChangedEvent(
CaretChangedReason::Visibilitychange));
EXPECT_CALL(check, Call("scrollstart1"));
EXPECT_CALL(mManager, DispatchCaretStateChangedEvent(
CaretChangedReason::Updateposition));
EXPECT_CALL(check, Call("reflow1"));
// After scroll ended, first caret is visible and second caret is out of
// scroll port.
.WillRepeatedly(Return(PositionChangedResult::Changed));
EXPECT_CALL(mManager.SecondCaret(), SetPosition(_, _))
.WillOnce(Return(PositionChangedResult::Invisible));
.WillRepeatedly(Return(PositionChangedResult::Invisible));
EXPECT_CALL(mManager, DispatchCaretStateChangedEvent(
CaretChangedReason::Updateposition));
EXPECT_CALL(check, Call("scrollend1"));
EXPECT_CALL(mManager, DispatchCaretStateChangedEvent(
CaretChangedReason::Visibilitychange));
EXPECT_CALL(check, Call("scrollstart2"));
EXPECT_CALL(mManager, DispatchCaretStateChangedEvent(
CaretChangedReason::Updateposition));
EXPECT_CALL(check, Call("reflow2"));
// After the scroll ended, both carets are visible.
EXPECT_CALL(mManager, DispatchCaretStateChangedEvent(
CaretChangedReason::Updateposition));
EXPECT_CALL(check, Call("scrollend2"));
CaretChangedReason::Updateposition)).Times(1);
}
AutoRestore<bool> savePref(
MockAccessibleCaretManager::sCaretsExtendedVisibility);
MockAccessibleCaretManager::sCaretsExtendedVisibility = true;
mManager.UpdateCarets();
EXPECT_EQ(FirstCaretAppearance(), Appearance::NormalNotShown);
EXPECT_EQ(SecondCaretAppearance(), Appearance::Normal);
check.Call("updatecarets");
mManager.OnScrollStart();
EXPECT_EQ(FirstCaretAppearance(), Appearance::NormalNotShown);
EXPECT_EQ(SecondCaretAppearance(), Appearance::NormalNotShown);
check.Call("scrollstart1");
mManager.OnReflow();
EXPECT_EQ(FirstCaretAppearance(), Appearance::NormalNotShown);
EXPECT_EQ(SecondCaretAppearance(), Appearance::NormalNotShown);
check.Call("reflow1");
EXPECT_EQ(FirstCaretAppearance(), Appearance::None);
EXPECT_EQ(SecondCaretAppearance(), Appearance::None);
check.Call("scrollstart");
mManager.OnScrollEnd();
EXPECT_EQ(FirstCaretAppearance(), Appearance::Normal);
EXPECT_EQ(SecondCaretAppearance(), Appearance::NormalNotShown);
check.Call("scrollend1");
mManager.OnScrollStart();
EXPECT_EQ(FirstCaretAppearance(), Appearance::NormalNotShown);
EXPECT_EQ(SecondCaretAppearance(), Appearance::NormalNotShown);
check.Call("scrollstart2");
mManager.OnReflow();
EXPECT_EQ(FirstCaretAppearance(), Appearance::NormalNotShown);
EXPECT_EQ(SecondCaretAppearance(), Appearance::NormalNotShown);
check.Call("reflow2");
mManager.OnScrollEnd();
EXPECT_EQ(FirstCaretAppearance(), Appearance::Normal);
EXPECT_EQ(SecondCaretAppearance(), Appearance::Normal);
check.Call("scrollend2");
}
TEST_F(AccessibleCaretManagerTester, TestScrollInCursorModeWhenLogicallyVisible)
@ -654,7 +537,7 @@ TEST_F(AccessibleCaretManagerTester, TestScrollInCursorModeOnEmptyContent)
EXPECT_CALL(mManager, DispatchCaretStateChangedEvent(
CaretChangedReason::Updateposition));
EXPECT_CALL(check, Call("scrollend3"));
}
}
// Simulate a single tap on an empty content.
mManager.UpdateCarets();
@ -683,6 +566,7 @@ TEST_F(AccessibleCaretManagerTester, TestScrollInCursorModeOnEmptyContent)
check.Call("scrollend3");
}
TEST_F(AccessibleCaretManagerTester,
TestScrollInCursorModeOnEmptyContentWithSpecialPreference)
{

4
mobile/android/app/mobile.js
View File

@ -955,8 +955,8 @@ pref("layout.accessiblecaret.timeout_ms", 0);
pref("layout.accessiblecaret.use_long_tap_injector", false);
// AccessibleCarets behaviour is extended to support Android specific
// requirements to hide carets while maintaining ActionBar visiblity during page
// scroll.
// requirements during caret-drag, tapping into empty inputs, and to
// hide carets while maintaining ActionBar visiblity during page scroll.
pref("layout.accessiblecaret.extendedvisibility", true);
// Selection change notifications generated by Javascript changes