The Tor Browser / file revision

 /* -*- 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/. */

 /* rendering object for textual content of elements */

 #include "nsTextFrame.h"

 #include "mozilla/Attributes.h"

 #include "mozilla/DebugOnly.h"

 #include "mozilla/Likely.h"

 #include "mozilla/MathAlgorithms.h"

 #include "mozilla/TextEvents.h"

 #include "nsCOMPtr.h"

 #include "nsBlockFrame.h"

 #include "nsCRT.h"

 #include "nsSplittableFrame.h"

 #include "nsLineLayout.h"

 #include "nsString.h"

 #include "nsUnicharUtils.h"

 #include "nsPresContext.h"

 #include "nsIContent.h"

 #include "nsStyleConsts.h"

 #include "nsStyleContext.h"

 #include "nsStyleStruct.h"

 #include "nsStyleStructInlines.h"

 #include "SVGTextFrame.h"

 #include "nsCoord.h"

 #include "nsRenderingContext.h"

 #include "nsIPresShell.h"

 #include "nsTArray.h"

 #include "nsCSSPseudoElements.h"

 #include "nsCSSFrameConstructor.h"

 #include "nsCompatibility.h"

 #include "nsCSSColorUtils.h"

 #include "nsLayoutUtils.h"

 #include "nsDisplayList.h"

 #include "nsFrame.h"

 #include "nsIMathMLFrame.h"

 #include "nsPlaceholderFrame.h"

 #include "nsTextFrameUtils.h"

 #include "nsTextRunTransformations.h"

 #include "MathMLTextRunFactory.h"

 #include "nsExpirationTracker.h"

 #include "nsUnicodeProperties.h"

 #include "nsTextFragment.h"

 #include "nsGkAtoms.h"

 #include "nsFrameSelection.h"

 #include "nsRange.h"

 #include "nsCSSRendering.h"

 #include "nsContentUtils.h"

 #include "nsLineBreaker.h"

 #include "nsIWordBreaker.h"

 #include "nsGenericDOMDataNode.h"

 #include "nsIFrameInlines.h"

 #include <algorithm>

 #ifdef ACCESSIBILITY

 #include "nsAccessibilityService.h"

 #endif

 #include "nsAutoPtr.h"

 #include "nsPrintfCString.h"

 #include "gfxFont.h"

 #include "gfxContext.h"

 #include "mozilla/dom/Element.h"

 #include "mozilla/LookAndFeel.h"

 #include "GeckoProfiler.h"

 #ifdef DEBUG

 #undef NOISY_REFLOW

 #undef NOISY_TRIM

 #else

 #undef NOISY_REFLOW

 #undef NOISY_TRIM

 #endif

 #ifdef DrawText

 #undef DrawText

 #endif

 using namespace mozilla;

 using namespace mozilla::dom;

 struct TabWidth {

   TabWidth(uint32_t aOffset, uint32_t aWidth)

     : mOffset(aOffset), mWidth(float(aWidth))

   { }

   uint32_t mOffset; // DOM offset relative to the current frame's offset.

   float    mWidth;  // extra space to be added at this position (in app units)

 };

 struct TabWidthStore {

   TabWidthStore(int32_t aValidForContentOffset)

     : mLimit(0)

     , mValidForContentOffset(aValidForContentOffset)

   { }

   // Apply tab widths to the aSpacing array, which corresponds to characters

   // beginning at aOffset and has length aLength. (Width records outside this

   // range will be ignored.)

   void ApplySpacing(gfxTextRun::PropertyProvider::Spacing *aSpacing,

                     uint32_t aOffset, uint32_t aLength);

   // Offset up to which tabs have been measured; positions beyond this have not

   // been calculated yet but may be appended if needed later.  It's a DOM

   // offset relative to the current frame's offset.

   uint32_t mLimit;

   // Need to recalc tab offsets if frame content offset differs from this.

   int32_t mValidForContentOffset;

   // A TabWidth record for each tab character measured so far.

   nsTArray<TabWidth> mWidths;

 };

 void

 TabWidthStore::ApplySpacing(gfxTextRun::PropertyProvider::Spacing *aSpacing,

                             uint32_t aOffset, uint32_t aLength)

 {

   uint32_t i = 0, len = mWidths.Length();

   // If aOffset is non-zero, do a binary search to find where to start

   // processing the tab widths, in case the list is really long. (See bug

   // 953247.)

   // We need to start from the first entry where mOffset >= aOffset.

   if (aOffset > 0) {

     uint32_t lo = 0, hi = len;

     while (lo < hi) {

       i = (lo + hi) / 2;

       const TabWidth& tw = mWidths[i];

       if (tw.mOffset < aOffset) {

         // mWidths[i] precedes the target range; new search range

         // will be [i+1, hi)

         lo = ++i;

         continue;

       }

       if (tw.mOffset > aOffset) {

         // mWidths[i] is within (or beyond) the target range;

         // new search range is [lo, i). If it turns out that

         // mWidths[i] was the first entry within the range,

         // we'll never move hi any further, and end up exiting

         // when i == lo == this value of hi.

         hi = i;

         continue;

       }

       // Found an exact match for aOffset, so end search now

       break;

     }

   }

   uint32_t limit = aOffset + aLength;

   while (i < len) {

     const TabWidth& tw = mWidths[i];

     if (tw.mOffset >= limit) {

       break;

     }

     aSpacing[tw.mOffset - aOffset].mAfter += tw.mWidth;

     i++;

   }

 }

 static void DestroyTabWidth(void* aPropertyValue)

 {

   delete static_cast<TabWidthStore*>(aPropertyValue);

 }

 NS_DECLARE_FRAME_PROPERTY(TabWidthProperty, DestroyTabWidth)

 NS_DECLARE_FRAME_PROPERTY(OffsetToFrameProperty, nullptr)

 // text runs are destroyed by the text run cache

 NS_DECLARE_FRAME_PROPERTY(UninflatedTextRunProperty, nullptr)

 NS_DECLARE_FRAME_PROPERTY(FontSizeInflationProperty, nullptr)

 class GlyphObserver : public gfxFont::GlyphChangeObserver {

 public:

   GlyphObserver(gfxFont* aFont, nsTextFrame* aFrame)

     : gfxFont::GlyphChangeObserver(aFont), mFrame(aFrame) {}

   virtual void NotifyGlyphsChanged() MOZ_OVERRIDE;

 private:

   nsTextFrame* mFrame;

 };

 static void DestroyGlyphObserverList(void* aPropertyValue)

 {

   delete static_cast<nsTArray<nsAutoPtr<GlyphObserver> >*>(aPropertyValue);

 }

 /**

  * This property is set on text frames with TEXT_IN_TEXTRUN_USER_DATA set that

  * have potentially-animated glyphs.

  * The only reason this list is in a property is to automatically destroy the

  * list when the frame is deleted, unregistering the observers.

  */

 NS_DECLARE_FRAME_PROPERTY(TextFrameGlyphObservers, DestroyGlyphObserverList);

 #define TEXT_REFLOW_FLAGS    \

   (TEXT_FIRST_LETTER|TEXT_START_OF_LINE|TEXT_END_OF_LINE|TEXT_HYPHEN_BREAK| \

    TEXT_TRIMMED_TRAILING_WHITESPACE|TEXT_JUSTIFICATION_ENABLED| \

    TEXT_HAS_NONCOLLAPSED_CHARACTERS|TEXT_SELECTION_UNDERLINE_OVERFLOWED)

 #define TEXT_WHITESPACE_FLAGS      (TEXT_IS_ONLY_WHITESPACE | \

                                     TEXT_ISNOT_ONLY_WHITESPACE)

 /*

  * Some general notes

  * 

  * Text frames delegate work to gfxTextRun objects. The gfxTextRun object

  * transforms text to positioned glyphs. It can report the geometry of the

  * glyphs and paint them. Text frames configure gfxTextRuns by providing text,

  * spacing, language, and other information.

  * 

  * A gfxTextRun can cover more than one DOM text node. This is necessary to

  * get kerning, ligatures and shaping for text that spans multiple text nodes

  * but is all the same font. The userdata for a gfxTextRun object is a

  * TextRunUserData* or an nsIFrame*.

  * 

  * We go to considerable effort to make sure things work even if in-flow

  * siblings have different style contexts (i.e., first-letter and first-line).

  * 

  * Our convention is that unsigned integer character offsets are offsets into

  * the transformed string. Signed integer character offsets are offsets into

  * the DOM string.

  * 

  * XXX currently we don't handle hyphenated breaks between text frames where the

  * hyphen occurs at the end of the first text frame, e.g.

  *   <b>Kit&shy;</b>ty

  */

 /**

  * We use an array of these objects to record which text frames

  * are associated with the textrun. mStartFrame is the start of a list of

  * text frames. Some sequence of its continuations are covered by the textrun.

  * A content textnode can have at most one TextRunMappedFlow associated with it

  * for a given textrun.

  * 

  * mDOMOffsetToBeforeTransformOffset is added to DOM offsets for those frames to obtain

  * the offset into the before-transformation text of the textrun. It can be

  * positive (when a text node starts in the middle of a text run) or

  * negative (when a text run starts in the middle of a text node). Of course

  * it can also be zero.

  */

 struct TextRunMappedFlow {

   nsTextFrame* mStartFrame;

   int32_t      mDOMOffsetToBeforeTransformOffset;

   // The text mapped starts at mStartFrame->GetContentOffset() and is this long

   uint32_t     mContentLength;

 };

 /**

  * This is our user data for the textrun, when textRun->GetFlags() does not

  * have TEXT_IS_SIMPLE_FLOW set. When TEXT_IS_SIMPLE_FLOW is set, there is

  * just one flow, the textrun's user data pointer is a pointer to mStartFrame

  * for that flow, mDOMOffsetToBeforeTransformOffset is zero, and mContentLength

  * is the length of the text node.

  */

 struct TextRunUserData {

   TextRunMappedFlow* mMappedFlows;

   uint32_t           mMappedFlowCount;

   uint32_t           mLastFlowIndex;

 };

 /**

  * This helper object computes colors used for painting, and also IME

  * underline information. The data is computed lazily and cached as necessary.

  * These live for just the duration of one paint operation.

  */

 class nsTextPaintStyle {

 public:

   nsTextPaintStyle(nsTextFrame* aFrame);

   void SetResolveColors(bool aResolveColors) {

     NS_ASSERTION(mFrame->IsSVGText() || aResolveColors,

                  "must resolve colors is frame is not for SVG text");

     mResolveColors = aResolveColors;

   }

   nscolor GetTextColor();

   /**

    * Compute the colors for normally-selected text. Returns false if

    * the normal selection is not being displayed.

    */

   bool GetSelectionColors(nscolor* aForeColor,

                             nscolor* aBackColor);

   void GetHighlightColors(nscolor* aForeColor,

                           nscolor* aBackColor);

   void GetURLSecondaryColor(nscolor* aForeColor);

   void GetIMESelectionColors(int32_t  aIndex,

                              nscolor* aForeColor,

                              nscolor* aBackColor);

   // if this returns false, we don't need to draw underline.

   bool GetSelectionUnderlineForPaint(int32_t  aIndex,

                                        nscolor* aLineColor,

                                        float*   aRelativeSize,

                                        uint8_t* aStyle);

   // if this returns false, we don't need to draw underline.

   static bool GetSelectionUnderline(nsPresContext* aPresContext,

                                       int32_t aIndex,

                                       nscolor* aLineColor,

                                       float* aRelativeSize,

                                       uint8_t* aStyle);

   // if this returns false, no text-shadow was specified for the selection

   // and the *aShadow parameter was not modified.

   bool GetSelectionShadow(nsCSSShadowArray** aShadow);

   nsPresContext* PresContext() const { return mPresContext; }

   enum {

     eIndexRawInput = 0,

     eIndexSelRawText,

     eIndexConvText,

     eIndexSelConvText,

     eIndexSpellChecker

   };

   static int32_t GetUnderlineStyleIndexForSelectionType(int32_t aSelectionType)

   {

     switch (aSelectionType) {

       case nsISelectionController::SELECTION_IME_RAWINPUT:

         return eIndexRawInput;

       case nsISelectionController::SELECTION_IME_SELECTEDRAWTEXT:

         return eIndexSelRawText;

       case nsISelectionController::SELECTION_IME_CONVERTEDTEXT:

         return eIndexConvText;

       case nsISelectionController::SELECTION_IME_SELECTEDCONVERTEDTEXT:

         return eIndexSelConvText;

       case nsISelectionController::SELECTION_SPELLCHECK:

         return eIndexSpellChecker;

       default:

         NS_WARNING("non-IME selection type");

         return eIndexRawInput;

     }

   }

 protected:

   nsTextFrame*   mFrame;

   nsPresContext* mPresContext;

   bool           mInitCommonColors;

   bool           mInitSelectionColorsAndShadow;

   bool           mResolveColors;

   // Selection data

   int16_t      mSelectionStatus; // see nsIDocument.h SetDisplaySelection()

   nscolor      mSelectionTextColor;

   nscolor      mSelectionBGColor;

   nsRefPtr<nsCSSShadowArray> mSelectionShadow;

   bool                       mHasSelectionShadow;

   // Common data

   int32_t mSufficientContrast;

   nscolor mFrameBackgroundColor;

   // selection colors and underline info, the colors are resolved colors if

   // mResolveColors is true (which is the default), i.e., the foreground color

   // and background color are swapped if it's needed. And also line color will

   // be resolved from them.

   struct nsSelectionStyle {

     bool    mInit;

     nscolor mTextColor;

     nscolor mBGColor;

     nscolor mUnderlineColor;

     uint8_t mUnderlineStyle;

     float   mUnderlineRelativeSize;

   };

   nsSelectionStyle mSelectionStyle[5];

   // Color initializations

   void InitCommonColors();

   bool InitSelectionColorsAndShadow();

   nsSelectionStyle* GetSelectionStyle(int32_t aIndex);

   void InitSelectionStyle(int32_t aIndex);

   bool EnsureSufficientContrast(nscolor *aForeColor, nscolor *aBackColor);

   nscolor GetResolvedForeColor(nscolor aColor, nscolor aDefaultForeColor,

                                nscolor aBackColor);

 };

 static void

 DestroyUserData(void* aUserData)

 {

   TextRunUserData* userData = static_cast<TextRunUserData*>(aUserData);

   if (userData) {

     nsMemory::Free(userData);

   }

 }

 /**

  * Remove |aTextRun| from the frame continuation chain starting at

  * |aStartContinuation| if non-null, otherwise starting at |aFrame|.

  * Unmark |aFrame| as a text run owner if it's the frame we start at.

  * Return true if |aStartContinuation| is non-null and was found

  * in the next-continuation chain of |aFrame|.

  */

 static bool

 ClearAllTextRunReferences(nsTextFrame* aFrame, gfxTextRun* aTextRun,

                           nsTextFrame* aStartContinuation,

                           nsFrameState aWhichTextRunState)

 {

   NS_PRECONDITION(aFrame, "");

   NS_PRECONDITION(!aStartContinuation ||

                   (!aStartContinuation->GetTextRun(nsTextFrame::eInflated) ||

                    aStartContinuation->GetTextRun(nsTextFrame::eInflated) == aTextRun) ||

                   (!aStartContinuation->GetTextRun(nsTextFrame::eNotInflated) ||

                    aStartContinuation->GetTextRun(nsTextFrame::eNotInflated) == aTextRun),

                   "wrong aStartContinuation for this text run");

   if (!aStartContinuation || aStartContinuation == aFrame) {

     aFrame->RemoveStateBits(aWhichTextRunState);

   } else {

     do {

       NS_ASSERTION(aFrame->GetType() == nsGkAtoms::textFrame, "Bad frame");

       aFrame = static_cast<nsTextFrame*>(aFrame->GetNextContinuation());

     } while (aFrame && aFrame != aStartContinuation);

   }

   bool found = aStartContinuation == aFrame;

   while (aFrame) {

     NS_ASSERTION(aFrame->GetType() == nsGkAtoms::textFrame, "Bad frame");

     if (!aFrame->RemoveTextRun(aTextRun)) {

       break;

     }

     aFrame = static_cast<nsTextFrame*>(aFrame->GetNextContinuation());

   }

   NS_POSTCONDITION(!found || aStartContinuation, "how did we find null?");

   return found;

 }

 /**

  * Kill all references to |aTextRun| starting at |aStartContinuation|.

  * It could be referenced by any of its owners, and all their in-flows.

  * If |aStartContinuation| is null then process all userdata frames

  * and their continuations.

  * @note the caller is expected to take care of possibly destroying the

  * text run if all userdata frames were reset (userdata is deallocated

  * by this function though). The caller can detect this has occured by

  * checking |aTextRun->GetUserData() == nullptr|.

  */

 static void

 UnhookTextRunFromFrames(gfxTextRun* aTextRun, nsTextFrame* aStartContinuation)

 {

   if (!aTextRun->GetUserData())

     return;

   if (aTextRun->GetFlags() & nsTextFrameUtils::TEXT_IS_SIMPLE_FLOW) {

     nsTextFrame* userDataFrame = static_cast<nsTextFrame*>(

       static_cast<nsIFrame*>(aTextRun->GetUserData()));

     nsFrameState whichTextRunState =

       userDataFrame->GetTextRun(nsTextFrame::eInflated) == aTextRun

         ? TEXT_IN_TEXTRUN_USER_DATA

         : TEXT_IN_UNINFLATED_TEXTRUN_USER_DATA;

     DebugOnly<bool> found =

       ClearAllTextRunReferences(userDataFrame, aTextRun,

                                 aStartContinuation, whichTextRunState);

     NS_ASSERTION(!aStartContinuation || found,

                  "aStartContinuation wasn't found in simple flow text run");

     if (!(userDataFrame->GetStateBits() & whichTextRunState)) {

       aTextRun->SetUserData(nullptr);

     }

   } else {

     TextRunUserData* userData =

       static_cast<TextRunUserData*>(aTextRun->GetUserData());

     int32_t destroyFromIndex = aStartContinuation ? -1 : 0;

     for (uint32_t i = 0; i < userData->mMappedFlowCount; ++i) {

       nsTextFrame* userDataFrame = userData->mMappedFlows[i].mStartFrame;

       nsFrameState whichTextRunState =

         userDataFrame->GetTextRun(nsTextFrame::eInflated) == aTextRun

           ? TEXT_IN_TEXTRUN_USER_DATA

           : TEXT_IN_UNINFLATED_TEXTRUN_USER_DATA;

       bool found =

         ClearAllTextRunReferences(userDataFrame, aTextRun,

                                   aStartContinuation, whichTextRunState);

       if (found) {

         if (userDataFrame->GetStateBits() & whichTextRunState) {

           destroyFromIndex = i + 1;

         }

         else {

           destroyFromIndex = i;

         }

         aStartContinuation = nullptr;

       }

     }

     NS_ASSERTION(destroyFromIndex >= 0,

                  "aStartContinuation wasn't found in multi flow text run");

     if (destroyFromIndex == 0) {

       DestroyUserData(userData);

       aTextRun->SetUserData(nullptr);

     }

     else {

       userData->mMappedFlowCount = uint32_t(destroyFromIndex);

       if (userData->mLastFlowIndex >= uint32_t(destroyFromIndex)) {

         userData->mLastFlowIndex = uint32_t(destroyFromIndex) - 1;

       }

     }

   }

 }

 void

 GlyphObserver::NotifyGlyphsChanged()

 {

   nsIPresShell* shell = mFrame->PresContext()->PresShell();

   for (nsIFrame* f = mFrame; f;

        f = nsLayoutUtils::GetNextContinuationOrIBSplitSibling(f)) {

     if (f != mFrame && f->HasAnyStateBits(TEXT_IN_TEXTRUN_USER_DATA)) {

       // f will have its own GlyphObserver (if needed) so we can stop here.

       break;

     }

     f->InvalidateFrame();

     // Theoretically we could just update overflow areas, perhaps using

     // OverflowChangedTracker, but that would do a bunch of work eagerly that

     // we should probably do lazily here since there could be a lot

     // of text frames affected and we'd like to coalesce the work. So that's

     // not easy to do well.

     shell->FrameNeedsReflow(f, nsIPresShell::eResize, NS_FRAME_IS_DIRTY);

   }

 }

 class FrameTextRunCache;

 static FrameTextRunCache *gTextRuns = nullptr;

 /*

  * Cache textruns and expire them after 3*10 seconds of no use.

  */

 class FrameTextRunCache MOZ_FINAL : public nsExpirationTracker<gfxTextRun,3> {

 public:

   enum { TIMEOUT_SECONDS = 10 };

   FrameTextRunCache()

       : nsExpirationTracker<gfxTextRun,3>(TIMEOUT_SECONDS*1000) {}

   ~FrameTextRunCache() {

     AgeAllGenerations();

   }

   void RemoveFromCache(gfxTextRun* aTextRun) {

     if (aTextRun->GetExpirationState()->IsTracked()) {

       RemoveObject(aTextRun);

     }

   }

   // This gets called when the timeout has expired on a gfxTextRun

   virtual void NotifyExpired(gfxTextRun* aTextRun) {

     UnhookTextRunFromFrames(aTextRun, nullptr);

     RemoveFromCache(aTextRun);

     delete aTextRun;

   }

 };

 // Helper to create a textrun and remember it in the textframe cache,

 // for either 8-bit or 16-bit text strings

 template<typename T>

 gfxTextRun *

 MakeTextRun(const T *aText, uint32_t aLength,

             gfxFontGroup *aFontGroup, const gfxFontGroup::Parameters* aParams,

             uint32_t aFlags)

 {

     nsAutoPtr<gfxTextRun> textRun(aFontGroup->MakeTextRun(aText, aLength,

                                                           aParams, aFlags));

     if (!textRun) {

         return nullptr;

     }

     nsresult rv = gTextRuns->AddObject(textRun);

     if (NS_FAILED(rv)) {

         gTextRuns->RemoveFromCache(textRun);

         return nullptr;

     }

 #ifdef NOISY_BIDI

     printf("Created textrun\n");

 #endif

     return textRun.forget();

 }

 void

 nsTextFrameTextRunCache::Init() {

     gTextRuns = new FrameTextRunCache();

 }

 void

 nsTextFrameTextRunCache::Shutdown() {

     delete gTextRuns;

     gTextRuns = nullptr;

 }

 int32_t nsTextFrame::GetContentEnd() const {

   nsTextFrame* next = static_cast<nsTextFrame*>(GetNextContinuation());

   return next ? next->GetContentOffset() : mContent->GetText()->GetLength();

 }

 struct FlowLengthProperty {

   int32_t mStartOffset;

   // The offset of the next fixed continuation after mStartOffset, or

   // of the end of the text if there is none

   int32_t mEndFlowOffset;

 };

 int32_t nsTextFrame::GetInFlowContentLength() {

   if (!(mState & NS_FRAME_IS_BIDI)) {

     return mContent->TextLength() - mContentOffset;

   }

   FlowLengthProperty* flowLength =

     static_cast<FlowLengthProperty*>(mContent->GetProperty(nsGkAtoms::flowlength));

   /**

    * This frame must start inside the cached flow. If the flow starts at

    * mContentOffset but this frame is empty, logically it might be before the

    * start of the cached flow.

    */

   if (flowLength && 

       (flowLength->mStartOffset < mContentOffset ||

        (flowLength->mStartOffset == mContentOffset && GetContentEnd() > mContentOffset)) &&

       flowLength->mEndFlowOffset > mContentOffset) {

 #ifdef DEBUG

     NS_ASSERTION(flowLength->mEndFlowOffset >= GetContentEnd(),

 		 "frame crosses fixed continuation boundary");

 #endif

     return flowLength->mEndFlowOffset - mContentOffset;

   }

   nsTextFrame* nextBidi = static_cast<nsTextFrame*>(LastInFlow()->GetNextContinuation());

   int32_t endFlow = nextBidi ? nextBidi->GetContentOffset() : mContent->TextLength();

   if (!flowLength) {

     flowLength = new FlowLengthProperty;

     if (NS_FAILED(mContent->SetProperty(nsGkAtoms::flowlength, flowLength,

                                         nsINode::DeleteProperty<FlowLengthProperty>))) {

       delete flowLength;

       flowLength = nullptr;

     }

   }

   if (flowLength) {

     flowLength->mStartOffset = mContentOffset;

     flowLength->mEndFlowOffset = endFlow;

   }

   return endFlow - mContentOffset;

 }

 // Smarter versions of dom::IsSpaceCharacter.

 // Unicode is really annoying; sometimes a space character isn't whitespace ---

 // when it combines with another character

 // So we have several versions of IsSpace for use in different contexts.

 static bool IsSpaceCombiningSequenceTail(const nsTextFragment* aFrag, uint32_t aPos)

 {

   NS_ASSERTION(aPos <= aFrag->GetLength(), "Bad offset");

   if (!aFrag->Is2b())

     return false;

   return nsTextFrameUtils::IsSpaceCombiningSequenceTail(

     aFrag->Get2b() + aPos, aFrag->GetLength() - aPos);

 }

 // Check whether aPos is a space for CSS 'word-spacing' purposes

 static bool IsCSSWordSpacingSpace(const nsTextFragment* aFrag,

                                     uint32_t aPos, const nsStyleText* aStyleText)

 {

   NS_ASSERTION(aPos < aFrag->GetLength(), "No text for IsSpace!");

   char16_t ch = aFrag->CharAt(aPos);

   switch (ch) {

   case ' ':

   case CH_NBSP:

     return !IsSpaceCombiningSequenceTail(aFrag, aPos + 1);

   case '\r':

   case '\t': return !aStyleText->WhiteSpaceIsSignificant();

   case '\n': return !aStyleText->NewlineIsSignificant() &&

                     !aStyleText->NewlineIsDiscarded();

   default: return false;

   }

 }

 // Check whether the string aChars/aLength starts with space that's

 // trimmable according to CSS 'white-space:normal/nowrap'. 

 static bool IsTrimmableSpace(const char16_t* aChars, uint32_t aLength)

 {

   NS_ASSERTION(aLength > 0, "No text for IsSpace!");

   char16_t ch = *aChars;

   if (ch == ' ')

     return !nsTextFrameUtils::IsSpaceCombiningSequenceTail(aChars + 1, aLength - 1);

   return ch == '\t' || ch == '\f' || ch == '\n' || ch == '\r';

 }

 // Check whether the character aCh is trimmable according to CSS

 // 'white-space:normal/nowrap'

 static bool IsTrimmableSpace(char aCh)

 {

   return aCh == ' ' || aCh == '\t' || aCh == '\f' || aCh == '\n' || aCh == '\r';

 }

 static bool IsTrimmableSpace(const nsTextFragment* aFrag, uint32_t aPos,

                                const nsStyleText* aStyleText)

 {

   NS_ASSERTION(aPos < aFrag->GetLength(), "No text for IsSpace!");

   switch (aFrag->CharAt(aPos)) {

   case ' ': return !aStyleText->WhiteSpaceIsSignificant() &&

                    !IsSpaceCombiningSequenceTail(aFrag, aPos + 1);

   case '\n': return !aStyleText->NewlineIsSignificant() &&

                     !aStyleText->NewlineIsDiscarded();

   case '\t':

   case '\r':

   case '\f': return !aStyleText->WhiteSpaceIsSignificant();

   default: return false;

   }

 }

 static bool IsSelectionSpace(const nsTextFragment* aFrag, uint32_t aPos)

 {

   NS_ASSERTION(aPos < aFrag->GetLength(), "No text for IsSpace!");

   char16_t ch = aFrag->CharAt(aPos);

   if (ch == ' ' || ch == CH_NBSP)

     return !IsSpaceCombiningSequenceTail(aFrag, aPos + 1);

   return ch == '\t' || ch == '\n' || ch == '\f' || ch == '\r';

 }

 // Count the amount of trimmable whitespace (as per CSS

 // 'white-space:normal/nowrap') in a text fragment. The first

 // character is at offset aStartOffset; the maximum number of characters

 // to check is aLength. aDirection is -1 or 1 depending on whether we should

 // progress backwards or forwards.

 static uint32_t

 GetTrimmableWhitespaceCount(const nsTextFragment* aFrag,

                             int32_t aStartOffset, int32_t aLength,

                             int32_t aDirection)

 {

   int32_t count = 0;

   if (aFrag->Is2b()) {

     const char16_t* str = aFrag->Get2b() + aStartOffset;

     int32_t fragLen = aFrag->GetLength() - aStartOffset;

     for (; count < aLength; ++count) {

       if (!IsTrimmableSpace(str, fragLen))

         break;

       str += aDirection;

       fragLen -= aDirection;

     }

   } else {

     const char* str = aFrag->Get1b() + aStartOffset;

     for (; count < aLength; ++count) {

       if (!IsTrimmableSpace(*str))

         break;

       str += aDirection;

     }

   }

   return count;

 }

 static bool

 IsAllWhitespace(const nsTextFragment* aFrag, bool aAllowNewline)

 {

   if (aFrag->Is2b())

     return false;

   int32_t len = aFrag->GetLength();

   const char* str = aFrag->Get1b();

   for (int32_t i = 0; i < len; ++i) {

     char ch = str[i];

     if (ch == ' ' || ch == '\t' || ch == '\r' || (ch == '\n' && aAllowNewline))

       continue;

     return false;

   }

   return true;

 }

 static bool

 IsAllNewlines(const nsTextFragment* aFrag)

 {

   if (aFrag->Is2b())

     return false;

   int32_t len = aFrag->GetLength();

   const char* str = aFrag->Get1b();

   for (int32_t i = 0; i < len; ++i) {

     char ch = str[i];

     if (ch != '\n')

       return false;

   }

   return true;

 }

 static void

 CreateObserverForAnimatedGlyphs(nsTextFrame* aFrame, const nsTArray<gfxFont*>& aFonts)

 {

   if (!(aFrame->GetStateBits() & TEXT_IN_TEXTRUN_USER_DATA)) {

     // Maybe the textrun was created for uninflated text.

     return;

   }

   nsTArray<nsAutoPtr<GlyphObserver> >* observers =

     new nsTArray<nsAutoPtr<GlyphObserver> >();

   for (uint32_t i = 0, count = aFonts.Length(); i < count; ++i) {

     observers->AppendElement(new GlyphObserver(aFonts[i], aFrame));

   }

   aFrame->Properties().Set(TextFrameGlyphObservers(), observers);

   // We are lazy and don't try to remove a property value that might be

   // obsolete due to style changes or font selection changes. That is

   // likely to be rarely needed, and we don't want to eat the overhead of

   // doing it for the overwhelmingly common case of no property existing.

   // (And we're out of state bits to conveniently use for a fast property

   // existence check.) The only downside is that in some rare cases we might

   // keep fonts alive for longer than necessary, or unnecessarily invalidate

   // frames.

 }

 static void

 CreateObserversForAnimatedGlyphs(gfxTextRun* aTextRun)

 {

   if (!aTextRun->GetUserData()) {

     return;

   }

   nsTArray<gfxFont*> fontsWithAnimatedGlyphs;

   uint32_t numGlyphRuns;

   const gfxTextRun::GlyphRun* glyphRuns =

     aTextRun->GetGlyphRuns(&numGlyphRuns);

   for (uint32_t i = 0; i < numGlyphRuns; ++i) {

     gfxFont* font = glyphRuns[i].mFont;

     if (font->GlyphsMayChange() && !fontsWithAnimatedGlyphs.Contains(font)) {

       fontsWithAnimatedGlyphs.AppendElement(font);

     }

   }

   if (fontsWithAnimatedGlyphs.IsEmpty()) {

     return;

   }

   if (aTextRun->GetFlags() & nsTextFrameUtils::TEXT_IS_SIMPLE_FLOW) {

     CreateObserverForAnimatedGlyphs(static_cast<nsTextFrame*>(

       static_cast<nsIFrame*>(aTextRun->GetUserData())), fontsWithAnimatedGlyphs);

   } else {

     TextRunUserData* userData =

       static_cast<TextRunUserData*>(aTextRun->GetUserData());

     for (uint32_t i = 0; i < userData->mMappedFlowCount; ++i) {

       CreateObserverForAnimatedGlyphs(userData->mMappedFlows[i].mStartFrame,

                                       fontsWithAnimatedGlyphs);

     }

   }

 }

 /**

  * This class accumulates state as we scan a paragraph of text. It detects

  * textrun boundaries (changes from text to non-text, hard

  * line breaks, and font changes) and builds a gfxTextRun at each boundary.

  * It also detects linebreaker run boundaries (changes from text to non-text,

  * and hard line breaks) and at each boundary runs the linebreaker to compute

  * potential line breaks. It also records actual line breaks to store them in

  * the textruns.

  */

 class BuildTextRunsScanner {

 public:

   BuildTextRunsScanner(nsPresContext* aPresContext, gfxContext* aContext,

       nsIFrame* aLineContainer, nsTextFrame::TextRunType aWhichTextRun) :

     mCurrentFramesAllSameTextRun(nullptr),

     mContext(aContext),

     mLineContainer(aLineContainer),

     mBidiEnabled(aPresContext->BidiEnabled()),

     mSkipIncompleteTextRuns(false),

     mWhichTextRun(aWhichTextRun),

     mNextRunContextInfo(nsTextFrameUtils::INCOMING_NONE),

     mCurrentRunContextInfo(nsTextFrameUtils::INCOMING_NONE) {

     ResetRunInfo();

   }

   ~BuildTextRunsScanner() {

     NS_ASSERTION(mBreakSinks.IsEmpty(), "Should have been cleared");

     NS_ASSERTION(mTextRunsToDelete.IsEmpty(), "Should have been cleared");

     NS_ASSERTION(mLineBreakBeforeFrames.IsEmpty(), "Should have been cleared");

     NS_ASSERTION(mMappedFlows.IsEmpty(), "Should have been cleared");

   }

   void SetAtStartOfLine() {

     mStartOfLine = true;

     mCanStopOnThisLine = false;

   }

   void SetSkipIncompleteTextRuns(bool aSkip) {

     mSkipIncompleteTextRuns = aSkip;

   }

   void SetCommonAncestorWithLastFrame(nsIFrame* aFrame) {

     mCommonAncestorWithLastFrame = aFrame;

   }

   bool CanStopOnThisLine() {

     return mCanStopOnThisLine;

   }

   nsIFrame* GetCommonAncestorWithLastFrame() {

     return mCommonAncestorWithLastFrame;

   }

   void LiftCommonAncestorWithLastFrameToParent(nsIFrame* aFrame) {

     if (mCommonAncestorWithLastFrame &&

         mCommonAncestorWithLastFrame->GetParent() == aFrame) {

       mCommonAncestorWithLastFrame = aFrame;

     }

   }

   void ScanFrame(nsIFrame* aFrame);

   bool IsTextRunValidForMappedFlows(gfxTextRun* aTextRun);

   void FlushFrames(bool aFlushLineBreaks, bool aSuppressTrailingBreak);

   void FlushLineBreaks(gfxTextRun* aTrailingTextRun);

   void ResetRunInfo() {

     mLastFrame = nullptr;

     mMappedFlows.Clear();

     mLineBreakBeforeFrames.Clear();

     mMaxTextLength = 0;

     mDoubleByteText = false;

   }

   void AccumulateRunInfo(nsTextFrame* aFrame);

   /**

    * @return null to indicate either textrun construction failed or

    * we constructed just a partial textrun to set up linebreaker and other

    * state for following textruns.

    */

   gfxTextRun* BuildTextRunForFrames(void* aTextBuffer);

   bool SetupLineBreakerContext(gfxTextRun *aTextRun);

   void AssignTextRun(gfxTextRun* aTextRun, float aInflation);

   nsTextFrame* GetNextBreakBeforeFrame(uint32_t* aIndex);

   enum SetupBreakSinksFlags {

     SBS_DOUBLE_BYTE =      (1 << 0),

     SBS_EXISTING_TEXTRUN = (1 << 1),

     SBS_SUPPRESS_SINK    = (1 << 2)

   };

   void SetupBreakSinksForTextRun(gfxTextRun* aTextRun,

                                  const void* aTextPtr,

                                  uint32_t    aFlags);

   struct FindBoundaryState {

     nsIFrame*    mStopAtFrame;

     nsTextFrame* mFirstTextFrame;

     nsTextFrame* mLastTextFrame;

     bool mSeenTextRunBoundaryOnLaterLine;

     bool mSeenTextRunBoundaryOnThisLine;

     bool mSeenSpaceForLineBreakingOnThisLine;

   };

   enum FindBoundaryResult {

     FB_CONTINUE,

     FB_STOPPED_AT_STOP_FRAME,

     FB_FOUND_VALID_TEXTRUN_BOUNDARY

   };

   FindBoundaryResult FindBoundaries(nsIFrame* aFrame, FindBoundaryState* aState);

   bool ContinueTextRunAcrossFrames(nsTextFrame* aFrame1, nsTextFrame* aFrame2);

   // Like TextRunMappedFlow but with some differences. mStartFrame to mEndFrame

   // (exclusive) are a sequence of in-flow frames (if mEndFrame is null, then

   // continuations starting from mStartFrame are a sequence of in-flow frames).

   struct MappedFlow {

     nsTextFrame* mStartFrame;

     nsTextFrame* mEndFrame;

     // When we consider breaking between elements, the nearest common

     // ancestor of the elements containing the characters is the one whose

     // CSS 'white-space' property governs. So this records the nearest common

     // ancestor of mStartFrame and the previous text frame, or null if there

     // was no previous text frame on this line.

     nsIFrame*    mAncestorControllingInitialBreak;

     int32_t GetContentEnd() {

       return mEndFrame ? mEndFrame->GetContentOffset()

           : mStartFrame->GetContent()->GetText()->GetLength();

     }

   };

   class BreakSink MOZ_FINAL : public nsILineBreakSink {

   public:

     BreakSink(gfxTextRun* aTextRun, gfxContext* aContext, uint32_t aOffsetIntoTextRun,

               bool aExistingTextRun) :

                 mTextRun(aTextRun), mContext(aContext),

                 mOffsetIntoTextRun(aOffsetIntoTextRun),

                 mChangedBreaks(false), mExistingTextRun(aExistingTextRun) {}

     virtual void SetBreaks(uint32_t aOffset, uint32_t aLength,

                            uint8_t* aBreakBefore) MOZ_OVERRIDE {

       if (mTextRun->SetPotentialLineBreaks(aOffset + mOffsetIntoTextRun, aLength,

                                            aBreakBefore, mContext)) {

         mChangedBreaks = true;

         // Be conservative and assume that some breaks have been set

         mTextRun->ClearFlagBits(nsTextFrameUtils::TEXT_NO_BREAKS);

       }

     }

     virtual void SetCapitalization(uint32_t aOffset, uint32_t aLength,

                                    bool* aCapitalize) MOZ_OVERRIDE {

       NS_ASSERTION(mTextRun->GetFlags() & nsTextFrameUtils::TEXT_IS_TRANSFORMED,

                    "Text run should be transformed!");

       nsTransformedTextRun* transformedTextRun =

         static_cast<nsTransformedTextRun*>(mTextRun);

       transformedTextRun->SetCapitalization(aOffset + mOffsetIntoTextRun, aLength,

                                             aCapitalize, mContext);

     }

     void Finish() {

       NS_ASSERTION(!(mTextRun->GetFlags() &

                      (gfxTextRunFactory::TEXT_UNUSED_FLAGS |

                       nsTextFrameUtils::TEXT_UNUSED_FLAG)),

                    "Flag set that should never be set! (memory safety error?)");

       if (mTextRun->GetFlags() & nsTextFrameUtils::TEXT_IS_TRANSFORMED) {

         nsTransformedTextRun* transformedTextRun =

           static_cast<nsTransformedTextRun*>(mTextRun);

         transformedTextRun->FinishSettingProperties(mContext);

       }

       // The way nsTransformedTextRun is implemented, its glyph runs aren't

       // available until after nsTransformedTextRun::FinishSettingProperties()

       // is called. So that's why we defer checking for animated glyphs to here.

       CreateObserversForAnimatedGlyphs(mTextRun);

     }

     gfxTextRun*  mTextRun;

     gfxContext*  mContext;

     uint32_t     mOffsetIntoTextRun;

     bool mChangedBreaks;

     bool mExistingTextRun;

   };

 private:

   nsAutoTArray<MappedFlow,10>   mMappedFlows;

   nsAutoTArray<nsTextFrame*,50> mLineBreakBeforeFrames;

   nsAutoTArray<nsAutoPtr<BreakSink>,10> mBreakSinks;

   nsAutoTArray<gfxTextRun*,5>   mTextRunsToDelete;

   nsLineBreaker                 mLineBreaker;

   gfxTextRun*                   mCurrentFramesAllSameTextRun;

   gfxContext*                   mContext;

   nsIFrame*                     mLineContainer;

   nsTextFrame*                  mLastFrame;

   // The common ancestor of the current frame and the previous leaf frame

   // on the line, or null if there was no previous leaf frame.

   nsIFrame*                     mCommonAncestorWithLastFrame;

   // mMaxTextLength is an upper bound on the size of the text in all mapped frames

   // The value UINT32_MAX represents overflow; text will be discarded

   uint32_t                      mMaxTextLength;

   bool                          mDoubleByteText;

   bool                          mBidiEnabled;

   bool                          mStartOfLine;

   bool                          mSkipIncompleteTextRuns;

   bool                          mCanStopOnThisLine;

   nsTextFrame::TextRunType      mWhichTextRun;

   uint8_t                       mNextRunContextInfo;

   uint8_t                       mCurrentRunContextInfo;

 };

 static nsIFrame*

 FindLineContainer(nsIFrame* aFrame)

 {

   while (aFrame && aFrame->CanContinueTextRun()) {

     aFrame = aFrame->GetParent();

   }

   return aFrame;

 }

 static bool

 IsLineBreakingWhiteSpace(char16_t aChar)

 {

   // 0x0A (\n) is not handled as white-space by the line breaker, since

   // we break before it, if it isn't transformed to a normal space.

   // (If we treat it as normal white-space then we'd only break after it.)

   // However, it does induce a line break or is converted to a regular

   // space, and either way it can be used to bound the region of text

   // that needs to be analyzed for line breaking.

   return nsLineBreaker::IsSpace(aChar) || aChar == 0x0A;

 }

 static bool

 TextContainsLineBreakerWhiteSpace(const void* aText, uint32_t aLength,

                                   bool aIsDoubleByte)

 {

   if (aIsDoubleByte) {

     const char16_t* chars = static_cast<const char16_t*>(aText);

     for (uint32_t i = 0; i < aLength; ++i) {

       if (IsLineBreakingWhiteSpace(chars[i]))

         return true;

     }

     return false;

   } else {

     const uint8_t* chars = static_cast<const uint8_t*>(aText);

     for (uint32_t i = 0; i < aLength; ++i) {

       if (IsLineBreakingWhiteSpace(chars[i]))

         return true;

     }

     return false;

   }

 }

 struct FrameTextTraversal {

   // These fields identify which frames should be recursively scanned

   // The first normal frame to scan (or null, if no such frame should be scanned)

   nsIFrame*    mFrameToScan;

   // The first overflow frame to scan (or null, if no such frame should be scanned)

   nsIFrame*    mOverflowFrameToScan;

   // Whether to scan the siblings of mFrameToDescendInto/mOverflowFrameToDescendInto

   bool mScanSiblings;

   // These identify the boundaries of the context required for

   // line breaking or textrun construction

   bool mLineBreakerCanCrossFrameBoundary;

   bool mTextRunCanCrossFrameBoundary;

   nsIFrame* NextFrameToScan() {

     nsIFrame* f;

     if (mFrameToScan) {

       f = mFrameToScan;

       mFrameToScan = mScanSiblings ? f->GetNextSibling() : nullptr;

     } else if (mOverflowFrameToScan) {

       f = mOverflowFrameToScan;

       mOverflowFrameToScan = mScanSiblings ? f->GetNextSibling() : nullptr;

     } else {

       f = nullptr;

     }

     return f;

   }

 };

 static FrameTextTraversal

 CanTextCrossFrameBoundary(nsIFrame* aFrame, nsIAtom* aType)

 {

   NS_ASSERTION(aType == aFrame->GetType(), "Wrong type");

   FrameTextTraversal result;

   bool continuesTextRun = aFrame->CanContinueTextRun();

   if (aType == nsGkAtoms::placeholderFrame) {

     // placeholders are "invisible", so a text run should be able to span

     // across one. But don't descend into the out-of-flow.

     result.mLineBreakerCanCrossFrameBoundary = true;

     result.mOverflowFrameToScan = nullptr;

     if (continuesTextRun) {

       // ... Except for first-letter floats, which are really in-flow

       // from the point of view of capitalization etc, so we'd better

       // descend into them. But we actually need to break the textrun for

       // first-letter floats since things look bad if, say, we try to make a

       // ligature across the float boundary.

       result.mFrameToScan =

         (static_cast<nsPlaceholderFrame*>(aFrame))->GetOutOfFlowFrame();

       result.mScanSiblings = false;

       result.mTextRunCanCrossFrameBoundary = false;

     } else {

       result.mFrameToScan = nullptr;

       result.mTextRunCanCrossFrameBoundary = true;

     }

   } else {

     if (continuesTextRun) {

       result.mFrameToScan = aFrame->GetFirstPrincipalChild();

       result.mOverflowFrameToScan =

         aFrame->GetFirstChild(nsIFrame::kOverflowList);

       NS_WARN_IF_FALSE(!result.mOverflowFrameToScan,

                        "Scanning overflow inline frames is something we should avoid");

       result.mScanSiblings = true;

       result.mTextRunCanCrossFrameBoundary = true;

       result.mLineBreakerCanCrossFrameBoundary = true;

     } else {

       result.mFrameToScan = nullptr;

       result.mOverflowFrameToScan = nullptr;

       result.mTextRunCanCrossFrameBoundary = false;

       result.mLineBreakerCanCrossFrameBoundary = false;

     }

   }    

   return result;

 }

 BuildTextRunsScanner::FindBoundaryResult

 BuildTextRunsScanner::FindBoundaries(nsIFrame* aFrame, FindBoundaryState* aState)

 {

   nsIAtom* frameType = aFrame->GetType();

   nsTextFrame* textFrame = frameType == nsGkAtoms::textFrame

     ? static_cast<nsTextFrame*>(aFrame) : nullptr;

   if (textFrame) {

     if (aState->mLastTextFrame &&

         textFrame != aState->mLastTextFrame->GetNextInFlow() &&

         !ContinueTextRunAcrossFrames(aState->mLastTextFrame, textFrame)) {

       aState->mSeenTextRunBoundaryOnThisLine = true;

       if (aState->mSeenSpaceForLineBreakingOnThisLine)

         return FB_FOUND_VALID_TEXTRUN_BOUNDARY;

     }

     if (!aState->mFirstTextFrame) {

       aState->mFirstTextFrame = textFrame;

     }

     aState->mLastTextFrame = textFrame;

   }

   if (aFrame == aState->mStopAtFrame)

     return FB_STOPPED_AT_STOP_FRAME;

   if (textFrame) {

     if (!aState->mSeenSpaceForLineBreakingOnThisLine) {

       const nsTextFragment* frag = textFrame->GetContent()->GetText();

       uint32_t start = textFrame->GetContentOffset();

       const void* text = frag->Is2b()

           ? static_cast<const void*>(frag->Get2b() + start)

           : static_cast<const void*>(frag->Get1b() + start);

       if (TextContainsLineBreakerWhiteSpace(text, textFrame->GetContentLength(),

                                             frag->Is2b())) {

         aState->mSeenSpaceForLineBreakingOnThisLine = true;

         if (aState->mSeenTextRunBoundaryOnLaterLine)

           return FB_FOUND_VALID_TEXTRUN_BOUNDARY;

       }

     }

     return FB_CONTINUE; 

   }

   FrameTextTraversal traversal =

     CanTextCrossFrameBoundary(aFrame, frameType);

   if (!traversal.mTextRunCanCrossFrameBoundary) {

     aState->mSeenTextRunBoundaryOnThisLine = true;

     if (aState->mSeenSpaceForLineBreakingOnThisLine)

       return FB_FOUND_VALID_TEXTRUN_BOUNDARY;

   }

   for (nsIFrame* f = traversal.NextFrameToScan(); f;

        f = traversal.NextFrameToScan()) {

     FindBoundaryResult result = FindBoundaries(f, aState);

     if (result != FB_CONTINUE)

       return result;

   }

   if (!traversal.mTextRunCanCrossFrameBoundary) {

     aState->mSeenTextRunBoundaryOnThisLine = true;

     if (aState->mSeenSpaceForLineBreakingOnThisLine)

       return FB_FOUND_VALID_TEXTRUN_BOUNDARY;

   }

   return FB_CONTINUE;

 }

 // build text runs for the 200 lines following aForFrame, and stop after that

 // when we get a chance.

 #define NUM_LINES_TO_BUILD_TEXT_RUNS 200

 /**

  * General routine for building text runs. This is hairy because of the need

  * to build text runs that span content nodes.

  * 

  * @param aContext The gfxContext we're using to construct this text run.

  * @param aForFrame The nsTextFrame for which we're building this text run.

  * @param aLineContainer the line container containing aForFrame; if null,

  *        we'll walk the ancestors to find it.  It's required to be non-null

  *        when aForFrameLine is non-null.

  * @param aForFrameLine the line containing aForFrame; if null, we'll figure

  *        out the line (slowly)

  * @param aWhichTextRun The type of text run we want to build. If font inflation

  *        is enabled, this will be eInflated, otherwise it's eNotInflated.

  */

 static void

 BuildTextRuns(gfxContext* aContext, nsTextFrame* aForFrame,

               nsIFrame* aLineContainer,

               const nsLineList::iterator* aForFrameLine,

               nsTextFrame::TextRunType aWhichTextRun)

 {

   NS_ASSERTION(aForFrame || aLineContainer,

                "One of aForFrame or aLineContainer must be set!");

   NS_ASSERTION(!aForFrameLine || aLineContainer,

                "line but no line container");

   nsIFrame* lineContainerChild = aForFrame;

   if (!aLineContainer) {

     if (aForFrame->IsFloatingFirstLetterChild()) {

       lineContainerChild = aForFrame->PresContext()->PresShell()->

         GetPlaceholderFrameFor(aForFrame->GetParent());

     }

     aLineContainer = FindLineContainer(lineContainerChild);

   } else {

     NS_ASSERTION(!aForFrame ||

                  (aLineContainer == FindLineContainer(aForFrame) ||

                   (aLineContainer->GetType() == nsGkAtoms::letterFrame &&

                    aLineContainer->IsFloating())),

                  "Wrong line container hint");

   }

   if (aForFrame) {

     if (aForFrame->HasAnyStateBits(TEXT_IS_IN_TOKEN_MATHML)) {

       aLineContainer->AddStateBits(TEXT_IS_IN_TOKEN_MATHML);

       if (aForFrame->HasAnyStateBits(NS_FRAME_IS_IN_SINGLE_CHAR_MI)) {

         aLineContainer->AddStateBits(NS_FRAME_IS_IN_SINGLE_CHAR_MI);

       }

     }

     if (aForFrame->HasAnyStateBits(NS_FRAME_MATHML_SCRIPT_DESCENDANT)) {

       aLineContainer->AddStateBits(NS_FRAME_MATHML_SCRIPT_DESCENDANT);

     }

   }

   nsPresContext* presContext = aLineContainer->PresContext();

   BuildTextRunsScanner scanner(presContext, aContext, aLineContainer,

                                aWhichTextRun);

   nsBlockFrame* block = nsLayoutUtils::GetAsBlock(aLineContainer);

   if (!block) {

     NS_ASSERTION(!aLineContainer->GetPrevInFlow() && !aLineContainer->GetNextInFlow(),

                  "Breakable non-block line containers not supported");

     // Just loop through all the children of the linecontainer ... it's really

     // just one line

     scanner.SetAtStartOfLine();

     scanner.SetCommonAncestorWithLastFrame(nullptr);

     nsIFrame* child = aLineContainer->GetFirstPrincipalChild();

     while (child) {

       scanner.ScanFrame(child);

       child = child->GetNextSibling();

     }

     // Set mStartOfLine so FlushFrames knows its textrun ends a line

     scanner.SetAtStartOfLine();

     scanner.FlushFrames(true, false);

     return;

   }

   // Find the line containing 'lineContainerChild'.

   bool isValid = true;

   nsBlockInFlowLineIterator backIterator(block, &isValid);

   if (aForFrameLine) {

     backIterator = nsBlockInFlowLineIterator(block, *aForFrameLine);

   } else {

     backIterator = nsBlockInFlowLineIterator(block, lineContainerChild, &isValid);

     NS_ASSERTION(isValid, "aForFrame not found in block, someone lied to us");

     NS_ASSERTION(backIterator.GetContainer() == block,

                  "Someone lied to us about the block");

   }

   nsBlockFrame::line_iterator startLine = backIterator.GetLine();

   // Find a line where we can start building text runs. We choose the last line

   // where:

   // -- there is a textrun boundary between the start of the line and the

   // start of aForFrame

   // -- there is a space between the start of the line and the textrun boundary

   // (this is so we can be sure the line breaks will be set properly

   // on the textruns we construct).

   // The possibly-partial text runs up to and including the first space

   // are not reconstructed. We construct partial text runs for that text ---

   // for the sake of simplifying the code and feeding the linebreaker ---

   // but we discard them instead of assigning them to frames.

   // This is a little awkward because we traverse lines in the reverse direction

   // but we traverse the frames in each line in the forward direction.

   nsBlockInFlowLineIterator forwardIterator = backIterator;

   nsIFrame* stopAtFrame = lineContainerChild;

   nsTextFrame* nextLineFirstTextFrame = nullptr;

   bool seenTextRunBoundaryOnLaterLine = false;

   bool mayBeginInTextRun = true;

   while (true) {

     forwardIterator = backIterator;

     nsBlockFrame::line_iterator line = backIterator.GetLine();

     if (!backIterator.Prev() || backIterator.GetLine()->IsBlock()) {

       mayBeginInTextRun = false;

       break;

     }

     BuildTextRunsScanner::FindBoundaryState state = { stopAtFrame, nullptr, nullptr,

       bool(seenTextRunBoundaryOnLaterLine), false, false };

     nsIFrame* child = line->mFirstChild;

     bool foundBoundary = false;

     for (int32_t i = line->GetChildCount() - 1; i >= 0; --i) {

       BuildTextRunsScanner::FindBoundaryResult result =

           scanner.FindBoundaries(child, &state);

       if (result == BuildTextRunsScanner::FB_FOUND_VALID_TEXTRUN_BOUNDARY) {

         foundBoundary = true;

         break;

       } else if (result == BuildTextRunsScanner::FB_STOPPED_AT_STOP_FRAME) {

         break;

       }

       child = child->GetNextSibling();

     }

     if (foundBoundary)

       break;

     if (!stopAtFrame && state.mLastTextFrame && nextLineFirstTextFrame &&

         !scanner.ContinueTextRunAcrossFrames(state.mLastTextFrame, nextLineFirstTextFrame)) {

       // Found a usable textrun boundary at the end of the line

       if (state.mSeenSpaceForLineBreakingOnThisLine)

         break;

       seenTextRunBoundaryOnLaterLine = true;

     } else if (state.mSeenTextRunBoundaryOnThisLine) {

       seenTextRunBoundaryOnLaterLine = true;

     }

     stopAtFrame = nullptr;

     if (state.mFirstTextFrame) {

       nextLineFirstTextFrame = state.mFirstTextFrame;

     }

   }

   scanner.SetSkipIncompleteTextRuns(mayBeginInTextRun);

   // Now iterate over all text frames starting from the current line. First-in-flow

   // text frames will be accumulated into textRunFrames as we go. When a

   // text run boundary is required we flush textRunFrames ((re)building their

   // gfxTextRuns as necessary).

   bool seenStartLine = false;

   uint32_t linesAfterStartLine = 0;

   do {

     nsBlockFrame::line_iterator line = forwardIterator.GetLine();

     if (line->IsBlock())

       break;

     line->SetInvalidateTextRuns(false);

     scanner.SetAtStartOfLine();

     scanner.SetCommonAncestorWithLastFrame(nullptr);

     nsIFrame* child = line->mFirstChild;

     for (int32_t i = line->GetChildCount() - 1; i >= 0; --i) {

       scanner.ScanFrame(child);

       child = child->GetNextSibling();

     }

     if (line.get() == startLine.get()) {

       seenStartLine = true;

     }

     if (seenStartLine) {

       ++linesAfterStartLine;

       if (linesAfterStartLine >= NUM_LINES_TO_BUILD_TEXT_RUNS && scanner.CanStopOnThisLine()) {

         // Don't flush frames; we may be in the middle of a textrun

         // that we can't end here. That's OK, we just won't build it.

         // Note that we must already have finished the textrun for aForFrame,

         // because we've seen the end of a textrun in a line after the line

         // containing aForFrame.

         scanner.FlushLineBreaks(nullptr);

         // This flushes out mMappedFlows and mLineBreakBeforeFrames, which

         // silences assertions in the scanner destructor.

         scanner.ResetRunInfo();

         return;

       }

     }

   } while (forwardIterator.Next());

   // Set mStartOfLine so FlushFrames knows its textrun ends a line

   scanner.SetAtStartOfLine();

   scanner.FlushFrames(true, false);

 }

 static char16_t*

 ExpandBuffer(char16_t* aDest, uint8_t* aSrc, uint32_t aCount)

 {

   while (aCount) {

     *aDest = *aSrc;

     ++aDest;

     ++aSrc;

     --aCount;

   }

   return aDest;

 }

 bool BuildTextRunsScanner::IsTextRunValidForMappedFlows(gfxTextRun* aTextRun)

 {

   if (aTextRun->GetFlags() & nsTextFrameUtils::TEXT_IS_SIMPLE_FLOW)

     return mMappedFlows.Length() == 1 &&

       mMappedFlows[0].mStartFrame == static_cast<nsTextFrame*>(aTextRun->GetUserData()) &&

       mMappedFlows[0].mEndFrame == nullptr;

   TextRunUserData* userData = static_cast<TextRunUserData*>(aTextRun->GetUserData());

   if (userData->mMappedFlowCount != mMappedFlows.Length())

     return false;

   for (uint32_t i = 0; i < mMappedFlows.Length(); ++i) {

     if (userData->mMappedFlows[i].mStartFrame != mMappedFlows[i].mStartFrame ||

         int32_t(userData->mMappedFlows[i].mContentLength) !=

             mMappedFlows[i].GetContentEnd() - mMappedFlows[i].mStartFrame->GetContentOffset())

       return false;

   }

   return true;

 }

 /**

  * This gets called when we need to make a text run for the current list of

  * frames.

  */

 void BuildTextRunsScanner::FlushFrames(bool aFlushLineBreaks, bool aSuppressTrailingBreak)

 {

   gfxTextRun* textRun = nullptr;

   if (!mMappedFlows.IsEmpty()) {

     if (!mSkipIncompleteTextRuns && mCurrentFramesAllSameTextRun &&

         ((mCurrentFramesAllSameTextRun->GetFlags() & nsTextFrameUtils::TEXT_INCOMING_WHITESPACE) != 0) ==

         ((mCurrentRunContextInfo & nsTextFrameUtils::INCOMING_WHITESPACE) != 0) &&

         ((mCurrentFramesAllSameTextRun->GetFlags() & gfxTextRunFactory::TEXT_INCOMING_ARABICCHAR) != 0) ==

         ((mCurrentRunContextInfo & nsTextFrameUtils::INCOMING_ARABICCHAR) != 0) &&

         IsTextRunValidForMappedFlows(mCurrentFramesAllSameTextRun)) {

       // Optimization: We do not need to (re)build the textrun.

       textRun = mCurrentFramesAllSameTextRun;

       // Feed this run's text into the linebreaker to provide context.

       if (!SetupLineBreakerContext(textRun)) {

         return;

       }

       // Update mNextRunContextInfo appropriately

       mNextRunContextInfo = nsTextFrameUtils::INCOMING_NONE;

       if (textRun->GetFlags() & nsTextFrameUtils::TEXT_TRAILING_WHITESPACE) {

         mNextRunContextInfo |= nsTextFrameUtils::INCOMING_WHITESPACE;

       }

       if (textRun->GetFlags() & gfxTextRunFactory::TEXT_TRAILING_ARABICCHAR) {

         mNextRunContextInfo |= nsTextFrameUtils::INCOMING_ARABICCHAR;

       }

     } else {

       AutoFallibleTArray<uint8_t,BIG_TEXT_NODE_SIZE> buffer;

       uint32_t bufferSize = mMaxTextLength*(mDoubleByteText ? 2 : 1);

       if (bufferSize < mMaxTextLength || bufferSize == UINT32_MAX ||

           !buffer.AppendElements(bufferSize)) {

         return;

       }

       textRun = BuildTextRunForFrames(buffer.Elements());

     }

   }

   if (aFlushLineBreaks) {

     FlushLineBreaks(aSuppressTrailingBreak ? nullptr : textRun);

   }

   mCanStopOnThisLine = true;

   ResetRunInfo();

 }

 void BuildTextRunsScanner::FlushLineBreaks(gfxTextRun* aTrailingTextRun)

 {

   bool trailingLineBreak;

   nsresult rv = mLineBreaker.Reset(&trailingLineBreak);

   // textRun may be null for various reasons, including because we constructed

   // a partial textrun just to get the linebreaker and other state set up

   // to build the next textrun.

   if (NS_SUCCEEDED(rv) && trailingLineBreak && aTrailingTextRun) {

     aTrailingTextRun->SetFlagBits(nsTextFrameUtils::TEXT_HAS_TRAILING_BREAK);

   }

   for (uint32_t i = 0; i < mBreakSinks.Length(); ++i) {

     if (!mBreakSinks[i]->mExistingTextRun || mBreakSinks[i]->mChangedBreaks) {

       // TODO cause frames associated with the textrun to be reflowed, if they

       // aren't being reflowed already!

     }

     mBreakSinks[i]->Finish();

   }

   mBreakSinks.Clear();

   for (uint32_t i = 0; i < mTextRunsToDelete.Length(); ++i) {

     gfxTextRun* deleteTextRun = mTextRunsToDelete[i];

     gTextRuns->RemoveFromCache(deleteTextRun);

     delete deleteTextRun;

   }

   mTextRunsToDelete.Clear();

 }

 void BuildTextRunsScanner::AccumulateRunInfo(nsTextFrame* aFrame)

 {

   if (mMaxTextLength != UINT32_MAX) {

     NS_ASSERTION(mMaxTextLength < UINT32_MAX - aFrame->GetContentLength(), "integer overflow");

     if (mMaxTextLength >= UINT32_MAX - aFrame->GetContentLength()) {

       mMaxTextLength = UINT32_MAX;

     } else {

       mMaxTextLength += aFrame->GetContentLength();

     }

   }

   mDoubleByteText |= aFrame->GetContent()->GetText()->Is2b();

   mLastFrame = aFrame;

   mCommonAncestorWithLastFrame = aFrame->GetParent();

   MappedFlow* mappedFlow = &mMappedFlows[mMappedFlows.Length() - 1];

   NS_ASSERTION(mappedFlow->mStartFrame == aFrame ||

                mappedFlow->GetContentEnd() == aFrame->GetContentOffset(),

                "Overlapping or discontiguous frames => BAD");

   mappedFlow->mEndFrame = static_cast<nsTextFrame*>(aFrame->GetNextContinuation());

   if (mCurrentFramesAllSameTextRun != aFrame->GetTextRun(mWhichTextRun)) {

     mCurrentFramesAllSameTextRun = nullptr;

   }

   if (mStartOfLine) {

     mLineBreakBeforeFrames.AppendElement(aFrame);

     mStartOfLine = false;

   }

 }

 static nscoord StyleToCoord(const nsStyleCoord& aCoord)

 {

   if (eStyleUnit_Coord == aCoord.GetUnit()) {

     return aCoord.GetCoordValue();

   } else {

     return 0;

   }

 }

 static bool

 HasTerminalNewline(const nsTextFrame* aFrame)

 {

   if (aFrame->GetContentLength() == 0)

     return false;

   const nsTextFragment* frag = aFrame->GetContent()->GetText();

   return frag->CharAt(aFrame->GetContentEnd() - 1) == '\n';

 }

 static nscoord

 LetterSpacing(nsIFrame* aFrame, const nsStyleText* aStyleText = nullptr)

 {

   if (aFrame->IsSVGText()) {

     return 0;

   }

   if (!aStyleText) {

     aStyleText = aFrame->StyleText();

   }

   return StyleToCoord(aStyleText->mLetterSpacing);

 }

 static nscoord

 WordSpacing(nsIFrame* aFrame, const nsStyleText* aStyleText = nullptr)

 {

   if (aFrame->IsSVGText()) {

     return 0;

   }

   if (!aStyleText) {

     aStyleText = aFrame->StyleText();

   }

   return aStyleText->mWordSpacing;

 }

 bool

 BuildTextRunsScanner::ContinueTextRunAcrossFrames(nsTextFrame* aFrame1, nsTextFrame* aFrame2)

 {

   // We don't need to check font size inflation, since

   // |FindLineContainer| above (via |nsIFrame::CanContinueTextRun|)

   // ensures that text runs never cross block boundaries.  This means

   // that the font size inflation on all text frames in the text run is

   // already guaranteed to be the same as each other (and for the line

   // container).

   if (mBidiEnabled &&

       (NS_GET_EMBEDDING_LEVEL(aFrame1) != NS_GET_EMBEDDING_LEVEL(aFrame2) ||

        NS_GET_PARAGRAPH_DEPTH(aFrame1) != NS_GET_PARAGRAPH_DEPTH(aFrame2)))

     return false;

   nsStyleContext* sc1 = aFrame1->StyleContext();

   const nsStyleText* textStyle1 = sc1->StyleText();

   // If the first frame ends in a preformatted newline, then we end the textrun

   // here. This avoids creating giant textruns for an entire plain text file.

   // Note that we create a single text frame for a preformatted text node,

   // even if it has newlines in it, so typically we won't see trailing newlines

   // until after reflow has broken up the frame into one (or more) frames per

   // line. That's OK though.

   if (textStyle1->NewlineIsSignificant() && HasTerminalNewline(aFrame1))

     return false;

   if (aFrame1->GetContent() == aFrame2->GetContent() &&

       aFrame1->GetNextInFlow() != aFrame2) {

     // aFrame2 must be a non-fluid continuation of aFrame1. This can happen

     // sometimes when the unicode-bidi property is used; the bidi resolver

     // breaks text into different frames even though the text has the same

     // direction. We can't allow these two frames to share the same textrun

     // because that would violate our invariant that two flows in the same

     // textrun have different content elements.

     return false;

   }

   nsStyleContext* sc2 = aFrame2->StyleContext();

   const nsStyleText* textStyle2 = sc2->StyleText();

   if (sc1 == sc2)

     return true;

   const nsStyleFont* fontStyle1 = sc1->StyleFont();

   const nsStyleFont* fontStyle2 = sc2->StyleFont();

   nscoord letterSpacing1 = LetterSpacing(aFrame1);

   nscoord letterSpacing2 = LetterSpacing(aFrame2);

   return fontStyle1->mFont.BaseEquals(fontStyle2->mFont) &&

     sc1->StyleFont()->mLanguage == sc2->StyleFont()->mLanguage &&

     textStyle1->mTextTransform == textStyle2->mTextTransform &&

     nsLayoutUtils::GetTextRunFlagsForStyle(sc1, fontStyle1, textStyle1, letterSpacing1) ==

       nsLayoutUtils::GetTextRunFlagsForStyle(sc2, fontStyle2, textStyle2, letterSpacing2);

 }

 void BuildTextRunsScanner::ScanFrame(nsIFrame* aFrame)

 {

   // First check if we can extend the current mapped frame block. This is common.

   if (mMappedFlows.Length() > 0) {

     MappedFlow* mappedFlow = &mMappedFlows[mMappedFlows.Length() - 1];

     if (mappedFlow->mEndFrame == aFrame &&

         (aFrame->GetStateBits() & NS_FRAME_IS_FLUID_CONTINUATION)) {

       NS_ASSERTION(aFrame->GetType() == nsGkAtoms::textFrame,

                    "Flow-sibling of a text frame is not a text frame?");

       // Don't do this optimization if mLastFrame has a terminal newline...

       // it's quite likely preformatted and we might want to end the textrun here.

       // This is almost always true:

       if (mLastFrame->StyleContext() == aFrame->StyleContext() &&

           !HasTerminalNewline(mLastFrame)) {

         AccumulateRunInfo(static_cast<nsTextFrame*>(aFrame));

         return;

       }

     }

   }

   nsIAtom* frameType = aFrame->GetType();

   // Now see if we can add a new set of frames to the current textrun

   if (frameType == nsGkAtoms::textFrame) {

     nsTextFrame* frame = static_cast<nsTextFrame*>(aFrame);

     if (mLastFrame) {

       if (!ContinueTextRunAcrossFrames(mLastFrame, frame)) {

         FlushFrames(false, false);

       } else {

         if (mLastFrame->GetContent() == frame->GetContent()) {

           AccumulateRunInfo(frame);

           return;

         }

       }

     }

     MappedFlow* mappedFlow = mMappedFlows.AppendElement();

     if (!mappedFlow)

       return;

     mappedFlow->mStartFrame = frame;

     mappedFlow->mAncestorControllingInitialBreak = mCommonAncestorWithLastFrame;

     AccumulateRunInfo(frame);

     if (mMappedFlows.Length() == 1) {

       mCurrentFramesAllSameTextRun = frame->GetTextRun(mWhichTextRun);

       mCurrentRunContextInfo = mNextRunContextInfo;

     }

     return;

   }

   FrameTextTraversal traversal =

     CanTextCrossFrameBoundary(aFrame, frameType);

   bool isBR = frameType == nsGkAtoms::brFrame;

   if (!traversal.mLineBreakerCanCrossFrameBoundary) {

     // BR frames are special. We do not need or want to record a break opportunity

     // before a BR frame.

     FlushFrames(true, isBR);

     mCommonAncestorWithLastFrame = aFrame;

     mNextRunContextInfo &= ~nsTextFrameUtils::INCOMING_WHITESPACE;

     mStartOfLine = false;

   } else if (!traversal.mTextRunCanCrossFrameBoundary) {

     FlushFrames(false, false);

   }

   for (nsIFrame* f = traversal.NextFrameToScan(); f;

        f = traversal.NextFrameToScan()) {

     ScanFrame(f);

   }

   if (!traversal.mLineBreakerCanCrossFrameBoundary) {

     // Really if we're a BR frame this is unnecessary since descendInto will be

     // false. In fact this whole "if" statement should move into the descendInto.

     FlushFrames(true, isBR);

     mCommonAncestorWithLastFrame = aFrame;

     mNextRunContextInfo &= ~nsTextFrameUtils::INCOMING_WHITESPACE;

   } else if (!traversal.mTextRunCanCrossFrameBoundary) {

     FlushFrames(false, false);

   }

   LiftCommonAncestorWithLastFrameToParent(aFrame->GetParent());

 }

 nsTextFrame*

 BuildTextRunsScanner::GetNextBreakBeforeFrame(uint32_t* aIndex)

 {

   uint32_t index = *aIndex;

   if (index >= mLineBreakBeforeFrames.Length())

     return nullptr;

   *aIndex = index + 1;

   return static_cast<nsTextFrame*>(mLineBreakBeforeFrames.ElementAt(index));

 }

 static uint32_t

 GetSpacingFlags(nscoord spacing)

 {

   return spacing ? gfxTextRunFactory::TEXT_ENABLE_SPACING : 0;

 }

 static gfxFontGroup*

 GetFontGroupForFrame(nsIFrame* aFrame, float aFontSizeInflation,

                      nsFontMetrics** aOutFontMetrics = nullptr)

 {

   if (aOutFontMetrics)

     *aOutFontMetrics = nullptr;

   nsRefPtr<nsFontMetrics> metrics;

   nsLayoutUtils::GetFontMetricsForFrame(aFrame, getter_AddRefs(metrics),

                                         aFontSizeInflation);

   if (!metrics)

     return nullptr;

   if (aOutFontMetrics) {

     *aOutFontMetrics = metrics;

     NS_ADDREF(*aOutFontMetrics);

   }

   // XXX this is a bit bogus, we're releasing 'metrics' so the

   // returned font-group might actually be torn down, although because

   // of the way the device context caches font metrics, this seems to

   // not actually happen. But we should fix this.

   return metrics->GetThebesFontGroup();

 }

 static already_AddRefed<gfxContext>

 CreateReferenceThebesContext(nsTextFrame* aTextFrame)

 {

   nsRefPtr<nsRenderingContext> tmp =

     aTextFrame->PresContext()->PresShell()->CreateReferenceRenderingContext();

   nsRefPtr<gfxContext> ctx = tmp->ThebesContext();

   return ctx.forget();

 }

 /**

  * The returned textrun must be deleted when no longer needed.

  */

 static gfxTextRun*

 GetHyphenTextRun(gfxTextRun* aTextRun, gfxContext* aContext, nsTextFrame* aTextFrame)

 {

   nsRefPtr<gfxContext> ctx = aContext;

   if (!ctx) {

     ctx = CreateReferenceThebesContext(aTextFrame);

   }

   if (!ctx)

     return nullptr;

   return aTextRun->GetFontGroup()->

     MakeHyphenTextRun(ctx, aTextRun->GetAppUnitsPerDevUnit());

 }

 static gfxFont::Metrics

 GetFirstFontMetrics(gfxFontGroup* aFontGroup)

 {

   if (!aFontGroup)

     return gfxFont::Metrics();

   gfxFont* font = aFontGroup->GetFontAt(0);

   if (!font)

     return gfxFont::Metrics();

   return font->GetMetrics();

 }

 PR_STATIC_ASSERT(NS_STYLE_WHITESPACE_NORMAL == 0);

 PR_STATIC_ASSERT(NS_STYLE_WHITESPACE_PRE == 1);

 PR_STATIC_ASSERT(NS_STYLE_WHITESPACE_NOWRAP == 2);

 PR_STATIC_ASSERT(NS_STYLE_WHITESPACE_PRE_WRAP == 3);

 PR_STATIC_ASSERT(NS_STYLE_WHITESPACE_PRE_LINE == 4);

 PR_STATIC_ASSERT(NS_STYLE_WHITESPACE_PRE_DISCARD_NEWLINES == 5);

 static const nsTextFrameUtils::CompressionMode CSSWhitespaceToCompressionMode[] =

 {

   nsTextFrameUtils::COMPRESS_WHITESPACE_NEWLINE, // normal

   nsTextFrameUtils::COMPRESS_NONE,               // pre

   nsTextFrameUtils::COMPRESS_WHITESPACE_NEWLINE, // nowrap

   nsTextFrameUtils::COMPRESS_NONE,               // pre-wrap

   nsTextFrameUtils::COMPRESS_WHITESPACE,         // pre-line

   nsTextFrameUtils::DISCARD_NEWLINE              // -moz-pre-discard-newlines

 };

 gfxTextRun*

 BuildTextRunsScanner::BuildTextRunForFrames(void* aTextBuffer)

 {

   gfxSkipChars skipChars;

   const void* textPtr = aTextBuffer;

   bool anySmallcapsStyle = false;

   bool anyTextTransformStyle = false;

   bool anyMathMLStyling = false;

   uint8_t sstyScriptLevel = 0;

   uint32_t textFlags = nsTextFrameUtils::TEXT_NO_BREAKS;

   if (mCurrentRunContextInfo & nsTextFrameUtils::INCOMING_WHITESPACE) {

     textFlags |= nsTextFrameUtils::TEXT_INCOMING_WHITESPACE;

   }

   if (mCurrentRunContextInfo & nsTextFrameUtils::INCOMING_ARABICCHAR) {

     textFlags |= gfxTextRunFactory::TEXT_INCOMING_ARABICCHAR;

   }

   nsAutoTArray<int32_t,50> textBreakPoints;

   TextRunUserData dummyData;

   TextRunMappedFlow dummyMappedFlow;

   TextRunUserData* userData;

   TextRunUserData* userDataToDestroy;

   // If the situation is particularly simple (and common) we don't need to

   // allocate userData.

   if (mMappedFlows.Length() == 1 && !mMappedFlows[0].mEndFrame &&

       mMappedFlows[0].mStartFrame->GetContentOffset() == 0) {

     userData = &dummyData;

     userDataToDestroy = nullptr;

     dummyData.mMappedFlows = &dummyMappedFlow;

   } else {

     userData = static_cast<TextRunUserData*>

       (nsMemory::Alloc(sizeof(TextRunUserData) + mMappedFlows.Length()*sizeof(TextRunMappedFlow)));

     userDataToDestroy = userData;

     userData->mMappedFlows = reinterpret_cast<TextRunMappedFlow*>(userData + 1);

   }

   userData->mMappedFlowCount = mMappedFlows.Length();

   userData->mLastFlowIndex = 0;

   uint32_t currentTransformedTextOffset = 0;

   uint32_t nextBreakIndex = 0;

   nsTextFrame* nextBreakBeforeFrame = GetNextBreakBeforeFrame(&nextBreakIndex);

   bool enabledJustification = mLineContainer &&

     (mLineContainer->StyleText()->mTextAlign == NS_STYLE_TEXT_ALIGN_JUSTIFY ||

      mLineContainer->StyleText()->mTextAlignLast == NS_STYLE_TEXT_ALIGN_JUSTIFY) &&

     !mLineContainer->IsSVGText();

   // for word-break style

   switch (mLineContainer->StyleText()->mWordBreak) {

     case NS_STYLE_WORDBREAK_BREAK_ALL:

       mLineBreaker.SetWordBreak(nsILineBreaker::kWordBreak_BreakAll);

       break;

     case NS_STYLE_WORDBREAK_KEEP_ALL:

       mLineBreaker.SetWordBreak(nsILineBreaker::kWordBreak_KeepAll);

       break;

     default:

       mLineBreaker.SetWordBreak(nsILineBreaker::kWordBreak_Normal);

       break;

   }

   const nsStyleText* textStyle = nullptr;

   const nsStyleFont* fontStyle = nullptr;

   nsStyleContext* lastStyleContext = nullptr;

   for (uint32_t i = 0; i < mMappedFlows.Length(); ++i) {

     MappedFlow* mappedFlow = &mMappedFlows[i];

     nsTextFrame* f = mappedFlow->mStartFrame;

     lastStyleContext = f->StyleContext();

     // Detect use of text-transform or font-variant anywhere in the run

     textStyle = f->StyleText();

     if (NS_STYLE_TEXT_TRANSFORM_NONE != textStyle->mTextTransform) {

       anyTextTransformStyle = true;

     }

     textFlags |= GetSpacingFlags(LetterSpacing(f));

     textFlags |= GetSpacingFlags(WordSpacing(f));

     nsTextFrameUtils::CompressionMode compression =

       CSSWhitespaceToCompressionMode[textStyle->mWhiteSpace];

     if (enabledJustification && !textStyle->WhiteSpaceIsSignificant()) {

       textFlags |= gfxTextRunFactory::TEXT_ENABLE_SPACING;

     }

     fontStyle = f->StyleFont();

     if (NS_STYLE_FONT_VARIANT_SMALL_CAPS == fontStyle->mFont.variant) {

       anySmallcapsStyle = true;

     }

     if (NS_MATHML_MATHVARIANT_NONE != fontStyle->mMathVariant) {

       anyMathMLStyling = true;

     } else if (mLineContainer->GetStateBits() & NS_FRAME_IS_IN_SINGLE_CHAR_MI) {

       textFlags |= nsTextFrameUtils::TEXT_IS_SINGLE_CHAR_MI;

       anyMathMLStyling = true;

     }

     nsIFrame* parent = mLineContainer->GetParent();

     if (mLineContainer->HasAnyStateBits(TEXT_IS_IN_TOKEN_MATHML)) {

       // All MathML tokens except <mtext> use 'math' script.

       if (!(parent && parent->GetContent() &&

           parent->GetContent()->Tag() == nsGkAtoms::mtext_)) {

         textFlags |= gfxTextRunFactory::TEXT_USE_MATH_SCRIPT;

       }

     }

     nsIFrame* child = mLineContainer;

     uint8_t oldScriptLevel = 0;

     while (parent && 

            child->HasAnyStateBits(NS_FRAME_MATHML_SCRIPT_DESCENDANT)) {

       // Reconstruct the script level ignoring any user overrides. It is

       // calculated this way instead of using scriptlevel to ensure the 

       // correct ssty font feature setting is used even if the user sets a

       // different (especially negative) scriptlevel.

       nsIMathMLFrame* mathFrame= do_QueryFrame(parent);

       if (mathFrame) {

         sstyScriptLevel += mathFrame->ScriptIncrement(child);

       }

       if (sstyScriptLevel < oldScriptLevel) {

         // overflow

         sstyScriptLevel = UINT8_MAX;

         break;

       }

       child = parent;

       parent = parent->GetParent();

       oldScriptLevel = sstyScriptLevel;

     }

     if (sstyScriptLevel) {

       anyMathMLStyling = true;

     }

     // Figure out what content is included in this flow.

     nsIContent* content = f->GetContent();

     const nsTextFragment* frag = content->GetText();

     int32_t contentStart = mappedFlow->mStartFrame->GetContentOffset();

     int32_t contentEnd = mappedFlow->GetContentEnd();

     int32_t contentLength = contentEnd - contentStart;

     TextRunMappedFlow* newFlow = &userData->mMappedFlows[i];

     newFlow->mStartFrame = mappedFlow->mStartFrame;

     newFlow->mDOMOffsetToBeforeTransformOffset = skipChars.GetOriginalCharCount() -

       mappedFlow->mStartFrame->GetContentOffset();

     newFlow->mContentLength = contentLength;

     while (nextBreakBeforeFrame && nextBreakBeforeFrame->GetContent() == content) {

       textBreakPoints.AppendElement(

           nextBreakBeforeFrame->GetContentOffset() + newFlow->mDOMOffsetToBeforeTransformOffset);

       nextBreakBeforeFrame = GetNextBreakBeforeFrame(&nextBreakIndex);

     }

     uint32_t analysisFlags;

     if (frag->Is2b()) {

       NS_ASSERTION(mDoubleByteText, "Wrong buffer char size!");

       char16_t* bufStart = static_cast<char16_t*>(aTextBuffer);

       char16_t* bufEnd = nsTextFrameUtils::TransformText(

           frag->Get2b() + contentStart, contentLength, bufStart,

           compression, &mNextRunContextInfo, &skipChars, &analysisFlags);

       aTextBuffer = bufEnd;

       currentTransformedTextOffset = bufEnd - static_cast<const char16_t*>(textPtr);

     } else {

       if (mDoubleByteText) {

         // Need to expand the text. First transform it into a temporary buffer,

         // then expand.

         AutoFallibleTArray<uint8_t,BIG_TEXT_NODE_SIZE> tempBuf;

         uint8_t* bufStart = tempBuf.AppendElements(contentLength);

         if (!bufStart) {

           DestroyUserData(userDataToDestroy);

           return nullptr;

         }

         uint8_t* end = nsTextFrameUtils::TransformText(

             reinterpret_cast<const uint8_t*>(frag->Get1b()) + contentStart, contentLength,

             bufStart, compression, &mNextRunContextInfo, &skipChars, &analysisFlags);

         aTextBuffer = ExpandBuffer(static_cast<char16_t*>(aTextBuffer),

                                    tempBuf.Elements(), end - tempBuf.Elements());

         currentTransformedTextOffset =

           static_cast<char16_t*>(aTextBuffer) - static_cast<const char16_t*>(textPtr);

       } else {

         uint8_t* bufStart = static_cast<uint8_t*>(aTextBuffer);

         uint8_t* end = nsTextFrameUtils::TransformText(

             reinterpret_cast<const uint8_t*>(frag->Get1b()) + contentStart, contentLength,

             bufStart, compression, &mNextRunContextInfo, &skipChars, &analysisFlags);

         aTextBuffer = end;

         currentTransformedTextOffset = end - static_cast<const uint8_t*>(textPtr);

       }

     }

     textFlags |= analysisFlags;

   }

   void* finalUserData;

   if (userData == &dummyData) {

     textFlags |= nsTextFrameUtils::TEXT_IS_SIMPLE_FLOW;

     userData = nullptr;

     finalUserData = mMappedFlows[0].mStartFrame;

   } else {

     finalUserData = userData;

   }

   uint32_t transformedLength = currentTransformedTextOffset;

   // Now build the textrun

   nsTextFrame* firstFrame = mMappedFlows[0].mStartFrame;

   float fontInflation;

   if (mWhichTextRun == nsTextFrame::eNotInflated) {

     fontInflation = 1.0f;

   } else {

     fontInflation = nsLayoutUtils::FontSizeInflationFor(firstFrame);

   }

   gfxFontGroup* fontGroup = GetFontGroupForFrame(firstFrame, fontInflation);

   if (!fontGroup) {

     DestroyUserData(userDataToDestroy);

     return nullptr;

   }

   if (textFlags & nsTextFrameUtils::TEXT_HAS_TAB) {

     textFlags |= gfxTextRunFactory::TEXT_ENABLE_SPACING;

   }

   if (textFlags & nsTextFrameUtils::TEXT_HAS_SHY) {

     textFlags |= gfxTextRunFactory::TEXT_ENABLE_HYPHEN_BREAKS;

   }

   if (mBidiEnabled && (NS_GET_EMBEDDING_LEVEL(firstFrame) & 1)) {

     textFlags |= gfxTextRunFactory::TEXT_IS_RTL;

   }

   if (mNextRunContextInfo & nsTextFrameUtils::INCOMING_WHITESPACE) {

     textFlags |= nsTextFrameUtils::TEXT_TRAILING_WHITESPACE;

   }

   if (mNextRunContextInfo & nsTextFrameUtils::INCOMING_ARABICCHAR) {

     textFlags |= gfxTextRunFactory::TEXT_TRAILING_ARABICCHAR;

   }

   // ContinueTextRunAcrossFrames guarantees that it doesn't matter which

   // frame's style is used, so we use a mixture of the first frame and

   // last frame's style

   textFlags |= nsLayoutUtils::GetTextRunFlagsForStyle(lastStyleContext,

       fontStyle, textStyle, LetterSpacing(firstFrame, textStyle));

   // XXX this is a bit of a hack. For performance reasons, if we're favouring

   // performance over quality, don't try to get accurate glyph extents.

   if (!(textFlags & gfxTextRunFactory::TEXT_OPTIMIZE_SPEED)) {

     textFlags |= gfxTextRunFactory::TEXT_NEED_BOUNDING_BOX;

   }

   // Convert linebreak coordinates to transformed string offsets

   NS_ASSERTION(nextBreakIndex == mLineBreakBeforeFrames.Length(),

                "Didn't find all the frames to break-before...");

   gfxSkipCharsIterator iter(skipChars);

   nsAutoTArray<uint32_t,50> textBreakPointsAfterTransform;

   for (uint32_t i = 0; i < textBreakPoints.Length(); ++i) {

     nsTextFrameUtils::AppendLineBreakOffset(&textBreakPointsAfterTransform, 

             iter.ConvertOriginalToSkipped(textBreakPoints[i]));

   }

   if (mStartOfLine) {

     nsTextFrameUtils::AppendLineBreakOffset(&textBreakPointsAfterTransform,

                                             transformedLength);

   }

   // Setup factory chain

   nsAutoPtr<nsTransformingTextRunFactory> transformingFactory;

   if (anySmallcapsStyle) {

     transformingFactory = new nsFontVariantTextRunFactory();

   }

   if (anyTextTransformStyle) {

     transformingFactory =

       new nsCaseTransformTextRunFactory(transformingFactory.forget());

   }

   if (anyMathMLStyling) {

     transformingFactory =

       new MathMLTextRunFactory(transformingFactory.forget(), sstyScriptLevel);

   }

   nsTArray<nsStyleContext*> styles;

   if (transformingFactory) {

     iter.SetOriginalOffset(0);

     for (uint32_t i = 0; i < mMappedFlows.Length(); ++i) {

       MappedFlow* mappedFlow = &mMappedFlows[i];

       nsTextFrame* f;

       for (f = mappedFlow->mStartFrame; f != mappedFlow->mEndFrame;

            f = static_cast<nsTextFrame*>(f->GetNextContinuation())) {

         uint32_t offset = iter.GetSkippedOffset();

         iter.AdvanceOriginal(f->GetContentLength());

         uint32_t end = iter.GetSkippedOffset();

         nsStyleContext* sc = f->StyleContext();

         uint32_t j;

         for (j = offset; j < end; ++j) {

           styles.AppendElement(sc);

         }

       }

     }

     textFlags |= nsTextFrameUtils::TEXT_IS_TRANSFORMED;

     NS_ASSERTION(iter.GetSkippedOffset() == transformedLength,

                  "We didn't cover all the characters in the text run!");

   }

   gfxTextRun* textRun;

   gfxTextRunFactory::Parameters params =

       { mContext, finalUserData, &skipChars,

         textBreakPointsAfterTransform.Elements(),

         textBreakPointsAfterTransform.Length(),

         int32_t(firstFrame->PresContext()->AppUnitsPerDevPixel())};

   if (mDoubleByteText) {

     const char16_t* text = static_cast<const char16_t*>(textPtr);

     if (transformingFactory) {

       textRun = transformingFactory->MakeTextRun(text, transformedLength, &params,

                                                  fontGroup, textFlags, styles.Elements());

       if (textRun) {

         // ownership of the factory has passed to the textrun

         transformingFactory.forget();

       }

     } else {

       textRun = MakeTextRun(text, transformedLength, fontGroup, &params, textFlags);

     }

   } else {

     const uint8_t* text = static_cast<const uint8_t*>(textPtr);

     textFlags |= gfxFontGroup::TEXT_IS_8BIT;

     if (transformingFactory) {

       textRun = transformingFactory->MakeTextRun(text, transformedLength, &params,

                                                  fontGroup, textFlags, styles.Elements());

       if (textRun) {

         // ownership of the factory has passed to the textrun

         transformingFactory.forget();

       }

     } else {

       textRun = MakeTextRun(text, transformedLength, fontGroup, &params, textFlags);

     }

   }

   if (!textRun) {

     DestroyUserData(userDataToDestroy);

     return nullptr;

   }

   // We have to set these up after we've created the textrun, because

   // the breaks may be stored in the textrun during this very call.

   // This is a bit annoying because it requires another loop over the frames

   // making up the textrun, but I don't see a way to avoid this.

   uint32_t flags = 0;

   if (mDoubleByteText) {

     flags |= SBS_DOUBLE_BYTE;

   }

   if (mSkipIncompleteTextRuns) {

     flags |= SBS_SUPPRESS_SINK;

   }

   SetupBreakSinksForTextRun(textRun, textPtr, flags);

   if (mSkipIncompleteTextRuns) {

     mSkipIncompleteTextRuns = !TextContainsLineBreakerWhiteSpace(textPtr,

         transformedLength, mDoubleByteText);

     // Arrange for this textrun to be deleted the next time the linebreaker

     // is flushed out

     mTextRunsToDelete.AppendElement(textRun);

     // Since we're doing to destroy the user data now, avoid a dangling

     // pointer. Strictly speaking we don't need to do this since it should

     // not be used (since this textrun will not be used and will be

     // itself deleted soon), but it's always better to not have dangling

     // pointers around.

     textRun->SetUserData(nullptr);

     DestroyUserData(userDataToDestroy);

     return nullptr;

   }

   // Actually wipe out the textruns associated with the mapped frames and associate

   // those frames with this text run.

   AssignTextRun(textRun, fontInflation);

   return textRun;

 }

 // This is a cut-down version of BuildTextRunForFrames used to set up

 // context for the line-breaker, when the textrun has already been created.

 // So it does the same walk over the mMappedFlows, but doesn't actually

 // build a new textrun.

 bool

 BuildTextRunsScanner::SetupLineBreakerContext(gfxTextRun *aTextRun)

 {

   AutoFallibleTArray<uint8_t,BIG_TEXT_NODE_SIZE> buffer;

   uint32_t bufferSize = mMaxTextLength*(mDoubleByteText ? 2 : 1);

   if (bufferSize < mMaxTextLength || bufferSize == UINT32_MAX) {

     return false;

   }

   void *textPtr = buffer.AppendElements(bufferSize);

   if (!textPtr) {

     return false;

   }

   gfxSkipChars skipChars;

   nsAutoTArray<int32_t,50> textBreakPoints;

   TextRunUserData dummyData;

   TextRunMappedFlow dummyMappedFlow;

   TextRunUserData* userData;

   TextRunUserData* userDataToDestroy;

   // If the situation is particularly simple (and common) we don't need to

   // allocate userData.

   if (mMappedFlows.Length() == 1 && !mMappedFlows[0].mEndFrame &&

       mMappedFlows[0].mStartFrame->GetContentOffset() == 0) {

     userData = &dummyData;

     userDataToDestroy = nullptr;

     dummyData.mMappedFlows = &dummyMappedFlow;

   } else {

     userData = static_cast<TextRunUserData*>

       (nsMemory::Alloc(sizeof(TextRunUserData) + mMappedFlows.Length()*sizeof(TextRunMappedFlow)));

     userDataToDestroy = userData;

     userData->mMappedFlows = reinterpret_cast<TextRunMappedFlow*>(userData + 1);

   }

   userData->mMappedFlowCount = mMappedFlows.Length();

   userData->mLastFlowIndex = 0;

   uint32_t nextBreakIndex = 0;

   nsTextFrame* nextBreakBeforeFrame = GetNextBreakBeforeFrame(&nextBreakIndex);

   const nsStyleText* textStyle = nullptr;

   for (uint32_t i = 0; i < mMappedFlows.Length(); ++i) {

     MappedFlow* mappedFlow = &mMappedFlows[i];

     nsTextFrame* f = mappedFlow->mStartFrame;

     textStyle = f->StyleText();

     nsTextFrameUtils::CompressionMode compression =

       CSSWhitespaceToCompressionMode[textStyle->mWhiteSpace];

     // Figure out what content is included in this flow.

     nsIContent* content = f->GetContent();

     const nsTextFragment* frag = content->GetText();

     int32_t contentStart = mappedFlow->mStartFrame->GetContentOffset();

     int32_t contentEnd = mappedFlow->GetContentEnd();

     int32_t contentLength = contentEnd - contentStart;

     TextRunMappedFlow* newFlow = &userData->mMappedFlows[i];

     newFlow->mStartFrame = mappedFlow->mStartFrame;

     newFlow->mDOMOffsetToBeforeTransformOffset = skipChars.GetOriginalCharCount() -

       mappedFlow->mStartFrame->GetContentOffset();

     newFlow->mContentLength = contentLength;

     while (nextBreakBeforeFrame && nextBreakBeforeFrame->GetContent() == content) {

       textBreakPoints.AppendElement(

           nextBreakBeforeFrame->GetContentOffset() + newFlow->mDOMOffsetToBeforeTransformOffset);

       nextBreakBeforeFrame = GetNextBreakBeforeFrame(&nextBreakIndex);

     }

     uint32_t analysisFlags;

     if (frag->Is2b()) {

       NS_ASSERTION(mDoubleByteText, "Wrong buffer char size!");

       char16_t* bufStart = static_cast<char16_t*>(textPtr);

       char16_t* bufEnd = nsTextFrameUtils::TransformText(

           frag->Get2b() + contentStart, contentLength, bufStart,

           compression, &mNextRunContextInfo, &skipChars, &analysisFlags);

       textPtr = bufEnd;

     } else {

       if (mDoubleByteText) {

         // Need to expand the text. First transform it into a temporary buffer,

         // then expand.

         AutoFallibleTArray<uint8_t,BIG_TEXT_NODE_SIZE> tempBuf;

         uint8_t* bufStart = tempBuf.AppendElements(contentLength);

         if (!bufStart) {

           DestroyUserData(userDataToDestroy);

           return false;

         }

         uint8_t* end = nsTextFrameUtils::TransformText(

             reinterpret_cast<const uint8_t*>(frag->Get1b()) + contentStart, contentLength,

             bufStart, compression, &mNextRunContextInfo, &skipChars, &analysisFlags);

         textPtr = ExpandBuffer(static_cast<char16_t*>(textPtr),

                                tempBuf.Elements(), end - tempBuf.Elements());

       } else {

         uint8_t* bufStart = static_cast<uint8_t*>(textPtr);

         uint8_t* end = nsTextFrameUtils::TransformText(

             reinterpret_cast<const uint8_t*>(frag->Get1b()) + contentStart, contentLength,

             bufStart, compression, &mNextRunContextInfo, &skipChars, &analysisFlags);

         textPtr = end;

       }

     }

   }

   // We have to set these up after we've created the textrun, because

   // the breaks may be stored in the textrun during this very call.

   // This is a bit annoying because it requires another loop over the frames

   // making up the textrun, but I don't see a way to avoid this.

   uint32_t flags = 0;

   if (mDoubleByteText) {

     flags |= SBS_DOUBLE_BYTE;

   }

   if (mSkipIncompleteTextRuns) {

     flags |= SBS_SUPPRESS_SINK;

   }

   SetupBreakSinksForTextRun(aTextRun, buffer.Elements(), flags);

   DestroyUserData(userDataToDestroy);

   return true;

 }

 static bool

 HasCompressedLeadingWhitespace(nsTextFrame* aFrame, const nsStyleText* aStyleText,

                                int32_t aContentEndOffset,

                                const gfxSkipCharsIterator& aIterator)

 {

   if (!aIterator.IsOriginalCharSkipped())

     return false;

   gfxSkipCharsIterator iter = aIterator;

   int32_t frameContentOffset = aFrame->GetContentOffset();

   const nsTextFragment* frag = aFrame->GetContent()->GetText();

   while (frameContentOffset < aContentEndOffset && iter.IsOriginalCharSkipped()) {

     if (IsTrimmableSpace(frag, frameContentOffset, aStyleText))

       return true;

     ++frameContentOffset;

     iter.AdvanceOriginal(1);

   }

   return false;

 }

 void

 BuildTextRunsScanner::SetupBreakSinksForTextRun(gfxTextRun* aTextRun,

                                                 const void* aTextPtr,

                                                 uint32_t    aFlags)

 {

   // textruns have uniform language

   const nsStyleFont *styleFont = mMappedFlows[0].mStartFrame->StyleFont();

   // We should only use a language for hyphenation if it was specified

   // explicitly.

   nsIAtom* hyphenationLanguage =

     styleFont->mExplicitLanguage ? styleFont->mLanguage : nullptr;

   // We keep this pointed at the skip-chars data for the current mappedFlow.

   // This lets us cheaply check whether the flow has compressed initial

   // whitespace...

   gfxSkipCharsIterator iter(aTextRun->GetSkipChars());

   for (uint32_t i = 0; i < mMappedFlows.Length(); ++i) {

     MappedFlow* mappedFlow = &mMappedFlows[i];

     uint32_t offset = iter.GetSkippedOffset();

     gfxSkipCharsIterator iterNext = iter;

     iterNext.AdvanceOriginal(mappedFlow->GetContentEnd() -

             mappedFlow->mStartFrame->GetContentOffset());

     nsAutoPtr<BreakSink>* breakSink = mBreakSinks.AppendElement(

       new BreakSink(aTextRun, mContext, offset,

                     (aFlags & SBS_EXISTING_TEXTRUN) != 0));

     if (!breakSink || !*breakSink)

       return;

     uint32_t length = iterNext.GetSkippedOffset() - offset;

     uint32_t flags = 0;

     nsIFrame* initialBreakController = mappedFlow->mAncestorControllingInitialBreak;

     if (!initialBreakController) {

       initialBreakController = mLineContainer;

     }

     if (!initialBreakController->StyleText()->

                                  WhiteSpaceCanWrap(initialBreakController)) {

       flags |= nsLineBreaker::BREAK_SUPPRESS_INITIAL;

     }

     nsTextFrame* startFrame = mappedFlow->mStartFrame;

     const nsStyleText* textStyle = startFrame->StyleText();

     if (!textStyle->WhiteSpaceCanWrap(startFrame)) {

       flags |= nsLineBreaker::BREAK_SUPPRESS_INSIDE;

     }

     if (aTextRun->GetFlags() & nsTextFrameUtils::TEXT_NO_BREAKS) {

       flags |= nsLineBreaker::BREAK_SKIP_SETTING_NO_BREAKS;

     }

     if (textStyle->mTextTransform == NS_STYLE_TEXT_TRANSFORM_CAPITALIZE) {

       flags |= nsLineBreaker::BREAK_NEED_CAPITALIZATION;

     }

     if (textStyle->mHyphens == NS_STYLE_HYPHENS_AUTO) {

       flags |= nsLineBreaker::BREAK_USE_AUTO_HYPHENATION;

     }

     if (HasCompressedLeadingWhitespace(startFrame, textStyle,

                                        mappedFlow->GetContentEnd(), iter)) {

       mLineBreaker.AppendInvisibleWhitespace(flags);

     }

     if (length > 0) {

       BreakSink* sink =

         (aFlags & SBS_SUPPRESS_SINK) ? nullptr : (*breakSink).get();

       if (aFlags & SBS_DOUBLE_BYTE) {

         const char16_t* text = reinterpret_cast<const char16_t*>(aTextPtr);

         mLineBreaker.AppendText(hyphenationLanguage, text + offset,

                                 length, flags, sink);

       } else {

         const uint8_t* text = reinterpret_cast<const uint8_t*>(aTextPtr);

         mLineBreaker.AppendText(hyphenationLanguage, text + offset,

                                 length, flags, sink);

       }

     }

     iter = iterNext;

   }

 }

 // Find the flow corresponding to aContent in aUserData

 static inline TextRunMappedFlow*

 FindFlowForContent(TextRunUserData* aUserData, nsIContent* aContent)

 {

   // Find the flow that contains us

   int32_t i = aUserData->mLastFlowIndex;

   int32_t delta = 1;

   int32_t sign = 1;

   // Search starting at the current position and examine close-by

   // positions first, moving further and further away as we go.

   while (i >= 0 && uint32_t(i) < aUserData->mMappedFlowCount) {

     TextRunMappedFlow* flow = &aUserData->mMappedFlows[i];

     if (flow->mStartFrame->GetContent() == aContent) {

       return flow;

     }

     i += delta;

     sign = -sign;

     delta = -delta + sign;

   }

   // We ran into an array edge.  Add |delta| to |i| once more to get

   // back to the side where we still need to search, then step in

   // the |sign| direction.

   i += delta;

   if (sign > 0) {

     for (; i < int32_t(aUserData->mMappedFlowCount); ++i) {

       TextRunMappedFlow* flow = &aUserData->mMappedFlows[i];

       if (flow->mStartFrame->GetContent() == aContent) {

         return flow;

       }

     }

   } else {

     for (; i >= 0; --i) {

       TextRunMappedFlow* flow = &aUserData->mMappedFlows[i];

       if (flow->mStartFrame->GetContent() == aContent) {

         return flow;

       }

     }

   }

   return nullptr;

 }

 void

 BuildTextRunsScanner::AssignTextRun(gfxTextRun* aTextRun, float aInflation)

 {

   for (uint32_t i = 0; i < mMappedFlows.Length(); ++i) {

     MappedFlow* mappedFlow = &mMappedFlows[i];

     nsTextFrame* startFrame = mappedFlow->mStartFrame;

     nsTextFrame* endFrame = mappedFlow->mEndFrame;

     nsTextFrame* f;

     for (f = startFrame; f != endFrame;

          f = static_cast<nsTextFrame*>(f->GetNextContinuation())) {

 #ifdef DEBUG_roc

       if (f->GetTextRun(mWhichTextRun)) {

         gfxTextRun* textRun = f->GetTextRun(mWhichTextRun);

         if (textRun->GetFlags() & nsTextFrameUtils::TEXT_IS_SIMPLE_FLOW) {

           if (mMappedFlows[0].mStartFrame != static_cast<nsTextFrame*>(textRun->GetUserData())) {

             NS_WARNING("REASSIGNING SIMPLE FLOW TEXT RUN!");

           }

         } else {

           TextRunUserData* userData =

             static_cast<TextRunUserData*>(textRun->GetUserData());

           if (userData->mMappedFlowCount >= mMappedFlows.Length() ||

               userData->mMappedFlows[userData->mMappedFlowCount - 1].mStartFrame !=

               mMappedFlows[userData->mMappedFlowCount - 1].mStartFrame) {

             NS_WARNING("REASSIGNING MULTIFLOW TEXT RUN (not append)!");

           }

         }

       }

 #endif

       gfxTextRun* oldTextRun = f->GetTextRun(mWhichTextRun);

       if (oldTextRun) {

         nsTextFrame* firstFrame = nullptr;

         uint32_t startOffset = 0;

         if (oldTextRun->GetFlags() & nsTextFrameUtils::TEXT_IS_SIMPLE_FLOW) {

           firstFrame = static_cast<nsTextFrame*>(oldTextRun->GetUserData());

         }

         else {

           TextRunUserData* userData = static_cast<TextRunUserData*>(oldTextRun->GetUserData());

           firstFrame = userData->mMappedFlows[0].mStartFrame;

           if (MOZ_UNLIKELY(f != firstFrame)) {

             TextRunMappedFlow* flow = FindFlowForContent(userData, f->GetContent());

             if (flow) {

               startOffset = flow->mDOMOffsetToBeforeTransformOffset;

             }

             else {

               NS_ERROR("Can't find flow containing frame 'f'");

             }

           }

         }

         // Optimization: if |f| is the first frame in the flow then there are no

         // prev-continuations that use |oldTextRun|.

         nsTextFrame* clearFrom = nullptr;

         if (MOZ_UNLIKELY(f != firstFrame)) {

           // If all the frames in the mapped flow starting at |f| (inclusive)

           // are empty then we let the prev-continuations keep the old text run.

           gfxSkipCharsIterator iter(oldTextRun->GetSkipChars(), startOffset, f->GetContentOffset());

           uint32_t textRunOffset = iter.ConvertOriginalToSkipped(f->GetContentOffset());

           clearFrom = textRunOffset == oldTextRun->GetLength() ? f : nullptr;

         }

         f->ClearTextRun(clearFrom, mWhichTextRun);

 #ifdef DEBUG

         if (firstFrame && !firstFrame->GetTextRun(mWhichTextRun)) {

           // oldTextRun was destroyed - assert that we don't reference it.

           for (uint32_t j = 0; j < mBreakSinks.Length(); ++j) {

             NS_ASSERTION(oldTextRun != mBreakSinks[j]->mTextRun,

                          "destroyed text run is still in use");

           }

         }

 #endif

       }

       f->SetTextRun(aTextRun, mWhichTextRun, aInflation);

     }

     // Set this bit now; we can't set it any earlier because

     // f->ClearTextRun() might clear it out.

     nsFrameState whichTextRunState =

       startFrame->GetTextRun(nsTextFrame::eInflated) == aTextRun

         ? TEXT_IN_TEXTRUN_USER_DATA

         : TEXT_IN_UNINFLATED_TEXTRUN_USER_DATA;

     startFrame->AddStateBits(whichTextRunState);

   }

 }

 NS_QUERYFRAME_HEAD(nsTextFrame)

   NS_QUERYFRAME_ENTRY(nsTextFrame)

 NS_QUERYFRAME_TAIL_INHERITING(nsTextFrameBase)

 gfxSkipCharsIterator

 nsTextFrame::EnsureTextRun(TextRunType aWhichTextRun,

                            gfxContext* aReferenceContext,

                            nsIFrame* aLineContainer,

                            const nsLineList::iterator* aLine,

                            uint32_t* aFlowEndInTextRun)

 {

   gfxTextRun *textRun = GetTextRun(aWhichTextRun);

   if (textRun && (!aLine || !(*aLine)->GetInvalidateTextRuns())) {

     if (textRun->GetExpirationState()->IsTracked()) {

       gTextRuns->MarkUsed(textRun);

     }

   } else {

     nsRefPtr<gfxContext> ctx = aReferenceContext;

     if (!ctx) {

       ctx = CreateReferenceThebesContext(this);

     }

     if (ctx) {

       BuildTextRuns(ctx, this, aLineContainer, aLine, aWhichTextRun);

     }

     textRun = GetTextRun(aWhichTextRun);

     if (!textRun) {

       // A text run was not constructed for this frame. This is bad. The caller

       // will check mTextRun.

       static const gfxSkipChars emptySkipChars;

       return gfxSkipCharsIterator(emptySkipChars, 0);

     }

     TabWidthStore* tabWidths =

       static_cast<TabWidthStore*>(Properties().Get(TabWidthProperty()));

     if (tabWidths && tabWidths->mValidForContentOffset != GetContentOffset()) {

       Properties().Delete(TabWidthProperty());

     }

   }

   if (textRun->GetFlags() & nsTextFrameUtils::TEXT_IS_SIMPLE_FLOW) {

     if (aFlowEndInTextRun) {

       *aFlowEndInTextRun = textRun->GetLength();

     }

     return gfxSkipCharsIterator(textRun->GetSkipChars(), 0, mContentOffset);

   }

   TextRunUserData* userData = static_cast<TextRunUserData*>(textRun->GetUserData());

   TextRunMappedFlow* flow = FindFlowForContent(userData, mContent);

   if (flow) {

     // Since textruns can only contain one flow for a given content element,

     // this must be our flow.

     uint32_t flowIndex = flow - userData->mMappedFlows;

     userData->mLastFlowIndex = flowIndex;

     gfxSkipCharsIterator iter(textRun->GetSkipChars(),

                               flow->mDOMOffsetToBeforeTransformOffset, mContentOffset);

     if (aFlowEndInTextRun) {

       if (flowIndex + 1 < userData->mMappedFlowCount) {

         gfxSkipCharsIterator end(textRun->GetSkipChars());

         *aFlowEndInTextRun = end.ConvertOriginalToSkipped(

               flow[1].mStartFrame->GetContentOffset() + flow[1].mDOMOffsetToBeforeTransformOffset);

       } else {

         *aFlowEndInTextRun = textRun->GetLength();

       }

     }

     return iter;

   }

   NS_ERROR("Can't find flow containing this frame???");

   static const gfxSkipChars emptySkipChars;

   return gfxSkipCharsIterator(emptySkipChars, 0);

 }

 static uint32_t

 GetEndOfTrimmedText(const nsTextFragment* aFrag, const nsStyleText* aStyleText,

                     uint32_t aStart, uint32_t aEnd,

                     gfxSkipCharsIterator* aIterator)

 {

   aIterator->SetSkippedOffset(aEnd);

   while (aIterator->GetSkippedOffset() > aStart) {

     aIterator->AdvanceSkipped(-1);

     if (!IsTrimmableSpace(aFrag, aIterator->GetOriginalOffset(), aStyleText))

       return aIterator->GetSkippedOffset() + 1;

   }

   return aStart;

 }

 nsTextFrame::TrimmedOffsets

 nsTextFrame::GetTrimmedOffsets(const nsTextFragment* aFrag,

                                bool aTrimAfter, bool aPostReflow)

 {

   NS_ASSERTION(mTextRun, "Need textrun here");

   if (aPostReflow) {

     // This should not be used during reflow. We need our TEXT_REFLOW_FLAGS

     // to be set correctly.  If our parent wasn't reflowed due to the frame

     // tree being too deep then the return value doesn't matter.

     NS_ASSERTION(!(GetStateBits() & NS_FRAME_FIRST_REFLOW) ||

                  (GetParent()->GetStateBits() &

                   NS_FRAME_TOO_DEEP_IN_FRAME_TREE),

                  "Can only call this on frames that have been reflowed");

     NS_ASSERTION(!(GetStateBits() & NS_FRAME_IN_REFLOW),

                  "Can only call this on frames that are not being reflowed");

   }

   TrimmedOffsets offsets = { GetContentOffset(), GetContentLength() };

   const nsStyleText* textStyle = StyleText();

   // Note that pre-line newlines should still allow us to trim spaces

   // for display

   if (textStyle->WhiteSpaceIsSignificant())

     return offsets;

   if (!aPostReflow || (GetStateBits() & TEXT_START_OF_LINE)) {