The Tor Browser: layout/generic/nsLineBox.h@6474c204b198 (annotated)

layout/generic/nsLineBox.h@6474c204b198 (annotated)

layout/generic/nsLineBox.h

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 // vim:cindent:ts=2:et:sw=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/. */
 /* representation of one line within a block frame, a CSS line box */
 #ifndef nsLineBox_h___
 #define nsLineBox_h___
 #include "mozilla/Attributes.h"
 #include "mozilla/Likely.h"
 #include "nsILineIterator.h"
 #include "nsIFrame.h"
 #include <algorithm>
 class nsLineBox;
 class nsFloatCache;
 class nsFloatCacheList;
 class nsFloatCacheFreeList;
 // State cached after reflowing a float. This state is used during
 // incremental reflow when we avoid reflowing a float.
 class nsFloatCache {
 public:
   nsFloatCache();
 #ifdef NS_BUILD_REFCNT_LOGGING
   ~nsFloatCache();
 #else
   ~nsFloatCache() { }
 #endif
   nsFloatCache* Next() const { return mNext; }
   nsIFrame* mFloat;                     // floating frame
 protected:
   nsFloatCache* mNext;
   friend class nsFloatCacheList;
   friend class nsFloatCacheFreeList;
 };
 //----------------------------------------
 class nsFloatCacheList {
 public:
 #ifdef NS_BUILD_REFCNT_LOGGING
   nsFloatCacheList();
 #else
   nsFloatCacheList() : mHead(nullptr) { }
 #endif
   ~nsFloatCacheList();
   bool IsEmpty() const {
     return nullptr == mHead;
   }
   bool NotEmpty() const {
     return nullptr != mHead;
   }
   nsFloatCache* Head() const {
     return mHead;
   }
   nsFloatCache* Tail() const;
   void DeleteAll();
   nsFloatCache* Find(nsIFrame* aOutOfFlowFrame);
   // Remove a nsFloatCache from this list.  Deleting this nsFloatCache
   // becomes the caller's responsibility.
   void Remove(nsFloatCache* aElement) { RemoveAndReturnPrev(aElement); }
   // Steal away aList's nsFloatCache objects and put them in this
   // list.  aList must not be empty.
   void Append(nsFloatCacheFreeList& aList);
 protected:
   nsFloatCache* mHead;
   // Remove a nsFloatCache from this list.  Deleting this nsFloatCache
   // becomes the caller's responsibility. Returns the nsFloatCache that was
   // before aElement, or nullptr if aElement was the first.
   nsFloatCache* RemoveAndReturnPrev(nsFloatCache* aElement);
   friend class nsFloatCacheFreeList;
 };
 //---------------------------------------
 // Like nsFloatCacheList, but with fast access to the tail
 class nsFloatCacheFreeList : private nsFloatCacheList {
 public:
 #ifdef NS_BUILD_REFCNT_LOGGING
   nsFloatCacheFreeList();
   ~nsFloatCacheFreeList();
 #else
   nsFloatCacheFreeList() : mTail(nullptr) { }
   ~nsFloatCacheFreeList() { }
 #endif
   // Reimplement trivial functions
   bool IsEmpty() const {
     return nullptr == mHead;
   }
   nsFloatCache* Head() const {
     return mHead;
   }
   nsFloatCache* Tail() const {
     return mTail;
   }
   bool NotEmpty() const {
     return nullptr != mHead;
   }
   void DeleteAll();
   // Steal away aList's nsFloatCache objects and put them on this
   // free-list.  aList must not be empty.
   void Append(nsFloatCacheList& aList);
   void Append(nsFloatCache* aFloatCache);
   void Remove(nsFloatCache* aElement);
   // Remove an nsFloatCache object from this list and return it, or create
   // a new one if this one is empty; Set its mFloat to aFloat.
   nsFloatCache* Alloc(nsIFrame* aFloat);
 protected:
   nsFloatCache* mTail;
   friend class nsFloatCacheList;
 };
 //----------------------------------------------------------------------
 #define LINE_MAX_BREAK_TYPE  ((1 << 4) - 1)
 #define LINE_MAX_CHILD_COUNT INT32_MAX
 /**
  * Function to create a line box and initialize it with a single frame.
  * The allocation is infallible.
  * If the frame was moved from another line then you're responsible
  * for notifying that line using NoteFrameRemoved().  Alternatively,
  * it's better to use the next function that does that for you in an
  * optimal way.
  */
 nsLineBox* NS_NewLineBox(nsIPresShell* aPresShell, nsIFrame* aFrame,
                          bool aIsBlock);
 /**
  * Function to create a line box and initialize it with aCount frames
  * that are currently on aFromLine.  The allocation is infallible.
  */
 nsLineBox* NS_NewLineBox(nsIPresShell* aPresShell, nsLineBox* aFromLine,
                          nsIFrame* aFrame, int32_t aCount);
 class nsLineList;
 // don't use the following names outside of this file.  Instead, use
 // nsLineList::iterator, etc.  These are just here to allow them to
 // be specified as parameters to methods of nsLineBox.
 class nsLineList_iterator;
 class nsLineList_const_iterator;
 class nsLineList_reverse_iterator;
 class nsLineList_const_reverse_iterator;
 /**
  * Users must have the class that is to be part of the list inherit
  * from nsLineLink.  If they want to be efficient, it should be the
  * first base class.  (This was originally nsCLink in a templatized
  * nsCList, but it's still useful separately.)
  */
 class nsLineLink {
   public:
     friend class nsLineList;
     friend class nsLineList_iterator;
     friend class nsLineList_reverse_iterator;
     friend class nsLineList_const_iterator;
     friend class nsLineList_const_reverse_iterator;
   private:
     nsLineLink *_mNext; // or head
     nsLineLink *_mPrev; // or tail
 };
 /**
  * The nsLineBox class represents a horizontal line of frames. It contains
  * enough state to support incremental reflow of the frames, event handling
  * for the frames, and rendering of the frames.
  */
 class nsLineBox MOZ_FINAL : public nsLineLink {
 private:
   nsLineBox(nsIFrame* aFrame, int32_t aCount, bool aIsBlock);
   ~nsLineBox();
   // Overloaded new operator. Uses an arena (which comes from the presShell)
   // to perform the allocation.
   void* operator new(size_t sz, nsIPresShell* aPresShell) CPP_THROW_NEW;
   void operator delete(void* aPtr, size_t sz) MOZ_DELETE;
 public:
   // Use these functions to allocate and destroy line boxes
   friend nsLineBox* NS_NewLineBox(nsIPresShell* aPresShell, nsIFrame* aFrame,
                                   bool aIsBlock);
   friend nsLineBox* NS_NewLineBox(nsIPresShell* aPresShell, nsLineBox* aFromLine,
                                   nsIFrame* aFrame, int32_t aCount);
   void Destroy(nsIPresShell* aPresShell);
   // mBlock bit
   bool IsBlock() const {
     return mFlags.mBlock;
   }
   bool IsInline() const {
     return 0 == mFlags.mBlock;
   }
   // mDirty bit
   void MarkDirty() {
     mFlags.mDirty = 1;
   }
   void ClearDirty() {
     mFlags.mDirty = 0;
   }
   bool IsDirty() const {
     return mFlags.mDirty;
   }
   // mPreviousMarginDirty bit
   void MarkPreviousMarginDirty() {
     mFlags.mPreviousMarginDirty = 1;
   }
   void ClearPreviousMarginDirty() {
     mFlags.mPreviousMarginDirty = 0;
   }
   bool IsPreviousMarginDirty() const {
     return mFlags.mPreviousMarginDirty;
   }
   // mHasClearance bit
   void SetHasClearance() {
     mFlags.mHasClearance = 1;
   }
   void ClearHasClearance() {
     mFlags.mHasClearance = 0;
   }
   bool HasClearance() const {
     return mFlags.mHasClearance;
   }
   // mImpactedByFloat bit
   void SetLineIsImpactedByFloat(bool aValue) {
     mFlags.mImpactedByFloat = aValue;
   }
   bool IsImpactedByFloat() const {
     return mFlags.mImpactedByFloat;
   }
   // mLineWrapped bit
   void SetLineWrapped(bool aOn) {
     mFlags.mLineWrapped = aOn;
   }
   bool IsLineWrapped() const {
     return mFlags.mLineWrapped;
   }
   // mInvalidateTextRuns bit
   void SetInvalidateTextRuns(bool aOn) {
     mFlags.mInvalidateTextRuns = aOn;
   }
   bool GetInvalidateTextRuns() const {
     return mFlags.mInvalidateTextRuns;
   }
   // mResizeReflowOptimizationDisabled bit
   void DisableResizeReflowOptimization() {
     mFlags.mResizeReflowOptimizationDisabled = true;
   }
   void EnableResizeReflowOptimization() {
     mFlags.mResizeReflowOptimizationDisabled = false;
   }
   bool ResizeReflowOptimizationDisabled() const {
     return mFlags.mResizeReflowOptimizationDisabled;
   }
   // mHasBullet bit
   void SetHasBullet() {
     mFlags.mHasBullet = true;
     InvalidateCachedIsEmpty();
   }
   void ClearHasBullet() {
     mFlags.mHasBullet = false;
     InvalidateCachedIsEmpty();
   }
   bool HasBullet() const {
     return mFlags.mHasBullet;
   }
   // mHadFloatPushed bit
   void SetHadFloatPushed() {
     mFlags.mHadFloatPushed = true;
   }
   void ClearHadFloatPushed() {
     mFlags.mHadFloatPushed = false;
   }
   bool HadFloatPushed() const {
     return mFlags.mHadFloatPushed;
   }
 private:
   // Add a hash table for fast lookup when the line has more frames than this.
   static const uint32_t kMinChildCountForHashtable = 200;
   /**
    * Take ownership of aFromLine's hash table and remove the frames that
    * stay on aFromLine from it, i.e. aFromLineNewCount frames starting with
    * mFirstChild.  This method is used to optimize moving a large number
    * of frames from one line to the next.
    */
   void StealHashTableFrom(nsLineBox* aFromLine, uint32_t aFromLineNewCount);
   /**
    * Does the equivalent of this->NoteFrameAdded and aFromLine->NoteFrameRemoved
    * for each frame on this line, but in a optimized way.
    */
   void NoteFramesMovedFrom(nsLineBox* aFromLine);
   void SwitchToHashtable()
   {
     MOZ_ASSERT(!mFlags.mHasHashedFrames);
     uint32_t count = GetChildCount();
     mFlags.mHasHashedFrames = 1;
     uint32_t minSize =
       std::max(kMinChildCountForHashtable, uint32_t(PL_DHASH_MIN_SIZE));
     mFrames = new nsTHashtable< nsPtrHashKey<nsIFrame> >(std::max(count, minSize));
     for (nsIFrame* f = mFirstChild; count-- > 0; f = f->GetNextSibling()) {
       mFrames->PutEntry(f);
     }
   }
   void SwitchToCounter() {
     MOZ_ASSERT(mFlags.mHasHashedFrames);
     uint32_t count = GetChildCount();
     delete mFrames;
     mFlags.mHasHashedFrames = 0;
     mChildCount = count;
   }
 public:
   int32_t GetChildCount() const {
     return MOZ_UNLIKELY(mFlags.mHasHashedFrames) ? mFrames->Count() : mChildCount;
   }
   /**
    * Register that aFrame is now on this line.
    */
   void NoteFrameAdded(nsIFrame* aFrame) {
     if (MOZ_UNLIKELY(mFlags.mHasHashedFrames)) {
       mFrames->PutEntry(aFrame);
     } else {
       if (++mChildCount >= kMinChildCountForHashtable) {
         SwitchToHashtable();
       }
     }
   }
   /**
    * Register that aFrame is not on this line anymore.
    */
   void NoteFrameRemoved(nsIFrame* aFrame) {
     MOZ_ASSERT(GetChildCount() > 0);
     if (MOZ_UNLIKELY(mFlags.mHasHashedFrames)) {
       mFrames->RemoveEntry(aFrame);
       if (mFrames->Count() < kMinChildCountForHashtable) {
         SwitchToCounter();
       }
     } else {
       --mChildCount;
     }
   }
   // mBreakType value
   // Break information is applied *before* the line if the line is a block,
   // or *after* the line if the line is an inline. Confusing, I know, but
   // using different names should help.
   bool HasBreakBefore() const {
     return IsBlock() && NS_STYLE_CLEAR_NONE != mFlags.mBreakType;
   }
   void SetBreakTypeBefore(uint8_t aBreakType) {
     NS_ASSERTION(IsBlock(), "Only blocks have break-before");
     NS_ASSERTION(aBreakType == NS_STYLE_CLEAR_NONE ||
                  aBreakType == NS_STYLE_CLEAR_LEFT ||
                  aBreakType == NS_STYLE_CLEAR_RIGHT ||
                  aBreakType == NS_STYLE_CLEAR_BOTH,
                  "Only float break types are allowed before a line");
     mFlags.mBreakType = aBreakType;
   }
   uint8_t GetBreakTypeBefore() const {
     return IsBlock() ? mFlags.mBreakType : NS_STYLE_CLEAR_NONE;
   }
   bool HasBreakAfter() const {
     return !IsBlock() && NS_STYLE_CLEAR_NONE != mFlags.mBreakType;
   }
   void SetBreakTypeAfter(uint8_t aBreakType) {
     NS_ASSERTION(!IsBlock(), "Only inlines have break-after");
     NS_ASSERTION(aBreakType <= LINE_MAX_BREAK_TYPE, "bad break type");
     mFlags.mBreakType = aBreakType;
   }
   bool HasFloatBreakAfter() const {
     return !IsBlock() && (NS_STYLE_CLEAR_LEFT == mFlags.mBreakType ||
                           NS_STYLE_CLEAR_RIGHT == mFlags.mBreakType ||
                           NS_STYLE_CLEAR_BOTH == mFlags.mBreakType);
   }
   uint8_t GetBreakTypeAfter() const {
     return !IsBlock() ? mFlags.mBreakType : NS_STYLE_CLEAR_NONE;
   }
   // mCarriedOutBottomMargin value
   nsCollapsingMargin GetCarriedOutBottomMargin() const;
   // Returns true if the margin changed
   bool SetCarriedOutBottomMargin(nsCollapsingMargin aValue);
   // mFloats
   bool HasFloats() const {
     return (IsInline() && mInlineData) && mInlineData->mFloats.NotEmpty();
   }
   nsFloatCache* GetFirstFloat();
   void FreeFloats(nsFloatCacheFreeList& aFreeList);
   void AppendFloats(nsFloatCacheFreeList& aFreeList);
   bool RemoveFloat(nsIFrame* aFrame);
   // Combined area is the area of the line that should influence the
   // overflow area of its parent block.  The combined area should be
   // used for painting-related things, but should never be used for
   // layout (except for handling of 'overflow').
   void SetOverflowAreas(const nsOverflowAreas& aOverflowAreas);
   nsRect GetOverflowArea(nsOverflowType aType) {
     return mData ? mData->mOverflowAreas.Overflow(aType) : GetPhysicalBounds();
   }
   nsOverflowAreas GetOverflowAreas() {
     if (mData) {
       return mData->mOverflowAreas;
     }
     nsRect bounds = GetPhysicalBounds();
     return nsOverflowAreas(bounds, bounds);
   }
   nsRect GetVisualOverflowArea()
     { return GetOverflowArea(eVisualOverflow); }
   nsRect GetScrollableOverflowArea()
     { return GetOverflowArea(eScrollableOverflow); }
   void SlideBy(nscoord aDBCoord, nscoord aContainerWidth) {
     NS_ASSERTION(aContainerWidth == mContainerWidth || mContainerWidth == -1,
                  "container width doesn't match");
     mContainerWidth = aContainerWidth;
     mBounds.BStart(mWritingMode) += aDBCoord;
     if (mData) {
       NS_FOR_FRAME_OVERFLOW_TYPES(otype) {
         mData->mOverflowAreas.Overflow(otype).y += aDBCoord;
       }
     }
   }
   void IndentBy(nscoord aDICoord, nscoord aContainerWidth) {
     NS_ASSERTION(aContainerWidth == mContainerWidth || mContainerWidth == -1,
                  "container width doesn't match");
     mContainerWidth = aContainerWidth;
     mBounds.IStart(mWritingMode) += aDICoord;
   }
   void ExpandBy(nscoord aDISize, nscoord aContainerWidth) {
     NS_ASSERTION(aContainerWidth == mContainerWidth || mContainerWidth == -1,
                  "container width doesn't match");
     mContainerWidth = aContainerWidth;
     mBounds.ISize(mWritingMode) += aDISize;
   }
   /**
    * The ascent (distance from top to baseline) of the linebox is the
    * ascent of the anonymous inline box (for which we don't actually
    * create a frame) that wraps all the consecutive inline children of a
    * block.
    *
    * This is currently unused for block lines.
    */
   nscoord GetAscent() const { return mAscent; }
   void SetAscent(nscoord aAscent) { mAscent = aAscent; }
   nscoord BStart() const {
     return mBounds.BStart(mWritingMode);
   }
   nscoord BSize() const {
     return mBounds.BSize(mWritingMode);
   }
   nscoord BEnd() const {
     return mBounds.BEnd(mWritingMode);
   }
   nscoord IStart() const {
     return mBounds.IStart(mWritingMode);
   }
   nscoord ISize() const {
     return mBounds.ISize(mWritingMode);
   }
   nscoord IEnd() const {
     return mBounds.IEnd(mWritingMode);
   }
   void SetBoundsEmpty() {
     mBounds.IStart(mWritingMode) = 0;
     mBounds.ISize(mWritingMode) = 0;
     mBounds.BStart(mWritingMode) = 0;
     mBounds.BSize(mWritingMode) = 0;
   }
   static void DeleteLineList(nsPresContext* aPresContext, nsLineList& aLines,
                              nsIFrame* aDestructRoot, nsFrameList* aFrames);
   // search from end to beginning of [aBegin, aEnd)
   // Returns true if it found the line and false if not.
   // Moves aEnd as it searches so that aEnd points to the resulting line.
   // aLastFrameBeforeEnd is the last frame before aEnd (so if aEnd is
   // the end of the line list, it's just the last frame in the frame
   // list).
   static bool RFindLineContaining(nsIFrame* aFrame,
                                     const nsLineList_iterator& aBegin,
                                     nsLineList_iterator& aEnd,
                                     nsIFrame* aLastFrameBeforeEnd,
                                     int32_t* aFrameIndexInLine);
 #ifdef DEBUG_FRAME_DUMP
   char* StateToString(char* aBuf, int32_t aBufSize) const;
   void List(FILE* out, int32_t aIndent, uint32_t aFlags = 0) const;
   void List(FILE* out = stderr, const char* aPrefix = "", uint32_t aFlags = 0) const;
   nsIFrame* LastChild() const;
 #endif
 private:
   int32_t IndexOf(nsIFrame* aFrame) const;
 public:
   bool Contains(nsIFrame* aFrame) const {
     return MOZ_UNLIKELY(mFlags.mHasHashedFrames) ? mFrames->Contains(aFrame)
                                                 : IndexOf(aFrame) >= 0;
   }
   // whether the line box is "logically" empty (just like nsIFrame::IsEmpty)
   bool IsEmpty() const;
   // Call this only while in Reflow() for the block the line belongs
   // to, only between reflowing the line (or sliding it, if we skip
   // reflowing it) and the end of reflowing the block.
   bool CachedIsEmpty();
   void InvalidateCachedIsEmpty() {
     mFlags.mEmptyCacheValid = false;
   }
   // For debugging purposes
   bool IsValidCachedIsEmpty() {
     return mFlags.mEmptyCacheValid;
   }
 #ifdef DEBUG
   static int32_t GetCtorCount();
 #endif
   nsIFrame* mFirstChild;
   mozilla::WritingMode mWritingMode;
   nscoord mContainerWidth;
  private:
   mozilla::LogicalRect mBounds;
  public:
   const mozilla::LogicalRect& GetBounds() { return mBounds; }
   nsRect GetPhysicalBounds() const
   {
     if (mBounds.IsEmpty()) {
       return nsRect(0, 0, 0, 0);
     }
     NS_ASSERTION(mContainerWidth != -1, "mContainerWidth not initialized");
     return mBounds.GetPhysicalRect(mWritingMode, mContainerWidth);
   }
   void SetBounds(mozilla::WritingMode aWritingMode,
                  nscoord aIStart, nscoord aBStart,
                  nscoord aISize, nscoord aBSize,
                  nscoord aContainerWidth)
   {
     mWritingMode = aWritingMode;
     mContainerWidth = aContainerWidth;
     mBounds = mozilla::LogicalRect(aWritingMode, aIStart, aBStart,
                                    aISize, aBSize);
   }
   void SetBounds(mozilla::WritingMode aWritingMode,
                  nsRect aRect, nscoord aContainerWidth)
   {
     mWritingMode = aWritingMode;
     mContainerWidth = aContainerWidth;
     mBounds = mozilla::LogicalRect(aWritingMode, aRect, aContainerWidth);
   }
   // mFlags.mHasHashedFrames says which one to use
   union {
     nsTHashtable< nsPtrHashKey<nsIFrame> >* mFrames;
     uint32_t mChildCount;
   };
   struct FlagBits {
     uint32_t mDirty : 1;
     uint32_t mPreviousMarginDirty : 1;
     uint32_t mHasClearance : 1;
     uint32_t mBlock : 1;
     uint32_t mImpactedByFloat : 1;
     uint32_t mLineWrapped: 1;
     uint32_t mInvalidateTextRuns : 1;
     uint32_t mResizeReflowOptimizationDisabled: 1;  // default 0 = means that the opt potentially applies to this line. 1 = never skip reflowing this line for a resize reflow
     uint32_t mEmptyCacheValid: 1;
     uint32_t mEmptyCacheState: 1;
     // mHasBullet indicates that this is an inline line whose block's
     // bullet is adjacent to this line and non-empty.
     uint32_t mHasBullet : 1;
     // Indicates that this line *may* have a placeholder for a float
     // that was pushed to a later column or page.
     uint32_t mHadFloatPushed : 1;
     uint32_t mHasHashedFrames: 1;
     uint32_t mBreakType : 4;
   };
   struct ExtraData {
     ExtraData(const nsRect& aBounds) : mOverflowAreas(aBounds, aBounds) {
     }
     nsOverflowAreas mOverflowAreas;
   };
   struct ExtraBlockData : public ExtraData {
     ExtraBlockData(const nsRect& aBounds)
       : ExtraData(aBounds),
         mCarriedOutBottomMargin()
     {
     }
     nsCollapsingMargin mCarriedOutBottomMargin;
   };
   struct ExtraInlineData : public ExtraData {
     ExtraInlineData(const nsRect& aBounds) : ExtraData(aBounds) {
     }
     nsFloatCacheList mFloats;
   };
 protected:
   nscoord mAscent;           // see |SetAscent| / |GetAscent|
   union {
     uint32_t mAllFlags;
     FlagBits mFlags;
   };
   union {
     ExtraData* mData;
     ExtraBlockData* mBlockData;
     ExtraInlineData* mInlineData;
   };
   void Cleanup();
   void MaybeFreeData();
 };
 /**
  * A linked list type where the items in the list must inherit from
  * a link type to fuse allocations.
  *
  * API heavily based on the |list| class in the C++ standard.
  */
 class nsLineList_iterator {
   public:
     friend class nsLineList;
     friend class nsLineList_reverse_iterator;
     friend class nsLineList_const_iterator;
     friend class nsLineList_const_reverse_iterator;
     typedef nsLineList_iterator         iterator_self_type;
     typedef nsLineList_reverse_iterator iterator_reverse_type;
     typedef nsLineBox&                  reference;
     typedef const nsLineBox&            const_reference;
     typedef nsLineBox*                  pointer;
     typedef const nsLineBox*            const_pointer;
     typedef uint32_t                    size_type;
     typedef int32_t                     difference_type;
     typedef nsLineLink                  link_type;
 #ifdef DEBUG
     nsLineList_iterator() { memset(&mCurrent, 0xcd, sizeof(mCurrent)); }
 #else
     // Auto generated default constructor OK.
 #endif
     // Auto generated copy-constructor OK.
     inline iterator_self_type&
         operator=(const iterator_self_type& aOther);
     inline iterator_self_type&
         operator=(const iterator_reverse_type& aOther);
     iterator_self_type& operator++()
     {
       mCurrent = mCurrent->_mNext;
       return *this;
     }
     iterator_self_type operator++(int)
     {
       iterator_self_type rv(*this);
       mCurrent = mCurrent->_mNext;
       return rv;
     }
     iterator_self_type& operator--()
     {
       mCurrent = mCurrent->_mPrev;
       return *this;
     }
     iterator_self_type operator--(int)
     {
       iterator_self_type rv(*this);
       mCurrent = mCurrent->_mPrev;
       return rv;
     }
     reference operator*()
     {
       NS_ABORT_IF_FALSE(mCurrent != mListLink, "running past end");
       return *static_cast<pointer>(mCurrent);
     }
     pointer operator->()
     {
       NS_ABORT_IF_FALSE(mCurrent != mListLink, "running past end");
       return static_cast<pointer>(mCurrent);
     }
     pointer get()
     {
       NS_ABORT_IF_FALSE(mCurrent != mListLink, "running past end");
       return static_cast<pointer>(mCurrent);
     }
     operator pointer()
     {
       NS_ABORT_IF_FALSE(mCurrent != mListLink, "running past end");
       return static_cast<pointer>(mCurrent);
     }
     const_reference operator*() const
     {
       NS_ABORT_IF_FALSE(mCurrent != mListLink, "running past end");
       return *static_cast<const_pointer>(mCurrent);
     }
     const_pointer operator->() const
     {
       NS_ABORT_IF_FALSE(mCurrent != mListLink, "running past end");
       return static_cast<const_pointer>(mCurrent);
     }
 #ifndef __MWERKS__
     operator const_pointer() const
     {
       NS_ABORT_IF_FALSE(mCurrent != mListLink, "running past end");
       return static_cast<const_pointer>(mCurrent);
     }
 #endif /* !__MWERKS__ */
     iterator_self_type next()
     {
       iterator_self_type copy(*this);
       return ++copy;
     }
     const iterator_self_type next() const
     {
       iterator_self_type copy(*this);
       return ++copy;
     }
     iterator_self_type prev()
     {
       iterator_self_type copy(*this);
       return --copy;
     }
     const iterator_self_type prev() const
     {
       iterator_self_type copy(*this);
       return --copy;
     }
     // Passing by value rather than by reference and reference to const
     // to keep AIX happy.
     bool operator==(const iterator_self_type aOther) const
     {
       NS_ABORT_IF_FALSE(mListLink == aOther.mListLink, "comparing iterators over different lists");
       return mCurrent == aOther.mCurrent;
     }
     bool operator!=(const iterator_self_type aOther) const
     {
       NS_ABORT_IF_FALSE(mListLink == aOther.mListLink, "comparing iterators over different lists");
       return mCurrent != aOther.mCurrent;
     }
     bool operator==(const iterator_self_type aOther)
     {
       NS_ABORT_IF_FALSE(mListLink == aOther.mListLink, "comparing iterators over different lists");
       return mCurrent == aOther.mCurrent;
     }
     bool operator!=(const iterator_self_type aOther)
     {
       NS_ABORT_IF_FALSE(mListLink == aOther.mListLink, "comparing iterators over different lists");
       return mCurrent != aOther.mCurrent;
     }
   private:
     link_type *mCurrent;
 #ifdef DEBUG
     link_type *mListLink; // the list's link, i.e., the end
 #endif
 };
 class nsLineList_reverse_iterator {
   public:
     friend class nsLineList;
     friend class nsLineList_iterator;
     friend class nsLineList_const_iterator;
     friend class nsLineList_const_reverse_iterator;
     typedef nsLineList_reverse_iterator iterator_self_type;
     typedef nsLineList_iterator         iterator_reverse_type;
     typedef nsLineBox&                  reference;
     typedef const nsLineBox&            const_reference;
     typedef nsLineBox*                  pointer;
     typedef const nsLineBox*            const_pointer;
     typedef uint32_t                    size_type;
     typedef int32_t                     difference_type;
     typedef nsLineLink                  link_type;
 #ifdef DEBUG
     nsLineList_reverse_iterator() { memset(&mCurrent, 0xcd, sizeof(mCurrent)); }
 #else
     // Auto generated default constructor OK.
 #endif
     // Auto generated copy-constructor OK.
     inline iterator_self_type&
         operator=(const iterator_reverse_type& aOther);
     inline iterator_self_type&
         operator=(const iterator_self_type& aOther);
     iterator_self_type& operator++()
     {
       mCurrent = mCurrent->_mPrev;
       return *this;
     }
     iterator_self_type operator++(int)
     {
       iterator_self_type rv(*this);
       mCurrent = mCurrent->_mPrev;
       return rv;
     }
     iterator_self_type& operator--()
     {
       mCurrent = mCurrent->_mNext;
       return *this;
     }
     iterator_self_type operator--(int)
     {
       iterator_self_type rv(*this);
       mCurrent = mCurrent->_mNext;
       return rv;
     }
     reference operator*()
     {
       NS_ABORT_IF_FALSE(mCurrent != mListLink, "running past end");
       return *static_cast<pointer>(mCurrent);
     }
     pointer operator->()
     {
       NS_ABORT_IF_FALSE(mCurrent != mListLink, "running past end");
       return static_cast<pointer>(mCurrent);
     }
     pointer get()
     {
       NS_ABORT_IF_FALSE(mCurrent != mListLink, "running past end");
       return static_cast<pointer>(mCurrent);
     }
     operator pointer()
     {
       NS_ABORT_IF_FALSE(mCurrent != mListLink, "running past end");
       return static_cast<pointer>(mCurrent);
     }
     const_reference operator*() const
     {
       NS_ABORT_IF_FALSE(mCurrent != mListLink, "running past end");
       return *static_cast<const_pointer>(mCurrent);
     }
     const_pointer operator->() const
     {
       NS_ABORT_IF_FALSE(mCurrent != mListLink, "running past end");
       return static_cast<const_pointer>(mCurrent);
     }
 #ifndef __MWERKS__
     operator const_pointer() const
     {
       NS_ABORT_IF_FALSE(mCurrent != mListLink, "running past end");
       return static_cast<const_pointer>(mCurrent);
     }
 #endif /* !__MWERKS__ */
     // Passing by value rather than by reference and reference to const
     // to keep AIX happy.
     bool operator==(const iterator_self_type aOther) const
     {
       NS_ASSERTION(mListLink == aOther.mListLink, "comparing iterators over different lists");
       return mCurrent == aOther.mCurrent;
     }
     bool operator!=(const iterator_self_type aOther) const
     {
       NS_ASSERTION(mListLink == aOther.mListLink, "comparing iterators over different lists");
       return mCurrent != aOther.mCurrent;
     }
     bool operator==(const iterator_self_type aOther)
     {
       NS_ASSERTION(mListLink == aOther.mListLink, "comparing iterators over different lists");
       return mCurrent == aOther.mCurrent;
     }
     bool operator!=(const iterator_self_type aOther)
     {
       NS_ASSERTION(mListLink == aOther.mListLink, "comparing iterators over different lists");
       return mCurrent != aOther.mCurrent;
     }
   private:
     link_type *mCurrent;
 #ifdef DEBUG
     link_type *mListLink; // the list's link, i.e., the end
 #endif
 };
 class nsLineList_const_iterator {
   public:
     friend class nsLineList;
     friend class nsLineList_iterator;
     friend class nsLineList_reverse_iterator;
     friend class nsLineList_const_reverse_iterator;
     typedef nsLineList_const_iterator           iterator_self_type;
     typedef nsLineList_const_reverse_iterator   iterator_reverse_type;
     typedef nsLineList_iterator                 iterator_nonconst_type;
     typedef nsLineList_reverse_iterator         iterator_nonconst_reverse_type;
     typedef nsLineBox&                  reference;
     typedef const nsLineBox&            const_reference;
     typedef nsLineBox*                  pointer;
     typedef const nsLineBox*            const_pointer;
     typedef uint32_t                    size_type;
     typedef int32_t                     difference_type;
     typedef nsLineLink                  link_type;
 #ifdef DEBUG
     nsLineList_const_iterator() { memset(&mCurrent, 0xcd, sizeof(mCurrent)); }
 #else
     // Auto generated default constructor OK.
 #endif
     // Auto generated copy-constructor OK.
     inline iterator_self_type&
         operator=(const iterator_nonconst_type& aOther);
     inline iterator_self_type&
         operator=(const iterator_nonconst_reverse_type& aOther);
     inline iterator_self_type&
         operator=(const iterator_self_type& aOther);
     inline iterator_self_type&
         operator=(const iterator_reverse_type& aOther);
     iterator_self_type& operator++()
     {
       mCurrent = mCurrent->_mNext;
       return *this;
     }
     iterator_self_type operator++(int)
     {
       iterator_self_type rv(*this);
       mCurrent = mCurrent->_mNext;
       return rv;
     }
     iterator_self_type& operator--()
     {
       mCurrent = mCurrent->_mPrev;
       return *this;
     }
     iterator_self_type operator--(int)
     {
       iterator_self_type rv(*this);
       mCurrent = mCurrent->_mPrev;
       return rv;
     }
     const_reference operator*() const
     {
       NS_ABORT_IF_FALSE(mCurrent != mListLink, "running past end");
       return *static_cast<const_pointer>(mCurrent);
     }
     const_pointer operator->() const
     {
       NS_ABORT_IF_FALSE(mCurrent != mListLink, "running past end");
       return static_cast<const_pointer>(mCurrent);
     }
     const_pointer get() const
     {
       NS_ABORT_IF_FALSE(mCurrent != mListLink, "running past end");
       return static_cast<const_pointer>(mCurrent);
     }
 #ifndef __MWERKS__
     operator const_pointer() const
     {
       NS_ABORT_IF_FALSE(mCurrent != mListLink, "running past end");
       return static_cast<const_pointer>(mCurrent);
     }
 #endif /* !__MWERKS__ */
     const iterator_self_type next() const
     {
       iterator_self_type copy(*this);
       return ++copy;
     }
     const iterator_self_type prev() const
     {
       iterator_self_type copy(*this);
       return --copy;
     }
     // Passing by value rather than by reference and reference to const
     // to keep AIX happy.
     bool operator==(const iterator_self_type aOther) const
     {
       NS_ASSERTION(mListLink == aOther.mListLink, "comparing iterators over different lists");
       return mCurrent == aOther.mCurrent;
     }
     bool operator!=(const iterator_self_type aOther) const
     {
       NS_ASSERTION(mListLink == aOther.mListLink, "comparing iterators over different lists");
       return mCurrent != aOther.mCurrent;
     }
     bool operator==(const iterator_self_type aOther)
     {
       NS_ASSERTION(mListLink == aOther.mListLink, "comparing iterators over different lists");
       return mCurrent == aOther.mCurrent;
     }
     bool operator!=(const iterator_self_type aOther)
     {
       NS_ASSERTION(mListLink == aOther.mListLink, "comparing iterators over different lists");
       return mCurrent != aOther.mCurrent;
     }
   private:
     const link_type *mCurrent;
 #ifdef DEBUG
     const link_type *mListLink; // the list's link, i.e., the end
 #endif
 };
 class nsLineList_const_reverse_iterator {
   public:
     friend class nsLineList;
     friend class nsLineList_iterator;
     friend class nsLineList_reverse_iterator;
     friend class nsLineList_const_iterator;
     typedef nsLineList_const_reverse_iterator   iterator_self_type;
     typedef nsLineList_const_iterator           iterator_reverse_type;
     typedef nsLineList_iterator                 iterator_nonconst_reverse_type;
     typedef nsLineList_reverse_iterator         iterator_nonconst_type;
     typedef nsLineBox&                  reference;
     typedef const nsLineBox&            const_reference;
     typedef nsLineBox*                  pointer;
     typedef const nsLineBox*            const_pointer;
     typedef uint32_t                    size_type;
     typedef int32_t                     difference_type;
     typedef nsLineLink                  link_type;
 #ifdef DEBUG
     nsLineList_const_reverse_iterator() { memset(&mCurrent, 0xcd, sizeof(mCurrent)); }
 #else
     // Auto generated default constructor OK.
 #endif
     // Auto generated copy-constructor OK.
     inline iterator_self_type&
         operator=(const iterator_nonconst_type& aOther);
     inline iterator_self_type&
         operator=(const iterator_nonconst_reverse_type& aOther);
     inline iterator_self_type&
         operator=(const iterator_self_type& aOther);
     inline iterator_self_type&
         operator=(const iterator_reverse_type& aOther);
     iterator_self_type& operator++()
     {
       mCurrent = mCurrent->_mPrev;
       return *this;
     }
     iterator_self_type operator++(int)
     {
       iterator_self_type rv(*this);
       mCurrent = mCurrent->_mPrev;
       return rv;
     }
     iterator_self_type& operator--()
     {
       mCurrent = mCurrent->_mNext;
       return *this;
     }
     iterator_self_type operator--(int)
     {
       iterator_self_type rv(*this);
       mCurrent = mCurrent->_mNext;
       return rv;
     }
     const_reference operator*() const
     {
       NS_ABORT_IF_FALSE(mCurrent != mListLink, "running past end");
       return *static_cast<const_pointer>(mCurrent);
     }
     const_pointer operator->() const
     {
       NS_ABORT_IF_FALSE(mCurrent != mListLink, "running past end");
       return static_cast<const_pointer>(mCurrent);
     }
     const_pointer get() const
     {
       NS_ABORT_IF_FALSE(mCurrent != mListLink, "running past end");
       return static_cast<const_pointer>(mCurrent);
     }
 #ifndef __MWERKS__
     operator const_pointer() const
     {
       NS_ABORT_IF_FALSE(mCurrent != mListLink, "running past end");
       return static_cast<const_pointer>(mCurrent);
     }
 #endif /* !__MWERKS__ */
     // Passing by value rather than by reference and reference to const
     // to keep AIX happy.
     bool operator==(const iterator_self_type aOther) const
     {
       NS_ASSERTION(mListLink == aOther.mListLink, "comparing iterators over different lists");
       return mCurrent == aOther.mCurrent;
     }
     bool operator!=(const iterator_self_type aOther) const
     {
       NS_ASSERTION(mListLink == aOther.mListLink, "comparing iterators over different lists");
       return mCurrent != aOther.mCurrent;
     }
     bool operator==(const iterator_self_type aOther)
     {
       NS_ASSERTION(mListLink == aOther.mListLink, "comparing iterators over different lists");
       return mCurrent == aOther.mCurrent;
     }
     bool operator!=(const iterator_self_type aOther)
     {
       NS_ASSERTION(mListLink == aOther.mListLink, "comparing iterators over different lists");
       return mCurrent != aOther.mCurrent;
     }
 //private:
     const link_type *mCurrent;
 #ifdef DEBUG
     const link_type *mListLink; // the list's link, i.e., the end
 #endif
 };
 class nsLineList {
   public:
   friend class nsLineList_iterator;
   friend class nsLineList_reverse_iterator;
   friend class nsLineList_const_iterator;
   friend class nsLineList_const_reverse_iterator;
   typedef uint32_t                    size_type;
   typedef int32_t                     difference_type;
   typedef nsLineLink                  link_type;
   private:
     link_type mLink;
   public:
     typedef nsLineList                  self_type;
     typedef nsLineBox&                  reference;
     typedef const nsLineBox&            const_reference;
     typedef nsLineBox*                  pointer;
     typedef const nsLineBox*            const_pointer;
     typedef nsLineList_iterator         iterator;
     typedef nsLineList_reverse_iterator reverse_iterator;
     typedef nsLineList_const_iterator   const_iterator;
     typedef nsLineList_const_reverse_iterator const_reverse_iterator;
     nsLineList()
     {
       MOZ_COUNT_CTOR(nsLineList);
       clear();
     }
     ~nsLineList()
     {
       MOZ_COUNT_DTOR(nsLineList);
     }
     const_iterator begin() const
     {
       const_iterator rv;
       rv.mCurrent = mLink._mNext;
 #ifdef DEBUG
       rv.mListLink = &mLink;
 #endif
       return rv;
     }
     iterator begin()
     {
       iterator rv;
       rv.mCurrent = mLink._mNext;
 #ifdef DEBUG
       rv.mListLink = &mLink;
 #endif
       return rv;
     }
     iterator begin(nsLineBox* aLine)
     {
       iterator rv;
       rv.mCurrent = aLine;
 #ifdef DEBUG
       rv.mListLink = &mLink;
 #endif
       return rv;
     }
     const_iterator end() const
     {
       const_iterator rv;
       rv.mCurrent = &mLink;
 #ifdef DEBUG
       rv.mListLink = &mLink;
 #endif
       return rv;
     }
     iterator end()
     {
       iterator rv;
       rv.mCurrent = &mLink;
 #ifdef DEBUG
       rv.mListLink = &mLink;
 #endif
       return rv;
     }
     const_reverse_iterator rbegin() const
     {
       const_reverse_iterator rv;
       rv.mCurrent = mLink._mPrev;
 #ifdef DEBUG
       rv.mListLink = &mLink;
 #endif
       return rv;
     }
     reverse_iterator rbegin()
     {
       reverse_iterator rv;
       rv.mCurrent = mLink._mPrev;
 #ifdef DEBUG
       rv.mListLink = &mLink;
 #endif
       return rv;
     }
     reverse_iterator rbegin(nsLineBox* aLine)
     {
       reverse_iterator rv;
       rv.mCurrent = aLine;
 #ifdef DEBUG
       rv.mListLink = &mLink;
 #endif
       return rv;
     }
     const_reverse_iterator rend() const
     {
       const_reverse_iterator rv;
       rv.mCurrent = &mLink;
 #ifdef DEBUG
       rv.mListLink = &mLink;
 #endif
       return rv;
     }
     reverse_iterator rend()
     {
       reverse_iterator rv;
       rv.mCurrent = &mLink;
 #ifdef DEBUG
       rv.mListLink = &mLink;
 #endif
       return rv;
     }
     bool empty() const
     {
       return mLink._mNext == &mLink;
     }
     // NOTE: O(N).
     size_type size() const
     {
       size_type count = 0;
       for (const link_type *cur = mLink._mNext;
            cur != &mLink;
            cur = cur->_mNext)
       {
         ++count;
       }
       return count;
     }
     pointer front()
     {
       NS_ASSERTION(!empty(), "no element to return");
       return static_cast<pointer>(mLink._mNext);
     }
     const_pointer front() const
     {
       NS_ASSERTION(!empty(), "no element to return");
       return static_cast<const_pointer>(mLink._mNext);
     }
     pointer back()
     {
       NS_ASSERTION(!empty(), "no element to return");
       return static_cast<pointer>(mLink._mPrev);
     }
     const_pointer back() const
     {
       NS_ASSERTION(!empty(), "no element to return");
       return static_cast<const_pointer>(mLink._mPrev);
     }
     void push_front(pointer aNew)
     {
       aNew->_mNext = mLink._mNext;
       mLink._mNext->_mPrev = aNew;
       aNew->_mPrev = &mLink;
       mLink._mNext = aNew;
     }
     void pop_front()
         // NOTE: leaves dangling next/prev pointers
     {
       NS_ASSERTION(!empty(), "no element to pop");
       link_type *newFirst = mLink._mNext->_mNext;
       newFirst->_mPrev = &mLink;
       // mLink._mNext->_mNext = nullptr;
       // mLink._mNext->_mPrev = nullptr;
       mLink._mNext = newFirst;
     }
     void push_back(pointer aNew)
     {
       aNew->_mPrev = mLink._mPrev;
       mLink._mPrev->_mNext = aNew;
       aNew->_mNext = &mLink;
       mLink._mPrev = aNew;
     }
     void pop_back()
         // NOTE: leaves dangling next/prev pointers
     {
       NS_ASSERTION(!empty(), "no element to pop");
       link_type *newLast = mLink._mPrev->_mPrev;
       newLast->_mNext = &mLink;
       // mLink._mPrev->_mPrev = nullptr;
       // mLink._mPrev->_mNext = nullptr;
       mLink._mPrev = newLast;
     }
     // inserts x before position
     iterator before_insert(iterator position, pointer x)
     {
       // use |mCurrent| to prevent DEBUG_PASS_END assertions
       x->_mPrev = position.mCurrent->_mPrev;
       x->_mNext = position.mCurrent;
       position.mCurrent->_mPrev->_mNext = x;
       position.mCurrent->_mPrev = x;
       return --position;
     }
     // inserts x after position
     iterator after_insert(iterator position, pointer x)
     {
       // use |mCurrent| to prevent DEBUG_PASS_END assertions
       x->_mNext = position.mCurrent->_mNext;
       x->_mPrev = position.mCurrent;
       position.mCurrent->_mNext->_mPrev = x;
       position.mCurrent->_mNext = x;
       return ++position;
     }
     // returns iterator pointing to after the element
     iterator erase(iterator position)
         // NOTE: leaves dangling next/prev pointers
     {
       position->_mPrev->_mNext = position->_mNext;
       position->_mNext->_mPrev = position->_mPrev;
       return ++position;
     }
     void swap(self_type& y)
     {
       link_type tmp(y.mLink);
       y.mLink = mLink;
       mLink = tmp;
       if (!empty()) {
         mLink._mNext->_mPrev = &mLink;
         mLink._mPrev->_mNext = &mLink;
       }
       if (!y.empty()) {
         y.mLink._mNext->_mPrev = &y.mLink;
         y.mLink._mPrev->_mNext = &y.mLink;
       }
     }
     void clear()
         // NOTE:  leaves dangling next/prev pointers
     {
       mLink._mNext = &mLink;
       mLink._mPrev = &mLink;
     }
     // inserts the conts of x before position and makes x empty
     void splice(iterator position, self_type& x)
     {
       // use |mCurrent| to prevent DEBUG_PASS_END assertions
       position.mCurrent->_mPrev->_mNext = x.mLink._mNext;
       x.mLink._mNext->_mPrev = position.mCurrent->_mPrev;
       x.mLink._mPrev->_mNext = position.mCurrent;
       position.mCurrent->_mPrev = x.mLink._mPrev;
       x.clear();
     }
     // Inserts element *i from list x before position and removes
     // it from x.
     void splice(iterator position, self_type& x, iterator i)
     {
       NS_ASSERTION(!x.empty(), "Can't insert from empty list.");
       NS_ASSERTION(position != i && position.mCurrent != i->_mNext,
                    "We don't check for this case.");
       // remove from |x|
       i->_mPrev->_mNext = i->_mNext;
       i->_mNext->_mPrev = i->_mPrev;
       // use |mCurrent| to prevent DEBUG_PASS_END assertions
       // link into |this|, before-side
       i->_mPrev = position.mCurrent->_mPrev;
       position.mCurrent->_mPrev->_mNext = i.get();
       // link into |this|, after-side
       i->_mNext = position.mCurrent;
       position.mCurrent->_mPrev = i.get();
     }
     // Inserts elements in [|first|, |last|), which are in |x|,
     // into |this| before |position| and removes them from |x|.
     void splice(iterator position, self_type& x, iterator first,
                 iterator last)
     {
       NS_ASSERTION(!x.empty(), "Can't insert from empty list.");
       if (first == last)
         return;
       --last; // so we now want to move [first, last]
       // remove from |x|
       first->_mPrev->_mNext = last->_mNext;
       last->_mNext->_mPrev = first->_mPrev;
       // use |mCurrent| to prevent DEBUG_PASS_END assertions
       // link into |this|, before-side
       first->_mPrev = position.mCurrent->_mPrev;
       position.mCurrent->_mPrev->_mNext = first.get();
       // link into |this|, after-side
       last->_mNext = position.mCurrent;
       position.mCurrent->_mPrev = last.get();
     }
 };
 // Many of these implementations of operator= don't work yet.  I don't
 // know why.
 #ifdef DEBUG
   // NOTE: ASSIGN_FROM is meant to be used *only* as the entire body
   // of a function and therefore lacks PR_{BEGIN,END}_MACRO
 #define ASSIGN_FROM(other_)          \
   mCurrent = other_.mCurrent;        \
   mListLink = other_.mListLink;      \
   return *this;
 #else /* !NS_LINELIST_DEBUG_PASS_END */
 #define ASSIGN_FROM(other_)          \
   mCurrent = other_.mCurrent;        \
   return *this;
 #endif /* !NS_LINELIST_DEBUG_PASS_END */
 inline
 nsLineList_iterator&
 nsLineList_iterator::operator=(const nsLineList_iterator& aOther)
 {
   ASSIGN_FROM(aOther)
 }
 inline
 nsLineList_iterator&
 nsLineList_iterator::operator=(const nsLineList_reverse_iterator& aOther)
 {
   ASSIGN_FROM(aOther)
 }
 inline
 nsLineList_reverse_iterator&
 nsLineList_reverse_iterator::operator=(const nsLineList_iterator& aOther)
 {
   ASSIGN_FROM(aOther)
 }
 inline
 nsLineList_reverse_iterator&
 nsLineList_reverse_iterator::operator=(const nsLineList_reverse_iterator& aOther)
 {
   ASSIGN_FROM(aOther)
 }
 inline
 nsLineList_const_iterator&
 nsLineList_const_iterator::operator=(const nsLineList_iterator& aOther)
 {
   ASSIGN_FROM(aOther)
 }
 inline
 nsLineList_const_iterator&
 nsLineList_const_iterator::operator=(const nsLineList_reverse_iterator& aOther)
 {
   ASSIGN_FROM(aOther)
 }
 inline
 nsLineList_const_iterator&
 nsLineList_const_iterator::operator=(const nsLineList_const_iterator& aOther)
 {
   ASSIGN_FROM(aOther)
 }
 inline
 nsLineList_const_iterator&
 nsLineList_const_iterator::operator=(const nsLineList_const_reverse_iterator& aOther)
 {
   ASSIGN_FROM(aOther)
 }
 inline
 nsLineList_const_reverse_iterator&
 nsLineList_const_reverse_iterator::operator=(const nsLineList_iterator& aOther)
 {
   ASSIGN_FROM(aOther)
 }
 inline
 nsLineList_const_reverse_iterator&
 nsLineList_const_reverse_iterator::operator=(const nsLineList_reverse_iterator& aOther)
 {
   ASSIGN_FROM(aOther)
 }
 inline
 nsLineList_const_reverse_iterator&
 nsLineList_const_reverse_iterator::operator=(const nsLineList_const_iterator& aOther)
 {
   ASSIGN_FROM(aOther)
 }
 inline
 nsLineList_const_reverse_iterator&
 nsLineList_const_reverse_iterator::operator=(const nsLineList_const_reverse_iterator& aOther)
 {
   ASSIGN_FROM(aOther)
 }
 //----------------------------------------------------------------------
 class nsLineIterator MOZ_FINAL : public nsILineIterator
 {
 public:
   nsLineIterator();
   ~nsLineIterator();
   virtual void DisposeLineIterator() MOZ_OVERRIDE;
   virtual int32_t GetNumLines() MOZ_OVERRIDE;
   virtual bool GetDirection() MOZ_OVERRIDE;
   NS_IMETHOD GetLine(int32_t aLineNumber,
                      nsIFrame** aFirstFrameOnLine,
                      int32_t* aNumFramesOnLine,
                      nsRect& aLineBounds,
                      uint32_t* aLineFlags) MOZ_OVERRIDE;
   virtual int32_t FindLineContaining(nsIFrame* aFrame, int32_t aStartLine = 0) MOZ_OVERRIDE;
   NS_IMETHOD FindFrameAt(int32_t aLineNumber,
                          nscoord aX,
                          nsIFrame** aFrameFound,
                          bool* aXIsBeforeFirstFrame,
                          bool* aXIsAfterLastFrame) MOZ_OVERRIDE;
   NS_IMETHOD GetNextSiblingOnLine(nsIFrame*& aFrame, int32_t aLineNumber) MOZ_OVERRIDE;
   NS_IMETHOD CheckLineOrder(int32_t                  aLine,
                             bool                     *aIsReordered,
                             nsIFrame                 **aFirstVisual,
                             nsIFrame                 **aLastVisual) MOZ_OVERRIDE;
   nsresult Init(nsLineList& aLines, bool aRightToLeft);
 private:
   nsLineBox* PrevLine() {
     if (0 == mIndex) {
       return nullptr;
     }
     return mLines[--mIndex];
   }
   nsLineBox* NextLine() {
     if (mIndex >= mNumLines - 1) {
       return nullptr;
     }
     return mLines[++mIndex];
   }
   nsLineBox* LineAt(int32_t aIndex) {
     if ((aIndex < 0) || (aIndex >= mNumLines)) {
       return nullptr;
     }
     return mLines[aIndex];
   }
   nsLineBox** mLines;
   int32_t mIndex;
   int32_t mNumLines;
   bool mRightToLeft;
 };
 #endif /* nsLineBox_h___ */

The Tor Browser / annotate

layout/generic/nsLineBox.h@6474c204b198 (annotated)

layout/generic/nsLineBox.h