The Tor Browser: layout/xul/nsListBoxBodyFrame.cpp@97036ab72558 (annotated)

layout/xul/nsListBoxBodyFrame.cpp@97036ab72558 (annotated)

layout/xul/nsListBoxBodyFrame.cpp

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "nsListBoxBodyFrame.h"
 #include "nsListBoxLayout.h"
 #include "nsCOMPtr.h"
 #include "nsGridRowGroupLayout.h"
 #include "nsIServiceManager.h"
 #include "nsGkAtoms.h"
 #include "nsIContent.h"
 #include "nsNameSpaceManager.h"
 #include "nsIDocument.h"
 #include "nsIDOMMouseEvent.h"
 #include "nsIDOMElement.h"
 #include "nsIDOMNodeList.h"
 #include "nsCSSFrameConstructor.h"
 #include "nsIScrollableFrame.h"
 #include "nsScrollbarFrame.h"
 #include "nsView.h"
 #include "nsViewManager.h"
 #include "nsStyleContext.h"
 #include "nsFontMetrics.h"
 #include "nsITimer.h"
 #include "nsAutoPtr.h"
 #include "nsStyleSet.h"
 #include "nsPIBoxObject.h"
 #include "nsINodeInfo.h"
 #include "nsLayoutUtils.h"
 #include "nsPIListBoxObject.h"
 #include "nsContentUtils.h"
 #include "ChildIterator.h"
 #include "nsRenderingContext.h"
 #include "prtime.h"
 #include <algorithm>
 #ifdef ACCESSIBILITY
 #include "nsAccessibilityService.h"
 #endif
 using namespace mozilla::dom;
 /////////////// nsListScrollSmoother //////////////////
 /* A mediator used to smooth out scrolling. It works by seeing if
  * we have time to scroll the amount of rows requested. This is determined
  * by measuring how long it takes to scroll a row. If we can scroll the
  * rows in time we do so. If not we start a timer and skip the request. We
  * do this until the timer finally first because the user has stopped moving
  * the mouse. Then do all the queued requests in on shot.
  */
 // the longest amount of time that can go by before the use
 // notices it as a delay.
 #define USER_TIME_THRESHOLD 150000
 // how long it takes to layout a single row initial value.
 // we will time this after we scroll a few rows.
 #define TIME_PER_ROW_INITAL  50000
 // if we decide we can't layout the rows in the amount of time. How long
 // do we wait before checking again?
 #define SMOOTH_INTERVAL 100
 class nsListScrollSmoother : public nsITimerCallback
 {
 public:
   NS_DECL_ISUPPORTS
   nsListScrollSmoother(nsListBoxBodyFrame* aOuter);
   virtual ~nsListScrollSmoother();
   // nsITimerCallback
   NS_DECL_NSITIMERCALLBACK
   void Start();
   void Stop();
   bool IsRunning();
   nsCOMPtr<nsITimer> mRepeatTimer;
   int32_t mDelta;
   nsListBoxBodyFrame* mOuter;
 };
 nsListScrollSmoother::nsListScrollSmoother(nsListBoxBodyFrame* aOuter)
 {
   mDelta = 0;
   mOuter = aOuter;
 }
 nsListScrollSmoother::~nsListScrollSmoother()
 {
   Stop();
 }
 NS_IMETHODIMP
 nsListScrollSmoother::Notify(nsITimer *timer)
 {
   Stop();
   NS_ASSERTION(mOuter, "mOuter is null, see bug #68365");
   if (!mOuter) return NS_OK;
   // actually do some work.
   mOuter->InternalPositionChangedCallback();
   return NS_OK;
 }
 bool
 nsListScrollSmoother::IsRunning()
 {
   return mRepeatTimer ? true : false;
 }
 void
 nsListScrollSmoother::Start()
 {
   Stop();
   mRepeatTimer = do_CreateInstance("@mozilla.org/timer;1");
   mRepeatTimer->InitWithCallback(this, SMOOTH_INTERVAL, nsITimer::TYPE_ONE_SHOT);
 }
 void
 nsListScrollSmoother::Stop()
 {
   if ( mRepeatTimer ) {
     mRepeatTimer->Cancel();
     mRepeatTimer = nullptr;
   }
 }
 NS_IMPL_ISUPPORTS(nsListScrollSmoother, nsITimerCallback)
 /////////////// nsListBoxBodyFrame //////////////////
 nsListBoxBodyFrame::nsListBoxBodyFrame(nsIPresShell* aPresShell,
                                        nsStyleContext* aContext,
                                        nsBoxLayout* aLayoutManager)
   : nsBoxFrame(aPresShell, aContext, false, aLayoutManager),
     mTopFrame(nullptr),
     mBottomFrame(nullptr),
     mLinkupFrame(nullptr),
     mScrollSmoother(nullptr),
     mRowsToPrepend(0),
     mRowCount(-1),
     mRowHeight(0),
     mAvailableHeight(0),
     mStringWidth(-1),
     mCurrentIndex(0),
     mOldIndex(0),
     mYPosition(0),
     mTimePerRow(TIME_PER_ROW_INITAL),
     mRowHeightWasSet(false),
     mScrolling(false),
     mAdjustScroll(false),
     mReflowCallbackPosted(false)
 {
 }
 nsListBoxBodyFrame::~nsListBoxBodyFrame()
 {
   NS_IF_RELEASE(mScrollSmoother);
 #if USE_TIMER_TO_DELAY_SCROLLING
   StopScrollTracking();
   mAutoScrollTimer = nullptr;
 #endif
 }
 NS_QUERYFRAME_HEAD(nsListBoxBodyFrame)
   NS_QUERYFRAME_ENTRY(nsIScrollbarMediator)
   NS_QUERYFRAME_ENTRY(nsListBoxBodyFrame)
 NS_QUERYFRAME_TAIL_INHERITING(nsBoxFrame)
 ////////// nsIFrame /////////////////
 void
 nsListBoxBodyFrame::Init(nsIContent*     aContent,
                          nsIFrame*       aParent,
                          nsIFrame*       aPrevInFlow)
 {
   nsBoxFrame::Init(aContent, aParent, aPrevInFlow);
   nsIScrollableFrame* scrollFrame = nsLayoutUtils::GetScrollableFrameFor(this);
   if (scrollFrame) {
     nsIFrame* verticalScrollbar = scrollFrame->GetScrollbarBox(true);
     nsScrollbarFrame* scrollbarFrame = do_QueryFrame(verticalScrollbar);
     if (scrollbarFrame) {
       scrollbarFrame->SetScrollbarMediatorContent(GetContent());
     }
   }
   nsRefPtr<nsFontMetrics> fm;
   nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fm));
   mRowHeight = fm->MaxHeight();
 }
 void
 nsListBoxBodyFrame::DestroyFrom(nsIFrame* aDestructRoot)
 {
   // make sure we cancel any posted callbacks.
   if (mReflowCallbackPosted)
      PresContext()->PresShell()->CancelReflowCallback(this);
   // Revoke any pending position changed events
   for (uint32_t i = 0; i < mPendingPositionChangeEvents.Length(); ++i) {
     mPendingPositionChangeEvents[i]->Revoke();
   }
   // Make sure we tell our listbox's box object we're being destroyed.
   if (mBoxObject) {
     mBoxObject->ClearCachedValues();
   }
   nsBoxFrame::DestroyFrom(aDestructRoot);
 }
 nsresult
 nsListBoxBodyFrame::AttributeChanged(int32_t aNameSpaceID,
                                      nsIAtom* aAttribute,
                                      int32_t aModType)
 {
   nsresult rv = NS_OK;
   if (aAttribute == nsGkAtoms::rows) {
     PresContext()->PresShell()->
       FrameNeedsReflow(this, nsIPresShell::eStyleChange, NS_FRAME_IS_DIRTY);
   }
   else
     rv = nsBoxFrame::AttributeChanged(aNameSpaceID, aAttribute, aModType);
   return rv;
 }
 /* virtual */ void
 nsListBoxBodyFrame::MarkIntrinsicWidthsDirty()
 {
   mStringWidth = -1;
   nsBoxFrame::MarkIntrinsicWidthsDirty();
 }
 /////////// nsBox ///////////////
 NS_IMETHODIMP
 nsListBoxBodyFrame::DoLayout(nsBoxLayoutState& aBoxLayoutState)
 {
   if (mScrolling)
     aBoxLayoutState.SetPaintingDisabled(true);
   nsresult rv = nsBoxFrame::DoLayout(aBoxLayoutState);
   // determine the real height for the scrollable area from the total number
   // of rows, since non-visible rows don't yet have frames
   nsRect rect(nsPoint(0, 0), GetSize());
   nsOverflowAreas overflow(rect, rect);
   if (mLayoutManager) {
     nsIFrame* childFrame = mFrames.FirstChild();
     while (childFrame) {
       ConsiderChildOverflow(overflow, childFrame);
       childFrame = childFrame->GetNextSibling();
     }
     nsSize prefSize = mLayoutManager->GetPrefSize(this, aBoxLayoutState);
     NS_FOR_FRAME_OVERFLOW_TYPES(otype) {
       nsRect& o = overflow.Overflow(otype);
       o.height = std::max(o.height, prefSize.height);
     }
   }
   FinishAndStoreOverflow(overflow, GetSize());
   if (mScrolling)
     aBoxLayoutState.SetPaintingDisabled(false);
   // if we are scrolled and the row height changed
   // make sure we are scrolled to a correct index.
   if (mAdjustScroll)
      PostReflowCallback();
   return rv;
 }
 nsSize
 nsListBoxBodyFrame::GetMinSizeForScrollArea(nsBoxLayoutState& aBoxLayoutState)
 {
   nsSize result(0, 0);
   if (nsContentUtils::HasNonEmptyAttr(GetContent(), kNameSpaceID_None,
                                       nsGkAtoms::sizemode)) {
     result = GetPrefSize(aBoxLayoutState);
     result.height = 0;
     nsIScrollableFrame* scrollFrame = nsLayoutUtils::GetScrollableFrameFor(this);
     if (scrollFrame &&
         scrollFrame->GetScrollbarStyles().mVertical == NS_STYLE_OVERFLOW_AUTO) {
       nsMargin scrollbars =
         scrollFrame->GetDesiredScrollbarSizes(&aBoxLayoutState);
       result.width += scrollbars.left + scrollbars.right;
     }
   }
   return result;
 }
 nsSize
 nsListBoxBodyFrame::GetPrefSize(nsBoxLayoutState& aBoxLayoutState)
 {
   nsSize pref = nsBoxFrame::GetPrefSize(aBoxLayoutState);
   int32_t size = GetFixedRowSize();
   if (size > -1)
     pref.height = size*GetRowHeightAppUnits();
   nsIScrollableFrame* scrollFrame = nsLayoutUtils::GetScrollableFrameFor(this);
   if (scrollFrame &&
       scrollFrame->GetScrollbarStyles().mVertical == NS_STYLE_OVERFLOW_AUTO) {
     nsMargin scrollbars = scrollFrame->GetDesiredScrollbarSizes(&aBoxLayoutState);
     pref.width += scrollbars.left + scrollbars.right;
   }
   return pref;
 }
 ///////////// nsIScrollbarMediator ///////////////
 NS_IMETHODIMP
 nsListBoxBodyFrame::PositionChanged(nsScrollbarFrame* aScrollbar, int32_t aOldIndex, int32_t& aNewIndex)
 {
   if (mScrolling || mRowHeight == 0)
     return NS_OK;
   nscoord oldTwipIndex, newTwipIndex;
   oldTwipIndex = mCurrentIndex*mRowHeight;
   newTwipIndex = nsPresContext::CSSPixelsToAppUnits(aNewIndex);
   int32_t twipDelta = newTwipIndex > oldTwipIndex ? newTwipIndex - oldTwipIndex : oldTwipIndex - newTwipIndex;
   int32_t rowDelta = twipDelta / mRowHeight;
   int32_t remainder = twipDelta % mRowHeight;
   if (remainder > (mRowHeight/2))
     rowDelta++;
   if (rowDelta == 0)
     return NS_OK;
   // update the position to be row based.
   int32_t newIndex = newTwipIndex > oldTwipIndex ? mCurrentIndex + rowDelta : mCurrentIndex - rowDelta;
   //aNewIndex = newIndex*mRowHeight/mOnePixel;
   nsListScrollSmoother* smoother = GetSmoother();
   // if we can't scroll the rows in time then start a timer. We will eat
   // events until the user stops moving and the timer stops.
   if (smoother->IsRunning() || rowDelta*mTimePerRow > USER_TIME_THRESHOLD) {
      smoother->Stop();
      smoother->mDelta = newTwipIndex > oldTwipIndex ? rowDelta : -rowDelta;
      smoother->Start();
      return NS_OK;
   }
   smoother->Stop();
   mCurrentIndex = newIndex;
   smoother->mDelta = 0;
   if (mCurrentIndex < 0) {
     mCurrentIndex = 0;
     return NS_OK;
   }
   return InternalPositionChanged(newTwipIndex < oldTwipIndex, rowDelta);
 }
 NS_IMETHODIMP
 nsListBoxBodyFrame::VisibilityChanged(bool aVisible)
 {
   if (mRowHeight == 0)
     return NS_OK;
   int32_t lastPageTopRow = GetRowCount() - (GetAvailableHeight() / mRowHeight);
   if (lastPageTopRow < 0)
     lastPageTopRow = 0;
   int32_t delta = mCurrentIndex - lastPageTopRow;
   if (delta > 0) {
     mCurrentIndex = lastPageTopRow;
     InternalPositionChanged(true, delta);
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsListBoxBodyFrame::ScrollbarButtonPressed(nsScrollbarFrame* aScrollbar, int32_t aOldIndex, int32_t aNewIndex)
 {
   if (aOldIndex == aNewIndex)
     return NS_OK;
   if (aNewIndex < aOldIndex)
     mCurrentIndex--;
   else mCurrentIndex++;
   if (mCurrentIndex < 0) {
     mCurrentIndex = 0;
     return NS_OK;
   }
   InternalPositionChanged(aNewIndex < aOldIndex, 1);
   return NS_OK;
 }
 ///////////// nsIReflowCallback ///////////////
 bool
 nsListBoxBodyFrame::ReflowFinished()
 {
   nsAutoScriptBlocker scriptBlocker;
   // now create or destroy any rows as needed
   CreateRows();
   // keep scrollbar in sync
   if (mAdjustScroll) {
      VerticalScroll(mYPosition);
      mAdjustScroll = false;
   }
   // if the row height changed then mark everything as a style change.
   // That will dirty the entire listbox
   if (mRowHeightWasSet) {
     PresContext()->PresShell()->
       FrameNeedsReflow(this, nsIPresShell::eStyleChange, NS_FRAME_IS_DIRTY);
      int32_t pos = mCurrentIndex * mRowHeight;
      if (mYPosition != pos)
        mAdjustScroll = true;
     mRowHeightWasSet = false;
   }
   mReflowCallbackPosted = false;
   return true;
 }
 void
 nsListBoxBodyFrame::ReflowCallbackCanceled()
 {
   mReflowCallbackPosted = false;
 }
 ///////// nsIListBoxObject ///////////////
 nsresult
 nsListBoxBodyFrame::GetRowCount(int32_t* aResult)
 {
   *aResult = GetRowCount();
   return NS_OK;
 }
 nsresult
 nsListBoxBodyFrame::GetNumberOfVisibleRows(int32_t *aResult)
 {
   *aResult= mRowHeight ? GetAvailableHeight() / mRowHeight : 0;
   return NS_OK;
 }
 nsresult
 nsListBoxBodyFrame::GetIndexOfFirstVisibleRow(int32_t *aResult)
 {
   *aResult = mCurrentIndex;
   return NS_OK;
 }
 nsresult
 nsListBoxBodyFrame::EnsureIndexIsVisible(int32_t aRowIndex)
 {
   if (aRowIndex < 0)
     return NS_ERROR_ILLEGAL_VALUE;
   int32_t rows = 0;
   if (mRowHeight)
     rows = GetAvailableHeight()/mRowHeight;
   if (rows <= 0)
     rows = 1;
   int32_t bottomIndex = mCurrentIndex + rows;
   // if row is visible, ignore
   if (mCurrentIndex <= aRowIndex && aRowIndex < bottomIndex)
     return NS_OK;
   int32_t delta;
   bool up = aRowIndex < mCurrentIndex;
   if (up) {
     delta = mCurrentIndex - aRowIndex;
     mCurrentIndex = aRowIndex;
   }
   else {
     // Check to be sure we're not scrolling off the bottom of the tree
     if (aRowIndex >= GetRowCount())
       return NS_ERROR_ILLEGAL_VALUE;
     // Bring it just into view.
     delta = 1 + (aRowIndex-bottomIndex);
     mCurrentIndex += delta;
   }
   // Safe to not go off an event here, since this is coming from the
   // box object.
   DoInternalPositionChangedSync(up, delta);
   return NS_OK;
 }
 nsresult
 nsListBoxBodyFrame::ScrollByLines(int32_t aNumLines)
 {
   int32_t scrollIndex, visibleRows;
   GetIndexOfFirstVisibleRow(&scrollIndex);
   GetNumberOfVisibleRows(&visibleRows);
   scrollIndex += aNumLines;
   if (scrollIndex < 0)
     scrollIndex = 0;
   else {
     int32_t numRows = GetRowCount();
     int32_t lastPageTopRow = numRows - visibleRows;
     if (scrollIndex > lastPageTopRow)
       scrollIndex = lastPageTopRow;
   }
   ScrollToIndex(scrollIndex);
   return NS_OK;
 }
 // walks the DOM to get the zero-based row index of the content
 nsresult
 nsListBoxBodyFrame::GetIndexOfItem(nsIDOMElement* aItem, int32_t* _retval)
 {
   if (aItem) {
     *_retval = 0;
     nsCOMPtr<nsIContent> itemContent(do_QueryInterface(aItem));
     FlattenedChildIterator iter(mContent);
     for (nsIContent* child = iter.GetNextChild(); child; child = iter.GetNextChild()) {
       // we hit a list row, count it
       if (child->Tag() == nsGkAtoms::listitem) {
         // is this it?
         if (child == itemContent)
           return NS_OK;
         ++(*_retval);
       }
     }
   }
   // not found
   *_retval = -1;
   return NS_OK;
 }
 nsresult
 nsListBoxBodyFrame::GetItemAtIndex(int32_t aIndex, nsIDOMElement** aItem)
 {
   *aItem = nullptr;
   if (aIndex < 0)
     return NS_OK;
   int32_t itemCount = 0;
   FlattenedChildIterator iter(mContent);
   for (nsIContent* child = iter.GetNextChild(); child; child = iter.GetNextChild()) {
     // we hit a list row, check if it is the one we are looking for
     if (child->Tag() == nsGkAtoms::listitem) {
       // is this it?
       if (itemCount == aIndex) {
         return CallQueryInterface(child, aItem);
       }
       ++itemCount;
     }
   }
   // not found
   return NS_OK;
 }
 /////////// nsListBoxBodyFrame ///////////////
 int32_t
 nsListBoxBodyFrame::GetRowCount()
 {
   if (mRowCount < 0)
     ComputeTotalRowCount();
   return mRowCount;
 }
 int32_t
 nsListBoxBodyFrame::GetFixedRowSize()
 {
   nsresult dummy;
   nsAutoString rows;
   mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::rows, rows);
   if (!rows.IsEmpty())
     return rows.ToInteger(&dummy);
   mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::size, rows);
   if (!rows.IsEmpty())
     return rows.ToInteger(&dummy);
   return -1;
 }
 void
 nsListBoxBodyFrame::SetRowHeight(nscoord aRowHeight)
 {
   if (aRowHeight > mRowHeight) {
     mRowHeight = aRowHeight;
     // signal we need to dirty everything
     // and we want to be notified after reflow
     // so we can create or destory rows as needed
     mRowHeightWasSet = true;
     PostReflowCallback();
   }
 }
 nscoord
 nsListBoxBodyFrame::GetAvailableHeight()
 {
   nsIScrollableFrame* scrollFrame =
     nsLayoutUtils::GetScrollableFrameFor(this);
   if (scrollFrame) {
     return scrollFrame->GetScrollPortRect().height;
   }
   return 0;
 }
 nscoord
 nsListBoxBodyFrame::GetYPosition()
 {
   return mYPosition;
 }
 nscoord
 nsListBoxBodyFrame::ComputeIntrinsicWidth(nsBoxLayoutState& aBoxLayoutState)
 {
   if (mStringWidth != -1)
     return mStringWidth;
   nscoord largestWidth = 0;
   int32_t index = 0;
   nsCOMPtr<nsIDOMElement> firstRowEl;
   GetItemAtIndex(index, getter_AddRefs(firstRowEl));
   nsCOMPtr<nsIContent> firstRowContent(do_QueryInterface(firstRowEl));
   if (firstRowContent) {
     nsRefPtr<nsStyleContext> styleContext;
     nsPresContext *presContext = aBoxLayoutState.PresContext();
     styleContext = presContext->StyleSet()->
       ResolveStyleFor(firstRowContent->AsElement(), nullptr);
     nscoord width = 0;
     nsMargin margin(0,0,0,0);
     if (styleContext->StylePadding()->GetPadding(margin))
       width += margin.LeftRight();
     width += styleContext->StyleBorder()->GetComputedBorder().LeftRight();
     if (styleContext->StyleMargin()->GetMargin(margin))
       width += margin.LeftRight();
     FlattenedChildIterator iter(mContent);
     for (nsIContent* child = iter.GetNextChild(); child; child = iter.GetNextChild()) {
       if (child->Tag() == nsGkAtoms::listitem) {
         nsRenderingContext* rendContext = aBoxLayoutState.GetRenderingContext();
         if (rendContext) {
           nsAutoString value;
           uint32_t textCount = child->GetChildCount();
           for (uint32_t j = 0; j < textCount; ++j) {
             nsIContent* text = child->GetChildAt(j);
             if (text && text->IsNodeOfType(nsINode::eTEXT)) {
               text->AppendTextTo(value);
             }
           }
           nsRefPtr<nsFontMetrics> fm;
           nsLayoutUtils::GetFontMetricsForStyleContext(styleContext,
                                                        getter_AddRefs(fm));
           rendContext->SetFont(fm);
           nscoord textWidth =
             nsLayoutUtils::GetStringWidth(this, rendContext, value.get(), value.Length());
           textWidth += width;
           if (textWidth > largestWidth)
             largestWidth = textWidth;
         }
       }
     }
   }
   mStringWidth = largestWidth;
   return mStringWidth;
 }
 void
 nsListBoxBodyFrame::ComputeTotalRowCount()
 {
   mRowCount = 0;
   FlattenedChildIterator iter(mContent);
   for (nsIContent* child = iter.GetNextChild(); child; child = iter.GetNextChild()) {
     if (child->Tag() == nsGkAtoms::listitem) {
       ++mRowCount;
     }
   }
 }
 void
 nsListBoxBodyFrame::PostReflowCallback()
 {
   if (!mReflowCallbackPosted) {
     mReflowCallbackPosted = true;
     PresContext()->PresShell()->PostReflowCallback(this);
   }
 }
 ////////// scrolling
 nsresult
 nsListBoxBodyFrame::ScrollToIndex(int32_t aRowIndex)
 {
   if (( aRowIndex < 0 ) || (mRowHeight == 0))
     return NS_OK;
   int32_t newIndex = aRowIndex;
   int32_t delta = mCurrentIndex > newIndex ? mCurrentIndex - newIndex : newIndex - mCurrentIndex;
   bool up = newIndex < mCurrentIndex;
   // Check to be sure we're not scrolling off the bottom of the tree
   int32_t lastPageTopRow = GetRowCount() - (GetAvailableHeight() / mRowHeight);
   if (lastPageTopRow < 0)
     lastPageTopRow = 0;
   if (aRowIndex > lastPageTopRow)
     return NS_OK;
   mCurrentIndex = newIndex;
   nsWeakFrame 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;
   }
   // This change has to happen immediately.
   // Flush any pending reflow commands.
   // XXXbz why, exactly?
   mContent->GetDocument()->FlushPendingNotifications(Flush_Layout);
   return NS_OK;
 }
 nsresult
 nsListBoxBodyFrame::InternalPositionChangedCallback()
 {
   nsListScrollSmoother* smoother = GetSmoother();
   if (smoother->mDelta == 0)
     return NS_OK;
   mCurrentIndex += smoother->mDelta;
   if (mCurrentIndex < 0)
     mCurrentIndex = 0;
   return DoInternalPositionChangedSync(smoother->mDelta < 0,
                                        smoother->mDelta < 0 ?
                                          -smoother->mDelta : smoother->mDelta);
 }
 nsresult
 nsListBoxBodyFrame::InternalPositionChanged(bool aUp, int32_t aDelta)
 {
   nsRefPtr<nsPositionChangedEvent> ev =
     new nsPositionChangedEvent(this, aUp, aDelta);
   nsresult rv = NS_DispatchToCurrentThread(ev);
   if (NS_SUCCEEDED(rv)) {
     if (!mPendingPositionChangeEvents.AppendElement(ev)) {
       rv = NS_ERROR_OUT_OF_MEMORY;
       ev->Revoke();
     }
   }
   return rv;
 }
 nsresult
 nsListBoxBodyFrame::DoInternalPositionChangedSync(bool aUp, int32_t aDelta)
 {
   nsWeakFrame weak(this);
   // Process all the pending position changes first
   nsTArray< nsRefPtr<nsPositionChangedEvent> > temp;
   temp.SwapElements(mPendingPositionChangeEvents);
   for (uint32_t i = 0; i < temp.Length(); ++i) {
     if (weak.IsAlive()) {
       temp[i]->Run();
     }
     temp[i]->Revoke();
   }
   if (!weak.IsAlive()) {
     return NS_OK;
   }
   return DoInternalPositionChanged(aUp, aDelta);
 }
 nsresult
 nsListBoxBodyFrame::DoInternalPositionChanged(bool aUp, int32_t aDelta)
 {
   if (aDelta == 0)
     return NS_OK;
   nsRefPtr<nsPresContext> presContext(PresContext());
   nsBoxLayoutState state(presContext);
   // begin timing how long it takes to scroll a row
   PRTime start = PR_Now();
   nsWeakFrame weakThis(this);
   mContent->GetDocument()->FlushPendingNotifications(Flush_Layout);
   if (!weakThis.IsAlive()) {
     return NS_OK;
   }
   {
     nsAutoScriptBlocker scriptBlocker;
     int32_t visibleRows = 0;
     if (mRowHeight)
       visibleRows = GetAvailableHeight()/mRowHeight;
     if (aDelta < visibleRows) {
       int32_t loseRows = aDelta;
       if (aUp) {
         // scrolling up, destroy rows from the bottom downwards
         ReverseDestroyRows(loseRows);
         mRowsToPrepend += aDelta;
         mLinkupFrame = nullptr;
       }
       else {
         // scrolling down, destroy rows from the top upwards
         DestroyRows(loseRows);
         mRowsToPrepend = 0;
       }
     }
     else {
       // We have scrolled so much that all of our current frames will
       // go off screen, so blow them all away. Weeee!
       nsIFrame *currBox = mFrames.FirstChild();
       nsCSSFrameConstructor* fc = presContext->PresShell()->FrameConstructor();
       fc->BeginUpdate();
       while (currBox) {
         nsIFrame *nextBox = currBox->GetNextSibling();
         RemoveChildFrame(state, currBox);
         currBox = nextBox;
       }
       fc->EndUpdate();
     }
     // clear frame markers so that CreateRows will re-create
     mTopFrame = mBottomFrame = nullptr;
     mYPosition = mCurrentIndex*mRowHeight;
     mScrolling = true;
     presContext->PresShell()->
       FrameNeedsReflow(this, nsIPresShell::eResize, NS_FRAME_HAS_DIRTY_CHILDREN);
   }
   if (!weakThis.IsAlive()) {
     return NS_OK;
   }
   // Flush calls CreateRows
   // XXXbz there has to be a better way to do this than flushing!
   presContext->PresShell()->FlushPendingNotifications(Flush_Layout);
   if (!weakThis.IsAlive()) {
     return NS_OK;
   }
   mScrolling = false;
   VerticalScroll(mYPosition);
   PRTime end = PR_Now();
   int32_t newTime = int32_t(end - start) / aDelta;
   // average old and new
   mTimePerRow = (newTime + mTimePerRow)/2;
   return NS_OK;
 }
 nsListScrollSmoother*
 nsListBoxBodyFrame::GetSmoother()
 {
   if (!mScrollSmoother) {
     mScrollSmoother = new nsListScrollSmoother(this);
     NS_ASSERTION(mScrollSmoother, "out of memory");
     NS_IF_ADDREF(mScrollSmoother);
   }
   return mScrollSmoother;
 }
 void
 nsListBoxBodyFrame::VerticalScroll(int32_t aPosition)
 {
   nsIScrollableFrame* scrollFrame
     = nsLayoutUtils::GetScrollableFrameFor(this);
   if (!scrollFrame) {
     return;
   }
   nsPoint scrollPosition = scrollFrame->GetScrollPosition();
   nsWeakFrame weakFrame(this);
   scrollFrame->ScrollTo(nsPoint(scrollPosition.x, aPosition),
                         nsIScrollableFrame::INSTANT);
   if (!weakFrame.IsAlive()) {
     return;
   }
   mYPosition = aPosition;
 }
 ////////// frame and box retrieval
 nsIFrame*
 nsListBoxBodyFrame::GetFirstFrame()
 {
   mTopFrame = mFrames.FirstChild();
   return mTopFrame;
 }
 nsIFrame*
 nsListBoxBodyFrame::GetLastFrame()
 {
   return mFrames.LastChild();
 }
 bool
 nsListBoxBodyFrame::SupportsOrdinalsInChildren()
 {
   return false;
 }
 ////////// lazy row creation and destruction
 void
 nsListBoxBodyFrame::CreateRows()
 {
   // Get our client rect.
   nsRect clientRect;
   GetClientRect(clientRect);
   // Get the starting y position and the remaining available
   // height.
   nscoord availableHeight = GetAvailableHeight();
   if (availableHeight <= 0) {
     bool fixed = (GetFixedRowSize() != -1);
     if (fixed)
       availableHeight = 10;
     else
       return;
   }
   // get the first tree box. If there isn't one create one.
   bool created = false;
   nsIFrame* box = GetFirstItemBox(0, &created);
   nscoord rowHeight = GetRowHeightAppUnits();
   while (box) {
     if (created && mRowsToPrepend > 0)
       --mRowsToPrepend;
     // if the row height is 0 then fail. Wait until someone
     // laid out and sets the row height.
     if (rowHeight == 0)
         return;
     availableHeight -= rowHeight;
     // should we continue? Is the enought height?
     if (!ContinueReflow(availableHeight))
       break;
     // get the next tree box. Create one if needed.
     box = GetNextItemBox(box, 0, &created);
   }
   mRowsToPrepend = 0;
   mLinkupFrame = nullptr;
 }
 void
 nsListBoxBodyFrame::DestroyRows(int32_t& aRowsToLose)
 {
   // We need to destroy frames until our row count has been properly
   // reduced.  A reflow will then pick up and create the new frames.
   nsIFrame* childFrame = GetFirstFrame();
   nsBoxLayoutState state(PresContext());
   nsCSSFrameConstructor* fc = PresContext()->PresShell()->FrameConstructor();
   fc->BeginUpdate();
   while (childFrame && aRowsToLose > 0) {
     --aRowsToLose;
     nsIFrame* nextFrame = childFrame->GetNextSibling();
     RemoveChildFrame(state, childFrame);
     mTopFrame = childFrame = nextFrame;
   }
   fc->EndUpdate();
   PresContext()->PresShell()->
     FrameNeedsReflow(this, nsIPresShell::eTreeChange,
                      NS_FRAME_HAS_DIRTY_CHILDREN);
 }
 void
 nsListBoxBodyFrame::ReverseDestroyRows(int32_t& aRowsToLose)
 {
   // We need to destroy frames until our row count has been properly
   // reduced.  A reflow will then pick up and create the new frames.
   nsIFrame* childFrame = GetLastFrame();
   nsBoxLayoutState state(PresContext());
   nsCSSFrameConstructor* fc = PresContext()->PresShell()->FrameConstructor();
   fc->BeginUpdate();
   while (childFrame && aRowsToLose > 0) {
     --aRowsToLose;
     nsIFrame* prevFrame;
     prevFrame = childFrame->GetPrevSibling();
     RemoveChildFrame(state, childFrame);
     mBottomFrame = childFrame = prevFrame;
   }
   fc->EndUpdate();
   PresContext()->PresShell()->
     FrameNeedsReflow(this, nsIPresShell::eTreeChange,
                      NS_FRAME_HAS_DIRTY_CHILDREN);
 }
 static bool
 IsListItemChild(nsListBoxBodyFrame* aParent, nsIContent* aChild,
                 nsIFrame** aChildFrame)
 {
   *aChildFrame = nullptr;
   if (!aChild->IsXUL() || aChild->Tag() != nsGkAtoms::listitem) {
     return false;
   }
   nsIFrame* existingFrame = aChild->GetPrimaryFrame();
   if (existingFrame && existingFrame->GetParent() != aParent) {
     return false;
   }
   *aChildFrame = existingFrame;
   return true;
 }
 //
 // Get the nsIFrame for the first visible listitem, and if none exists,
 // create one.
 //
 nsIFrame*
 nsListBoxBodyFrame::GetFirstItemBox(int32_t aOffset, bool* aCreated)
 {
   if (aCreated)
    *aCreated = false;
   // Clear ourselves out.
   mBottomFrame = mTopFrame;
   if (mTopFrame) {
     return mTopFrame->IsBoxFrame() ? mTopFrame : nullptr;
   }
   // top frame was cleared out
   mTopFrame = GetFirstFrame();
   mBottomFrame = mTopFrame;
   if (mTopFrame && mRowsToPrepend <= 0) {
     return mTopFrame->IsBoxFrame() ? mTopFrame : nullptr;
   }
   // At this point, we either have no frames at all,
   // or the user has scrolled upwards, leaving frames
   // to be created at the top.  Let's determine which
   // content needs a new frame first.
   nsCOMPtr<nsIContent> startContent;
   if (mTopFrame && mRowsToPrepend > 0) {
     // We need to insert rows before the top frame
     nsIContent* topContent = mTopFrame->GetContent();
     nsIContent* topParent = topContent->GetParent();
     int32_t contentIndex = topParent->IndexOf(topContent);
     contentIndex -= aOffset;
     if (contentIndex < 0)
       return nullptr;
     startContent = topParent->GetChildAt(contentIndex - mRowsToPrepend);
   } else {
     // This will be the first item frame we create.  Use the content
     // at the current index, which is the first index scrolled into view
     GetListItemContentAt(mCurrentIndex+aOffset, getter_AddRefs(startContent));
   }
   if (startContent) {
     nsIFrame* existingFrame;
     if (!IsListItemChild(this, startContent, &existingFrame)) {
       return GetFirstItemBox(++aOffset, aCreated);
     }
     if (existingFrame) {
       return existingFrame->IsBoxFrame() ? existingFrame : nullptr;
     }
     // Either append the new frame, or prepend it (at index 0)
     // XXX check here if frame was even created, it may not have been if
     //     display: none was on listitem content
     bool isAppend = mRowsToPrepend <= 0;
     nsPresContext* presContext = PresContext();
     nsCSSFrameConstructor* fc = presContext->PresShell()->FrameConstructor();
     nsIFrame* topFrame = nullptr;
     fc->CreateListBoxContent(presContext, this, nullptr, startContent,
                              &topFrame, isAppend, false, nullptr);
     mTopFrame = topFrame;
     if (mTopFrame) {
       if (aCreated)
         *aCreated = true;
       mBottomFrame = mTopFrame;
       return mTopFrame->IsBoxFrame() ? mTopFrame : nullptr;
     } else
       return GetFirstItemBox(++aOffset, 0);
   }
   return nullptr;
 }
 //
 // Get the nsIFrame for the next visible listitem after aBox, and if none
 // exists, create one.
 //
 nsIFrame*
 nsListBoxBodyFrame::GetNextItemBox(nsIFrame* aBox, int32_t aOffset,
                                    bool* aCreated)
 {
   if (aCreated)
     *aCreated = false;
   nsIFrame* result = aBox->GetNextSibling();
   if (!result || result == mLinkupFrame || mRowsToPrepend > 0) {
     // No result found. See if there's a content node that wants a frame.
     nsIContent* prevContent = aBox->GetContent();
     nsIContent* parentContent = prevContent->GetParent();
     int32_t i = parentContent->IndexOf(prevContent);
     uint32_t childCount = parentContent->GetChildCount();
     if (((uint32_t)i + aOffset + 1) < childCount) {
       // There is a content node that wants a frame.
       nsIContent *nextContent = parentContent->GetChildAt(i + aOffset + 1);
       nsIFrame* existingFrame;
       if (!IsListItemChild(this, nextContent, &existingFrame)) {
         return GetNextItemBox(aBox, ++aOffset, aCreated);
       }
       if (!existingFrame) {
         // Either append the new frame, or insert it after the current frame
         bool isAppend = result != mLinkupFrame && mRowsToPrepend <= 0;
         nsIFrame* prevFrame = isAppend ? nullptr : aBox;
         nsPresContext* presContext = PresContext();
         nsCSSFrameConstructor* fc = presContext->PresShell()->FrameConstructor();
         fc->CreateListBoxContent(presContext, this, prevFrame, nextContent,
                                  &result, isAppend, false, nullptr);
         if (result) {
           if (aCreated)
             *aCreated = true;
         } else
           return GetNextItemBox(aBox, ++aOffset, aCreated);
       } else {
         result = existingFrame;
       }
       mLinkupFrame = nullptr;
     }
   }
   if (!result)
     return nullptr;
   mBottomFrame = result;
   NS_ASSERTION(!result->IsBoxFrame() || result->GetParent() == this,
                "returning frame that is not in childlist");
   return result->IsBoxFrame() ? result : nullptr;
 }
 bool
 nsListBoxBodyFrame::ContinueReflow(nscoord height)
 {
 #ifdef ACCESSIBILITY
   if (nsIPresShell::IsAccessibilityActive()) {
     // Create all the frames at once so screen readers and
     // onscreen keyboards can see the full list right away
     return true;
   }
 #endif
   if (height <= 0) {
     nsIFrame* lastChild = GetLastFrame();
     nsIFrame* startingPoint = mBottomFrame;
     if (startingPoint == nullptr) {
       // We just want to delete everything but the first item.
       startingPoint = GetFirstFrame();
     }
     if (lastChild != startingPoint) {
       // We have some hangers on (probably caused by shrinking the size of the window).
       // Nuke them.
       nsIFrame* currFrame = startingPoint->GetNextSibling();
       nsBoxLayoutState state(PresContext());
       nsCSSFrameConstructor* fc =
         PresContext()->PresShell()->FrameConstructor();
       fc->BeginUpdate();
       while (currFrame) {
         nsIFrame* nextFrame = currFrame->GetNextSibling();
         RemoveChildFrame(state, currFrame);
         currFrame = nextFrame;
       }
       fc->EndUpdate();
       PresContext()->PresShell()->
         FrameNeedsReflow(this, nsIPresShell::eTreeChange,
                          NS_FRAME_HAS_DIRTY_CHILDREN);
     }
     return false;
   }
   else
     return true;
 }
 NS_IMETHODIMP
 nsListBoxBodyFrame::ListBoxAppendFrames(nsFrameList& aFrameList)
 {
   // append them after
   nsBoxLayoutState state(PresContext());
   const nsFrameList::Slice& newFrames = mFrames.AppendFrames(nullptr, aFrameList);
   if (mLayoutManager)
     mLayoutManager->ChildrenAppended(this, state, newFrames);
   PresContext()->PresShell()->
     FrameNeedsReflow(this, nsIPresShell::eTreeChange,
                      NS_FRAME_HAS_DIRTY_CHILDREN);
   return NS_OK;
 }
 NS_IMETHODIMP
 nsListBoxBodyFrame::ListBoxInsertFrames(nsIFrame* aPrevFrame,
                                         nsFrameList& aFrameList)
 {
   // insert the frames to our info list
   nsBoxLayoutState state(PresContext());
   const nsFrameList::Slice& newFrames =
     mFrames.InsertFrames(nullptr, aPrevFrame, aFrameList);
   if (mLayoutManager)
     mLayoutManager->ChildrenInserted(this, state, aPrevFrame, newFrames);
   PresContext()->PresShell()->
     FrameNeedsReflow(this, nsIPresShell::eTreeChange,
                      NS_FRAME_HAS_DIRTY_CHILDREN);
   return NS_OK;
 }
 //
 // Called by nsCSSFrameConstructor when a new listitem content is inserted.
 //
 void
 nsListBoxBodyFrame::OnContentInserted(nsPresContext* aPresContext, nsIContent* aChildContent)
 {
   if (mRowCount >= 0)
     ++mRowCount;
   // The RDF content builder will build content nodes such that they are all
   // ready when OnContentInserted is first called, meaning the first call
   // to CreateRows will create all the frames, but OnContentInserted will
   // still be called again for each content node - so we need to make sure
   // that the frame for each content node hasn't already been created.
   nsIFrame* childFrame = aChildContent->GetPrimaryFrame();
   if (childFrame)
     return;
   int32_t siblingIndex;
   nsCOMPtr<nsIContent> nextSiblingContent;
   GetListItemNextSibling(aChildContent, getter_AddRefs(nextSiblingContent), siblingIndex);
   // if we're inserting our item before the first visible content,
   // then we need to shift all rows down by one
   if (siblingIndex >= 0 &&  siblingIndex-1 <= mCurrentIndex) {
     mTopFrame = nullptr;
     mRowsToPrepend = 1;
   } else if (nextSiblingContent) {
     // we may be inserting before a frame that is on screen
     nsIFrame* nextSiblingFrame = nextSiblingContent->GetPrimaryFrame();
     mLinkupFrame = nextSiblingFrame;
   }
   CreateRows();
   PresContext()->PresShell()->
     FrameNeedsReflow(this, nsIPresShell::eTreeChange,
                      NS_FRAME_HAS_DIRTY_CHILDREN);
 }
 //
 // Called by nsCSSFrameConstructor when listitem content is removed.
 //
 void
 nsListBoxBodyFrame::OnContentRemoved(nsPresContext* aPresContext,
                                      nsIContent* aContainer,
                                      nsIFrame* aChildFrame,
                                      nsIContent* aOldNextSibling)
 {
   NS_ASSERTION(!aChildFrame || aChildFrame->GetParent() == this,
                "Removing frame that's not our child... Not good");
   if (mRowCount >= 0)
     --mRowCount;
   if (aContainer) {
     if (!aChildFrame) {
       // The row we are removing is out of view, so we need to try to
       // determine the index of its next sibling.
       int32_t siblingIndex = -1;
       if (aOldNextSibling) {
         nsCOMPtr<nsIContent> nextSiblingContent;
         GetListItemNextSibling(aOldNextSibling,
                                getter_AddRefs(nextSiblingContent),
                                siblingIndex);
       }
       // 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);
         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
       // of the scrollbar is to stay locked to the bottom.  Since we are
       // removing visible content, the first visible row will have to move
       // down by one, and we will have to insert a new frame at the top.
       // if the last content node has a frame, we are scrolled to the bottom
       nsIContent* lastChild = nullptr;
       FlattenedChildIterator iter(mContent);
       for (nsIContent* child = iter.GetNextChild(); child; child = iter.GetNextChild()) {
         lastChild = child;
       }
       if (lastChild) {
         nsIFrame* lastChildFrame = lastChild->GetPrimaryFrame();
         if (lastChildFrame) {
           mTopFrame = nullptr;
           mRowsToPrepend = 1;
           --mCurrentIndex;
           mYPosition = mCurrentIndex*mRowHeight;
           nsWeakFrame weakChildFrame(aChildFrame);
           VerticalScroll(mYPosition);
           if (!weakChildFrame.IsAlive()) {
             return;
           }
         }
       }
     }
   }
   // if we're removing the top row, the new top row is the next row
   if (mTopFrame && mTopFrame == aChildFrame)
     mTopFrame = mTopFrame->GetNextSibling();
   // Go ahead and delete the frame.
   nsBoxLayoutState state(aPresContext);
   if (aChildFrame) {
     RemoveChildFrame(state, aChildFrame);
   }
   PresContext()->PresShell()->
     FrameNeedsReflow(this, nsIPresShell::eTreeChange,
                      NS_FRAME_HAS_DIRTY_CHILDREN);
 }
 void
 nsListBoxBodyFrame::GetListItemContentAt(int32_t aIndex, nsIContent** aContent)
 {
   *aContent = nullptr;
   int32_t itemsFound = 0;
   FlattenedChildIterator iter(mContent);
   for (nsIContent* child = iter.GetNextChild(); child; child = iter.GetNextChild()) {
     if (child->Tag() == nsGkAtoms::listitem) {
       ++itemsFound;
       if (itemsFound-1 == aIndex) {
         *aContent = child;
         NS_IF_ADDREF(*aContent);
         return;
       }
     }
   }
 }
 void
 nsListBoxBodyFrame::GetListItemNextSibling(nsIContent* aListItem, nsIContent** aContent, int32_t& aSiblingIndex)
 {
   *aContent = nullptr;
   aSiblingIndex = -1;
   nsIContent *prevKid = nullptr;
   FlattenedChildIterator iter(mContent);
   for (nsIContent* child = iter.GetNextChild(); child; child = iter.GetNextChild()) {
     if (child->Tag() == nsGkAtoms::listitem) {
       ++aSiblingIndex;
       if (prevKid == aListItem) {
         *aContent = child;
         NS_IF_ADDREF(*aContent);
         return;
       }
     }
     prevKid = child;
   }
   aSiblingIndex = -1; // no match, so there is no next sibling
 }
 void
 nsListBoxBodyFrame::RemoveChildFrame(nsBoxLayoutState &aState,
                                      nsIFrame         *aFrame)
 {
   MOZ_ASSERT(mFrames.ContainsFrame(aFrame));
   MOZ_ASSERT(aFrame != GetContentInsertionFrame());
 #ifdef ACCESSIBILITY
   nsAccessibilityService* accService = nsIPresShell::AccService();
   if (accService) {
     nsIContent* content = aFrame->GetContent();
     accService->ContentRemoved(PresContext()->PresShell(), content->GetParent(),
                                content);
   }
 #endif
   mFrames.RemoveFrame(aFrame);
   if (mLayoutManager)
     mLayoutManager->ChildrenRemoved(this, aState, aFrame);
   aFrame->Destroy();
 }
 // Creation Routines ///////////////////////////////////////////////////////////////////////
 already_AddRefed<nsBoxLayout> NS_NewListBoxLayout();
 nsIFrame*
 NS_NewListBoxBodyFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
 {
   nsCOMPtr<nsBoxLayout> layout = NS_NewListBoxLayout();
   return new (aPresShell) nsListBoxBodyFrame(aPresShell, aContext, layout);
 }
 NS_IMPL_FRAMEARENA_HELPERS(nsListBoxBodyFrame)

The Tor Browser / annotate

layout/xul/nsListBoxBodyFrame.cpp@97036ab72558 (annotated)

layout/xul/nsListBoxBodyFrame.cpp