--- a/accessible/base/SelectionManager.h
+++ b/accessible/base/SelectionManager.h
@@ -116,17 +116,17 @@ protected:
/**
* Process DOM selection change. Fire selection and caret move events.
*/
void ProcessSelectionChanged(SelData* aSelData);
private:
// Currently focused control.
- nsWeakFrame mCurrCtrlFrame;
+ AutoWeakFrame mCurrCtrlFrame;
int32_t mCaretOffset;
HyperTextAccessible* mAccWithCaret;
};
} // namespace a11y
} // namespace mozilla
#endif
--- a/accessible/base/nsCoreUtils.cpp
+++ b/accessible/base/nsCoreUtils.cpp
@@ -106,17 +106,17 @@ nsCoreUtils::DispatchClickEvent(nsITreeB
int32_t tcX = 0;
tcBoxObj->GetX(&tcX);
int32_t tcY = 0;
tcBoxObj->GetY(&tcY);
// Dispatch mouse events.
- nsWeakFrame tcFrame = tcContent->GetPrimaryFrame();
+ AutoWeakFrame tcFrame = tcContent->GetPrimaryFrame();
nsIFrame* rootFrame = presShell->GetRootFrame();
nsPoint offset;
nsIWidget *rootWidget =
rootFrame->GetView()->GetNearestWidget(&offset);
RefPtr<nsPresContext> presContext = presShell->GetPresContext();
--- a/accessible/generic/Accessible.cpp
+++ b/accessible/generic/Accessible.cpp
@@ -1825,17 +1825,17 @@ Accessible::DispatchClickEvent(nsIConten
nsCOMPtr<nsIPresShell> presShell = mDoc->PresShell();
// Scroll into view.
presShell->ScrollContentIntoView(aContent,
nsIPresShell::ScrollAxis(),
nsIPresShell::ScrollAxis(),
nsIPresShell::SCROLL_OVERFLOW_HIDDEN);
- nsWeakFrame frame = aContent->GetPrimaryFrame();
+ AutoWeakFrame frame = aContent->GetPrimaryFrame();
if (!frame)
return;
// Compute x and y coordinates.
nsPoint point;
nsCOMPtr<nsIWidget> widget = frame->GetNearestWidget(point);
if (!widget)
return;
--- a/dom/base/Element.cpp
+++ b/dom/base/Element.cpp
@@ -853,17 +853,17 @@ Element::SetScrollLeft(int32_t aScrollLe
bool
Element::ScrollByNoFlush(int32_t aDx, int32_t aDy)
{
nsIScrollableFrame* sf = GetScrollFrame(nullptr, false);
if (!sf) {
return false;
}
- nsWeakFrame weakRef(sf->GetScrolledFrame());
+ AutoWeakFrame weakRef(sf->GetScrolledFrame());
CSSIntPoint before = sf->GetScrollPositionCSSPixels();
sf->ScrollToCSSPixelsApproximate(CSSIntPoint(before.x + aDx, before.y + aDy));
// The frame was destroyed, can't keep on scrolling.
if (!weakRef.IsAlive()) {
return false;
}
--- a/dom/base/nsFrameLoader.cpp
+++ b/dom/base/nsFrameLoader.cpp
@@ -2694,17 +2694,17 @@ nsFrameLoader::UpdateBaseWindowPositionA
GetDocShell(getter_AddRefs(docShell));
nsCOMPtr<nsIBaseWindow> baseWindow(do_QueryInterface(docShell));
// resize the sub document
if (baseWindow) {
int32_t x = 0;
int32_t y = 0;
- nsWeakFrame weakFrame(aIFrame);
+ AutoWeakFrame weakFrame(aIFrame);
baseWindow->GetPosition(&x, &y);
if (!weakFrame.IsAlive()) {
// GetPosition() killed us
return;
}
--- a/dom/base/nsFrameLoader.h
+++ b/dom/base/nsFrameLoader.h
@@ -324,17 +324,17 @@ private:
// After the frameloader has been removed from the DOM but before all of the
// messages from the frame have been received, we keep a strong reference to
// our <browser> element.
RefPtr<mozilla::dom::Element> mOwnerContentStrong;
// Stores the root frame of the subdocument while the subdocument is being
// reframed. Used to restore the presentation after reframing.
- nsWeakFrame mDetachedSubdocFrame;
+ AutoWeakFrame mDetachedSubdocFrame;
// Stores the containing document of the frame corresponding to this
// frame loader. This is reference is kept valid while the subframe's
// presentation is detached and stored in mDetachedSubdocFrame. This
// enables us to detect whether the frame has moved documents during
// a reframe, so that we know not to restore the presentation.
nsCOMPtr<nsIDocument> mContainerDocWhileDetached;
// An opener window which should be used when the docshell is created.
--- a/dom/base/nsObjectLoadingContent.h
+++ b/dom/base/nsObjectLoadingContent.h
@@ -710,16 +710,16 @@ class nsObjectLoadingContent : public ns
// videos.
bool mRewrittenYoutubeEmbed : 1;
// Cache the answer of PreferFallback() because ShouldPlay is called several
// times during the load process.
bool mPreferFallback : 1;
bool mPreferFallbackKnown : 1;
- nsWeakFrame mPrintFrame;
+ AutoWeakFrame mPrintFrame;
RefPtr<nsPluginInstanceOwner> mInstanceOwner;
nsTArray<mozilla::dom::MozPluginParameter> mCachedAttributes;
nsTArray<mozilla::dom::MozPluginParameter> mCachedParameters;
};
#endif
--- a/dom/events/EventStateManager.cpp
+++ b/dom/events/EventStateManager.cpp
@@ -110,17 +110,17 @@ using namespace dom;
static const LayoutDeviceIntPoint kInvalidRefPoint = LayoutDeviceIntPoint(-1,-1);
static uint32_t gMouseOrKeyboardEventCounter = 0;
static nsITimer* gUserInteractionTimer = nullptr;
static nsITimerCallback* gUserInteractionTimerCallback = nullptr;
static const double kCursorLoadingTimeout = 1000; // ms
-static nsWeakFrame gLastCursorSourceFrame;
+static AutoWeakFrame gLastCursorSourceFrame;
static TimeStamp gLastCursorUpdateTime;
static inline int32_t
RoundDown(double aDouble)
{
return (aDouble > 0) ? static_cast<int32_t>(floor(aDouble)) :
static_cast<int32_t>(ceil(aDouble));
}
@@ -278,17 +278,17 @@ NS_INTERFACE_MAP_END
static uint32_t sESMInstanceCount = 0;
static bool sPointerEventEnabled = false;
uint64_t EventStateManager::sUserInputCounter = 0;
int32_t EventStateManager::sUserInputEventDepth = 0;
bool EventStateManager::sNormalLMouseEventInProcess = false;
EventStateManager* EventStateManager::sActiveESM = nullptr;
nsIDocument* EventStateManager::sMouseOverDocument = nullptr;
-nsWeakFrame EventStateManager::sLastDragOverFrame = nullptr;
+AutoWeakFrame EventStateManager::sLastDragOverFrame = nullptr;
LayoutDeviceIntPoint EventStateManager::sPreLockPoint = LayoutDeviceIntPoint(0, 0);
LayoutDeviceIntPoint EventStateManager::sLastRefPoint = kInvalidRefPoint;
CSSIntPoint EventStateManager::sLastScreenPoint = CSSIntPoint(0, 0);
LayoutDeviceIntPoint EventStateManager::sSynthCenteringPoint = kInvalidRefPoint;
CSSIntPoint EventStateManager::sLastClientPoint = CSSIntPoint(0, 0);
bool EventStateManager::sIsPointerLocked = false;
// Reference to the pointer locked element.
nsWeakPtr EventStateManager::sPointerLockedElement;
@@ -2232,17 +2232,17 @@ EventStateManager::DispatchLegacyMouseSc
}
// Send the legacy events in following order:
// 1. Vertical scroll
// 2. Vertical pixel scroll (even if #1 isn't consumed)
// 3. Horizontal scroll (even if #1 and/or #2 are consumed)
// 4. Horizontal pixel scroll (even if #3 isn't consumed)
- nsWeakFrame targetFrame(aTargetFrame);
+ AutoWeakFrame targetFrame(aTargetFrame);
MOZ_ASSERT(*aStatus != nsEventStatus_eConsumeNoDefault &&
!aEvent->DefaultPrevented(),
"If you make legacy events dispatched for default prevented wheel "
"event, you need to initialize stateX and stateY");
EventState stateX, stateY;
if (scrollDeltaY) {
SendLineScrollEvent(aTargetFrame, aEvent, stateY,
@@ -2544,17 +2544,17 @@ EventStateManager::DoScrollText(nsIScrol
WidgetWheelEvent* aEvent)
{
MOZ_ASSERT(aScrollableFrame);
MOZ_ASSERT(aEvent);
nsIFrame* scrollFrame = do_QueryFrame(aScrollableFrame);
MOZ_ASSERT(scrollFrame);
- nsWeakFrame scrollFrameWeak(scrollFrame);
+ AutoWeakFrame scrollFrameWeak(scrollFrame);
if (!WheelTransaction::WillHandleDefaultAction(aEvent, scrollFrameWeak)) {
return;
}
// Default action's actual scroll amount should be computed from device
// pixels.
nsPresContext* pc = scrollFrame->PresContext();
nsSize scrollAmount = GetScrollAmount(pc, aEvent, aScrollableFrame);
@@ -3925,17 +3925,17 @@ EventStateManager::DispatchMouseOrPointe
if (!aTargetContent) {
return nullptr;
}
nsAutoPtr<WidgetMouseEvent> dispatchEvent;
CreateMouseOrPointerWidgetEvent(aMouseEvent, aMessage,
aRelatedContent, dispatchEvent);
- nsWeakFrame previousTarget = mCurrentTarget;
+ AutoWeakFrame previousTarget = mCurrentTarget;
mCurrentTargetContent = aTargetContent;
nsIFrame* targetFrame = nullptr;
if (aMouseEvent->AsMouseEvent()) {
PROFILER_LABEL("Input", "DispatchMouseEvent",
js::ProfileEntry::Category::EVENTS);
}
@@ -4497,17 +4497,17 @@ EventStateManager::GenerateDragDropEnter
}
void
EventStateManager::FireDragEnterOrExit(nsPresContext* aPresContext,
WidgetDragEvent* aDragEvent,
EventMessage aMessage,
nsIContent* aRelatedTarget,
nsIContent* aTargetContent,
- nsWeakFrame& aTargetFrame)
+ AutoWeakFrame& aTargetFrame)
{
MOZ_ASSERT(aMessage == eDragLeave || aMessage == eDragExit ||
aMessage == eDragEnter);
nsEventStatus status = nsEventStatus_eIgnore;
WidgetDragEvent event(aDragEvent->IsTrusted(), aMessage, aDragEvent->mWidget);
event.AssignDragEventData(*aDragEvent, true);
mCurrentTargetContent = aTargetContent;
@@ -4636,17 +4636,17 @@ EventStateManager::SetClickCount(WidgetM
}
nsresult
EventStateManager::InitAndDispatchClickEvent(WidgetMouseEvent* aEvent,
nsEventStatus* aStatus,
EventMessage aMessage,
nsIPresShell* aPresShell,
nsIContent* aMouseTarget,
- nsWeakFrame aCurrentTarget,
+ AutoWeakFrame aCurrentTarget,
bool aNoContentDispatch)
{
WidgetMouseEvent event(aEvent->IsTrusted(), aMessage,
aEvent->mWidget, WidgetMouseEvent::eReal);
event.mRefPoint = aEvent->mRefPoint;
event.mClickCount = aEvent->mClickCount;
event.mModifiers = aEvent->mModifiers;
@@ -4694,17 +4694,17 @@ EventStateManager::CheckForAndDispatchCl
mouseContent = mouseContent->GetParent();
}
if (!mouseContent && !mCurrentTarget) {
return NS_OK;
}
// HandleEvent clears out mCurrentTarget which we might need again
- nsWeakFrame currentTarget = mCurrentTarget;
+ AutoWeakFrame currentTarget = mCurrentTarget;
ret = InitAndDispatchClickEvent(aEvent, aStatus, eMouseClick,
presShell, mouseContent, currentTarget,
notDispatchToContents);
if (NS_SUCCEEDED(ret) && aEvent->mClickCount == 2 &&
mouseContent && mouseContent->IsInComposedDoc()) {
//fire double click
ret = InitAndDispatchClickEvent(aEvent, aStatus, eMouseDoubleClick,
--- a/dom/events/EventStateManager.h
+++ b/dom/events/EventStateManager.h
@@ -49,17 +49,17 @@ class OverOutElementsWrapper final : pub
~OverOutElementsWrapper();
public:
OverOutElementsWrapper();
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
NS_DECL_CYCLE_COLLECTION_CLASS(OverOutElementsWrapper)
- nsWeakFrame mLastOverFrame;
+ AutoWeakFrame mLastOverFrame;
nsCOMPtr<nsIContent> mLastOverElement;
// The last element on which we fired a over event, or null if
// the last over event we fired has finished processing.
nsCOMPtr<nsIContent> mFirstOverEventElement;
// The last element on which we fired a out event, or null if
@@ -403,29 +403,29 @@ protected:
* @param aTargetContent target to set for the event
* @param aTargetFrame target frame for the event
*/
void FireDragEnterOrExit(nsPresContext* aPresContext,
WidgetDragEvent* aDragEvent,
EventMessage aMessage,
nsIContent* aRelatedTarget,
nsIContent* aTargetContent,
- nsWeakFrame& aTargetFrame);
+ AutoWeakFrame& aTargetFrame);
/**
* Update the initial drag session data transfer with any changes that occur
* on cloned data transfer objects used for events.
*/
void UpdateDragDataTransfer(WidgetDragEvent* dragEvent);
static nsresult InitAndDispatchClickEvent(WidgetMouseEvent* aEvent,
nsEventStatus* aStatus,
EventMessage aMessage,
nsIPresShell* aPresShell,
nsIContent* aMouseTarget,
- nsWeakFrame aCurrentTarget,
+ AutoWeakFrame aCurrentTarget,
bool aNoContentDispatch);
nsresult SetClickCount(WidgetMouseEvent* aEvent, nsEventStatus* aStatus);
nsresult CheckForAndDispatchClick(WidgetMouseEvent* aEvent,
nsEventStatus* aStatus);
void EnsureDocument(nsPresContext* aPresContext);
void FlushPendingEvents(nsPresContext* aPresContext);
/**
@@ -925,19 +925,19 @@ private:
// Stores the mRefPoint of the last synthetic mouse move we dispatched
// to re-center the mouse when we were pointer locked. If this is (-1,-1) it
// means we've not recently dispatched a centering event. We use this to
// detect when we receive the synth event, so we can cancel and not send it
// to content.
static LayoutDeviceIntPoint sSynthCenteringPoint;
- nsWeakFrame mCurrentTarget;
+ AutoWeakFrame mCurrentTarget;
nsCOMPtr<nsIContent> mCurrentTargetContent;
- static nsWeakFrame sLastDragOverFrame;
+ static AutoWeakFrame sLastDragOverFrame;
// Stores the mRefPoint (the offset from the widget's origin in device
// pixels) of the last mouse event.
static LayoutDeviceIntPoint sLastRefPoint;
// member variables for the d&d gesture state machine
LayoutDeviceIntPoint mGestureDownPoint; // screen coordinates
// The content to use as target if we start a d&d (what we drag).
--- a/dom/events/WheelHandlingHelper.cpp
+++ b/dom/events/WheelHandlingHelper.cpp
@@ -78,17 +78,17 @@ WheelHandlingUtils::CanScrollOn(nsIScrol
CanScrollInRange(scrollRange.y, scrollPt.y,
scrollRange.YMost(), aDirectionY));
}
/******************************************************************/
/* mozilla::WheelTransaction */
/******************************************************************/
-nsWeakFrame WheelTransaction::sTargetFrame(nullptr);
+AutoWeakFrame WheelTransaction::sTargetFrame(nullptr);
uint32_t WheelTransaction::sTime = 0;
uint32_t WheelTransaction::sMouseMoved = 0;
nsITimer* WheelTransaction::sTimer = nullptr;
int32_t WheelTransaction::sScrollSeriesCounter = 0;
bool WheelTransaction::sOwnScrollbars = false;
/* static */ bool
WheelTransaction::OutOfTime(uint32_t aBaseTime, uint32_t aThreshold)
@@ -174,17 +174,17 @@ WheelTransaction::EndTransaction()
sOwnScrollbars = false;
ScrollbarsForWheel::OwnWheelTransaction(false);
ScrollbarsForWheel::Inactivate();
}
}
/* static */ bool
WheelTransaction::WillHandleDefaultAction(WidgetWheelEvent* aWheelEvent,
- nsWeakFrame& aTargetWeakFrame)
+ AutoWeakFrame& aTargetWeakFrame)
{
nsIFrame* lastTargetFrame = GetTargetFrame();
if (!lastTargetFrame) {
BeginTransaction(aTargetWeakFrame.GetFrame(), aWheelEvent);
} else if (lastTargetFrame != aTargetWeakFrame.GetFrame()) {
EndTransaction();
BeginTransaction(aTargetWeakFrame.GetFrame(), aWheelEvent);
} else {
@@ -422,18 +422,18 @@ WheelTransaction::OverrideSystemScrollSp
/******************************************************************/
/* mozilla::ScrollbarsForWheel */
/******************************************************************/
const DeltaValues ScrollbarsForWheel::directions[kNumberOfTargets] = {
DeltaValues(-1, 0), DeltaValues(+1, 0), DeltaValues(0, -1), DeltaValues(0, +1)
};
-nsWeakFrame ScrollbarsForWheel::sActiveOwner = nullptr;
-nsWeakFrame ScrollbarsForWheel::sActivatedScrollTargets[kNumberOfTargets] = {
+AutoWeakFrame ScrollbarsForWheel::sActiveOwner = nullptr;
+AutoWeakFrame ScrollbarsForWheel::sActivatedScrollTargets[kNumberOfTargets] = {
nullptr, nullptr, nullptr, nullptr
};
bool ScrollbarsForWheel::sHadWheelStart = false;
bool ScrollbarsForWheel::sOwnWheelTransaction = false;
/* static */ void
ScrollbarsForWheel::PrepareToScrollText(EventStateManager* aESM,
@@ -515,17 +515,17 @@ ScrollbarsForWheel::OwnWheelTransaction(
/* static */ void
ScrollbarsForWheel::TemporarilyActivateAllPossibleScrollTargets(
EventStateManager* aESM,
nsIFrame* aTargetFrame,
WidgetWheelEvent* aEvent)
{
for (size_t i = 0; i < kNumberOfTargets; i++) {
const DeltaValues *dir = &directions[i];
- nsWeakFrame* scrollTarget = &sActivatedScrollTargets[i];
+ AutoWeakFrame* scrollTarget = &sActivatedScrollTargets[i];
MOZ_ASSERT(!*scrollTarget, "scroll target still temporarily activated!");
nsIScrollableFrame* target = do_QueryFrame(
aESM->ComputeScrollTarget(aTargetFrame, dir->deltaX, dir->deltaY, aEvent,
EventStateManager::COMPUTE_DEFAULT_ACTION_TARGET));
nsIScrollbarMediator* scrollbarMediator = do_QueryFrame(target);
if (scrollbarMediator) {
nsIFrame* targetFrame = do_QueryFrame(target);
*scrollTarget = targetFrame;
@@ -533,17 +533,17 @@ ScrollbarsForWheel::TemporarilyActivateA
}
}
}
/* static */ void
ScrollbarsForWheel::DeactivateAllTemporarilyActivatedScrollTargets()
{
for (size_t i = 0; i < kNumberOfTargets; i++) {
- nsWeakFrame* scrollTarget = &sActivatedScrollTargets[i];
+ AutoWeakFrame* scrollTarget = &sActivatedScrollTargets[i];
if (*scrollTarget) {
nsIScrollbarMediator* scrollbarMediator = do_QueryFrame(*scrollTarget);
if (scrollbarMediator) {
scrollbarMediator->ScrollbarActivityStopped();
}
*scrollTarget = nullptr;
}
}
--- a/dom/events/WheelHandlingHelper.h
+++ b/dom/events/WheelHandlingHelper.h
@@ -91,18 +91,18 @@ public:
static void MayInactivate();
static void Inactivate();
static bool IsActive();
static void OwnWheelTransaction(bool aOwn);
protected:
static const size_t kNumberOfTargets = 4;
static const DeltaValues directions[kNumberOfTargets];
- static nsWeakFrame sActiveOwner;
- static nsWeakFrame sActivatedScrollTargets[kNumberOfTargets];
+ static AutoWeakFrame sActiveOwner;
+ static AutoWeakFrame sActivatedScrollTargets[kNumberOfTargets];
static bool sHadWheelStart;
static bool sOwnWheelTransaction;
/**
* These two methods are called upon eWheelOperationStart/eWheelOperationEnd
* events to show/hide the right scrollbars.
*/
@@ -129,21 +129,21 @@ public:
/**
* WillHandleDefaultAction() is called before handling aWheelEvent on
* aTargetFrame.
*
* @return false if the caller cannot continue to handle the default
* action. Otherwise, true.
*/
static bool WillHandleDefaultAction(WidgetWheelEvent* aWheelEvent,
- nsWeakFrame& aTargetWeakFrame);
+ AutoWeakFrame& aTargetWeakFrame);
static bool WillHandleDefaultAction(WidgetWheelEvent* aWheelEvent,
nsIFrame* aTargetFrame)
{
- nsWeakFrame targetWeakFrame(aTargetFrame);
+ AutoWeakFrame targetWeakFrame(aTargetFrame);
return WillHandleDefaultAction(aWheelEvent, targetWeakFrame);
}
static void OnEvent(WidgetEvent* aEvent);
static void Shutdown();
static uint32_t GetTimeoutTime();
static void OwnScrollbars(bool aOwn);
@@ -164,17 +164,17 @@ protected:
static void SetTimeout();
static uint32_t GetIgnoreMoveDelayTime();
static int32_t GetAccelerationStart();
static int32_t GetAccelerationFactor();
static DeltaValues OverrideSystemScrollSpeed(WidgetWheelEvent* aEvent);
static double ComputeAcceleratedWheelDelta(double aDelta, int32_t aFactor);
static bool OutOfTime(uint32_t aBaseTime, uint32_t aThreshold);
- static nsWeakFrame sTargetFrame;
+ static AutoWeakFrame sTargetFrame;
static uint32_t sTime; // in milliseconds
static uint32_t sMouseMoved; // in milliseconds
static nsITimer* sTimer;
static int32_t sScrollSeriesCounter;
static bool sOwnScrollbars;
};
} // namespace mozilla
--- a/dom/html/HTMLInputElement.cpp
+++ b/dom/html/HTMLInputElement.cpp
@@ -4114,17 +4114,17 @@ HTMLInputElement::PreHandleEvent(EventCh
MOZ_ASSERT(aVisitor.mEvent->mMessage == eEditorInput);
MOZ_ASSERT(numberControlFrame);
MOZ_ASSERT(numberControlFrame->GetAnonTextControl() ==
aVisitor.mEvent->mOriginalTarget);
// Propogate the anon text control's new value to our HTMLInputElement:
nsAutoString value;
numberControlFrame->GetValueOfAnonTextControl(value);
numberControlFrame->HandlingInputEvent(true);
- nsWeakFrame weakNumberControlFrame(numberControlFrame);
+ AutoWeakFrame weakNumberControlFrame(numberControlFrame);
rv = SetValueInternal(value,
nsTextEditorState::eSetValue_BySetUserInput |
nsTextEditorState::eSetValue_Notify);
NS_ENSURE_SUCCESS(rv, rv);
if (weakNumberControlFrame.IsAlive()) {
numberControlFrame->HandlingInputEvent(false);
}
}
--- a/dom/html/HTMLSelectElement.cpp
+++ b/dom/html/HTMLSelectElement.cpp
@@ -273,17 +273,17 @@ HTMLSelectElement::InsertOptionsIntoList
mSelectedIndex += (insertIndex - aListIndex);
SetSelectionChanged(true, aNotify);
}
// Get the frame stuff for notification. No need to flush here
// since if there's no frame for the select yet the select will
// get into the right state once it's created.
nsISelectControlFrame* selectFrame = nullptr;
- nsWeakFrame weakSelectFrame;
+ AutoWeakFrame weakSelectFrame;
bool didGetFrame = false;
// Actually select the options if the added options warrant it
for (int32_t i = aListIndex; i < insertIndex; i++) {
// Notify the frame that the option is added
if (!didGetFrame || (selectFrame && !weakSelectFrame.IsAlive())) {
selectFrame = GetSelectFrame();
weakSelectFrame = do_QueryFrame(selectFrame);
@@ -926,17 +926,17 @@ HTMLSelectElement::SetOptionsSelectedByI
// These variables tell us whether any options were selected
// or deselected.
bool optionsSelected = false;
bool optionsDeselected = false;
nsISelectControlFrame* selectFrame = nullptr;
bool didGetFrame = false;
- nsWeakFrame weakSelectFrame;
+ AutoWeakFrame weakSelectFrame;
if (aOptionsMask & IS_SELECTED) {
// Setting selectedIndex to an out-of-bounds index means -1. (HTML5)
if (aStartIndex < 0 || AssertedCast<uint32_t>(aStartIndex) >= numItems ||
aEndIndex < 0 || AssertedCast<uint32_t>(aEndIndex) >= numItems) {
aStartIndex = -1;
aEndIndex = -1;
}
--- a/dom/html/nsTextEditorState.cpp
+++ b/dom/html/nsTextEditorState.cpp
@@ -116,17 +116,17 @@ public:
}
if (mTextEditorState) {
mTextEditorState->FinishedRestoringSelection();
}
return NS_OK;
}
- // Let the text editor tell us we're no longer relevant - avoids use of nsWeakFrame
+ // Let the text editor tell us we're no longer relevant - avoids use of AutoWeakFrame
void Revoke() {
mFrame = nullptr;
mTextEditorState = nullptr;
}
private:
nsTextControlFrame* mFrame;
nsTextEditorState* mTextEditorState;
@@ -785,17 +785,17 @@ NS_IMPL_ISUPPORTS(nsTextInputListener,
nsIDOMEventListener)
// BEGIN nsIDOMSelectionListener
NS_IMETHODIMP
nsTextInputListener::NotifySelectionChanged(nsIDOMDocument* aDoc, nsISelection* aSel, int16_t aReason)
{
bool collapsed;
- nsWeakFrame weakFrame = mFrame;
+ AutoWeakFrame weakFrame = mFrame;
if (!aDoc || !aSel || NS_FAILED(aSel->GetIsCollapsed(&collapsed)))
return NS_OK;
// Fire the select event
// The specs don't exactly say when we should fire the select event.
// IE: Whenever you add/remove a character to/from the selection. Also
// each time for select all. Also if you get to the end of the text
@@ -936,17 +936,17 @@ NS_IMETHODIMP
nsTextInputListener::EditAction()
{
if (!mFrame) {
// We've been disconnected from the nsTextEditorState object, nothing to do
// here.
return NS_OK;
}
- nsWeakFrame weakFrame = mFrame;
+ AutoWeakFrame weakFrame = mFrame;
nsITextControlFrame* frameBase = do_QueryFrame(mFrame);
nsTextControlFrame* frame = static_cast<nsTextControlFrame*> (frameBase);
NS_ASSERTION(frame, "Where is our frame?");
//
// Update the undo / redo menus
//
nsCOMPtr<nsIEditor> editor;
@@ -2052,17 +2052,17 @@ nsTextEditorState::SetValue(const nsAStr
NS_ASSERTION(mEditorInitialized || mInitializing,
"We should never try to use the editor if we're not initialized unless we're being initialized");
}
#endif
nsAutoString currentValue;
mBoundFrame->GetText(currentValue);
- nsWeakFrame weakFrame(mBoundFrame);
+ AutoWeakFrame weakFrame(mBoundFrame);
// this is necessary to avoid infinite recursion
if (!currentValue.Equals(newValue))
{
ValueSetter valueSetter(mEditor);
// \r is an illegal character in the dom, but people use them,
// so convert windows and mac platform linebreaks to \n:
--- a/layout/base/AccessibleCaretManager.cpp
+++ b/layout/base/AccessibleCaretManager.cpp
@@ -583,17 +583,17 @@ AccessibleCaretManager::SelectWordOrShor
}
nsIFrame* rootFrame = mPresShell->GetRootFrame();
if (!rootFrame) {
return NS_ERROR_NOT_AVAILABLE;
}
// Find the frame under point.
- nsWeakFrame ptFrame = nsLayoutUtils::GetFrameForPoint(rootFrame, aPoint,
+ AutoWeakFrame 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
@@ -1255,17 +1255,17 @@ AccessibleCaretManager::DragCaretInterna
ClearMaintainedSelection();
nsIFrame* anchorFrame = nullptr;
selection->GetPrimaryFrameForAnchorNode(&anchorFrame);
nsIFrame* scrollable =
nsLayoutUtils::GetClosestFrameOfType(anchorFrame, nsGkAtoms::scrollFrame);
- nsWeakFrame weakScrollable = scrollable;
+ AutoWeakFrame 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.
--- a/layout/base/GeometryUtils.cpp
+++ b/layout/base/GeometryUtils.cpp
@@ -258,17 +258,17 @@ void GetBoxQuads(nsINode* aNode,
CallerType aCallerType,
ErrorResult& aRv)
{
nsIFrame* frame = GetFrameForNode(aNode);
if (!frame) {
// No boxes to return
return;
}
- nsWeakFrame weakFrame(frame);
+ AutoWeakFrame weakFrame(frame);
nsIDocument* ownerDoc = aNode->OwnerDoc();
nsIFrame* relativeToFrame =
GetFirstNonAnonymousFrameForGeometryNode(aOptions.mRelativeTo, ownerDoc);
// The first frame might be destroyed now if the above call lead to an
// EnsureFrameForTextNode call. We need to get the first frame again
// when that happens and re-check it.
if (!weakFrame.IsAlive()) {
frame = GetFrameForNode(aNode);
@@ -296,17 +296,17 @@ void GetBoxQuads(nsINode* aNode,
static void
TransformPoints(nsINode* aTo, const GeometryNode& aFrom,
uint32_t aPointCount, CSSPoint* aPoints,
const ConvertCoordinateOptions& aOptions,
CallerType aCallerType, ErrorResult& aRv)
{
nsIFrame* fromFrame = GetFirstNonAnonymousFrameForGeometryNode(aFrom);
- nsWeakFrame weakFrame(fromFrame);
+ AutoWeakFrame weakFrame(fromFrame);
nsIFrame* toFrame = GetFirstNonAnonymousFrameForNode(aTo);
// The first frame might be destroyed now if the above call lead to an
// EnsureFrameForTextNode call. We need to get the first frame again
// when that happens.
if (fromFrame && !weakFrame.IsAlive()) {
fromFrame = GetFirstNonAnonymousFrameForGeometryNode(aFrom);
}
if (!fromFrame || !toFrame) {
--- a/layout/base/PresShell.cpp
+++ b/layout/base/PresShell.cpp
@@ -660,45 +660,45 @@ nsIPresShell::GetVerifyReflowEnable()
void
nsIPresShell::SetVerifyReflowEnable(bool aEnabled)
{
gVerifyReflowEnabled = aEnabled;
}
/* virtual */ void
-nsIPresShell::AddWeakFrameExternal(nsWeakFrame* aWeakFrame)
+nsIPresShell::AddWeakFrameExternal(AutoWeakFrame* aWeakFrame)
{
AddWeakFrameInternal(aWeakFrame);
}
void
-nsIPresShell::AddWeakFrameInternal(nsWeakFrame* aWeakFrame)
+nsIPresShell::AddWeakFrameInternal(AutoWeakFrame* aWeakFrame)
{
if (aWeakFrame->GetFrame()) {
aWeakFrame->GetFrame()->AddStateBits(NS_FRAME_EXTERNAL_REFERENCE);
}
aWeakFrame->SetPreviousWeakFrame(mWeakFrames);
mWeakFrames = aWeakFrame;
}
/* virtual */ void
-nsIPresShell::RemoveWeakFrameExternal(nsWeakFrame* aWeakFrame)
+nsIPresShell::RemoveWeakFrameExternal(AutoWeakFrame* aWeakFrame)
{
RemoveWeakFrameInternal(aWeakFrame);
}
void
-nsIPresShell::RemoveWeakFrameInternal(nsWeakFrame* aWeakFrame)
+nsIPresShell::RemoveWeakFrameInternal(AutoWeakFrame* aWeakFrame)
{
if (mWeakFrames == aWeakFrame) {
mWeakFrames = aWeakFrame->GetPreviousWeakFrame();
return;
}
- nsWeakFrame* nextWeak = mWeakFrames;
+ AutoWeakFrame* nextWeak = mWeakFrames;
while (nextWeak && nextWeak->GetPreviousWeakFrame() != aWeakFrame) {
nextWeak = nextWeak->GetPreviousWeakFrame();
}
if (nextWeak) {
nextWeak->SetPreviousWeakFrame(aWeakFrame->GetPreviousWeakFrame());
}
}
@@ -2944,19 +2944,19 @@ nsIPresShell::SetForwardingContainer(con
mForwardingContainer = aContainer;
}
void
PresShell::ClearFrameRefs(nsIFrame* aFrame)
{
mPresContext->EventStateManager()->ClearFrameRefs(aFrame);
- nsWeakFrame* weakFrame = mWeakFrames;
+ AutoWeakFrame* weakFrame = mWeakFrames;
while (weakFrame) {
- nsWeakFrame* prev = weakFrame->GetPreviousWeakFrame();
+ AutoWeakFrame* prev = weakFrame->GetPreviousWeakFrame();
if (weakFrame->GetFrame() == aFrame) {
// This removes weakFrame from mWeakFrames.
weakFrame->Clear(this);
}
weakFrame = prev;
}
}
@@ -7127,17 +7127,17 @@ PresShell::HandleEvent(nsIFrame* aFrame,
type = SourceEventType::Key;
}
AutoSourceEvent taskTracerEvent(type);
#endif
NS_ASSERTION(aFrame, "aFrame should be not null");
if (sPointerEventEnabled) {
- nsWeakFrame weakFrame(aFrame);
+ AutoWeakFrame weakFrame(aFrame);
nsCOMPtr<nsIContent> targetContent;
DispatchPointerFromMouseOrTouch(this, aFrame, aEvent, aDontRetargetEvents,
aEventStatus,
getter_AddRefs(targetContent));
if (!weakFrame.IsAlive()) {
if (targetContent) {
aFrame = targetContent->GetPrimaryFrame();
if (!aFrame) {
@@ -7289,17 +7289,17 @@ PresShell::HandleEvent(nsIFrame* aFrame,
if (aEvent->IsUsingCoordinates()) {
ReleasePointerCaptureCaller releasePointerCaptureCaller;
if (mDocument) {
if (aEvent->mClass == eTouchEventClass) {
nsIDocument::UnlockPointer();
}
- nsWeakFrame weakFrame(frame);
+ AutoWeakFrame weakFrame(frame);
{ // scope for scriptBlocker.
nsAutoScriptBlocker scriptBlocker;
FlushThrottledStyles(GetRootPresShell()->GetDocument(), nullptr);
}
if (!weakFrame.IsAlive()) {
frame = GetNearestFrameContainingPresShell(this);
@@ -7510,17 +7510,17 @@ PresShell::HandleEvent(nsIFrame* aFrame,
frame = capturingFrame;
}
}
if (aEvent->mClass == ePointerEventClass) {
if (WidgetPointerEvent* pointerEvent = aEvent->AsPointerEvent()) {
// Try to keep frame for following check, because
// frame can be damaged during CheckPointerCaptureState.
- nsWeakFrame frameKeeper(frame);
+ AutoWeakFrame frameKeeper(frame);
// Handle pending pointer capture before any pointer events except
// gotpointercapture / lostpointercapture.
CheckPointerCaptureState(pointerEvent->pointerId,
pointerEvent->inputSource,
pointerEvent->mIsPrimary);
// Prevent application crashes, in case damaged frame.
if (!frameKeeper.IsAlive()) {
frame = nullptr;
@@ -7660,17 +7660,17 @@ PresShell::HandleEvent(nsIFrame* aFrame,
}
}
}
}
}
// Before HandlePositionedEvent we should save mPointerEventTarget in some
// cases
- nsWeakFrame weakFrame;
+ AutoWeakFrame weakFrame;
if (sPointerEventEnabled && aTargetContent &&
ePointerEventClass == aEvent->mClass) {
weakFrame = frame;
shell->mPointerEventTarget = frame->GetContent();
MOZ_ASSERT(!frame->GetContent() ||
shell->GetDocument() == frame->GetContent()->OwnerDoc());
}
@@ -9521,17 +9521,17 @@ PresShell::Observe(nsISupports* aSubject
#ifdef MOZ_XUL
if (!nsCRT::strcmp(aTopic, "chrome-flush-skin-caches")) {
nsIFrame *rootFrame = mFrameConstructor->GetRootFrame();
// Need to null-check because "chrome-flush-skin-caches" can happen
// at interesting times during startup.
if (rootFrame) {
NS_ASSERTION(mViewManager, "View manager must exist");
- nsWeakFrame weakRoot(rootFrame);
+ AutoWeakFrame weakRoot(rootFrame);
// Have to make sure that the content notifications are flushed before we
// start messing with the frame model; otherwise we can get content doubling.
mDocument->FlushPendingNotifications(FlushType::ContentAndNotify);
if (weakRoot.IsAlive()) {
WalkFramesThroughPlaceholders(mPresContext, rootFrame,
&ReResolveMenusAndTrees, nullptr);
--- a/layout/base/nsIPresShell.h
+++ b/layout/base/nsIPresShell.h
@@ -73,17 +73,17 @@ class CSSStyleSheet;
class nsFrameSelection;
class nsFrameManager;
class nsILayoutHistoryState;
class nsIReflowCallback;
class nsIDOMNode;
class nsCSSFrameConstructor;
class nsISelection;
template<class E> class nsCOMArray;
-class nsWeakFrame;
+class AutoWeakFrame;
class nsIScrollableFrame;
class gfxContext;
class nsIDOMEvent;
class nsDisplayList;
class nsDisplayListBuilder;
class nsPIDOMWindowOuter;
struct nsPoint;
class nsINode;
@@ -1187,32 +1187,32 @@ public:
* frames.
*/
virtual already_AddRefed<mozilla::gfx::SourceSurface>
RenderSelection(nsISelection* aSelection,
const mozilla::LayoutDeviceIntPoint aPoint,
mozilla::LayoutDeviceIntRect* aScreenRect,
uint32_t aFlags) = 0;
- void AddWeakFrameInternal(nsWeakFrame* aWeakFrame);
- virtual void AddWeakFrameExternal(nsWeakFrame* aWeakFrame);
+ void AddWeakFrameInternal(AutoWeakFrame* aWeakFrame);
+ virtual void AddWeakFrameExternal(AutoWeakFrame* aWeakFrame);
- void AddWeakFrame(nsWeakFrame* aWeakFrame)
+ void AddWeakFrame(AutoWeakFrame* aWeakFrame)
{
#ifdef MOZILLA_INTERNAL_API
AddWeakFrameInternal(aWeakFrame);
#else
AddWeakFrameExternal(aWeakFrame);
#endif
}
- void RemoveWeakFrameInternal(nsWeakFrame* aWeakFrame);
- virtual void RemoveWeakFrameExternal(nsWeakFrame* aWeakFrame);
+ void RemoveWeakFrameInternal(AutoWeakFrame* aWeakFrame);
+ virtual void RemoveWeakFrameExternal(AutoWeakFrame* aWeakFrame);
- void RemoveWeakFrame(nsWeakFrame* aWeakFrame)
+ void RemoveWeakFrame(AutoWeakFrame* aWeakFrame)
{
#ifdef MOZILLA_INTERNAL_API
RemoveWeakFrameInternal(aWeakFrame);
#else
RemoveWeakFrameExternal(aWeakFrame);
#endif
}
@@ -1811,17 +1811,17 @@ protected:
// Count of the number of times this presshell has been painted to a window.
uint64_t mPaintCount;
nsSize mScrollPositionClampingScrollPortSize;
// A list of weak frames. This is a pointer to the last item in the list.
- nsWeakFrame* mWeakFrames;
+ AutoWeakFrame* mWeakFrames;
// Most recent canvas background color.
nscolor mCanvasBackgroundColor;
// Used to force allocation and rendering of proportionally more or
// less pixels in both dimensions.
mozilla::Maybe<float> mResolution;
--- a/layout/forms/nsComboboxControlFrame.cpp
+++ b/layout/forms/nsComboboxControlFrame.cpp
@@ -263,17 +263,17 @@ nsComboboxControlFrame::AccessibleType()
{
return a11y::eHTMLComboboxType;
}
#endif
void
nsComboboxControlFrame::SetFocus(bool aOn, bool aRepaint)
{
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
if (aOn) {
nsListControlFrame::ComboboxFocusSet();
sFocused = this;
if (mDelayedShowDropDown) {
ShowDropDown(true); // might destroy us
if (!weakFrame.IsAlive()) {
return;
}
@@ -347,17 +347,17 @@ nsComboboxControlFrame::ShowList(bool aS
} else {
nsIWidget* widget = view->GetWidget();
if (widget) {
// We must do this before ShowPopup in case it destroys us (bug 813442).
widget->CaptureRollupEvents(this, false);
}
}
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
ShowPopup(aShowList); // might destroy us
if (!weakFrame.IsAlive()) {
return false;
}
mDroppedDown = aShowList;
nsIWidget* widget = view->GetWidget();
if (mDroppedDown) {
@@ -408,17 +408,17 @@ public:
{
if (mFrame.IsAlive()) {
static_cast<nsComboboxControlFrame*>(mFrame.GetFrame())->
AbsolutelyPositionDropDown();
}
return NS_OK;
}
- nsWeakFrame mFrame;
+ AutoWeakFrame mFrame;
};
void
nsComboboxControlFrame::ReflowDropdown(nsPresContext* aPresContext,
const ReflowInput& aReflowInput)
{
// All we want out of it later on, really, is the block size of a row, so we
// don't even need to cache mDropdownFrame's ascent or anything. If we don't
@@ -522,17 +522,17 @@ public:
NS_IMETHOD Run() override
{
if (mFrame.IsAlive()) {
static_cast<nsComboboxControlFrame*>(mFrame.GetFrame())
->RollupFromList();
}
return NS_OK;
}
- nsWeakFrame mFrame;
+ AutoWeakFrame mFrame;
};
class nsAsyncResize : public Runnable
{
public:
explicit nsAsyncResize(nsComboboxControlFrame* aFrame) : mFrame(aFrame) {}
NS_IMETHOD Run() override
{
@@ -551,17 +551,17 @@ public:
SetSuppressScrollbarUpdate(false);
if (combo->mDelayedShowDropDown) {
combo->ShowDropDown(true);
}
}
}
return NS_OK;
}
- nsWeakFrame mFrame;
+ AutoWeakFrame mFrame;
};
void
nsComboboxControlFrame::GetAvailableDropdownSpace(WritingMode aWM,
nscoord* aBefore,
nscoord* aAfter,
LogicalPoint* aTranslation)
{
@@ -1020,17 +1020,17 @@ void
nsComboboxControlFrame::HandleRedisplayTextEvent()
{
// First, make sure that the content model is up to date and we've
// constructed the frames for all our content in the right places.
// Otherwise they'll end up under the wrong insertion frame when we
// ActuallyDisplayText, since that flushes out the content sink by
// calling SetText on a DOM node with aNotify set to true. See bug
// 289730.
- nsWeakFrame weakThis(this);
+ AutoWeakFrame weakThis(this);
PresContext()->Document()->
FlushPendingNotifications(FlushType::ContentAndNotify);
if (!weakThis.IsAlive())
return;
// Redirect frame insertions during this method (see GetContentInsertionFrame())
// so that any reframing that the frame constructor forces upon us is inserted
// into the correct parent (mDisplayFrame). See bug 282607.
@@ -1089,17 +1089,17 @@ nsComboboxControlFrame::AddOption(int32_
nsListControlFrame* lcf = static_cast<nsListControlFrame*>(mDropdownFrame);
return lcf->AddOption(aIndex);
}
NS_IMETHODIMP
nsComboboxControlFrame::RemoveOption(int32_t aIndex)
{
- nsWeakFrame weakThis(this);
+ AutoWeakFrame weakThis(this);
if (mListControlFrame->GetNumberOfOptions() > 0) {
if (aIndex < mDisplayedIndex) {
--mDisplayedIndex;
} else if (aIndex == mDisplayedIndex) {
mDisplayedIndex = 0; // IE6 compat
RedisplayText(mDisplayedIndex);
}
}
@@ -1455,17 +1455,17 @@ bool
nsComboboxControlFrame::Rollup(uint32_t aCount, bool aFlush,
const nsIntPoint* pos, nsIContent** aLastRolledUp)
{
if (!mDroppedDown) {
return false;
}
bool consume = !!COMBOBOX_ROLLUP_CONSUME_EVENT;
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
mListControlFrame->AboutToRollup(); // might destroy us
if (!weakFrame.IsAlive()) {
return consume;
}
ShowDropDown(false); // might destroy us
if (weakFrame.IsAlive()) {
mListControlFrame->CaptureMouseEvents(false);
}
@@ -1620,17 +1620,17 @@ nsComboboxControlFrame::OnOptionSelected
if (selectFrame) {
selectFrame->OnOptionSelected(aIndex, aSelected);
}
} else {
if (aSelected) {
nsAutoScriptBlocker blocker;
RedisplayText(aIndex);
} else {
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
RedisplaySelectedText();
if (weakFrame.IsAlive()) {
FireValueChangeEvent(); // Fire after old option is unselected
}
}
}
return NS_OK;
--- a/layout/forms/nsDateTimeControlFrame.h
+++ b/layout/forms/nsDateTimeControlFrame.h
@@ -98,17 +98,17 @@ private:
static_cast<nsDateTimeControlFrame*>(mFrame.GetFrame());
NS_ENSURE_STATE(frame);
frame->SyncDisabledState();
return NS_OK;
}
private:
- nsWeakFrame mFrame;
+ AutoWeakFrame mFrame;
};
/**
* Sync the disabled state of the anonymous children up with our content's.
*/
void SyncDisabledState();
// Anonymous child which is bound via XBL to an element that wraps the input
--- a/layout/forms/nsFileControlFrame.h
+++ b/layout/forms/nsFileControlFrame.h
@@ -106,17 +106,17 @@ protected:
nsFileControlFrame* frame = static_cast<nsFileControlFrame*>(mFrame.GetFrame());
NS_ENSURE_STATE(frame);
frame->SyncDisabledState();
return NS_OK;
}
private:
- nsWeakFrame mFrame;
+ AutoWeakFrame mFrame;
};
class DnDListener: public MouseListener {
public:
explicit DnDListener(nsFileControlFrame* aFrame)
: MouseListener(aFrame)
{}
--- a/layout/forms/nsListControlFrame.cpp
+++ b/layout/forms/nsListControlFrame.cpp
@@ -667,17 +667,17 @@ nsListControlFrame::SingleSelection(int3
bool wasChanged = false;
// Get Current selection
if (aDoToggle) {
wasChanged = ToggleOptionSelectedFromFrame(aClickedIndex);
} else {
wasChanged = SetOptionsSelectedFromFrame(aClickedIndex, aClickedIndex,
true, true);
}
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
ScrollToIndex(aClickedIndex);
if (!weakFrame.IsAlive()) {
return wasChanged;
}
#ifdef ACCESSIBILITY
bool isCurrentOptionChanged = mEndSelectionIndex != aClickedIndex;
#endif
@@ -803,17 +803,17 @@ nsListControlFrame::PerformSelection(int
endIndex = aClickedIndex;
} else {
startIndex = aClickedIndex;
endIndex = mStartSelectionIndex;
}
// Clear only if control was not pressed
wasChanged = ExtendedSelection(startIndex, endIndex, !aIsControl);
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
ScrollToIndex(aClickedIndex);
if (!weakFrame.IsAlive()) {
return wasChanged;
}
if (mStartSelectionIndex == kNothingSelected) {
mStartSelectionIndex = aClickedIndex;
}
@@ -1051,17 +1051,17 @@ nsListControlFrame::ResetList(bool aAllo
// Scroll to the selected index
int32_t indexToSelect = kNothingSelected;
nsCOMPtr<nsIDOMHTMLSelectElement> selectElement(do_QueryInterface(mContent));
NS_ASSERTION(selectElement, "No select element!");
if (selectElement) {
selectElement->GetSelectedIndex(&indexToSelect);
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
ScrollToIndex(indexToSelect);
if (!weakFrame.IsAlive()) {
return;
}
}
}
mStartSelectionIndex = kNothingSelected;
@@ -1324,17 +1324,17 @@ nsListControlFrame::ToggleOptionSelected
// Dispatch event and such
bool
nsListControlFrame::UpdateSelection()
{
if (mIsAllFramesHere) {
// if it's a combobox, display the new text
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
if (mComboboxFrame) {
mComboboxFrame->RedisplaySelectedText();
// When dropdown list is open, onchange event will be fired when Enter key
// is hit or when dropdown list is dismissed.
if (mComboboxFrame->IsDroppedDown()) {
return weakFrame.IsAlive();
}
@@ -1352,17 +1352,17 @@ nsListControlFrame::ComboboxFinish(int32
{
gLastKeyTime = 0;
if (mComboboxFrame) {
int32_t displayIndex = mComboboxFrame->GetIndexOfDisplayArea();
// Make sure we can always reset to the displayed index
mForceSelection = displayIndex == aIndex;
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
PerformSelection(aIndex, false, false); // might destroy us
if (!weakFrame.IsAlive() || !mComboboxFrame) {
return;
}
if (displayIndex != aIndex) {
mComboboxFrame->RedisplaySelectedText(); // might destroy us
}
@@ -1405,17 +1405,17 @@ NS_IMETHODIMP
nsListControlFrame::OnSetSelectedIndex(int32_t aOldIndex, int32_t aNewIndex)
{
if (mComboboxFrame) {
// UpdateRecentIndex with NS_SKIP_NOTIFY_INDEX, so that we won't fire an onchange
// event for this setting of selectedIndex.
mComboboxFrame->UpdateRecentIndex(NS_SKIP_NOTIFY_INDEX);
}
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
ScrollToIndex(aNewIndex);
if (!weakFrame.IsAlive()) {
return NS_OK;
}
mStartSelectionIndex = aNewIndex;
mEndSelectionIndex = aNewIndex;
InvalidateFocus();
@@ -1471,17 +1471,17 @@ nsListControlFrame::AboutToDropDown()
mLastDropdownBackstopColor);
context = context->GetParent();
}
mLastDropdownBackstopColor =
NS_ComposeColors(PresContext()->DefaultBackgroundColor(),
mLastDropdownBackstopColor);
if (mIsAllContentHere && mIsAllFramesHere && mHasBeenInitialized) {
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
ScrollToIndex(GetSelectedIndex());
if (!weakFrame.IsAlive()) {
return;
}
#ifdef ACCESSIBILITY
FireMenuItemActiveEvent(); // Inform assistive tech what got focus
#endif
}
@@ -1681,17 +1681,17 @@ nsListControlFrame::MouseUp(nsIDOMEvent*
if (isDisabled) {
aMouseEvent->PreventDefault();
aMouseEvent->StopPropagation();
CaptureMouseEvents(false);
return NS_ERROR_FAILURE;
}
if (kNothingSelected != selectedIndex) {
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
ComboboxFinish(selectedIndex);
if (!weakFrame.IsAlive()) {
return NS_OK;
}
FireOnInputAndOnChange();
}
@@ -1842,17 +1842,17 @@ nsListControlFrame::MouseDown(nsIDOMEven
}
}
int32_t selectedIndex;
if (NS_SUCCEEDED(GetIndexFromDOMEvent(aMouseEvent, selectedIndex))) {
// Handle Like List
mButtonDown = true;
CaptureMouseEvents(true);
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
bool change =
HandleListSelection(aMouseEvent, selectedIndex); // might destroy us
if (!weakFrame.IsAlive()) {
return NS_OK;
}
mChangesSinceDragStart = change;
} else {
// NOTE: the combo box is responsible for dropping it down
@@ -1881,17 +1881,17 @@ nsListControlFrame::MouseDown(nsIDOMEven
if (!IgnoreMouseEventForSelection(aMouseEvent)) {
return NS_OK;
}
if (!nsComboboxControlFrame::ToolkitHasNativePopup())
{
bool isDroppedDown = mComboboxFrame->IsDroppedDown();
nsIFrame* comboFrame = do_QueryFrame(mComboboxFrame);
- nsWeakFrame weakFrame(comboFrame);
+ AutoWeakFrame weakFrame(comboFrame);
mComboboxFrame->ShowDropDown(!isDroppedDown);
if (!weakFrame.IsAlive())
return NS_OK;
if (isDroppedDown) {
CaptureMouseEvents(false);
}
}
}
@@ -1944,17 +1944,17 @@ nsListControlFrame::DragMove(nsIDOMEvent
nsCOMPtr<nsIDOMMouseEvent> mouseEvent = do_QueryInterface(aMouseEvent);
NS_ASSERTION(mouseEvent, "aMouseEvent is not an nsIDOMMouseEvent!");
bool isControl;
#ifdef XP_MACOSX
mouseEvent->GetMetaKey(&isControl);
#else
mouseEvent->GetCtrlKey(&isControl);
#endif
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
// Turn SHIFT on when you are dragging, unless control is on.
bool wasChanged = PerformSelection(selectedIndex,
!isControl, isControl);
if (!weakFrame.IsAlive()) {
return NS_OK;
}
mChangesSinceDragStart = mChangesSinceDragStart || wasChanged;
}
@@ -2116,17 +2116,17 @@ nsListControlFrame::DropDownToggleKey(ns
// dropdowns there.
if (IsInDropDownMode() && !nsComboboxControlFrame::ToolkitHasNativePopup()) {
aKeyEvent->PreventDefault();
if (!mComboboxFrame->IsDroppedDown()) {
if (!FireShowDropDownEvent(mContent, true, false)) {
mComboboxFrame->ShowDropDown(true);
}
} else {
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
// mEndSelectionIndex is the last item that got selected.
ComboboxFinish(mEndSelectionIndex);
if (weakFrame.IsAlive()) {
FireOnInputAndOnChange();
}
}
}
}
@@ -2231,17 +2231,17 @@ nsListControlFrame::KeyDown(nsIDOMEvent*
break;
case NS_VK_RETURN:
if (IsInDropDownMode()) {
if (mComboboxFrame->IsDroppedDown()) {
// If the select element is a dropdown style, Enter key should be
// consumed while the dropdown is open for security.
aKeyEvent->PreventDefault();
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
ComboboxFinish(mEndSelectionIndex);
if (!weakFrame.IsAlive()) {
return NS_OK;
}
}
FireOnInputAndOnChange();
return NS_OK;
}
@@ -2443,17 +2443,17 @@ nsListControlFrame::KeyPress(nsIDOMEvent
}
// now make sure there are options or we are wasting our time
RefPtr<dom::HTMLOptionsCollection> options = GetOptions();
NS_ENSURE_TRUE(options, NS_ERROR_FAILURE);
uint32_t numOptions = options->Length();
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
for (uint32_t i = 0; i < numOptions; ++i) {
uint32_t index = (i + startIndex) % numOptions;
RefPtr<dom::HTMLOptionElement> optionElement =
options->ItemAsOption(index);
if (!optionElement || !optionElement->GetPrimaryFrame()) {
continue;
}
@@ -2502,17 +2502,17 @@ nsListControlFrame::PostHandleKeyEvent(i
// the user acted on.
if (!GetNonDisabledOptionFrom(0, &aNewIndex)) {
return;
}
}
// If you hold control, but not shift, no key will actually do anything
// except space.
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
bool wasChanged = false;
if (aIsControlOrMeta && !aIsShift && aCharCode != ' ') {
mStartSelectionIndex = aNewIndex;
mEndSelectionIndex = aNewIndex;
InvalidateFocus();
ScrollToIndex(aNewIndex);
if (!weakFrame.IsAlive()) {
return;
--- a/layout/forms/nsNumberControlFrame.h
+++ b/layout/forms/nsNumberControlFrame.h
@@ -187,17 +187,17 @@ private:
static_cast<nsNumberControlFrame*>(mFrame.GetFrame());
NS_ENSURE_STATE(frame);
frame->SyncDisabledState();
return NS_OK;
}
private:
- nsWeakFrame mFrame;
+ AutoWeakFrame mFrame;
};
/**
* Sync the disabled state of the anonymous children up with our content's.
*/
void SyncDisabledState();
/**
--- a/layout/forms/nsTextControlFrame.cpp
+++ b/layout/forms/nsTextControlFrame.cpp
@@ -245,17 +245,17 @@ nsTextControlFrame::EnsureEditorInitiali
// when we actually need an editor.
if (mEditorHasBeenInitialized)
return NS_OK;
nsIDocument* doc = mContent->GetComposedDoc();
NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
// Flush out content on our document. Have to do this, because script
// blockers don't prevent the sink flushing out content and notifying in the
// process, which can destroy frames.
doc->FlushPendingNotifications(FlushType::ContentAndNotify);
NS_ENSURE_TRUE(weakFrame.IsAlive(), NS_ERROR_FAILURE);
// Make sure that editor init doesn't do things that would kill us off
@@ -706,17 +706,17 @@ nsresult nsTextControlFrame::SetFormProp
// Select all the text.
//
// XXX: This is lame, we can't call editor's SelectAll method
// because that triggers AutoCopies in unix builds.
// Instead, we have to call our own homegrown version
// of select all which merely builds a range that selects
// all of the content and adds that to the selection.
- nsWeakFrame weakThis = this;
+ AutoWeakFrame weakThis = this;
SelectAllOrCollapseToEndOfText(true); // NOTE: can destroy the world
if (!weakThis.IsAlive()) {
return NS_OK;
}
}
mIsProcessing = false;
}
return NS_OK;
@@ -1252,17 +1252,17 @@ nsTextControlFrame::SetInitialChildList(
void
nsTextControlFrame::SetValueChanged(bool aValueChanged)
{
nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent());
NS_ASSERTION(txtCtrl, "Content not a text control element");
if (mUsePlaceholder) {
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
txtCtrl->UpdatePlaceholderVisibility(true);
if (!weakFrame.IsAlive()) {
return;
}
}
txtCtrl->SetValueChanged(aValueChanged);
}
@@ -1308,17 +1308,17 @@ nsTextControlFrame::UpdateValueDisplay(b
txtCtrl->GetTextEditorValue(value, true);
}
// Update the display of the placeholder value if needed.
// We don't need to do this if we're about to initialize the
// editor, since EnsureEditorInitialized takes care of this.
if (mUsePlaceholder && !aBeforeEditorInit)
{
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
txtCtrl->UpdatePlaceholderVisibility(aNotify);
NS_ENSURE_STATE(weakFrame.IsAlive());
}
if (aBeforeEditorInit && value.IsEmpty()) {
rootNode->RemoveChildAt(0, true);
return NS_OK;
}
--- a/layout/forms/nsTextControlFrame.h
+++ b/layout/forms/nsTextControlFrame.h
@@ -238,17 +238,17 @@ protected:
class EditorInitializer : public mozilla::Runnable {
public:
explicit EditorInitializer(nsTextControlFrame* aFrame) :
mFrame(aFrame) {}
NS_IMETHOD Run() override;
- // avoids use of nsWeakFrame
+ // avoids use of AutoWeakFrame
void Revoke() {
mFrame = nullptr;
}
private:
nsTextControlFrame* mFrame;
};
--- a/layout/generic/ScrollbarActivity.cpp
+++ b/layout/generic/ScrollbarActivity.cpp
@@ -369,17 +369,17 @@ ScrollbarActivity::UpdateOpacity(TimeSta
// Avoid division by zero if mScrollbarFadeDuration is zero, just jump
// to the end of the fade animation
double progress = mScrollbarFadeDuration
? ((aTime - mFadeBeginTime) / FadeDuration())
: 1.0;
double opacity = 1.0 - std::max(0.0, std::min(1.0, progress));
// 'this' may be getting destroyed during SetOpacityOnElement calls.
- nsWeakFrame weakFrame((do_QueryFrame(mScrollableFrame)));
+ AutoWeakFrame weakFrame((do_QueryFrame(mScrollableFrame)));
SetOpacityOnElement(GetHorizontalScrollbar(), opacity);
if (!weakFrame.IsAlive()) {
return false;
}
SetOpacityOnElement(GetVerticalScrollbar(), opacity);
if (!weakFrame.IsAlive()) {
return false;
}
@@ -403,17 +403,17 @@ ScrollbarActivity::SetIsFading(bool aNew
{
if (mIsFading == aNewFading)
return true;
mIsFading = aNewFading;
if (!mIsFading) {
mFadeBeginTime = TimeStamp();
// 'this' may be getting destroyed during UnsetOpacityOnElement calls.
- nsWeakFrame weakFrame((do_QueryFrame(mScrollableFrame)));
+ AutoWeakFrame weakFrame((do_QueryFrame(mScrollableFrame)));
UnsetOpacityOnElement(GetHorizontalScrollbar());
if (!weakFrame.IsAlive()) {
return false;
}
UnsetOpacityOnElement(GetVerticalScrollbar());
if (!weakFrame.IsAlive()) {
return false;
}
--- a/layout/generic/nsContainerFrame.cpp
+++ b/layout/generic/nsContainerFrame.cpp
@@ -681,17 +681,17 @@ nsContainerFrame::SyncWindowProperties(n
return;
if (aFlags & SET_ASYNC) {
aView->SetNeedsWindowPropertiesSync();
return;
}
RefPtr<nsPresContext> kungFuDeathGrip(aPresContext);
- nsWeakFrame weak(rootFrame);
+ AutoWeakFrame weak(rootFrame);
nsTransparencyMode mode = nsLayoutUtils::GetFrameTransparency(aFrame, rootFrame);
int32_t shadow = rootFrame->StyleUIReset()->mWindowShadow;
nsCOMPtr<nsIWidget> viewWidget = aView->GetWidget();
viewWidget->SetTransparencyMode(mode);
windowWidget->SetWindowShadowStyle(shadow);
if (!aRC)
--- a/layout/generic/nsFrame.cpp
+++ b/layout/generic/nsFrame.cpp
@@ -402,23 +402,23 @@ nsIFrame::FindCloserFrameForSelection(
}
void
nsIFrame::ContentStatesChanged(mozilla::EventStates aStates)
{
}
void
-nsWeakFrame::Init(nsIFrame* aFrame)
+AutoWeakFrame::Init(nsIFrame* aFrame)
{
Clear(mFrame ? mFrame->PresContext()->GetPresShell() : nullptr);
mFrame = aFrame;
if (mFrame) {
nsIPresShell* shell = mFrame->PresContext()->GetPresShell();
- NS_WARNING_ASSERTION(shell, "Null PresShell in nsWeakFrame!");
+ NS_WARNING_ASSERTION(shell, "Null PresShell in AutoWeakFrame!");
if (shell) {
shell->AddWeakFrame(this);
} else {
mFrame = nullptr;
}
}
}
@@ -3425,17 +3425,17 @@ nsFrame::HandlePress(nsPresContext* aPre
bool control = mouseEvent->IsMeta();
#else
bool control = mouseEvent->IsControl();
#endif
RefPtr<nsFrameSelection> fc = const_cast<nsFrameSelection*>(frameselection);
if (mouseEvent->mClickCount > 1) {
// These methods aren't const but can't actually delete anything,
- // so no need for nsWeakFrame.
+ // so no need for AutoWeakFrame.
fc->SetDragState(true);
fc->SetMouseDoubleDown(true);
return HandleMultiplePress(aPresContext, mouseEvent, aEventStatus, control);
}
nsPoint pt = nsLayoutUtils::GetEventCoordinatesRelativeTo(mouseEvent, this);
ContentOffsets offsets = GetContentOffsetsFromPoint(pt, SKIP_HIDDEN);
@@ -3756,17 +3756,17 @@ NS_IMETHODIMP nsFrame::HandleDrag(nsPres
int32_t target;
WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent();
nsCOMPtr<nsIPresShell> presShell = aPresContext->PresShell();
nsresult result;
result = GetDataForTableSelection(frameselection, presShell, mouseEvent,
getter_AddRefs(parentContent),
&contentOffset, &target);
- nsWeakFrame weakThis = this;
+ AutoWeakFrame weakThis = this;
if (NS_SUCCEEDED(result) && parentContent) {
frameselection->HandleTableSelection(parentContent, contentOffset, target,
mouseEvent);
} else {
nsPoint pt = nsLayoutUtils::GetEventCoordinatesRelativeTo(mouseEvent, this);
frameselection->HandleDrag(this, pt);
}
--- a/layout/generic/nsFrameSetFrame.cpp
+++ b/layout/generic/nsFrameSetFrame.cpp
@@ -1251,17 +1251,17 @@ nsHTMLFramesetFrame::MouseDrag(nsPresCon
// if the capture ended, reset the drag state
if (nsIPresShell::GetCapturingContent() != GetContent()) {
mDragger = nullptr;
gDragInProgress = false;
return;
}
int32_t change; // measured positive from left-to-right or top-to-bottom
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
if (mDragger->mVertical) {
change = aPresContext->DevPixelsToAppUnits(
aEvent->mRefPoint.x - mFirstDragPoint.x);
if (change > mNextNeighborOrigSize - mMinDrag) {
change = mNextNeighborOrigSize - mMinDrag;
} else if (change <= mMinDrag - mPrevNeighborOrigSize) {
change = mMinDrag - mPrevNeighborOrigSize;
}
--- a/layout/generic/nsGfxScrollFrame.cpp
+++ b/layout/generic/nsGfxScrollFrame.cpp
@@ -2146,17 +2146,17 @@ ScrollFrameHelper::AsyncScrollCallback(S
}
void
ScrollFrameHelper::CompleteAsyncScroll(const nsRect &aRange, nsIAtom* aOrigin)
{
// Apply desired destination range since this is the last step of scrolling.
mAsyncSmoothMSDScroll = nullptr;
mAsyncScroll = nullptr;
- nsWeakFrame weakFrame(mOuter);
+ AutoWeakFrame weakFrame(mOuter);
ScrollToImpl(mDestination, aRange, aOrigin);
if (!weakFrame.IsAlive()) {
return;
}
// We are done scrolling, set our destination to wherever we actually ended
// up scrolling to.
mDestination = GetScrollPosition();
}
@@ -2899,17 +2899,17 @@ ScrollFrameHelper::ScrollToImpl(nsPoint
// Update the overflow for the outer so that we recompute scrollbars.
mOuter->UpdateOverflow();
}
ScheduleSyntheticMouseMove();
{ // scope the AutoScrollbarRepaintSuppression
AutoScrollbarRepaintSuppression repaintSuppression(this, !schedulePaint);
- nsWeakFrame weakFrame(mOuter);
+ AutoWeakFrame weakFrame(mOuter);
UpdateScrollbarPosition();
if (!weakFrame.IsAlive()) {
return;
}
}
presContext->RecordInteractionTime(
nsPresContext::InteractionType::eScrollInteraction,
@@ -4012,17 +4012,17 @@ ScrollFrameHelper::ScrollBy(nsIntPoint a
CalcRangeForScrollBy(aDelta.x, newPos.x, negativeTolerance, positiveTolerance,
deltaMultiplier.width, &rangeLowerX, &rangeUpperX);
CalcRangeForScrollBy(aDelta.y, newPos.y, negativeTolerance, positiveTolerance,
deltaMultiplier.height, &rangeLowerY, &rangeUpperY);
nsRect range(rangeLowerX,
rangeLowerY,
rangeUpperX - rangeLowerX,
rangeUpperY - rangeLowerY);
- nsWeakFrame weakFrame(mOuter);
+ AutoWeakFrame weakFrame(mOuter);
ScrollToWithOrigin(newPos, aMode, aOrigin, &range);
if (!weakFrame.IsAlive()) {
return;
}
if (aOverflow) {
nsPoint clampAmount = newPos - mDestination;
float appUnitsPerDevPixel = mOuter->PresContext()->AppUnitsPerDevPixel();
@@ -4219,17 +4219,17 @@ ScrollFrameHelper::ScrollToRestoredPosit
// and scroll many times.
if (mRestorePos != mLastPos /* GetLogicalScrollPosition() */) {
nsPoint scrollToPos = mRestorePos;
if (!IsPhysicalLTR()) {
// convert from logical to physical scroll position
scrollToPos.x = mScrollPort.x -
(mScrollPort.XMost() - scrollToPos.x - mScrolledFrame->GetRect().width);
}
- nsWeakFrame weakFrame(mOuter);
+ AutoWeakFrame weakFrame(mOuter);
ScrollToWithOrigin(scrollToPos, nsIScrollableFrame::INSTANT,
nsGkAtoms::restore, nullptr);
if (!weakFrame.IsAlive()) {
return;
}
if (PageIsStillLoading() || NS_SUBTREE_DIRTY(mOuter)) {
// If we're trying to do a history scroll restore, then we want to
// keep trying this until we succeed, because the page can be loading
@@ -4596,17 +4596,17 @@ ScrollFrameHelper::Destroy()
* Called when we want to update the scrollbar position, either because scrolling happened
* or the user moved the scrollbar position and we need to undo that (e.g., when the user
* clicks to scroll and we're using smooth scrolling, so we need to put the thumb back
* to its initial position for the start of the smooth sequence).
*/
void
ScrollFrameHelper::UpdateScrollbarPosition()
{
- nsWeakFrame weakFrame(mOuter);
+ AutoWeakFrame weakFrame(mOuter);
mFrameIsUpdatingScrollbar = true;
nsPoint pt = GetScrollPosition();
if (mVScrollbarBox) {
SetCoordAttribute(mVScrollbarBox->GetContent(), nsGkAtoms::curpos,
pt.y - GetScrolledRect().y);
if (!weakFrame.IsAlive()) {
return;
@@ -4668,17 +4668,17 @@ void ScrollFrameHelper::CurPosAttributeC
}
bool isSmooth = aContent->HasAttr(kNameSpaceID_None, nsGkAtoms::smooth);
if (isSmooth) {
// Make sure an attribute-setting callback occurs even if the view
// didn't actually move yet. We need to make sure other listeners
// see that the scroll position is not (yet) what they thought it
// was.
- nsWeakFrame weakFrame(mOuter);
+ AutoWeakFrame weakFrame(mOuter);
UpdateScrollbarPosition();
if (!weakFrame.IsAlive()) {
return;
}
}
ScrollToWithOrigin(dest,
isSmooth ? nsIScrollableFrame::SMOOTH : nsIScrollableFrame::INSTANT,
nsGkAtoms::scrollbars, &allowedRange);
@@ -5304,17 +5304,17 @@ ScrollFrameHelper::ReflowFinished()
mVScrollbarBox ? mVScrollbarBox->GetContent() : nullptr;
nsCOMPtr<nsIContent> hScroll =
mHScrollbarBox ? mHScrollbarBox->GetContent() : nullptr;
// Note, in some cases mOuter may get deleted while finishing reflow
// for scrollbars. XXXmats is this still true now that we have a script
// blocker in this scope? (if not, remove the weak frame checks below).
if (vScroll || hScroll) {
- nsWeakFrame weakFrame(mOuter);
+ AutoWeakFrame weakFrame(mOuter);
nsPoint scrollPos = GetScrollPosition();
nsSize lineScrollAmount = GetLineScrollAmount();
if (vScroll) {
const double kScrollMultiplier =
Preferences::GetInt("toolkit.scrollbox.verticalScrollDistance",
NS_DEFAULT_VERTICAL_SCROLL_DISTANCE);
nscoord increment = lineScrollAmount.height * kScrollMultiplier;
// We normally use (scrollArea.height - increment) for height
@@ -5668,17 +5668,17 @@ ScrollFrameHelper::SetCoordAttribute(nsI
// only set the attribute if it changed.
nsAutoString newValue;
newValue.AppendInt(pixelSize);
if (aContent->AttrValueIs(kNameSpaceID_None, aAtom, newValue, eCaseMatters))
return;
- nsWeakFrame weakFrame(mOuter);
+ AutoWeakFrame weakFrame(mOuter);
nsCOMPtr<nsIContent> kungFuDeathGrip = aContent;
aContent->SetAttr(kNameSpaceID_None, aAtom, newValue, true);
MOZ_ASSERT(ShellIsAlive(weakShell), "pres shell was destroyed by scrolling");
if (!weakFrame.IsAlive()) {
return;
}
if (mScrollbarActivity) {
--- a/layout/generic/nsIFrame.h
+++ b/layout/generic/nsIFrame.h
@@ -3798,48 +3798,48 @@ public:
virtual nsresult DumpRegressionData(nsPresContext* aPresContext,
FILE* out, int32_t aIndent) = 0;
#endif
};
//----------------------------------------------------------------------
/**
- * nsWeakFrame can be used to keep a reference to a nsIFrame in a safe way.
- * Whenever an nsIFrame object is deleted, the nsWeakFrames pointing
+ * AutoWeakFrame can be used to keep a reference to a nsIFrame in a safe way.
+ * Whenever an nsIFrame object is deleted, the AutoWeakFrames pointing
* to it will be cleared.
*
- * Create nsWeakFrame object when it is sure that nsIFrame object
+ * Create AutoWeakFrame object when it is sure that nsIFrame object
* is alive and after some operations which may destroy the nsIFrame
* (for example any DOM modifications) use IsAlive() or GetFrame() methods to
* check whether it is safe to continue to use the nsIFrame object.
*
* @note The usage of this class should be kept to a minimum.
*/
-class nsWeakFrame {
+class AutoWeakFrame {
public:
- nsWeakFrame() : mPrev(nullptr), mFrame(nullptr) { }
-
- nsWeakFrame(const nsWeakFrame& aOther) : mPrev(nullptr), mFrame(nullptr)
+ AutoWeakFrame() : mPrev(nullptr), mFrame(nullptr) { }
+
+ AutoWeakFrame(const AutoWeakFrame& aOther) : mPrev(nullptr), mFrame(nullptr)
{
Init(aOther.GetFrame());
}
- MOZ_IMPLICIT nsWeakFrame(nsIFrame* aFrame) : mPrev(nullptr), mFrame(nullptr)
+ MOZ_IMPLICIT AutoWeakFrame(nsIFrame* aFrame) : mPrev(nullptr), mFrame(nullptr)
{
Init(aFrame);
}
- nsWeakFrame& operator=(nsWeakFrame& aOther) {
+ AutoWeakFrame& operator=(AutoWeakFrame& aOther) {
Init(aOther.GetFrame());
return *this;
}
- nsWeakFrame& operator=(nsIFrame* aFrame) {
+ AutoWeakFrame& operator=(nsIFrame* aFrame) {
Init(aFrame);
return *this;
}
nsIFrame* operator->()
{
return mFrame;
}
@@ -3856,28 +3856,28 @@ public:
mFrame = nullptr;
mPrev = nullptr;
}
bool IsAlive() { return !!mFrame; }
nsIFrame* GetFrame() const { return mFrame; }
- nsWeakFrame* GetPreviousWeakFrame() { return mPrev; }
-
- void SetPreviousWeakFrame(nsWeakFrame* aPrev) { mPrev = aPrev; }
-
- ~nsWeakFrame()
+ AutoWeakFrame* GetPreviousWeakFrame() { return mPrev; }
+
+ void SetPreviousWeakFrame(AutoWeakFrame* aPrev) { mPrev = aPrev; }
+
+ ~AutoWeakFrame()
{
Clear(mFrame ? mFrame->PresContext()->GetPresShell() : nullptr);
}
private:
void Init(nsIFrame* aFrame);
- nsWeakFrame* mPrev;
+ AutoWeakFrame* mPrev;
nsIFrame* mFrame;
};
inline bool
nsFrameList::ContinueRemoveFrame(nsIFrame* aFrame)
{
MOZ_ASSERT(!aFrame->GetPrevSibling() || !aFrame->GetNextSibling(),
"Forgot to call StartRemoveFrame?");
--- a/layout/generic/nsPluginFrame.cpp
+++ b/layout/generic/nsPluginFrame.cpp
@@ -1847,17 +1847,17 @@ nsPluginFrame::EndSwapDocShells(nsISuppo
nsRootPresContext* rootPC = objectFrame->PresContext()->GetRootPresContext();
NS_ASSERTION(rootPC, "unable to register the plugin frame");
nsIWidget* widget = objectFrame->mWidget;
if (widget) {
// Reparent the widget.
nsIWidget* parent =
rootPC->PresShell()->GetRootFrame()->GetNearestWidget();
widget->SetParent(parent);
- nsWeakFrame weakFrame(objectFrame);
+ AutoWeakFrame weakFrame(objectFrame);
objectFrame->CallSetWindow();
if (!weakFrame.IsAlive()) {
return;
}
}
if (objectFrame->mInstanceOwner) {
objectFrame->RegisterPluginForGeometryUpdates();
--- a/layout/generic/nsSelection.cpp
+++ b/layout/generic/nsSelection.cpp
@@ -299,17 +299,17 @@ public:
mDelay = aDelay;
return NS_OK;
}
NS_IMETHOD Notify(nsITimer *timer) override
{
if (mSelection && mPresContext)
{
- nsWeakFrame frame =
+ AutoWeakFrame frame =
mContent ? mPresContext->GetPrimaryFrameFor(mContent) : nullptr;
if (!frame)
return NS_OK;
mContent = nullptr;
nsPoint pt = mPoint -
frame->GetOffsetTo(mPresContext->PresShell()->FrameManager()->GetRootFrame());
mFrameSelection->HandleDrag(frame, pt);
@@ -4855,18 +4855,18 @@ Selection::DoAutoScroll(nsIFrame* aFrame
(void)mAutoScrollTimer->Stop();
nsPresContext* presContext = aFrame->PresContext();
nsCOMPtr<nsIPresShell> shell = presContext->PresShell();
nsRootPresContext* rootPC = presContext->GetRootPresContext();
if (!rootPC)
return NS_OK;
nsIFrame* rootmostFrame = rootPC->PresShell()->FrameManager()->GetRootFrame();
- nsWeakFrame weakRootFrame(rootmostFrame);
- nsWeakFrame weakFrame(aFrame);
+ AutoWeakFrame weakRootFrame(rootmostFrame);
+ AutoWeakFrame weakFrame(aFrame);
// Get the point relative to the root most frame because the scroll we are
// about to do will change the coordinates of aFrame.
nsPoint globalPoint = aPoint + aFrame->GetOffsetToCrossDoc(rootmostFrame);
bool done = false;
bool didScroll;
while (true) {
didScroll = shell->ScrollFrameRectIntoView(
--- a/layout/generic/nsSimplePageSequenceFrame.cpp
+++ b/layout/generic/nsSimplePageSequenceFrame.cpp
@@ -656,17 +656,17 @@ nsSimplePageSequenceFrame::PrePrintNextP
if (!ctx) {
continue;
}
// Initialize the context with the new DrawTarget.
ctx->InitializeWithDrawTarget(nullptr, WrapNotNull(canvasTarget));
// Start the rendering process.
- nsWeakFrame weakFrame = this;
+ AutoWeakFrame weakFrame = this;
canvas->DispatchPrintCallback(aCallback);
NS_ENSURE_STATE(weakFrame.IsAlive());
}
}
}
uint32_t doneCounter = 0;
for (int32_t i = mCurrentCanvasList.Length() - 1; i >= 0 ; i--) {
HTMLCanvasElement* canvas = mCurrentCanvasList[i];
--- a/layout/generic/nsSubDocumentFrame.cpp
+++ b/layout/generic/nsSubDocumentFrame.cpp
@@ -88,17 +88,17 @@ public:
{
PROFILER_LABEL("mozilla", "AsyncFrameInit::Run", js::ProfileEntry::Category::OTHER);
if (mFrame.IsAlive()) {
static_cast<nsSubDocumentFrame*>(mFrame.GetFrame())->ShowViewer();
}
return NS_OK;
}
private:
- nsWeakFrame mFrame;
+ AutoWeakFrame mFrame;
};
static void
InsertViewsInReverseOrder(nsView* aSibling, nsView* aParent);
static void
EndSwapDocShellsForViews(nsView* aView);
@@ -176,17 +176,17 @@ nsSubDocumentFrame::ShowViewer()
if (!PresContext()->IsDynamic()) {
// We let the printing code take care of loading the document; just
// create the inner view for it to use.
(void) EnsureInnerView();
} else {
RefPtr<nsFrameLoader> frameloader = FrameLoader();
if (frameloader) {
CSSIntSize margin = GetMarginAttributes();
- nsWeakFrame weakThis(this);
+ AutoWeakFrame weakThis(this);
mCallingShow = true;
const nsAttrValue* attrValue =
GetContent()->AsElement()->GetParsedAttr(nsGkAtoms::scrolling);
int32_t scrolling =
nsGenericHTMLFrameElement::MapScrollingAttribute(attrValue);
bool didCreateDoc =
frameloader->Show(margin.width, margin.height,
scrolling, scrolling, this);
@@ -810,17 +810,17 @@ nsSubDocumentFrame::Reflow(nsPresContext
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
}
bool
nsSubDocumentFrame::ReflowFinished()
{
if (mFrameLoader) {
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
mFrameLoader->UpdatePositionAndSize(this);
if (weakFrame.IsAlive()) {
// Make sure that we can post a reflow callback in the future.
mPostedReflowCallback = false;
}
} else {
@@ -1177,18 +1177,18 @@ EndSwapDocShellsForViews(nsView* aSiblin
}
}
}
void
nsSubDocumentFrame::EndSwapDocShells(nsIFrame* aOther)
{
nsSubDocumentFrame* other = static_cast<nsSubDocumentFrame*>(aOther);
- nsWeakFrame weakThis(this);
- nsWeakFrame weakOther(aOther);
+ AutoWeakFrame weakThis(this);
+ AutoWeakFrame weakOther(aOther);
if (mInnerView) {
::EndSwapDocShellsForViews(mInnerView->GetFirstChild());
}
if (other->mInnerView) {
::EndSwapDocShellsForViews(other->mInnerView->GetFirstChild());
}
--- a/layout/painting/ActiveLayerTracker.cpp
+++ b/layout/painting/ActiveLayerTracker.cpp
@@ -100,17 +100,17 @@ public:
nsExpirationState mState;
// Previous scale due to the CSS transform property.
Maybe<gfxSize> mPreviousTransformScale;
// The scroll frame during for which we most recently received a call to
// NotifyAnimatedFromScrollHandler.
- nsWeakFrame mAnimatingScrollHandlerFrame;
+ AutoWeakFrame mAnimatingScrollHandlerFrame;
// The set of activities that were triggered during
// mAnimatingScrollHandlerFrame's scroll event handler.
EnumSet<ActivityIndex> mScrollHandlerInducedActivity;
// Number of restyle operations detected
uint8_t mRestyleCounts[ACTIVITY_COUNT];
bool mContentActive;
};
@@ -127,17 +127,17 @@ public:
~LayerActivityTracker() {
mDestroying = true;
AgeAllGenerations();
}
virtual void NotifyExpired(LayerActivity* aObject);
public:
- nsWeakFrame mCurrentScrollHandlerFrame;
+ AutoWeakFrame mCurrentScrollHandlerFrame;
private:
bool mDestroying;
};
static LayerActivityTracker* gLayerActivityTracker = nullptr;
LayerActivity::~LayerActivity()
--- a/layout/printing/nsPrintEngine.h
+++ b/layout/printing/nsPrintEngine.h
@@ -258,17 +258,17 @@ protected:
bool mProgressDialogIsShown;
nsCOMPtr<nsIDocumentViewerPrint> mDocViewerPrint;
nsWeakPtr mContainer;
float mScreenDPI;
mozilla::UniquePtr<nsPrintData> mPrt;
nsPagePrintTimer* mPagePrintTimer;
- nsWeakFrame mPageSeqFrame;
+ AutoWeakFrame mPageSeqFrame;
// Print Preview
mozilla::UniquePtr<nsPrintData> mPrtPreview;
mozilla::UniquePtr<nsPrintData> mOldPrtPreview;
nsCOMPtr<nsIDocument> mDocument;
FILE* mDebugFile;
--- a/layout/tables/nsTableFrame.cpp
+++ b/layout/tables/nsTableFrame.cpp
@@ -4856,17 +4856,17 @@ public:
nsTableFrame* tableFrame = static_cast <nsTableFrame*>(mFrame.GetFrame());
if (tableFrame->NeedToCalcBCBorders()) {
tableFrame->CalcBCBorders();
}
}
return NS_OK;
}
private:
- nsWeakFrame mFrame;
+ AutoWeakFrame mFrame;
};
bool
nsTableFrame::BCRecalcNeeded(nsStyleContext* aOldStyleContext,
nsStyleContext* aNewStyleContext)
{
// Attention: the old style context is the one we're forgetting,
// and hence possibly completely bogus for GetStyle* purposes.
--- a/layout/xul/nsListBoxBodyFrame.cpp
+++ b/layout/xul/nsListBoxBodyFrame.cpp
@@ -327,58 +327,58 @@ nsListBoxBodyFrame::GetXULPrefSize(nsBox
void
nsListBoxBodyFrame::ScrollByPage(nsScrollbarFrame* aScrollbar, int32_t aDirection,
nsIScrollbarMediator::ScrollSnapMode aSnap)
{
// CSS Scroll Snapping is not enabled for XUL, aSnap is ignored
MOZ_ASSERT(aScrollbar != nullptr);
aScrollbar->SetIncrementToPage(aDirection);
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
int32_t newPos = aScrollbar->MoveToNewPosition();
if (!weakFrame.IsAlive()) {
return;
}
UpdateIndex(newPos);
}
void
nsListBoxBodyFrame::ScrollByWhole(nsScrollbarFrame* aScrollbar, int32_t aDirection,
nsIScrollbarMediator::ScrollSnapMode aSnap)
{
// CSS Scroll Snapping is not enabled for XUL, aSnap is ignored
MOZ_ASSERT(aScrollbar != nullptr);
aScrollbar->SetIncrementToWhole(aDirection);
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
int32_t newPos = aScrollbar->MoveToNewPosition();
if (!weakFrame.IsAlive()) {
return;
}
UpdateIndex(newPos);
}
void
nsListBoxBodyFrame::ScrollByLine(nsScrollbarFrame* aScrollbar, int32_t aDirection,
nsIScrollbarMediator::ScrollSnapMode aSnap)
{
// CSS Scroll Snapping is not enabled for XUL, aSnap is ignored
MOZ_ASSERT(aScrollbar != nullptr);
aScrollbar->SetIncrementToLine(aDirection);
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
int32_t newPos = aScrollbar->MoveToNewPosition();
if (!weakFrame.IsAlive()) {
return;
}
UpdateIndex(newPos);
}
void
nsListBoxBodyFrame::RepeatButtonScroll(nsScrollbarFrame* aScrollbar)
{
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
int32_t newPos = aScrollbar->MoveToNewPosition();
if (!weakFrame.IsAlive()) {
return;
}
UpdateIndex(newPos);
}
int32_t
@@ -785,17 +785,17 @@ nsListBoxBodyFrame::ScrollToIndex(int32_
if (lastPageTopRow < 0)
lastPageTopRow = 0;
if (aRowIndex > lastPageTopRow)
return NS_OK;
mCurrentIndex = newIndex;
- nsWeakFrame weak(this);
+ AutoWeakFrame weak(this);
// Since we're going to flush anyway, we need to not do this off an event
DoInternalPositionChangedSync(up, delta);
if (!weak.IsAlive()) {
return NS_OK;
}
@@ -838,17 +838,17 @@ nsListBoxBodyFrame::InternalPositionChan
}
}
return rv;
}
nsresult
nsListBoxBodyFrame::DoInternalPositionChangedSync(bool aUp, int32_t aDelta)
{
- nsWeakFrame weak(this);
+ AutoWeakFrame weak(this);
// Process all the pending position changes first
nsTArray< RefPtr<nsPositionChangedEvent> > temp;
temp.SwapElements(mPendingPositionChangeEvents);
for (uint32_t i = 0; i < temp.Length(); ++i) {
if (weak.IsAlive()) {
temp[i]->Run();
}
@@ -869,17 +869,17 @@ nsListBoxBodyFrame::DoInternalPositionCh
return NS_OK;
RefPtr<nsPresContext> presContext(PresContext());
nsBoxLayoutState state(presContext);
// begin timing how long it takes to scroll a row
PRTime start = PR_Now();
- nsWeakFrame weakThis(this);
+ AutoWeakFrame weakThis(this);
mContent->GetComposedDoc()->FlushPendingNotifications(FlushType::Layout);
if (!weakThis.IsAlive()) {
return NS_OK;
}
{
nsAutoScriptBlocker scriptBlocker;
@@ -965,17 +965,17 @@ nsListBoxBodyFrame::VerticalScroll(int32
nsIScrollableFrame* scrollFrame
= nsLayoutUtils::GetScrollableFrameFor(this);
if (!scrollFrame) {
return;
}
nsPoint scrollPosition = scrollFrame->GetScrollPosition();
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
scrollFrame->ScrollTo(nsPoint(scrollPosition.x, aPosition),
nsIScrollableFrame::INSTANT);
if (!weakFrame.IsAlive()) {
return;
}
mYPosition = aPosition;
}
@@ -1402,17 +1402,17 @@ nsListBoxBodyFrame::OnContentRemoved(nsP
}
// if the row being removed is off-screen and above the top frame, we need to
// adjust our top index and tell the scrollbar to shift up one row.
if (siblingIndex >= 0 && siblingIndex-1 < mCurrentIndex) {
NS_PRECONDITION(mCurrentIndex > 0, "mCurrentIndex > 0");
--mCurrentIndex;
mYPosition = mCurrentIndex*mRowHeight;
- nsWeakFrame weakChildFrame(aChildFrame);
+ AutoWeakFrame weakChildFrame(aChildFrame);
VerticalScroll(mYPosition);
if (!weakChildFrame.IsAlive()) {
return;
}
}
} else if (mCurrentIndex > 0) {
// At this point, we know we have a scrollbar, and we need to know
// if we are scrolled to the last row. In this case, the behavior
@@ -1430,17 +1430,17 @@ nsListBoxBodyFrame::OnContentRemoved(nsP
if (lastChild) {
nsIFrame* lastChildFrame = lastChild->GetPrimaryFrame();
if (lastChildFrame) {
mTopFrame = nullptr;
mRowsToPrepend = 1;
--mCurrentIndex;
mYPosition = mCurrentIndex*mRowHeight;
- nsWeakFrame weakChildFrame(aChildFrame);
+ AutoWeakFrame weakChildFrame(aChildFrame);
VerticalScroll(mYPosition);
if (!weakChildFrame.IsAlive()) {
return;
}
}
}
}
}
--- a/layout/xul/nsListBoxBodyFrame.h
+++ b/layout/xul/nsListBoxBodyFrame.h
@@ -180,17 +180,17 @@ protected:
void ComputeTotalRowCount();
int32_t ToRowIndex(nscoord aPos) const;
void RemoveChildFrame(nsBoxLayoutState &aState, nsIFrame *aChild);
nsTArray< RefPtr<nsPositionChangedEvent> > mPendingPositionChangeEvents;
nsCOMPtr<nsPIBoxObject> mBoxObject;
// frame markers
- nsWeakFrame mTopFrame;
+ AutoWeakFrame mTopFrame;
nsIFrame* mBottomFrame;
nsIFrame* mLinkupFrame;
nsListScrollSmoother* mScrollSmoother;
int32_t mRowsToPrepend;
// row height
--- a/layout/xul/nsMenuBarFrame.cpp
+++ b/layout/xul/nsMenuBarFrame.cpp
@@ -276,17 +276,17 @@ public:
nsMenuBarFrame* menubar = nullptr;
if (mOldMenu && mNewMenu) {
menubar = do_QueryFrame(mMenuBar->GetPrimaryFrame());
if (menubar)
menubar->SetStayActive(true);
}
if (mOldMenu) {
- nsWeakFrame weakMenuBar(menubar);
+ AutoWeakFrame weakMenuBar(menubar);
pm->HidePopup(mOldMenu, false, false, false, false);
// clear the flag again
if (mNewMenu && weakMenuBar.IsAlive())
menubar->SetStayActive(false);
}
if (mNewMenu)
pm->ShowMenu(mNewMenu, mSelectFirstItem, false);
--- a/layout/xul/nsMenuFrame.cpp
+++ b/layout/xul/nsMenuFrame.cpp
@@ -133,17 +133,17 @@ public:
else if (mAttr == nsGkAtoms::key) {
frame->BuildAcceleratorText(true);
} else if (mAttr == nsGkAtoms::type || mAttr == nsGkAtoms::name) {
frame->UpdateMenuType();
}
return NS_OK;
}
protected:
- nsWeakFrame mFrame;
+ AutoWeakFrame mFrame;
nsCOMPtr<nsIAtom> mAttr;
};
//
// NS_NewMenuFrame and NS_NewMenuItemFrame
//
// Wrappers for creating a new menu popup container
//
@@ -374,17 +374,17 @@ nsMenuFrame::HandleEvent(nsPresContext*
if (nsEventStatus_eConsumeNoDefault == *aEventStatus) {
return NS_OK;
}
nsMenuParent* menuParent = GetMenuParent();
if (menuParent && menuParent->IsMenuLocked()) {
return NS_OK;
}
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
if (*aEventStatus == nsEventStatus_eIgnore)
*aEventStatus = nsEventStatus_eConsumeDoDefault;
// If a menu just opened, ignore the mouseup event that might occur after a
// the mousedown event that opened it. However, if a different mousedown
// event occurs, just clear this flag.
if (gMenuJustOpenedOrClosed) {
if (aEvent->mMessage == eMouseDown) {
@@ -541,17 +541,17 @@ nsMenuFrame::ToggleMenuState()
OpenMenu(false);
}
void
nsMenuFrame::PopupOpened()
{
gMenuJustOpenedOrClosed = true;
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
mContent->SetAttr(kNameSpaceID_None, nsGkAtoms::open,
NS_LITERAL_STRING("true"), true);
if (!weakFrame.IsAlive())
return;
nsMenuParent* menuParent = GetMenuParent();
if (menuParent) {
menuParent->SetActive(true);
@@ -559,17 +559,17 @@ nsMenuFrame::PopupOpened()
// the menubar is highlighted
menuParent->SetCurrentMenuItem(this);
}
}
void
nsMenuFrame::PopupClosed(bool aDeselectMenu)
{
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
nsContentUtils::AddScriptRunner(
new nsUnsetAttrRunnable(mContent, nsGkAtoms::open));
if (!weakFrame.IsAlive())
return;
// if the popup is for a menu on a menubar, inform menubar to deactivate
nsMenuParent* menuParent = GetMenuParent();
if (menuParent && menuParent->MenuClosed()) {
@@ -892,17 +892,17 @@ nsMenuFrame::Notify(nsITimer* aTimer)
switch (mBlinkState++) {
case 0:
NS_ASSERTION(false, "Blink timer fired while not blinking");
StopBlinking();
break;
case 1:
{
// Turn the highlight back on and wait for a while before closing the menu.
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
mContent->SetAttr(kNameSpaceID_None, nsGkAtoms::menuactive,
NS_LITERAL_STRING("true"), true);
if (weakFrame.IsAlive()) {
aTimer->InitWithCallback(mTimerMediator, kBlinkDelay, nsITimer::TYPE_ONE_SHOT);
}
}
break;
default: {
@@ -937,17 +937,17 @@ nsMenuFrame::UpdateMenuType()
case 0: mType = eMenuType_Checkbox; break;
case 1:
mType = eMenuType_Radio;
mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::name, mGroupName);
break;
default:
if (mType != eMenuType_Normal) {
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
mContent->UnsetAttr(kNameSpaceID_None, nsGkAtoms::checked,
true);
ENSURE_TRUE(weakFrame.IsAlive());
}
mType = eMenuType_Normal;
break;
}
UpdateMenuSpecialState();
@@ -1031,17 +1031,17 @@ nsMenuFrame::BuildAcceleratorText(bool a
return;
}
// accelText is definitely empty here.
// Now we're going to compute the accelerator text, so remember that we did.
AddStateBits(NS_STATE_ACCELTEXT_IS_DERIVED);
// If anything below fails, just leave the accelerator text blank.
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
mContent->UnsetAttr(kNameSpaceID_None, nsGkAtoms::acceltext, aNotify);
ENSURE_TRUE(weakFrame.IsAlive());
// See if we have a key node and use that instead.
nsAutoString keyValue;
mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::key, keyValue);
if (keyValue.IsEmpty())
return;
@@ -1215,17 +1215,17 @@ nsMenuFrame::StartBlinking(WidgetGUIEven
CreateMenuCommandEvent(aEvent, aFlipChecked);
if (!ShouldBlink()) {
PassMenuCommandEventToPopupManager();
return;
}
// Blink off.
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
mContent->UnsetAttr(kNameSpaceID_None, nsGkAtoms::menuactive, true);
if (!weakFrame.IsAlive())
return;
nsMenuParent* menuParent = GetMenuParent();
if (menuParent) {
// Make this menu ignore events from now on.
menuParent->LockMenuUntilClosed(true);
--- a/layout/xul/nsMenuPopupFrame.cpp
+++ b/layout/xul/nsMenuPopupFrame.cpp
@@ -445,17 +445,17 @@ nsMenuPopupFrame::LayoutPopup(nsBoxLayou
}
}
// if the popup has just been opened, make sure the scrolled window is at 0,0
// Don't scroll menulists as they will scroll to their selected item on their own.
if (mIsOpenChanged && !IsMenuList()) {
nsIScrollableFrame *scrollframe = do_QueryFrame(nsBox::GetChildXULBox(this));
if (scrollframe) {
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
scrollframe->ScrollTo(nsPoint(0,0), nsIScrollableFrame::INSTANT);
if (!weakFrame.IsAlive()) {
return;
}
}
}
// get the preferred, minimum and maximum size. If the menu is sized to the
@@ -887,17 +887,17 @@ nsMenuPopupFrame::ShowPopup(bool aIsCont
EventStateManager::ClearGlobalActiveContent(activeESM);
}
nsIPresShell::SetCapturingContent(nullptr, 0);
}
nsMenuFrame* menuFrame = do_QueryFrame(GetParent());
if (menuFrame) {
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
menuFrame->PopupOpened();
if (!weakFrame.IsAlive())
return;
}
// do we need an actual reflow here?
// is SetPopupPosition all that is needed?
PresContext()->PresShell()->FrameNeedsReflow(this, nsIPresShell::eTreeChange,
--- a/layout/xul/nsProgressMeterFrame.cpp
+++ b/layout/xul/nsProgressMeterFrame.cpp
@@ -26,17 +26,17 @@ class nsReflowFrameRunnable : public moz
{
public:
nsReflowFrameRunnable(nsIFrame* aFrame,
nsIPresShell::IntrinsicDirty aIntrinsicDirty,
nsFrameState aBitToAdd);
NS_DECL_NSIRUNNABLE
- nsWeakFrame mWeakFrame;
+ AutoWeakFrame mWeakFrame;
nsIPresShell::IntrinsicDirty mIntrinsicDirty;
nsFrameState mBitToAdd;
};
nsReflowFrameRunnable::nsReflowFrameRunnable(nsIFrame* aFrame,
nsIPresShell::IntrinsicDirty aIntrinsicDirty,
nsFrameState aBitToAdd)
: mWeakFrame(aFrame),
@@ -95,17 +95,17 @@ public:
return shouldFlush;
}
virtual void ReflowCallbackCanceled() override
{
delete this;
}
- nsWeakFrame mWeakFrame;
+ AutoWeakFrame mWeakFrame;
};
NS_IMETHODIMP
nsProgressMeterFrame::DoXULLayout(nsBoxLayoutState& aState)
{
if (mNeedsReflowCallback) {
nsIReflowCallback* cb = new nsAsyncProgressMeterInit(this);
if (cb) {
--- a/layout/xul/nsResizerFrame.cpp
+++ b/layout/xul/nsResizerFrame.cpp
@@ -55,17 +55,17 @@ nsResizerFrame::HandleEvent(nsPresContex
WidgetGUIEvent* aEvent,
nsEventStatus* aEventStatus)
{
NS_ENSURE_ARG_POINTER(aEventStatus);
if (nsEventStatus_eConsumeNoDefault == *aEventStatus) {
return NS_OK;
}
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
bool doDefault = true;
switch (aEvent->mMessage) {
case eTouchStart:
case eMouseDown: {
if (aEvent->mClass == eTouchEventClass ||
(aEvent->mClass == eMouseEventClass &&
aEvent->AsMouseEvent()->button == WidgetMouseEvent::eLeftButton)) {
@@ -242,17 +242,17 @@ nsResizerFrame::HandleEvent(nsPresContex
nsRect appUnitsRect = ToAppUnits(rect.ToUnknownRect(), aPresContext->AppUnitsPerDevPixel());
if (appUnitsRect.width < mRect.width && mouseMove.x)
appUnitsRect.width = mRect.width;
if (appUnitsRect.height < mRect.height && mouseMove.y)
appUnitsRect.height = mRect.height;
nsIntRect cssRect = appUnitsRect.ToInsidePixels(nsPresContext::AppUnitsPerCSSPixel());
LayoutDeviceIntRect oldRect;
- nsWeakFrame weakFrame(menuPopupFrame);
+ AutoWeakFrame weakFrame(menuPopupFrame);
if (menuPopupFrame) {
nsCOMPtr<nsIWidget> widget = menuPopupFrame->GetWidget();
if (widget)
oldRect = widget->GetScreenBounds();
// convert the new rectangle into outer window coordinates
LayoutDeviceIntPoint clientOffset = widget->GetClientOffset();
rect.x -= clientOffset.x;
--- a/layout/xul/nsScrollbarButtonFrame.cpp
+++ b/layout/xul/nsScrollbarButtonFrame.cpp
@@ -125,17 +125,17 @@ nsScrollbarButtonFrame::HandleButtonPres
direction = 1;
else if (index == 1)
direction = -1;
else
return false;
bool repeat = pressedButtonAction != 2;
// set this attribute so we can style it later
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
mContent->SetAttr(kNameSpaceID_None, nsGkAtoms::active, NS_LITERAL_STRING("true"), true);
nsIPresShell::SetCapturingContent(mContent, CAPTURE_IGNOREALLOWED);
if (!weakFrame.IsAlive()) {
return false;
}
--- a/layout/xul/nsScrollbarFrame.cpp
+++ b/layout/xul/nsScrollbarFrame.cpp
@@ -263,17 +263,17 @@ nsScrollbarFrame::MoveToNewPosition()
} else if (curpos > maxpos) {
curpos = maxpos;
}
// set the current position of the slider.
nsAutoString curposStr;
curposStr.AppendInt(curpos);
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
if (mSmoothScroll) {
content->SetAttr(kNameSpaceID_None, nsGkAtoms::smooth, NS_LITERAL_STRING("true"), false);
}
content->SetAttr(kNameSpaceID_None, nsGkAtoms::curpos, curposStr, false);
// notify the nsScrollbarFrame of the change
AttributeChanged(kNameSpaceID_None, nsGkAtoms::curpos, nsIDOMMutationEvent::MODIFICATION);
if (!weakFrame.IsAlive()) {
return curpos;
--- a/layout/xul/nsSliderFrame.cpp
+++ b/layout/xul/nsSliderFrame.cpp
@@ -604,17 +604,17 @@ nsSliderFrame::HandleEvent(nsPresContext
}
nsSize thumbSize = thumbFrame->GetSize();
nscoord thumbLength = isHorizontal ? thumbSize.width : thumbSize.height;
mozilla::Telemetry::Accumulate(mozilla::Telemetry::SCROLL_INPUT_METHODS,
(uint32_t) ScrollInputMethod::MainThreadScrollbarTrackClick);
// set it
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
// should aMaySnap be true here?
SetCurrentThumbPosition(scrollbar, pos - thumbLength/2, false, false);
NS_ENSURE_TRUE(weakFrame.IsAlive(), NS_OK);
DragThumb(true);
#ifdef MOZ_WIDGET_GTK
nsCOMPtr<nsIContent> thumb = thumbFrame->GetContent();
@@ -871,17 +871,17 @@ nsSliderFrame::SetCurrentPosition(nsICon
}
void
nsSliderFrame::SetCurrentPositionInternal(nsIContent* aScrollbar, int32_t aNewPos,
bool aIsSmooth)
{
nsCOMPtr<nsIContent> scrollbar = aScrollbar;
nsIFrame* scrollbarBox = GetScrollbar();
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
mUserChanged = true;
nsScrollbarFrame* scrollbarFrame = do_QueryFrame(scrollbarBox);
if (scrollbarFrame) {
// See if we have a mediator.
nsIScrollbarMediator* mediator = scrollbarFrame->GetScrollbarMediator();
if (mediator) {
--- a/layout/xul/nsSplitterFrame.cpp
+++ b/layout/xul/nsSplitterFrame.cpp
@@ -379,17 +379,17 @@ nsSplitterFrame::HandleEvent(nsPresConte
WidgetGUIEvent* aEvent,
nsEventStatus* aEventStatus)
{
NS_ENSURE_ARG_POINTER(aEventStatus);
if (nsEventStatus_eConsumeNoDefault == *aEventStatus) {
return NS_OK;
}
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
RefPtr<nsSplitterFrameInner> inner(mInner);
switch (aEvent->mMessage) {
case eMouseMove:
inner->MouseDrag(aPresContext, aEvent);
break;
case eMouseUp:
if (aEvent->AsMouseEvent()->button == WidgetMouseEvent::eLeftButton) {
@@ -971,17 +971,17 @@ nsSplitterFrameInner::SetPreferredSize(n
// set its preferred size.
nsAutoString prefValue;
prefValue.AppendInt(pref/aOnePixel);
if (content->AttrValueIs(kNameSpaceID_None, attribute,
prefValue, eCaseMatters))
return;
- nsWeakFrame weakBox(aChildBox);
+ AutoWeakFrame weakBox(aChildBox);
content->SetAttr(kNameSpaceID_None, attribute, prefValue, true);
ENSURE_TRUE(weakBox.IsAlive());
aState.PresShell()->FrameNeedsReflow(aChildBox, nsIPresShell::eStyleChange,
NS_FRAME_IS_DIRTY);
}
void
--- a/layout/xul/nsTextBoxFrame.cpp
+++ b/layout/xul/nsTextBoxFrame.cpp
@@ -182,21 +182,21 @@ public:
return shouldFlush;
}
virtual void ReflowCallbackCanceled() override
{
delete this;
}
- nsWeakFrame mWeakFrame;
+ AutoWeakFrame mWeakFrame;
};
bool
-nsTextBoxFrame::UpdateAccesskey(nsWeakFrame& aWeakThis)
+nsTextBoxFrame::UpdateAccesskey(AutoWeakFrame& aWeakThis)
{
nsAutoString accesskey;
nsCOMPtr<nsIDOMXULLabelElement> labelElement = do_QueryInterface(mContent);
NS_ENSURE_TRUE(aWeakThis.IsAlive(), false);
if (labelElement) {
// Accesskey may be stored on control.
labelElement->GetAccessKey(accesskey);
NS_ENSURE_TRUE(aWeakThis.IsAlive(), false);
--- a/layout/xul/nsTextBoxFrame.h
+++ b/layout/xul/nsTextBoxFrame.h
@@ -66,17 +66,17 @@ public:
virtual void DidSetStyleContext(nsStyleContext* aOldStyleContext) override;
protected:
friend class nsAsyncAccesskeyUpdate;
friend class nsDisplayXULTextBox;
// Should be called only by nsAsyncAccesskeyUpdate.
// Returns true if accesskey was updated.
- bool UpdateAccesskey(nsWeakFrame& aWeakThis);
+ bool UpdateAccesskey(AutoWeakFrame& aWeakThis);
void UpdateAccessTitle();
void UpdateAccessIndex();
// Recompute our title, ignoring the access key but taking into
// account text-transform.
void RecomputeTitle();
// REVIEW: SORRY! Couldn't resist devirtualizing these
--- a/layout/xul/nsXULPopupManager.cpp
+++ b/layout/xul/nsXULPopupManager.cpp
@@ -931,17 +931,17 @@ nsXULPopupManager::ShowPopupCallback(nsI
// if the menu is on a menubar, use the menubar's listener instead
nsMenuFrame* menuFrame = do_QueryFrame(aPopupFrame->GetParent());
if (menuFrame) {
item->SetOnMenuBar(menuFrame->IsOnMenuBar());
}
}
// use a weak frame as the popup will set an open attribute if it is a menu
- nsWeakFrame weakFrame(aPopupFrame);
+ AutoWeakFrame weakFrame(aPopupFrame);
aPopupFrame->ShowPopup(aIsContextMenu);
ENSURE_TRUE(weakFrame.IsAlive());
// popups normally hide when an outside click occurs. Panels may use
// the noautohide attribute to disable this behaviour. It is expected
// that the application will hide these popups manually. The tooltip
// listener will handle closing the tooltip also.
if (aPopupFrame->IsNoAutoHide() || popupType == ePopupTypeTooltip) {
@@ -1182,17 +1182,17 @@ nsXULPopupManager::HidePopupCallback(nsI
break;
}
item = item->GetParent();
}
}
delete item;
- nsWeakFrame weakFrame(aPopupFrame);
+ AutoWeakFrame weakFrame(aPopupFrame);
aPopupFrame->HidePopup(aDeselectMenu, ePopupClosed);
ENSURE_TRUE(weakFrame.IsAlive());
// send the popuphidden event synchronously. This event has no default
// behaviour.
nsEventStatus status = nsEventStatus_eIgnore;
WidgetMouseEvent event(true, eXULPopupHidden, nullptr,
WidgetMouseEvent::eReal);
@@ -1260,20 +1260,20 @@ nsXULPopupManager::HidePopupAfterDelay(n
}
void
nsXULPopupManager::HidePopupsInList(const nsTArray<nsMenuPopupFrame *> &aFrames)
{
// Create a weak frame list. This is done in a separate array with the
// right capacity predetermined, otherwise the array would get resized and
// move the weak frame pointers around.
- nsTArray<nsWeakFrame> weakPopups(aFrames.Length());
+ nsTArray<AutoWeakFrame> weakPopups(aFrames.Length());
uint32_t f;
for (f = 0; f < aFrames.Length(); f++) {
- nsWeakFrame* wframe = weakPopups.AppendElement();
+ AutoWeakFrame* wframe = weakPopups.AppendElement();
if (wframe)
*wframe = aFrames[f];
}
for (f = 0; f < weakPopups.Length(); f++) {
// check to ensure that the frame is still alive before hiding it.
if (weakPopups[f].IsAlive()) {
nsMenuPopupFrame* frame =
@@ -2897,17 +2897,17 @@ nsXULMenuCommandEvent::Run()
// The order of the nsViewManager and nsIPresShell COM pointers is
// important below. We want the pres shell to get released before the
// associated view manager on exit from this function.
// See bug 54233.
// XXXndeakin is this still needed?
nsCOMPtr<nsIContent> popup;
nsMenuFrame* menuFrame = do_QueryFrame(mMenu->GetPrimaryFrame());
- nsWeakFrame weakFrame(menuFrame);
+ AutoWeakFrame weakFrame(menuFrame);
if (menuFrame && mFlipChecked) {
if (menuFrame->IsChecked()) {
mMenu->UnsetAttr(kNameSpaceID_None, nsGkAtoms::checked, true);
} else {
mMenu->SetAttr(kNameSpaceID_None, nsGkAtoms::checked,
NS_LITERAL_STRING("true"), true);
}
}
--- a/layout/xul/tree/nsTreeBodyFrame.cpp
+++ b/layout/xul/tree/nsTreeBodyFrame.cpp
@@ -352,17 +352,17 @@ nsTreeBodyFrame::EnsureView()
if (!mReflowCallbackPosted) {
mReflowCallbackPosted = true;
PresContext()->PresShell()->PostReflowCallback(this);
}
return;
}
nsCOMPtr<nsIBoxObject> box = do_QueryInterface(mTreeBoxObject);
if (box) {
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
nsCOMPtr<nsITreeView> treeView;
mTreeBoxObject->GetView(getter_AddRefs(treeView));
if (treeView && weakFrame.IsAlive()) {
nsXPIDLString rowStr;
box->GetProperty(u"topRow", getter_Copies(rowStr));
nsAutoString rowStr2(rowStr);
nsresult error;
int32_t rowIndex = rowStr2.ToInteger(&error);
@@ -412,17 +412,17 @@ nsTreeBodyFrame::SetXULBounds(nsBoxLayou
nsLeafBoxFrame::SetXULBounds(aBoxLayoutState, aRect, aRemoveOverflowArea);
}
bool
nsTreeBodyFrame::ReflowFinished()
{
if (!mView) {
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
EnsureView();
NS_ENSURE_TRUE(weakFrame.IsAlive(), false);
}
if (mView) {
CalcInnerBox();
ScrollParts parts = GetScrollParts();
mHorzWidth = CalcHorzWidth(parts);
if (!mHasFixedRowCount) {
@@ -464,17 +464,17 @@ nsTreeBodyFrame::ReflowCallbackCanceled(
{
mReflowCallbackPosted = false;
}
nsresult
nsTreeBodyFrame::GetView(nsITreeView * *aView)
{
*aView = nullptr;
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
EnsureView();
NS_ENSURE_STATE(weakFrame.IsAlive());
NS_IF_ADDREF(*aView = mView);
return NS_OK;
}
nsresult
nsTreeBodyFrame::SetView(nsITreeView * aView)
@@ -517,17 +517,17 @@ nsTreeBodyFrame::SetView(nsITreeView * a
sel->SetTree(mTreeBoxObject);
}
else {
NS_NewTreeSelection(mTreeBoxObject, getter_AddRefs(sel));
mView->SetSelection(sel);
}
// View, meet the tree.
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
mView->SetTree(mTreeBoxObject);
NS_ENSURE_STATE(weakFrame.IsAlive());
mView->GetRowCount(&mRowCount);
if (!PresContext()->PresShell()->IsReflowLocked()) {
// The scrollbar will need to be updated.
FullScrollbarsUpdate(false);
} else if (!mReflowCallbackPosted) {
@@ -847,17 +847,17 @@ nsTreeBodyFrame::ScrollParts nsTreeBodyF
return result;
}
void
nsTreeBodyFrame::UpdateScrollbars(const ScrollParts& aParts)
{
nscoord rowHeightAsPixels = nsPresContext::AppUnitsToIntCSSPixels(mRowHeight);
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
if (aParts.mVScrollbar) {
nsAutoString curPos;
curPos.AppendInt(mTopRowIndex*rowHeightAsPixels);
aParts.mVScrollbarContent->
SetAttr(kNameSpaceID_None, nsGkAtoms::curpos, curPos, true);
// 'this' might be deleted here
}
@@ -902,17 +902,17 @@ nsTreeBodyFrame::CheckOverflow(const Scr
horizontalOverflowChanged = true;
} else if (mHorizontalOverflow && bounds.width >= mHorzWidth) {
mHorizontalOverflow = false;
horizontalOverflowChanged = true;
}
}
}
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
RefPtr<nsPresContext> presContext = PresContext();
nsCOMPtr<nsIPresShell> presShell = presContext->GetPresShell();
nsCOMPtr<nsIContent> content = mContent;
if (verticalOverflowChanged) {
InternalScrollPortEvent event(true,
mVerticalOverflow ? eScrollPortOverflow : eScrollPortUnderflow,
@@ -942,21 +942,21 @@ nsTreeBodyFrame::CheckOverflow(const Scr
presShell->FlushPendingNotifications(FlushType::Layout);
if (!weakFrame.IsAlive()) {
return;
}
mCheckingOverflow = false;
}
void
-nsTreeBodyFrame::InvalidateScrollbars(const ScrollParts& aParts, nsWeakFrame& aWeakColumnsFrame)
+nsTreeBodyFrame::InvalidateScrollbars(const ScrollParts& aParts, AutoWeakFrame& aWeakColumnsFrame)
{
if (mUpdateBatchNest || !mView)
return;
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
if (aParts.mVScrollbar) {
// Do Vertical Scrollbar
nsAutoString maxposStr;
nscoord rowHeightAsPixels = nsPresContext::AppUnitsToIntCSSPixels(mRowHeight);
int32_t size = rowHeightAsPixels * (mRowCount > mPageLength ? mRowCount - mPageLength : 0);
@@ -4360,17 +4360,17 @@ nsTreeBodyFrame::ScrollHorzInternal(cons
if (aPosition > (mHorzWidth - bounds.width))
aPosition = mHorzWidth - bounds.width;
mHorzPosition = aPosition;
Invalidate();
// Update the column scroll view
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
aParts.mColumnsScrollFrame->ScrollTo(nsPoint(mHorzPosition, 0),
nsIScrollableFrame::INSTANT);
if (!weakFrame.IsAlive()) {
return NS_ERROR_FAILURE;
}
// And fire off an event about it all
PostScrollEvent();
return NS_OK;
@@ -4412,17 +4412,17 @@ nsTreeBodyFrame::RepeatButtonScroll(nsSc
int32_t direction = 0;
if (increment < 0) {
direction = -1;
} else if (increment > 0) {
direction = 1;
}
bool isHorizontal = aScrollbar->IsXULHorizontal();
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
if (isHorizontal) {
int32_t curpos = aScrollbar->MoveToNewPosition();
if (weakFrame.IsAlive()) {
ScrollHorzInternal(parts, curpos);
}
} else {
ScrollToRowInternal(parts, mTopRowIndex+direction);
}
@@ -4440,17 +4440,17 @@ nsTreeBodyFrame::ThumbMoved(nsScrollbarF
nscoord aOldPos,
nscoord aNewPos)
{
ScrollParts parts = GetScrollParts();
if (aOldPos == aNewPos)
return;
- nsWeakFrame weakFrame(this);
+ AutoWeakFrame weakFrame(this);
// Vertical Scrollbar
if (parts.mVScrollbar == aScrollbar) {
nscoord rh = nsPresContext::AppUnitsToIntCSSPixels(mRowHeight);
nscoord newIndex = nsPresContext::AppUnitsToIntCSSPixels(aNewPos);
nscoord newrow = newIndex/rh;
ScrollInternal(parts, newrow);
// Horizontal Scrollbar
@@ -4901,25 +4901,25 @@ public:
if (mFrame.IsAlive()) {
nsTreeBodyFrame* tree = static_cast<nsTreeBodyFrame*>(mFrame.GetFrame());
nsTreeBodyFrame::ScrollParts parts = tree->GetScrollParts();
tree->CheckOverflow(parts);
}
return NS_OK;
}
private:
- nsWeakFrame mFrame;
+ AutoWeakFrame mFrame;
};
bool
nsTreeBodyFrame::FullScrollbarsUpdate(bool aNeedsFullInvalidation)
{
ScrollParts parts = GetScrollParts();
- nsWeakFrame weakFrame(this);
- nsWeakFrame weakColumnsFrame(parts.mColumnsFrame);
+ AutoWeakFrame weakFrame(this);
+ AutoWeakFrame weakColumnsFrame(parts.mColumnsFrame);
UpdateScrollbars(parts);
NS_ENSURE_TRUE(weakFrame.IsAlive(), false);
if (aNeedsFullInvalidation) {
Invalidate();
}
InvalidateScrollbars(parts, weakColumnsFrame);
NS_ENSURE_TRUE(weakFrame.IsAlive(), false);
--- a/layout/xul/tree/nsTreeBodyFrame.h
+++ b/layout/xul/tree/nsTreeBodyFrame.h
@@ -369,17 +369,17 @@ protected:
// scrollable frame (with associated content and scrollable view). These
// are all volatile and should not be retained.
ScrollParts GetScrollParts();
// Update the curpos of the scrollbar.
void UpdateScrollbars(const ScrollParts& aParts);
// Update the maxpos of the scrollbar.
- void InvalidateScrollbars(const ScrollParts& aParts, nsWeakFrame& aWeakColumnsFrame);
+ void InvalidateScrollbars(const ScrollParts& aParts, AutoWeakFrame& aWeakColumnsFrame);
// Check overflow and generate events.
void CheckOverflow(const ScrollParts& aParts);
// Calls UpdateScrollbars, Invalidate aNeedsFullInvalidation if true,
// InvalidateScrollbars and finally CheckOverflow.
// returns true if the frame is still alive after the method call.
bool FullScrollbarsUpdate(bool aNeedsFullInvalidation);
--- a/servo/components/style/gecko_bindings/structs_debug.rs
+++ b/servo/components/style/gecko_bindings/structs_debug.rs
@@ -14760,17 +14760,17 @@ pub mod root {
pub mFrameManager: *mut root::nsFrameManagerBase,
pub mForwardingContainer: u64,
pub mDocAccessible: *mut root::mozilla::a11y::DocAccessible,
pub mReflowContinueTimer: root::nsCOMPtr<root::nsITimer>,
pub mDrawEventTargetFrame: *mut root::nsIFrame,
pub mAllocatedPointers: [u64; 6usize],
pub mPaintCount: u64,
pub mScrollPositionClampingScrollPortSize: root::nsSize,
- pub mWeakFrames: *mut root::nsWeakFrame,
+ pub mWeakFrames: *mut root::AutoWeakFrame,
pub mCanvasBackgroundColor: root::nscolor,
pub mResolution: [u32; 2usize],
pub mSelectionFlags: i16,
pub mRenderFlags: root::nsIPresShell_RenderFlags,
pub _bitfield_1: u8,
pub _bitfield_2: u8,
pub mPresShellId: u32,
pub mChangedScopeStyleRoots: [u64; 3usize],
@@ -21050,17 +21050,17 @@ pub mod root {
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nsIReflowCallback([u8; 0]);
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nsCSSFrameConstructor([u8; 0]);
#[repr(C)]
#[derive(Debug, Copy, Clone)]
- pub struct nsWeakFrame([u8; 0]);
+ pub struct AutoWeakFrame([u8; 0]);
/**
* Interface for frames that are scrollable. This interface exposes
* APIs for examining scroll state, observing changes to scroll state,
* and triggering scrolling.
*/
#[repr(C)]
#[derive(Debug, Copy)]
pub struct nsIScrollableFrame {
--- a/servo/components/style/gecko_bindings/structs_release.rs
+++ b/servo/components/style/gecko_bindings/structs_release.rs
@@ -14204,17 +14204,17 @@ pub mod root {
pub mFrameArena: root::nsPresArena,
pub mSelection: root::RefPtr<root::nsFrameSelection>,
pub mFrameManager: *mut root::nsFrameManagerBase,
pub mForwardingContainer: u64,
pub mDocAccessible: *mut root::mozilla::a11y::DocAccessible,
pub mReflowContinueTimer: root::nsCOMPtr<root::nsITimer>,
pub mPaintCount: u64,
pub mScrollPositionClampingScrollPortSize: root::nsSize,
- pub mWeakFrames: *mut root::nsWeakFrame,
+ pub mWeakFrames: *mut root::AutoWeakFrame,
pub mCanvasBackgroundColor: root::nscolor,
pub mResolution: [u32; 2usize],
pub mSelectionFlags: i16,
pub mRenderFlags: root::nsIPresShell_RenderFlags,
pub _bitfield_1: u8,
pub _bitfield_2: u8,
pub mPresShellId: u32,
pub mChangedScopeStyleRoots: [u64; 3usize],
@@ -20408,17 +20408,17 @@ pub mod root {
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nsIReflowCallback([u8; 0]);
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nsCSSFrameConstructor([u8; 0]);
#[repr(C)]
#[derive(Debug, Copy, Clone)]
- pub struct nsWeakFrame([u8; 0]);
+ pub struct AutoWeakFrame([u8; 0]);
/**
* Interface for frames that are scrollable. This interface exposes
* APIs for examining scroll state, observing changes to scroll state,
* and triggering scrolling.
*/
#[repr(C)]
#[derive(Debug, Copy)]
pub struct nsIScrollableFrame {