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

 // Main header first:

 #include "SVGTextFrame.h"

 // Keep others in (case-insensitive) order:

 #include "DOMSVGPoint.h"

 #include "gfx2DGlue.h"

 #include "gfxFont.h"

 #include "gfxSkipChars.h"

 #include "gfxTypes.h"

 #include "LookAndFeel.h"

 #include "mozilla/gfx/2D.h"

 #include "nsAlgorithm.h"

 #include "nsBlockFrame.h"

 #include "nsCaret.h"

 #include "nsContentUtils.h"

 #include "nsGkAtoms.h"

 #include "nsIDOMSVGLength.h"

 #include "nsISelection.h"

 #include "nsQuickSort.h"

 #include "nsRenderingContext.h"

 #include "nsSVGEffects.h"

 #include "nsSVGOuterSVGFrame.h"

 #include "nsSVGPaintServerFrame.h"

 #include "mozilla/dom/SVGRect.h"

 #include "nsSVGIntegrationUtils.h"

 #include "nsSVGUtils.h"

 #include "nsTArray.h"

 #include "nsTextFrame.h"

 #include "nsTextNode.h"

 #include "SVGAnimatedNumberList.h"

 #include "SVGContentUtils.h"

 #include "SVGLengthList.h"

 #include "SVGNumberList.h"

 #include "SVGPathElement.h"

 #include "SVGTextPathElement.h"

 #include "nsLayoutUtils.h"

 #include <algorithm>

 #include <cmath>

 #include <limits>

 using namespace mozilla;

 using namespace mozilla::dom;

 using namespace mozilla::gfx;

 // ============================================================================

 // Utility functions

 /**

  * Using the specified gfxSkipCharsIterator, converts an offset and length

  * in original char indexes to skipped char indexes.

  *

  * @param aIterator The gfxSkipCharsIterator to use for the conversion.

  * @param aOriginalOffset The original offset (input).

  * @param aOriginalLength The original length (input).

  * @param aSkippedOffset The skipped offset (output).

  * @param aSkippedLength The skipped length (output).

  */

 static void

 ConvertOriginalToSkipped(gfxSkipCharsIterator& aIterator,

                          uint32_t aOriginalOffset, uint32_t aOriginalLength,

                          uint32_t& aSkippedOffset, uint32_t& aSkippedLength)

 {

   aSkippedOffset = aIterator.ConvertOriginalToSkipped(aOriginalOffset);

   aIterator.AdvanceOriginal(aOriginalLength);

   aSkippedLength = aIterator.GetSkippedOffset() - aSkippedOffset;

 }

 /**

  * Using the specified gfxSkipCharsIterator, converts an offset and length

  * in original char indexes to skipped char indexes in place.

  *

  * @param aIterator The gfxSkipCharsIterator to use for the conversion.

  * @param aOriginalOffset The offset to convert from original to skipped.

  * @param aOriginalLength The length to convert from original to skipped.

  */

 static void

 ConvertOriginalToSkipped(gfxSkipCharsIterator& aIterator,

                          uint32_t& aOffset, uint32_t& aLength)

 {

   ConvertOriginalToSkipped(aIterator, aOffset, aLength, aOffset, aLength);

 }

 /**

  * Converts an nsPoint from app units to user space units using the specified

  * nsPresContext and returns it as a gfxPoint.

  */

 static gfxPoint

 AppUnitsToGfxUnits(const nsPoint& aPoint, const nsPresContext* aContext)

 {

   return gfxPoint(aContext->AppUnitsToGfxUnits(aPoint.x),

                   aContext->AppUnitsToGfxUnits(aPoint.y));

 }

 /**

  * Converts a gfxRect that is in app units to CSS pixels using the specified

  * nsPresContext and returns it as a gfxRect.

  */

 static gfxRect

 AppUnitsToFloatCSSPixels(const gfxRect& aRect, const nsPresContext* aContext)

 {

   return gfxRect(aContext->AppUnitsToFloatCSSPixels(aRect.x),

                  aContext->AppUnitsToFloatCSSPixels(aRect.y),

                  aContext->AppUnitsToFloatCSSPixels(aRect.width),

                  aContext->AppUnitsToFloatCSSPixels(aRect.height));

 }

 /**

  * Scales a gfxRect around a given point.

  *

  * @param aRect The rectangle to scale.

  * @param aPoint The point around which to scale.

  * @param aScale The scale amount.

  */

 static void

 ScaleAround(gfxRect& aRect, const gfxPoint& aPoint, double aScale)

 {

   aRect.x = aPoint.x - aScale * (aPoint.x - aRect.x);

   aRect.y = aPoint.y - aScale * (aPoint.y - aRect.y);

   aRect.width *= aScale;

   aRect.height *= aScale;

 }

 /**

  * Returns whether a gfxPoint lies within a gfxRect.

  */

 static bool

 Inside(const gfxRect& aRect, const gfxPoint& aPoint)

 {

   return aPoint.x >= aRect.x &&

          aPoint.x < aRect.XMost() &&

          aPoint.y >= aRect.y &&

          aPoint.y < aRect.YMost();

 }

 /**

  * Gets the measured ascent and descent of the text in the given nsTextFrame

  * in app units.

  *

  * @param aFrame The text frame.

  * @param aAscent The ascent in app units (output).

  * @param aDescent The descent in app units (output).

  */

 static void

 GetAscentAndDescentInAppUnits(nsTextFrame* aFrame,

                               gfxFloat& aAscent, gfxFloat& aDescent)

 {

   gfxSkipCharsIterator it = aFrame->EnsureTextRun(nsTextFrame::eInflated);

   gfxTextRun* textRun = aFrame->GetTextRun(nsTextFrame::eInflated);

   uint32_t offset, length;

   ConvertOriginalToSkipped(it,

                            aFrame->GetContentOffset(),

                            aFrame->GetContentLength(),

                            offset, length);

   gfxTextRun::Metrics metrics =

     textRun->MeasureText(offset, length, gfxFont::LOOSE_INK_EXTENTS, nullptr,

                          nullptr);

   aAscent = metrics.mAscent;

   aDescent = metrics.mDescent;

 }

 /**

  * Updates an interval by intersecting it with another interval.

  * The intervals are specified using a start index and a length.

  */

 static void

 IntersectInterval(uint32_t& aStart, uint32_t& aLength,

                   uint32_t aStartOther, uint32_t aLengthOther)

 {

   uint32_t aEnd = aStart + aLength;

   uint32_t aEndOther = aStartOther + aLengthOther;

   if (aStartOther >= aEnd || aStart >= aEndOther) {

     aLength = 0;

   } else {

     if (aStartOther >= aStart)

       aStart = aStartOther;

     aLength = std::min(aEnd, aEndOther) - aStart;

   }

 }

 /**

  * Intersects an interval as IntersectInterval does but by taking

  * the offset and length of the other interval from a

  * nsTextFrame::TrimmedOffsets object.

  */

 static void

 TrimOffsets(uint32_t& aStart, uint32_t& aLength,

             const nsTextFrame::TrimmedOffsets& aTrimmedOffsets)

 {

   IntersectInterval(aStart, aLength,

                     aTrimmedOffsets.mStart, aTrimmedOffsets.mLength);

 }

 /**

  * Returns the closest ancestor-or-self node that is not an SVG <a>

  * element.

  */

 static nsIContent*

 GetFirstNonAAncestor(nsIContent* aContent)

 {

   while (aContent && aContent->IsSVG(nsGkAtoms::a)) {

     aContent = aContent->GetParent();

   }

   return aContent;

 }

 /**

  * Returns whether the given node is a text content element[1], taking into

  * account whether it has a valid parent.

  *

  * For example, in:

  *

  *   <svg xmlns="http://www.w3.org/2000/svg">

  *     <text><a/><text/></text>

  *     <tspan/>

  *   </svg>

  *

  * true would be returned for the outer <text> element and the <a> element,

  * and false for the inner <text> element (since a <text> is not allowed

  * to be a child of another <text>) and the <tspan> element (because it

  * must be inside a <text> subtree).

  *

  * Note that we don't support the <tref> element yet and this function

  * returns false for it.

  *

  * [1] https://svgwg.org/svg2-draft/intro.html#TermTextContentElement

  */

 static bool

 IsTextContentElement(nsIContent* aContent)

 {

   if (!aContent->IsSVG()) {

     return false;

   }

   if (aContent->Tag() == nsGkAtoms::text) {

     nsIContent* parent = GetFirstNonAAncestor(aContent->GetParent());

     return !parent || !IsTextContentElement(parent);

   }

   if (aContent->Tag() == nsGkAtoms::textPath) {

     nsIContent* parent = GetFirstNonAAncestor(aContent->GetParent());

     return parent && parent->IsSVG(nsGkAtoms::text);

   }

   if (aContent->Tag() == nsGkAtoms::a ||

       aContent->Tag() == nsGkAtoms::tspan ||

       aContent->Tag() == nsGkAtoms::altGlyph) {

     return true;

   }

   return false;

 }

 /**

  * Returns whether the specified frame is an nsTextFrame that has some text

  * content.

  */

 static bool

 IsNonEmptyTextFrame(nsIFrame* aFrame)

 {

   nsTextFrame* textFrame = do_QueryFrame(aFrame);

   if (!textFrame) {

     return false;

   }

   return textFrame->GetContentLength() != 0;

 }

 /**

  * Takes an nsIFrame and if it is a text frame that has some text content,

  * returns it as an nsTextFrame and its corresponding nsTextNode.

  *

  * @param aFrame The frame to look at.

  * @param aTextFrame aFrame as an nsTextFrame (output).

  * @param aTextNode The nsTextNode content of aFrame (output).

  * @return true if aFrame is a non-empty text frame, false otherwise.

  */

 static bool

 GetNonEmptyTextFrameAndNode(nsIFrame* aFrame,

                             nsTextFrame*& aTextFrame,

                             nsTextNode*& aTextNode)

 {

   nsTextFrame* text = do_QueryFrame(aFrame);

   if (!text) {

     return false;

   }

   nsIContent* content = text->GetContent();

   NS_ASSERTION(content && content->IsNodeOfType(nsINode::eTEXT),

                "unexpected content type for nsTextFrame");

   nsTextNode* node = static_cast<nsTextNode*>(content);

   if (node->TextLength() == 0) {

     return false;

   }

   aTextFrame = text;

   aTextNode = node;

   return true;

 }

 /**

  * Returns whether the specified atom is for one of the five

  * glyph positioning attributes that can appear on SVG text

  * elements -- x, y, dx, dy or rotate.

  */

 static bool

 IsGlyphPositioningAttribute(nsIAtom* aAttribute)

 {

   return aAttribute == nsGkAtoms::x ||

          aAttribute == nsGkAtoms::y ||

          aAttribute == nsGkAtoms::dx ||

          aAttribute == nsGkAtoms::dy ||

          aAttribute == nsGkAtoms::rotate;

 }

 /**

  * Returns the position in app units of a given baseline (using an

  * SVG dominant-baseline property value) for a given nsTextFrame.

  *

  * @param aFrame The text frame to inspect.

  * @param aTextRun The text run of aFrame.

  * @param aDominantBaseline The dominant-baseline value to use.

  */

 static nscoord

 GetBaselinePosition(nsTextFrame* aFrame,

                     gfxTextRun* aTextRun,

                     uint8_t aDominantBaseline)

 {

   switch (aDominantBaseline) {

     case NS_STYLE_DOMINANT_BASELINE_HANGING:

     case NS_STYLE_DOMINANT_BASELINE_TEXT_BEFORE_EDGE:

       return 0;

     case NS_STYLE_DOMINANT_BASELINE_USE_SCRIPT:

     case NS_STYLE_DOMINANT_BASELINE_NO_CHANGE:

     case NS_STYLE_DOMINANT_BASELINE_RESET_SIZE:

       // These three should not simply map to 'baseline', but we don't

       // support the complex baseline model that SVG 1.1 has and which

       // css3-linebox now defines.

       // (fall through)

     case NS_STYLE_DOMINANT_BASELINE_AUTO:

     case NS_STYLE_DOMINANT_BASELINE_ALPHABETIC:

       return aFrame->GetBaseline();

   }

   gfxTextRun::Metrics metrics =

     aTextRun->MeasureText(0, aTextRun->GetLength(), gfxFont::LOOSE_INK_EXTENTS,

                           nullptr, nullptr);

   switch (aDominantBaseline) {

     case NS_STYLE_DOMINANT_BASELINE_TEXT_AFTER_EDGE:

     case NS_STYLE_DOMINANT_BASELINE_IDEOGRAPHIC:

       return metrics.mAscent + metrics.mDescent;

     case NS_STYLE_DOMINANT_BASELINE_CENTRAL:

     case NS_STYLE_DOMINANT_BASELINE_MIDDLE:

     case NS_STYLE_DOMINANT_BASELINE_MATHEMATICAL:

       return (metrics.mAscent + metrics.mDescent) / 2.0;

   }

   NS_NOTREACHED("unexpected dominant-baseline value");

   return aFrame->GetBaseline();

 }

 /**

  * For a given text run, returns the number of skipped characters that comprise

  * the ligature group and/or cluster that includes the character represented

  * by the specified gfxSkipCharsIterator.

  *

  * @param aTextRun The text run to use for determining whether a given character

  *   is part of a ligature or cluster.

  * @param aIterator The gfxSkipCharsIterator to use for the current position

  *   in the text run.

  */

 static uint32_t

 ClusterLength(gfxTextRun* aTextRun, const gfxSkipCharsIterator& aIterator)

 {

   uint32_t start = aIterator.GetSkippedOffset();

   uint32_t end = start + 1;

   while (end < aTextRun->GetLength() &&

          (!aTextRun->IsLigatureGroupStart(end) ||

           !aTextRun->IsClusterStart(end))) {

     end++;

   }

   return end - start;

 }

 /**

  * Truncates an array to be at most the length of another array.

  *

  * @param aArrayToTruncate The array to truncate.

  * @param aReferenceArray The array whose length will be used to truncate

  *   aArrayToTruncate to.

  */

 template<typename T, typename U>

 static void

 TruncateTo(nsTArray<T>& aArrayToTruncate, const nsTArray<U>& aReferenceArray)

 {

   uint32_t length = aReferenceArray.Length();

   if (aArrayToTruncate.Length() > length) {

     aArrayToTruncate.TruncateLength(length);

   }

 }

 /**

  * Asserts that the anonymous block child of the SVGTextFrame has been

  * reflowed (or does not exist).  Returns null if the child has not been

  * reflowed, and the frame otherwise.

  *

  * We check whether the kid has been reflowed and not the frame itself

  * since we sometimes need to call this function during reflow, after the

  * kid has been reflowed but before we have cleared the dirty bits on the

  * frame itself.

  */

 static SVGTextFrame*

 FrameIfAnonymousChildReflowed(SVGTextFrame* aFrame)

 {

   NS_PRECONDITION(aFrame, "aFrame must not be null");

   nsIFrame* kid = aFrame->GetFirstPrincipalChild();

   if (NS_SUBTREE_DIRTY(kid)) {

     MOZ_ASSERT(false, "should have already reflowed the anonymous block child");

     return nullptr;

   }

   return aFrame;

 }

 static double

 GetContextScale(const gfxMatrix& aMatrix)

 {

   // The context scale is the ratio of the length of the transformed

   // diagonal vector (1,1) to the length of the untransformed diagonal

   // (which is sqrt(2)).

   gfxPoint p = aMatrix.Transform(gfxPoint(1, 1)) -

                aMatrix.Transform(gfxPoint(0, 0));

   return SVGContentUtils::ComputeNormalizedHypotenuse(p.x, p.y);

 }

 // ============================================================================

 // Utility classes

 namespace mozilla {

 // ----------------------------------------------------------------------------

 // TextRenderedRun

 /**

  * A run of text within a single nsTextFrame whose glyphs can all be painted

  * with a single call to nsTextFrame::PaintText.  A text rendered run can

  * be created for a sequence of two or more consecutive glyphs as long as:

  *

  *   - Only the first glyph has (or none of the glyphs have) been positioned

  *     with SVG text positioning attributes

  *   - All of the glyphs have zero rotation

  *   - The glyphs are not on a text path

  *   - The glyphs correspond to content within the one nsTextFrame

  *

  * A TextRenderedRunIterator produces TextRenderedRuns required for painting a

  * whole SVGTextFrame.

  */

 struct TextRenderedRun

 {

   /**

    * Constructs a TextRenderedRun that is uninitialized except for mFrame

    * being null.

    */

   TextRenderedRun()

     : mFrame(nullptr)

   {

   }

   /**

    * Constructs a TextRenderedRun with all of the information required to

    * paint it.  See the comments documenting the member variables below

    * for descriptions of the arguments.

    */

   TextRenderedRun(nsTextFrame* aFrame, const gfxPoint& aPosition,

                   float aLengthAdjustScaleFactor, double aRotate,

                   float aFontSizeScaleFactor, nscoord aBaseline,

                   uint32_t aTextFrameContentOffset,

                   uint32_t aTextFrameContentLength,

                   uint32_t aTextElementCharIndex)

     : mFrame(aFrame),

       mPosition(aPosition),

       mLengthAdjustScaleFactor(aLengthAdjustScaleFactor),

       mRotate(static_cast<float>(aRotate)),

       mFontSizeScaleFactor(aFontSizeScaleFactor),

       mBaseline(aBaseline),

       mTextFrameContentOffset(aTextFrameContentOffset),

       mTextFrameContentLength(aTextFrameContentLength),

       mTextElementCharIndex(aTextElementCharIndex)

   {

   }

   /**

    * Returns the text run for the text frame that this rendered run is part of.

    */

   gfxTextRun* GetTextRun() const

   {

     mFrame->EnsureTextRun(nsTextFrame::eInflated);

     return mFrame->GetTextRun(nsTextFrame::eInflated);

   }

   /**

    * Returns whether this rendered run is RTL.

    */

   bool IsRightToLeft() const

   {

     return GetTextRun()->IsRightToLeft();

   }

   /**

    * Returns the transform that converts from a <text> element's user space into

    * the coordinate space that rendered runs can be painted directly in.

    *

    * The difference between this method and GetTransformFromRunUserSpaceToUserSpace

    * is that when calling in to nsTextFrame::PaintText, it will already take

    * into account any left clip edge (that is, it doesn't just apply a visual

    * clip to the rendered text, it shifts the glyphs over so that they are

    * painted with their left edge at the x coordinate passed in to it).

    * Thus we need to account for this in our transform.

    *

    *

    * Assume that we have <text x="100" y="100" rotate="0 0 1 0 0 1">abcdef</text>.

    * This would result in four text rendered runs:

    *

    *   - one for "ab"

    *   - one for "c"

    *   - one for "de"

    *   - one for "f"

    *

    * Assume now that we are painting the third TextRenderedRun.  It will have

    * a left clip edge that is the sum of the advances of "abc", and it will

    * have a right clip edge that is the advance of "f".  In

    * SVGTextFrame::PaintSVG(), we pass in nsPoint() (i.e., the origin)

    * as the point at which to paint the text frame, and we pass in the

    * clip edge values.  The nsTextFrame will paint the substring of its

    * text such that the top-left corner of the "d"'s glyph cell will be at

    * (0, 0) in the current coordinate system.

    *

    * Thus, GetTransformFromUserSpaceForPainting must return a transform from

    * whatever user space the <text> element is in to a coordinate space in

    * device pixels (as that's what nsTextFrame works in) where the origin is at

    * the same position as our user space mPositions[i].mPosition value for

    * the "d" glyph, which will be (100 + userSpaceAdvance("abc"), 100).

    * The translation required to do this (ignoring the scale to get from

    * user space to device pixels, and ignoring the

    * (100 + userSpaceAdvance("abc"), 100) translation) is:

    *

    *   (-leftEdge, -baseline)

    *

    * where baseline is the distance between the baseline of the text and the top

    * edge of the nsTextFrame.  We translate by -leftEdge horizontally because

    * the nsTextFrame will already shift the glyphs over by that amount and start

    * painting glyphs at x = 0.  We translate by -baseline vertically so that

    * painting the top edges of the glyphs at y = 0 will result in their

    * baselines being at our desired y position.

    *

    *

    * Now for an example with RTL text.  Assume our content is now

    * <text x="100" y="100" rotate="0 0 1 0 0 1">WERBEH</text>.  We'd have

    * the following text rendered runs:

    *

    *   - one for "EH"

    *   - one for "B"

    *   - one for "ER"

    *   - one for "W"

    *

    * Again, we are painting the third TextRenderedRun.  The left clip edge

    * is the advance of the "W" and the right clip edge is the sum of the

    * advances of "BEH".  Our translation to get the rendered "ER" glyphs

    * in the right place this time is:

    *

    *   (-frameWidth + rightEdge, -baseline)

    *

    * which is equivalent to:

    *

    *   (-(leftEdge + advance("ER")), -baseline)

    *

    * The reason we have to shift left additionally by the width of the run

    * of glyphs we are painting is that although the nsTextFrame is RTL,

    * we still supply the top-left corner to paint the frame at when calling

    * nsTextFrame::PaintText, even though our user space positions for each

    * glyph in mPositions specifies the origin of each glyph, which for RTL

    * glyphs is at the right edge of the glyph cell.

    *

    *

    * For any other use of an nsTextFrame in the context of a particular run

    * (such as hit testing, or getting its rectangle),

    * GetTransformFromRunUserSpaceToUserSpace should be used.

    *

    * @param aContext The context to use for unit conversions.

    * @param aItem The nsCharClipDisplayItem that holds the amount of clipping

    *   from the left and right edges of the text frame for this rendered run.

    *   An appropriate nsCharClipDisplayItem can be obtained by constructing an

    *   SVGCharClipDisplayItem for the TextRenderedRun.

    */

   gfxMatrix GetTransformFromUserSpaceForPainting(

                                       nsPresContext* aContext,

                                       const nsCharClipDisplayItem& aItem) const;

   /**

    * Returns the transform that converts from "run user space" to a <text>

    * element's user space.  Run user space is a coordinate system that has the

    * same size as the <text>'s user space but rotated and translated such that

    * (0,0) is the top-left of the rectangle that bounds the text.

    *

    * @param aContext The context to use for unit conversions.

    */

   gfxMatrix GetTransformFromRunUserSpaceToUserSpace(nsPresContext* aContext) const;

   /**

    * Returns the transform that converts from "run user space" to float pixels

    * relative to the nsTextFrame that this rendered run is a part of.

    *

    * @param aContext The context to use for unit conversions.

    */

   gfxMatrix GetTransformFromRunUserSpaceToFrameUserSpace(nsPresContext* aContext) const;

   /**

    * Flag values used for the aFlags arguments of GetRunUserSpaceRect,

    * GetFrameUserSpaceRect and GetUserSpaceRect.

    */

   enum {

     // Includes the fill geometry of the text in the returned rectangle.

     eIncludeFill = 1,

     // Includes the stroke geometry of the text in the returned rectangle.

     eIncludeStroke = 2,

     // Includes any text shadow in the returned rectangle.

     eIncludeTextShadow = 4,

     // Don't include any horizontal glyph overflow in the returned rectangle.

     eNoHorizontalOverflow = 8

   };

   /**

    * Returns a rectangle that bounds the fill and/or stroke of the rendered run

    * in run user space.

    *

    * @param aContext The context to use for unit conversions.

    * @param aFlags A combination of the flags above (eIncludeFill and

    *   eIncludeStroke) indicating what parts of the text to include in

    *   the rectangle.

    */

   SVGBBox GetRunUserSpaceRect(nsPresContext* aContext, uint32_t aFlags) const;

   /**

    * Returns a rectangle that covers the fill and/or stroke of the rendered run

    * in "frame user space".

    *

    * Frame user space is a coordinate space of the same scale as the <text>

    * element's user space, but with its rotation set to the rotation of

    * the glyphs within this rendered run and its origin set to the position

    * such that placing the nsTextFrame there would result in the glyphs in

    * this rendered run being at their correct positions.

    *

    * For example, say we have <text x="100 150" y="100">ab</text>.  Assume

    * the advance of both the "a" and the "b" is 12 user units, and the

    * ascent of the text is 8 user units and its descent is 6 user units,

    * and that we are not measuing the stroke of the text, so that we stay

    * entirely within the glyph cells.

    *

    * There will be two text rendered runs, one for "a" and one for "b".

    *

    * The frame user space for the "a" run will have its origin at

    * (100, 100 - 8) in the <text> element's user space and will have its

    * axes aligned with the user space (since there is no rotate="" or

    * text path involve) and with its scale the same as the user space.

    * The rect returned by this method will be (0, 0, 12, 14), since the "a"

    * glyph is right at the left of the nsTextFrame.

    *

    * The frame user space for the "b" run will have its origin at

    * (150 - 12, 100 - 8), and scale/rotation the same as above.  The rect

    * returned by this method will be (12, 0, 12, 14), since we are

    * advance("a") horizontally in to the text frame.

    *

    * @param aContext The context to use for unit conversions.

    * @param aFlags A combination of the flags above (eIncludeFill and

    *   eIncludeStroke) indicating what parts of the text to include in

    *   the rectangle.

    */

   SVGBBox GetFrameUserSpaceRect(nsPresContext* aContext, uint32_t aFlags) const;

   /**

    * Returns a rectangle that covers the fill and/or stroke of the rendered run

    * in the <text> element's user space.

    *

    * @param aContext The context to use for unit conversions.

    * @param aFlags A combination of the flags above indicating what parts of the

    *   text to include in the rectangle.

    * @param aAdditionalTransform An additional transform to apply to the

    *   frame user space rectangle before its bounds are transformed into

    *   user space.

    */

   SVGBBox GetUserSpaceRect(nsPresContext* aContext, uint32_t aFlags,

                            const gfxMatrix* aAdditionalTransform = nullptr) const;

   /**

    * Gets the app unit amounts to clip from the left and right edges of

    * the nsTextFrame in order to paint just this rendered run.

    *

    * Note that if clip edge amounts land in the middle of a glyph, the

    * glyph won't be painted at all.  The clip edges are thus more of

    * a selection mechanism for which glyphs will be painted, rather

    * than a geometric clip.

    */

   void GetClipEdges(nscoord& aLeftEdge, nscoord& aRightEdge) const;

   /**

    * Returns the advance width of the whole rendered run.

    */

   nscoord GetAdvanceWidth() const;

   /**

    * Returns the index of the character into this rendered run whose

    * glyph cell contains the given point, or -1 if there is no such

    * character.  This does not hit test against any overflow.

    *

    * @param aContext The context to use for unit conversions.

    * @param aPoint The point in the user space of the <text> element.

    */

   int32_t GetCharNumAtPosition(nsPresContext* aContext,

                                const gfxPoint& aPoint) const;

   /**

    * The text frame that this rendered run lies within.

    */

   nsTextFrame* mFrame;

   /**

    * The point in user space that the text is positioned at.

    *

    * The x coordinate is the left edge of a LTR run of text or the right edge of

    * an RTL run.  The y coordinate is the baseline of the text.

    */

   gfxPoint mPosition;

   /**

    * The horizontal scale factor to apply when painting glyphs to take

    * into account textLength="".

    */

   float mLengthAdjustScaleFactor;

   /**

    * The rotation in radians in the user coordinate system that the text has.

    */

   float mRotate;

   /**

    * The scale factor that was used to transform the text run's original font

    * size into a sane range for painting and measurement.

    */

   double mFontSizeScaleFactor;

   /**

    * The baseline in app units of this text run.  The measurement is from the

    * top of the text frame.

    */

   nscoord mBaseline;

   /**

    * The offset and length in mFrame's content nsTextNode that corresponds to

    * this text rendered run.  These are original char indexes.

    */

   uint32_t mTextFrameContentOffset;

   uint32_t mTextFrameContentLength;

   /**

    * The character index in the whole SVG <text> element that this text rendered

    * run begins at.

    */

   uint32_t mTextElementCharIndex;

 };

 gfxMatrix

 TextRenderedRun::GetTransformFromUserSpaceForPainting(

                                        nsPresContext* aContext,

                                        const nsCharClipDisplayItem& aItem) const

 {

   // We transform to device pixels positioned such that painting the text frame

   // at (0,0) with aItem will result in the text being in the right place.

   gfxMatrix m;

   if (!mFrame) {

     return m;

   }

   float cssPxPerDevPx = aContext->

     AppUnitsToFloatCSSPixels(aContext->AppUnitsPerDevPixel());

   // Glyph position in user space.

   m.Translate(mPosition / cssPxPerDevPx);

   // Take into account any font size scaling and scaling due to textLength="".

   m.Scale(1.0 / mFontSizeScaleFactor, 1.0 / mFontSizeScaleFactor);

   // Rotation due to rotate="" or a <textPath>.

   m.Rotate(mRotate);

   m.Scale(mLengthAdjustScaleFactor, 1.0);

   // Translation to get the text frame in the right place.

   nsPoint t(IsRightToLeft() ?

               -mFrame->GetRect().width + aItem.mRightEdge :

               -aItem.mLeftEdge,

             -mBaseline);

   m.Translate(AppUnitsToGfxUnits(t, aContext));

   return m;

 }

 gfxMatrix

 TextRenderedRun::GetTransformFromRunUserSpaceToUserSpace(

                                                   nsPresContext* aContext) const

 {

   gfxMatrix m;

   if (!mFrame) {

     return m;

   }

   float cssPxPerDevPx = aContext->

     AppUnitsToFloatCSSPixels(aContext->AppUnitsPerDevPixel());

   nscoord left, right;

   GetClipEdges(left, right);

   // Glyph position in user space.

   m.Translate(mPosition);

   // Rotation due to rotate="" or a <textPath>.

   m.Rotate(mRotate);

   // Scale due to textLength="".

   m.Scale(mLengthAdjustScaleFactor, 1.0);

   // Translation to get the text frame in the right place.

   nsPoint t(IsRightToLeft() ?

               -mFrame->GetRect().width + left + right :

               0,

             -mBaseline);

   m.Translate(AppUnitsToGfxUnits(t, aContext) *

                 cssPxPerDevPx / mFontSizeScaleFactor);

   return m;

 }

 gfxMatrix

 TextRenderedRun::GetTransformFromRunUserSpaceToFrameUserSpace(

                                                   nsPresContext* aContext) const

 {

   gfxMatrix m;

   if (!mFrame) {

     return m;

   }

   nscoord left, right;

   GetClipEdges(left, right);

   // Translate by the horizontal distance into the text frame this

   // rendered run is.

   return m.Translate(gfxPoint(gfxFloat(left) / aContext->AppUnitsPerCSSPixel(),

                               0));

 }

 SVGBBox

 TextRenderedRun::GetRunUserSpaceRect(nsPresContext* aContext,

                                      uint32_t aFlags) const

 {

   SVGBBox r;

   if (!mFrame) {

     return r;

   }

   // Determine the amount of overflow above and below the frame's mRect.

   //

   // We need to call GetVisualOverflowRectRelativeToSelf because this includes

   // overflowing decorations, which the MeasureText call below does not.  We

   // assume here the decorations only overflow above and below the frame, never

   // horizontally.

   nsRect self = mFrame->GetVisualOverflowRectRelativeToSelf();

   nsRect rect = mFrame->GetRect();

   nscoord above = -self.y;

   nscoord below = self.YMost() - rect.height;

   gfxSkipCharsIterator it = mFrame->EnsureTextRun(nsTextFrame::eInflated);

   gfxTextRun* textRun = mFrame->GetTextRun(nsTextFrame::eInflated);

   // Get the content range for this rendered run.

   uint32_t offset, length;

   ConvertOriginalToSkipped(it, mTextFrameContentOffset, mTextFrameContentLength,

                            offset, length);

   // Measure that range.

   gfxTextRun::Metrics metrics =

     textRun->MeasureText(offset, length, gfxFont::LOOSE_INK_EXTENTS,

                          nullptr, nullptr);

   // Determine the rectangle that covers the rendered run's fill,

   // taking into account the measured vertical overflow due to

   // decorations.

   nscoord baseline = metrics.mBoundingBox.y + metrics.mAscent;

   gfxFloat x, width;

   if (aFlags & eNoHorizontalOverflow) {

     x = 0.0;

     width = textRun->GetAdvanceWidth(offset, length, nullptr);

   } else {

     x = metrics.mBoundingBox.x;

     width = metrics.mBoundingBox.width;

   }

   nsRect fillInAppUnits(x, baseline - above,

                         width, metrics.mBoundingBox.height + above + below);

   // Account for text-shadow.

   if (aFlags & eIncludeTextShadow) {

     fillInAppUnits =

       nsLayoutUtils::GetTextShadowRectsUnion(fillInAppUnits, mFrame);

   }

   // Convert the app units rectangle to user units.

   gfxRect fill = AppUnitsToFloatCSSPixels(gfxRect(fillInAppUnits.x,

                                                   fillInAppUnits.y,

                                                   fillInAppUnits.width,

                                                   fillInAppUnits.height),

                                           aContext);

   // Scale the rectangle up due to any mFontSizeScaleFactor.  We scale

   // it around the text's origin.

   ScaleAround(fill,

               gfxPoint(0.0, aContext->AppUnitsToFloatCSSPixels(baseline)),

               1.0 / mFontSizeScaleFactor);

   // Include the fill if requested.

   if (aFlags & eIncludeFill) {

     r = fill;

   }

   // Include the stroke if requested.

   if ((aFlags & eIncludeStroke) &&

       nsSVGUtils::GetStrokeWidth(mFrame) > 0) {

     r.UnionEdges(nsSVGUtils::PathExtentsToMaxStrokeExtents(fill, mFrame,

                                                            gfxMatrix()));

   }

   return r;

 }

 SVGBBox

 TextRenderedRun::GetFrameUserSpaceRect(nsPresContext* aContext,

                                        uint32_t aFlags) const

 {

   SVGBBox r = GetRunUserSpaceRect(aContext, aFlags);

   if (r.IsEmpty()) {

     return r;

   }

   gfxMatrix m = GetTransformFromRunUserSpaceToFrameUserSpace(aContext);

   return m.TransformBounds(r.ToThebesRect());

 }

 SVGBBox

 TextRenderedRun::GetUserSpaceRect(nsPresContext* aContext,

                                   uint32_t aFlags,

                                   const gfxMatrix* aAdditionalTransform) const

 {

   SVGBBox r = GetRunUserSpaceRect(aContext, aFlags);

   if (r.IsEmpty()) {

     return r;

   }

   gfxMatrix m = GetTransformFromRunUserSpaceToUserSpace(aContext);

   if (aAdditionalTransform) {

     m.Multiply(*aAdditionalTransform);

   }

   return m.TransformBounds(r.ToThebesRect());

 }

 void

 TextRenderedRun::GetClipEdges(nscoord& aLeftEdge, nscoord& aRightEdge) const

 {

   uint32_t contentLength = mFrame->GetContentLength();

   if (mTextFrameContentOffset == 0 &&

       mTextFrameContentLength == contentLength) {

     // If the rendered run covers the entire content, we know we don't need

     // to clip without having to measure anything.

     aLeftEdge = 0;

     aRightEdge = 0;

     return;

   }

   gfxSkipCharsIterator it = mFrame->EnsureTextRun(nsTextFrame::eInflated);

   gfxTextRun* textRun = mFrame->GetTextRun(nsTextFrame::eInflated);

   // Get the covered content offset/length for this rendered run in skipped

   // characters, since that is what GetAdvanceWidth expects.

   uint32_t runOffset, runLength, frameOffset, frameLength;

   ConvertOriginalToSkipped(it, mTextFrameContentOffset, mTextFrameContentLength,

                                runOffset, runLength);

   // Get the offset/length of the whole nsTextFrame.

   frameOffset = mFrame->GetContentOffset();

   frameLength = mFrame->GetContentLength();

   // Trim the whole-nsTextFrame offset/length to remove any leading/trailing

   // white space, as the nsTextFrame when painting does not include them when

   // interpreting clip edges.

   nsTextFrame::TrimmedOffsets trimmedOffsets =

     mFrame->GetTrimmedOffsets(mFrame->GetContent()->GetText(), true);

   TrimOffsets(frameOffset, frameLength, trimmedOffsets);

   // Convert the trimmed whole-nsTextFrame offset/length into skipped

   // characters.

   ConvertOriginalToSkipped(it, frameOffset, frameLength);

   // Measure the advance width in the text run between the start of

   // frame's content and the start of the rendered run's content,

   nscoord leftEdge =

     textRun->GetAdvanceWidth(frameOffset, runOffset - frameOffset, nullptr);

   // and between the end of the rendered run's content and the end

   // of the frame's content.

   nscoord rightEdge =

     textRun->GetAdvanceWidth(runOffset + runLength,

                              frameOffset + frameLength - (runOffset + runLength),

                              nullptr);

   if (textRun->IsRightToLeft()) {

     aLeftEdge  = rightEdge;

     aRightEdge = leftEdge;

   } else {

     aLeftEdge  = leftEdge;

     aRightEdge = rightEdge;

   }

 }

 nscoord

 TextRenderedRun::GetAdvanceWidth() const

 {

   gfxSkipCharsIterator it = mFrame->EnsureTextRun(nsTextFrame::eInflated);

   gfxTextRun* textRun = mFrame->GetTextRun(nsTextFrame::eInflated);

   uint32_t offset, length;

   ConvertOriginalToSkipped(it, mTextFrameContentOffset, mTextFrameContentLength,

                            offset, length);

   return textRun->GetAdvanceWidth(offset, length, nullptr);

 }

 int32_t

 TextRenderedRun::GetCharNumAtPosition(nsPresContext* aContext,

                                       const gfxPoint& aPoint) const

 {

   if (mTextFrameContentLength == 0) {

     return -1;

   }

   float cssPxPerDevPx = aContext->

     AppUnitsToFloatCSSPixels(aContext->AppUnitsPerDevPixel());

   // Convert the point from user space into run user space, and take

   // into account any mFontSizeScaleFactor.

   gfxMatrix m = GetTransformFromRunUserSpaceToUserSpace(aContext).Invert();

   gfxPoint p = m.Transform(aPoint) / cssPxPerDevPx * mFontSizeScaleFactor;

   // First check that the point lies vertically between the top and bottom

   // edges of the text.

   gfxFloat ascent, descent;

   GetAscentAndDescentInAppUnits(mFrame, ascent, descent);

   gfxFloat topEdge = mFrame->GetBaseline() - ascent;

   gfxFloat bottomEdge = topEdge + ascent + descent;

   if (p.y < aContext->AppUnitsToGfxUnits(topEdge) ||

       p.y >= aContext->AppUnitsToGfxUnits(bottomEdge)) {

     return -1;

   }

   gfxSkipCharsIterator it = mFrame->EnsureTextRun(nsTextFrame::eInflated);

   gfxTextRun* textRun = mFrame->GetTextRun(nsTextFrame::eInflated);

   // Next check that the point lies horizontally within the left and right

   // edges of the text.

   uint32_t offset, length;

   ConvertOriginalToSkipped(it, mTextFrameContentOffset, mTextFrameContentLength,

                            offset, length);

   gfxFloat runAdvance =

     aContext->AppUnitsToGfxUnits(textRun->GetAdvanceWidth(offset, length,

                                                           nullptr));

   if (p.x < 0 || p.x >= runAdvance) {

     return -1;

   }

   // Finally, measure progressively smaller portions of the rendered run to

   // find which glyph it lies within.  This will need to change once we

   // support letter-spacing and word-spacing.

   bool rtl = textRun->IsRightToLeft();

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

     ConvertOriginalToSkipped(it, mTextFrameContentOffset, i, offset, length);

     gfxFloat advance =

       aContext->AppUnitsToGfxUnits(textRun->GetAdvanceWidth(offset, length,

                                                             nullptr));

     if ((rtl && p.x < runAdvance - advance) ||

         (!rtl && p.x >= advance)) {

       return i;

     }

   }

   return -1;

 }

 // ----------------------------------------------------------------------------

 // TextNodeIterator

 enum SubtreePosition

 {

   eBeforeSubtree,

   eWithinSubtree,

   eAfterSubtree

 };

 /**

  * An iterator class for nsTextNodes that are descendants of a given node, the

  * root.  Nodes are iterated in document order.  An optional subtree can be

  * specified, in which case the iterator will track whether the current state of

  * the traversal over the tree is within that subtree or is past that subtree.

  */

 class TextNodeIterator

 {

 public:

   /**

    * Constructs a TextNodeIterator with the specified root node and optional

    * subtree.

    */

   TextNodeIterator(nsIContent* aRoot, nsIContent* aSubtree = nullptr)

     : mRoot(aRoot),

       mSubtree(aSubtree == aRoot ? nullptr : aSubtree),

       mCurrent(aRoot),

       mSubtreePosition(mSubtree ? eBeforeSubtree : eWithinSubtree)

   {

     NS_ASSERTION(aRoot, "expected non-null root");

     if (!aRoot->IsNodeOfType(nsINode::eTEXT)) {

       Next();

     }

   }

   /**

    * Returns the current nsTextNode, or null if the iterator has finished.

    */

   nsTextNode* Current() const

   {

     return static_cast<nsTextNode*>(mCurrent);

   }

   /**

    * Advances to the next nsTextNode and returns it, or null if the end of

    * iteration has been reached.

    */

   nsTextNode* Next();

   /**

    * Returns whether the iterator is currently within the subtree rooted

    * at mSubtree.  Returns true if we are not tracking a subtree (we consider

    * that we're always within the subtree).

    */

   bool IsWithinSubtree() const

   {

     return mSubtreePosition == eWithinSubtree;

   }

   /**

    * Returns whether the iterator is past the subtree rooted at mSubtree.

    * Returns false if we are not tracking a subtree.

    */

   bool IsAfterSubtree() const

   {

     return mSubtreePosition == eAfterSubtree;

   }

 private:

   /**

    * The root under which all nsTextNodes will be iterated over.

    */

   nsIContent* mRoot;

   /**

    * The node rooting the subtree to track.

    */

   nsIContent* mSubtree;

   /**

    * The current node during iteration.

    */

   nsIContent* mCurrent;

   /**

    * The current iterator position relative to mSubtree.

    */

   SubtreePosition mSubtreePosition;

 };

 nsTextNode*

 TextNodeIterator::Next()

 {

   // Starting from mCurrent, we do a non-recursive traversal to the next

   // nsTextNode beneath mRoot, updating mSubtreePosition appropriately if we

   // encounter mSubtree.

   if (mCurrent) {

     do {

       nsIContent* next = IsTextContentElement(mCurrent) ?

                            mCurrent->GetFirstChild() :

                            nullptr;

       if (next) {

         mCurrent = next;

         if (mCurrent == mSubtree) {

           mSubtreePosition = eWithinSubtree;

         }

       } else {

         for (;;) {

           if (mCurrent == mRoot) {

             mCurrent = nullptr;

             break;

           }

           if (mCurrent == mSubtree) {

             mSubtreePosition = eAfterSubtree;

           }

           next = mCurrent->GetNextSibling();

           if (next) {

             mCurrent = next;

             if (mCurrent == mSubtree) {

               mSubtreePosition = eWithinSubtree;

             }

             break;

           }

           if (mCurrent == mSubtree) {

             mSubtreePosition = eAfterSubtree;

           }

           mCurrent = mCurrent->GetParent();

         }

       }

     } while (mCurrent && !mCurrent->IsNodeOfType(nsINode::eTEXT));

   }

   return static_cast<nsTextNode*>(mCurrent);

 }

 // ----------------------------------------------------------------------------

 // TextNodeCorrespondenceRecorder

 /**

  * TextNodeCorrespondence is used as the value of a frame property that

  * is stored on all its descendant nsTextFrames.  It stores the number of DOM

  * characters between it and the previous nsTextFrame that did not have an

  * nsTextFrame created for them, due to either not being in a correctly

  * parented text content element, or because they were display:none.

  * These are called "undisplayed characters".

  *

  * See also TextNodeCorrespondenceRecorder below, which is what sets the

  * frame property.

  */

 struct TextNodeCorrespondence

 {

   TextNodeCorrespondence(uint32_t aUndisplayedCharacters)

     : mUndisplayedCharacters(aUndisplayedCharacters)

   {

   }

   uint32_t mUndisplayedCharacters;

 };

 static void DestroyTextNodeCorrespondence(void* aPropertyValue)

 {

   delete static_cast<TextNodeCorrespondence*>(aPropertyValue);

 }

 NS_DECLARE_FRAME_PROPERTY(TextNodeCorrespondenceProperty, DestroyTextNodeCorrespondence)

 /**

  * Returns the number of undisplayed characters before the specified

  * nsTextFrame.

  */

 static uint32_t

 GetUndisplayedCharactersBeforeFrame(nsTextFrame* aFrame)

 {

   void* value = aFrame->Properties().Get(TextNodeCorrespondenceProperty());

   TextNodeCorrespondence* correspondence =

     static_cast<TextNodeCorrespondence*>(value);

   if (!correspondence) {

     NS_NOTREACHED("expected a TextNodeCorrespondenceProperty on nsTextFrame "

                   "used for SVG text");

     return 0;

   }

   return correspondence->mUndisplayedCharacters;

 }

 /**

  * Traverses the nsTextFrames for an SVGTextFrame and records a

  * TextNodeCorrespondenceProperty on each for the number of undisplayed DOM

  * characters between each frame.  This is done by iterating simultaenously

  * over the nsTextNodes and nsTextFrames and noting when nsTextNodes (or

  * parts of them) are skipped when finding the next nsTextFrame.

  */

 class TextNodeCorrespondenceRecorder

 {

 public:

   /**

    * Entry point for the TextNodeCorrespondenceProperty recording.

    */

   static void RecordCorrespondence(SVGTextFrame* aRoot);

 private:

   TextNodeCorrespondenceRecorder(SVGTextFrame* aRoot)

     : mNodeIterator(aRoot->GetContent()),

       mPreviousNode(nullptr),

       mNodeCharIndex(0)

   {

   }

   void Record(SVGTextFrame* aRoot);

   void TraverseAndRecord(nsIFrame* aFrame);

   /**

    * Returns the next non-empty nsTextNode.

    */

   nsTextNode* NextNode();

   /**

    * The iterator over the nsTextNodes that we use as we simultaneously

    * iterate over the nsTextFrames.

    */

   TextNodeIterator mNodeIterator;

   /**

    * The previous nsTextNode we iterated over.

    */

   nsTextNode* mPreviousNode;

   /**

    * The index into the current nsTextNode's character content.

    */

   uint32_t mNodeCharIndex;

 };

 /* static */ void

 TextNodeCorrespondenceRecorder::RecordCorrespondence(SVGTextFrame* aRoot)

 {

   TextNodeCorrespondenceRecorder recorder(aRoot);

   recorder.Record(aRoot);

 }

 void

 TextNodeCorrespondenceRecorder::Record(SVGTextFrame* aRoot)

 {

   if (!mNodeIterator.Current()) {

     // If there are no nsTextNodes then there is nothing to do.

     return;

   }

   // Traverse over all the nsTextFrames and record the number of undisplayed

   // characters.

   TraverseAndRecord(aRoot);

   // Find how many undisplayed characters there are after the final nsTextFrame.

   uint32_t undisplayed = 0;

   if (mNodeIterator.Current()) {

     if (mPreviousNode && mPreviousNode->TextLength() != mNodeCharIndex) {

       // The last nsTextFrame ended part way through an nsTextNode.  The

       // remaining characters count as undisplayed.

       NS_ASSERTION(mNodeCharIndex < mPreviousNode->TextLength(),

                    "incorrect tracking of undisplayed characters in "

                    "text nodes");

       undisplayed += mPreviousNode->TextLength() - mNodeCharIndex;

     }

     // All the remaining nsTextNodes that we iterate must also be undisplayed.

     for (nsTextNode* textNode = mNodeIterator.Current();

          textNode;

          textNode = NextNode()) {

       undisplayed += textNode->TextLength();

     }

   }

   // Record the trailing number of undisplayed characters on the

   // SVGTextFrame.

   aRoot->mTrailingUndisplayedCharacters = undisplayed;

 }

 nsTextNode*

 TextNodeCorrespondenceRecorder::NextNode()

 {

   mPreviousNode = mNodeIterator.Current();

   nsTextNode* next;

   do {

     next = mNodeIterator.Next();

   } while (next && next->TextLength() == 0);

   return next;

 }

 void

 TextNodeCorrespondenceRecorder::TraverseAndRecord(nsIFrame* aFrame)

 {

   // Recursively iterate over the frame tree, for frames that correspond

   // to text content elements.

   if (IsTextContentElement(aFrame->GetContent())) {

     for (nsIFrame* f = aFrame->GetFirstPrincipalChild();

          f;

          f = f->GetNextSibling()) {

       TraverseAndRecord(f);

     }

     return;

   }

   nsTextFrame* frame;  // The current text frame.

   nsTextNode* node;    // The text node for the current text frame.

   if (!GetNonEmptyTextFrameAndNode(aFrame, frame, node)) {

     // If this isn't an nsTextFrame, or is empty, nothing to do.

     return;

   }

   NS_ASSERTION(frame->GetContentOffset() >= 0,

                "don't know how to handle negative content indexes");

   uint32_t undisplayed = 0;

   if (!mPreviousNode) {

     // Must be the very first text frame.

     NS_ASSERTION(mNodeCharIndex == 0, "incorrect tracking of undisplayed "

                                       "characters in text nodes");

     if (!mNodeIterator.Current()) {

       NS_NOTREACHED("incorrect tracking of correspondence between text frames "

                     "and text nodes");

     } else {

       // Each whole nsTextNode we find before we get to the text node for the

       // first text frame must be undisplayed.

       while (mNodeIterator.Current() != node) {

         undisplayed += mNodeIterator.Current()->TextLength();

         NextNode();

       }

       // If the first text frame starts at a non-zero content offset, then those

       // earlier characters are also undisplayed.

       undisplayed += frame->GetContentOffset();

       NextNode();

     }

   } else if (mPreviousNode == node) {

     // Same text node as last time.

     if (static_cast<uint32_t>(frame->GetContentOffset()) != mNodeCharIndex) {

       // We have some characters in the middle of the text node

       // that are undisplayed.

       NS_ASSERTION(mNodeCharIndex <

                      static_cast<uint32_t>(frame->GetContentOffset()),

                    "incorrect tracking of undisplayed characters in "

                    "text nodes");

       undisplayed = frame->GetContentOffset() - mNodeCharIndex;

     }

   } else {

     // Different text node from last time.

     if (mPreviousNode->TextLength() != mNodeCharIndex) {

       NS_ASSERTION(mNodeCharIndex < mPreviousNode->TextLength(),

                    "incorrect tracking of undisplayed characters in "

                    "text nodes");

       // Any trailing characters at the end of the previous nsTextNode are

       // undisplayed.

       undisplayed = mPreviousNode->TextLength() - mNodeCharIndex;

     }

     // Each whole nsTextNode we find before we get to the text node for

     // the current text frame must be undisplayed.

     while (mNodeIterator.Current() != node) {

       undisplayed += mNodeIterator.Current()->TextLength();

       NextNode();

     }

     // If the current text frame starts at a non-zero content offset, then those

     // earlier characters are also undisplayed.

     undisplayed += frame->GetContentOffset();

     NextNode();

   }

   // Set the frame property.

   frame->Properties().Set(TextNodeCorrespondenceProperty(),

                           new TextNodeCorrespondence(undisplayed));

   // Remember how far into the current nsTextNode we are.

   mNodeCharIndex = frame->GetContentEnd();

 }

 // ----------------------------------------------------------------------------

 // TextFrameIterator

 /**

  * An iterator class for nsTextFrames that are descendants of an

  * SVGTextFrame.  The iterator can optionally track whether the

  * current nsTextFrame is for a descendant of, or past, a given subtree

  * content node or frame.  (This functionality is used for example by the SVG

  * DOM text methods to get only the nsTextFrames for a particular <tspan>.)

  *

  * TextFrameIterator also tracks and exposes other information about the

  * current nsTextFrame:

  *

  *   * how many undisplayed characters came just before it

  *   * its position (in app units) relative to the SVGTextFrame's anonymous

  *     block frame

  *   * what nsInlineFrame corresponding to a <textPath> element it is a

  *     descendant of

  *   * what computed dominant-baseline value applies to it

  *

  * Note that any text frames that are empty -- whose ContentLength() is 0 --

  * will be skipped over.

  */

 class TextFrameIterator

 {

 public:

   /**

    * Constructs a TextFrameIterator for the specified SVGTextFrame

    * with an optional frame subtree to restrict iterated text frames to.

    */

   TextFrameIterator(SVGTextFrame* aRoot, nsIFrame* aSubtree = nullptr)

     : mRootFrame(aRoot),

       mSubtree(aSubtree),

       mCurrentFrame(aRoot),

       mCurrentPosition(),

       mSubtreePosition(mSubtree ? eBeforeSubtree : eWithinSubtree)

   {

     Init();

   }

   /**

    * Constructs a TextFrameIterator for the specified SVGTextFrame

    * with an optional frame content subtree to restrict iterated text frames to.

    */

   TextFrameIterator(SVGTextFrame* aRoot, nsIContent* aSubtree)

     : mRootFrame(aRoot),

       mSubtree(aRoot && aSubtree && aSubtree != aRoot->GetContent() ?

                  aSubtree->GetPrimaryFrame() :

                  nullptr),

       mCurrentFrame(aRoot),

       mCurrentPosition(),

       mSubtreePosition(mSubtree ? eBeforeSubtree : eWithinSubtree)

   {

     Init();

   }

   /**

    * Returns the root SVGTextFrame this TextFrameIterator is iterating over.

    */

   SVGTextFrame* Root() const

   {

     return mRootFrame;

   }

   /**

    * Returns the current nsTextFrame.

    */

   nsTextFrame* Current() const

   {

     return do_QueryFrame(mCurrentFrame);

   }

   /**

    * Returns the number of undisplayed characters in the DOM just before the

    * current frame.

    */

   uint32_t UndisplayedCharacters() const;

   /**

    * Returns the current frame's position, in app units, relative to the

    * root SVGTextFrame's anonymous block frame.

    */

   nsPoint Position() const

   {

     return mCurrentPosition;

   }

   /**

    * Advances to the next nsTextFrame and returns it.

    */

   nsTextFrame* Next();

   /**

    * Returns whether the iterator is within the subtree.

    */

   bool IsWithinSubtree() const

   {

     return mSubtreePosition == eWithinSubtree;

   }

   /**

    * Returns whether the iterator is past the subtree.

    */

   bool IsAfterSubtree() const

   {

     return mSubtreePosition == eAfterSubtree;

   }

   /**

    * Returns the frame corresponding to the <textPath> element, if we

    * are inside one.

    */

   nsIFrame* TextPathFrame() const

   {

     return mTextPathFrames.IsEmpty() ?

              nullptr :

              mTextPathFrames.ElementAt(mTextPathFrames.Length() - 1);

   }

   /**

    * Returns the current frame's computed dominant-baseline value.

    */

   uint8_t DominantBaseline() const

   {

     return mBaselines.ElementAt(mBaselines.Length() - 1);

   }

   /**

    * Finishes the iterator.

    */

   void Close()

   {

     mCurrentFrame = nullptr;

   }

 private:

   /**

    * Initializes the iterator and advances to the first item.

    */

   void Init()

   {

     if (!mRootFrame) {

       return;

     }

     mBaselines.AppendElement(mRootFrame->StyleSVGReset()->mDominantBaseline);

     Next();

   }

   /**

    * Pushes the specified frame's computed dominant-baseline value.

    * If the value of the property is "auto", then the parent frame's

    * computed value is used.

    */

   void PushBaseline(nsIFrame* aNextFrame);

   /**

    * Pops the current dominant-baseline off the stack.

    */

   void PopBaseline();

   /**

    * The root frame we are iterating through.

    */

   SVGTextFrame* mRootFrame;

   /**

    * The frame for the subtree we are also interested in tracking.

    */

   nsIFrame* mSubtree;

   /**

    * The current value of the iterator.

    */

   nsIFrame* mCurrentFrame;

   /**

    * The position, in app units, of the current frame relative to mRootFrame.

    */

   nsPoint mCurrentPosition;

   /**

    * Stack of frames corresponding to <textPath> elements that are in scope

    * for the current frame.

    */

   nsAutoTArray<nsIFrame*, 1> mTextPathFrames;

   /**

    * Stack of dominant-baseline values to record as we traverse through the

    * frame tree.

    */

   nsAutoTArray<uint8_t, 8> mBaselines;

   /**

    * The iterator's current position relative to mSubtree.

    */

   SubtreePosition mSubtreePosition;

 };

 uint32_t

 TextFrameIterator::UndisplayedCharacters() const

 {

   MOZ_ASSERT(!(mRootFrame->GetFirstPrincipalChild() &&

                NS_SUBTREE_DIRTY(mRootFrame->GetFirstPrincipalChild())),

              "should have already reflowed the anonymous block child");

   if (!mCurrentFrame) {

     return mRootFrame->mTrailingUndisplayedCharacters;

   }

   nsTextFrame* frame = do_QueryFrame(mCurrentFrame);

   return GetUndisplayedCharactersBeforeFrame(frame);

 }

 nsTextFrame*

 TextFrameIterator::Next()

 {

   // Starting from mCurrentFrame, we do a non-recursive traversal to the next

   // nsTextFrame beneath mRoot, updating mSubtreePosition appropriately if we

   // encounter mSubtree.

   if (mCurrentFrame) {

     do {

       nsIFrame* next = IsTextContentElement(mCurrentFrame->GetContent()) ?

                          mCurrentFrame->GetFirstPrincipalChild() :

                          nullptr;

       if (next) {

         // Descend into this frame, and accumulate its position.

         mCurrentPosition += next->GetPosition();

         if (next->GetContent()->Tag() == nsGkAtoms::textPath) {

           // Record this <textPath> frame.

           mTextPathFrames.AppendElement(next);

         }

         // Record the frame's baseline.

         PushBaseline(next);

         mCurrentFrame = next;

         if (mCurrentFrame == mSubtree) {

           // If the current frame is mSubtree, we have now moved into it.

           mSubtreePosition = eWithinSubtree;

         }

       } else {

         for (;;) {

           // We want to move past the current frame.

           if (mCurrentFrame == mRootFrame) {

             // If we've reached the root frame, we're finished.

             mCurrentFrame = nullptr;

             break;

           }

           // Remove the current frame's position.

           mCurrentPosition -= mCurrentFrame->GetPosition();

           if (mCurrentFrame->GetContent()->Tag() == nsGkAtoms::textPath) {

             // Pop off the <textPath> frame if this is a <textPath>.

             mTextPathFrames.TruncateLength(mTextPathFrames.Length() - 1);

           }

           // Pop off the current baseline.

           PopBaseline();

           if (mCurrentFrame == mSubtree) {

             // If this was mSubtree, we have now moved past it.

             mSubtreePosition = eAfterSubtree;

           }

           next = mCurrentFrame->GetNextSibling();

           if (next) {

             // Moving to the next sibling.

             mCurrentPosition += next->GetPosition();

             if (next->GetContent()->Tag() == nsGkAtoms::textPath) {

               // Record this <textPath> frame.

               mTextPathFrames.AppendElement(next);

             }

             // Record the frame's baseline.

             PushBaseline(next);

             mCurrentFrame = next;

             if (mCurrentFrame == mSubtree) {

               // If the current frame is mSubtree, we have now moved into it.

               mSubtreePosition = eWithinSubtree;

             }

             break;

           }

           if (mCurrentFrame == mSubtree) {

             // If there is no next sibling frame, and the current frame is

             // mSubtree, we have now moved past it.

             mSubtreePosition = eAfterSubtree;

           }

           // Ascend out of this frame.

           mCurrentFrame = mCurrentFrame->GetParent();

         }

       }

     } while (mCurrentFrame &&

              !IsNonEmptyTextFrame(mCurrentFrame));

   }

   return Current();

 }

 void

 TextFrameIterator::PushBaseline(nsIFrame* aNextFrame)

 {

   uint8_t baseline = aNextFrame->StyleSVGReset()->mDominantBaseline;

   if (baseline == NS_STYLE_DOMINANT_BASELINE_AUTO) {

     baseline = mBaselines.LastElement();

   }

   mBaselines.AppendElement(baseline);

 }

 void

 TextFrameIterator::PopBaseline()

 {

   NS_ASSERTION(!mBaselines.IsEmpty(), "popped too many baselines");

   mBaselines.TruncateLength(mBaselines.Length() - 1);

 }

 // -----------------------------------------------------------------------------

 // TextRenderedRunIterator

 /**

  * Iterator for TextRenderedRun objects for the SVGTextFrame.

  */

 class TextRenderedRunIterator

 {

 public:

   /**

    * Values for the aFilter argument of the constructor, to indicate which frames

    * we should be limited to iterating TextRenderedRun objects for.

    */

   enum RenderedRunFilter {

     // Iterate TextRenderedRuns for all nsTextFrames.

     eAllFrames,

     // Iterate only TextRenderedRuns for nsTextFrames that are

     // visibility:visible.

     eVisibleFrames

   };

   /**

    * Constructs a TextRenderedRunIterator with an optional frame subtree to

    * restrict iterated rendered runs to.

    *

    * @param aSVGTextFrame The SVGTextFrame whose rendered runs to iterate

    *   through.

    * @param aFilter Indicates whether to iterate rendered runs for non-visible

    *   nsTextFrames.

    * @param aSubtree An optional frame subtree to restrict iterated rendered

    *   runs to.

    */

   TextRenderedRunIterator(SVGTextFrame* aSVGTextFrame,

                           RenderedRunFilter aFilter = eAllFrames,

                           nsIFrame* aSubtree = nullptr)

     : mFrameIterator(FrameIfAnonymousChildReflowed(aSVGTextFrame), aSubtree),

       mFilter(aFilter),

       mTextElementCharIndex(0),

       mFrameStartTextElementCharIndex(0),

       mFontSizeScaleFactor(aSVGTextFrame->mFontSizeScaleFactor),

       mCurrent(First())

   {

   }

   /**

    * Constructs a TextRenderedRunIterator with a content subtree to restrict

    * iterated rendered runs to.

    *

    * @param aSVGTextFrame The SVGTextFrame whose rendered runs to iterate

    *   through.

    * @param aFilter Indicates whether to iterate rendered runs for non-visible

    *   nsTextFrames.

    * @param aSubtree A content subtree to restrict iterated rendered runs to.

    */

   TextRenderedRunIterator(SVGTextFrame* aSVGTextFrame,

                           RenderedRunFilter aFilter,

                           nsIContent* aSubtree)

     : mFrameIterator(FrameIfAnonymousChildReflowed(aSVGTextFrame), aSubtree),

       mFilter(aFilter),

       mTextElementCharIndex(0),

       mFrameStartTextElementCharIndex(0),

       mFontSizeScaleFactor(aSVGTextFrame->mFontSizeScaleFactor),

       mCurrent(First())

   {

   }

   /**

    * Returns the current TextRenderedRun.

    */

   TextRenderedRun Current() const

   {

     return mCurrent;

   }

   /**

    * Advances to the next TextRenderedRun and returns it.

    */

   TextRenderedRun Next();

 private:

   /**

    * Returns the root SVGTextFrame this iterator is for.

    */

   SVGTextFrame* Root() const

   {

     return mFrameIterator.Root();

   }

   /**

    * Advances to the first TextRenderedRun and returns it.

    */

   TextRenderedRun First();

   /**

    * The frame iterator to use.

    */

   TextFrameIterator mFrameIterator;

   /**

    * The filter indicating which TextRenderedRuns to return.

    */

   RenderedRunFilter mFilter;

   /**

    * The character index across the entire <text> element we are currently

    * up to.

    */

   uint32_t mTextElementCharIndex;

   /**

    * The character index across the entire <text> for the start of the current

    * frame.

    */

   uint32_t mFrameStartTextElementCharIndex;

   /**

    * The font-size scale factor we used when constructing the nsTextFrames.

    */

   double mFontSizeScaleFactor;

   /**

    * The current TextRenderedRun.

    */

   TextRenderedRun mCurrent;

 };

 TextRenderedRun

 TextRenderedRunIterator::Next()

 {

   if (!mFrameIterator.Current()) {

     // If there are no more frames, then there are no more rendered runs to

     // return.

     mCurrent = TextRenderedRun();

     return mCurrent;

   }

   // The values we will use to initialize the TextRenderedRun with.

   nsTextFrame* frame;

   gfxPoint pt;

   double rotate;

   nscoord baseline;

   uint32_t offset, length;

   uint32_t charIndex;

   // We loop, because we want to skip over rendered runs that either aren't

   // within our subtree of interest, because they don't match the filter,

   // or because they are hidden due to having fallen off the end of a

   // <textPath>.

   for (;;) {

     if (mFrameIterator.IsAfterSubtree()) {

       mCurrent = TextRenderedRun();

       return mCurrent;

     }

     frame = mFrameIterator.Current();

     charIndex = mTextElementCharIndex;

     // Find the end of the rendered run, by looking through the

     // SVGTextFrame's positions array until we find one that is recorded

     // as a run boundary.

     uint32_t runStart, runEnd;  // XXX Replace runStart with mTextElementCharIndex.

     runStart = mTextElementCharIndex;

     runEnd = runStart + 1;

     while (runEnd < Root()->mPositions.Length() &&

            !Root()->mPositions[runEnd].mRunBoundary) {

       runEnd++;

     }

     // Convert the global run start/end indexes into an offset/length into the

     // current frame's nsTextNode.

     offset = frame->GetContentOffset() + runStart -

              mFrameStartTextElementCharIndex;

     length = runEnd - runStart;

     // If the end of the frame's content comes before the run boundary we found

     // in SVGTextFrame's position array, we need to shorten the rendered run.

     uint32_t contentEnd = frame->GetContentEnd();

     if (offset + length > contentEnd) {

       length = contentEnd - offset;

     }

     NS_ASSERTION(offset >= uint32_t(frame->GetContentOffset()), "invalid offset");

     NS_ASSERTION(offset + length <= contentEnd, "invalid offset or length");

     // Get the frame's baseline position.

     frame->EnsureTextRun(nsTextFrame::eInflated);

     baseline = GetBaselinePosition(frame,

                                    frame->GetTextRun(nsTextFrame::eInflated),

                                    mFrameIterator.DominantBaseline());

     // Trim the offset/length to remove any leading/trailing white space.

     uint32_t untrimmedOffset = offset;

     uint32_t untrimmedLength = length;

     nsTextFrame::TrimmedOffsets trimmedOffsets =

       frame->GetTrimmedOffsets(frame->GetContent()->GetText(), true);

     TrimOffsets(offset, length, trimmedOffsets);

     charIndex += offset - untrimmedOffset;

     // Get the position and rotation of the character that begins this

     // rendered run.

     pt = Root()->mPositions[charIndex].mPosition;

     rotate = Root()->mPositions[charIndex].mAngle;

     // Determine if we should skip this rendered run.

     bool skip = !mFrameIterator.IsWithinSubtree() ||

                 Root()->mPositions[mTextElementCharIndex].mHidden;

     if (mFilter == eVisibleFrames) {

       skip = skip || !frame->StyleVisibility()->IsVisible();

     }

     // Update our global character index to move past the characters

     // corresponding to this rendered run.

     mTextElementCharIndex += untrimmedLength;

     // If we have moved past the end of the current frame's content, we need to

     // advance to the next frame.

     if (offset + untrimmedLength >= contentEnd) {

       mFrameIterator.Next();

       mTextElementCharIndex += mFrameIterator.UndisplayedCharacters();

       mFrameStartTextElementCharIndex = mTextElementCharIndex;

     }

     if (!mFrameIterator.Current()) {

       if (skip) {

         // That was the last frame, and we skipped this rendered run.  So we

         // have no rendered run to return.

         mCurrent = TextRenderedRun();

         return mCurrent;

       }

       break;

     }

     if (length && !skip) {

       // Only return a rendered run if it didn't get collapsed away entirely

       // (due to it being all white space) and if we don't want to skip it.

       break;

     }

   }

   mCurrent = TextRenderedRun(frame, pt, Root()->mLengthAdjustScaleFactor,

                              rotate, mFontSizeScaleFactor, baseline,

                              offset, length, charIndex);

   return mCurrent;

 }

 TextRenderedRun

 TextRenderedRunIterator::First()

 {

   if (!mFrameIterator.Current()) {

     return TextRenderedRun();

   }

   if (Root()->mPositions.IsEmpty()) {

     mFrameIterator.Close();

     return TextRenderedRun();

   }

   // Get the character index for the start of this rendered run, by skipping

   // any undisplayed characters.

   mTextElementCharIndex = mFrameIterator.UndisplayedCharacters();

   mFrameStartTextElementCharIndex = mTextElementCharIndex;

   return Next();

 }

 // -----------------------------------------------------------------------------

 // CharIterator

 /**

  * Iterator for characters within an SVGTextFrame.

  */

 class CharIterator

 {

 public:

   /**

    * Values for the aFilter argument of the constructor, to indicate which

    * characters we should be iterating over.

    */

   enum CharacterFilter {

     // Iterate over all original characters from the DOM that are within valid

     // text content elements.

     eOriginal,

     // Iterate only over characters that are addressable by the positioning

     // attributes x="", y="", etc.  This includes all characters after

     // collapsing white space as required by the value of 'white-space'.

     eAddressable,

     // Iterate only over characters that are the first of clusters or ligature

     // groups.

     eClusterAndLigatureGroupStart,

     // Iterate only over characters that are part of a cluster or ligature

     // group but not the first character.

     eClusterOrLigatureGroupMiddle

   };

   /**

    * Constructs a CharIterator.

    *

    * @param aSVGTextFrame The SVGTextFrame whose characters to iterate

    *   through.

    * @param aFilter Indicates which characters to iterate over.

    * @param aSubtree A content subtree to track whether the current character

    *   is within.

    */

   CharIterator(SVGTextFrame* aSVGTextFrame,

                CharacterFilter aFilter,

                nsIContent* aSubtree = nullptr);

   /**

    * Returns whether the iterator is finished.

    */

   bool AtEnd() const

   {

     return !mFrameIterator.Current();

   }

   /**

    * Advances to the next matching character.  Returns true if there was a

    * character to advance to, and false otherwise.

    */

   bool Next();

   /**

    * Advances ahead aCount matching characters.  Returns true if there were

    * enough characters to advance past, and false otherwise.

    */

   bool Next(uint32_t aCount);

   /**

    * Advances ahead up to aCount matching characters.

    */

   void NextWithinSubtree(uint32_t aCount);

   /**

    * Advances to the character with the specified index.  The index is in the

    * space of original characters (i.e., all DOM characters under the <text>

    * that are within valid text content elements).

    */

   bool AdvanceToCharacter(uint32_t aTextElementCharIndex);

   /**

    * Advances to the first matching character after the current nsTextFrame.

    */

   bool AdvancePastCurrentFrame();

   /**

    * Advances to the first matching character after the frames within

    * the current <textPath>.

    */

   bool AdvancePastCurrentTextPathFrame();

   /**

    * Advances to the first matching character of the subtree.  Returns true

    * if we successfully advance to the subtree, or if we are already within

    * the subtree.  Returns false if we are past the subtree.

    */

   bool AdvanceToSubtree();

   /**

    * Returns the nsTextFrame for the current character.

    */

   nsTextFrame* TextFrame() const

   {

     return mFrameIterator.Current();

   }

   /**

    * Returns whether the iterator is within the subtree.

    */

   bool IsWithinSubtree() const

   {

     return mFrameIterator.IsWithinSubtree();

   }

   /**

    * Returns whether the iterator is past the subtree.

    */

   bool IsAfterSubtree() const

   {

     return mFrameIterator.IsAfterSubtree();

   }

   /**

    * Returns whether the current character is a skipped character.

    */

   bool IsOriginalCharSkipped() const

   {

     return mSkipCharsIterator.IsOriginalCharSkipped();

   }

   /**

    * Returns whether the current character is the start of a cluster and

    * ligature group.

    */

   bool IsClusterAndLigatureGroupStart() const;

   /**

    * Returns whether the current character is trimmed away when painting,

    * due to it being leading/trailing white space.

    */

   bool IsOriginalCharTrimmed() const;

   /**

    * Returns whether the current character is unaddressable from the SVG glyph

    * positioning attributes.

    */

   bool IsOriginalCharUnaddressable() const

   {

     return IsOriginalCharSkipped() || IsOriginalCharTrimmed();

   }

   /**

    * Returns the text run for the current character.

    */

   gfxTextRun* TextRun() const

   {

     return mTextRun;

   }

   /**

    * Returns the current character index.

    */

   uint32_t TextElementCharIndex() const

   {

     return mTextElementCharIndex;

   }

   /**

    * Returns the character index for the start of the cluster/ligature group it

    * is part of.

    */

   uint32_t GlyphStartTextElementCharIndex() const

   {

     return mGlyphStartTextElementCharIndex;

   }

   /**

    * Returns the number of undisplayed characters between the beginning of

    * the glyph and the current character.

    */

   uint32_t GlyphUndisplayedCharacters() const

   {

     return mGlyphUndisplayedCharacters;

   }

   /**

    * Gets the original character offsets within the nsTextNode for the

    * cluster/ligature group the current character is a part of.

    *

    * @param aOriginalOffset The offset of the start of the cluster/ligature

    *   group (output).

    * @param aOriginalLength The length of cluster/ligature group (output).

    */

   void GetOriginalGlyphOffsets(uint32_t& aOriginalOffset,

                                uint32_t& aOriginalLength) const;

   /**

    * Gets the advance, in user units, of the glyph the current character is

    * part of.

    *

    * @param aContext The context to use for unit conversions.

    */

   gfxFloat GetGlyphAdvance(nsPresContext* aContext) const;

   /**

    * Gets the advance, in user units, of the current character.  If the

    * character is a part of ligature, then the advance returned will be

    * a fraction of the ligature glyph's advance.

    *

    * @param aContext The context to use for unit conversions.

    */

   gfxFloat GetAdvance(nsPresContext* aContext) const;

   /**

    * Gets the specified partial advance of the glyph the current character is

    * part of.  The partial advance is measured from the first character

    * corresponding to the glyph until the specified part length.

    *

    * The part length value does not include any undisplayed characters in the

    * middle of the cluster/ligature group.  For example, if you have:

    *

    *   <text>f<tspan display="none">x</tspan>i</text>

    *

    * and the "f" and "i" are ligaturized, then calling GetGlyphPartialAdvance

    * with aPartLength values will have the following results:

    *

    *   0 => 0

    *   1 => adv("fi") / 2

    *   2 => adv("fi")

    *

    * @param aPartLength The number of characters in the cluster/ligature group

    *   to measure.

    * @param aContext The context to use for unit conversions.

    */

   gfxFloat GetGlyphPartialAdvance(uint32_t aPartLength,

                                   nsPresContext* aContext) const;

   /**

    * Returns the frame corresponding to the <textPath> that the current

    * character is within.

    */

   nsIFrame* TextPathFrame() const

   {

     return mFrameIterator.TextPathFrame();

   }

 private:

   /**

    * Advances to the next character without checking it against the filter.

    * Returns true if there was a next character to advance to, or false

    * otherwise.

    */

   bool NextCharacter();

   /**

    * Returns whether the current character matches the filter.

    */

   bool MatchesFilter() const;

   /**

    * If this is the start of a glyph, record it.

    */

   void UpdateGlyphStartTextElementCharIndex() {

     if (!IsOriginalCharSkipped() && IsClusterAndLigatureGroupStart()) {

       mGlyphStartTextElementCharIndex = mTextElementCharIndex;

       mGlyphUndisplayedCharacters = 0;

     }

   }

   /**

    * The filter to use.

    */

   CharacterFilter mFilter;

   /**

    * The iterator for text frames.

    */

   TextFrameIterator mFrameIterator;

   /**

    * A gfxSkipCharsIterator for the text frame the current character is

    * a part of.

    */

   gfxSkipCharsIterator mSkipCharsIterator;

   // Cache for information computed by IsOriginalCharTrimmed.

   mutable nsTextFrame* mFrameForTrimCheck;

   mutable uint32_t mTrimmedOffset;

   mutable uint32_t mTrimmedLength;

   /**

    * The text run the current character is a part of.

    */

   gfxTextRun* mTextRun;

   /**

    * The current character's index.

    */

   uint32_t mTextElementCharIndex;

   /**

    * The index of the character that starts the cluster/ligature group the

    * current character is a part of.

    */

   uint32_t mGlyphStartTextElementCharIndex;

   /**

    * If we are iterating in mode eClusterOrLigatureGroupMiddle, then

    * this tracks how many undisplayed characters were encountered

    * between the start of this glyph (at mGlyphStartTextElementCharIndex)

    * and the current character (at mTextElementCharIndex).

    */

   uint32_t mGlyphUndisplayedCharacters;

   /**

    * The scale factor to apply to glyph advances returned by

    * GetGlyphAdvance etc. to take into account textLength="".

    */

   float mLengthAdjustScaleFactor;

 };

 CharIterator::CharIterator(SVGTextFrame* aSVGTextFrame,

                            CharIterator::CharacterFilter aFilter,

                            nsIContent* aSubtree)

   : mFilter(aFilter),

     mFrameIterator(FrameIfAnonymousChildReflowed(aSVGTextFrame), aSubtree),

     mFrameForTrimCheck(nullptr),

     mTrimmedOffset(0),

     mTrimmedLength(0),

     mTextElementCharIndex(0),

     mGlyphStartTextElementCharIndex(0),

     mLengthAdjustScaleFactor(aSVGTextFrame->mLengthAdjustScaleFactor)

 {

   if (!AtEnd()) {

     mSkipCharsIterator = TextFrame()->EnsureTextRun(nsTextFrame::eInflated);

     mTextRun = TextFrame()->GetTextRun(nsTextFrame::eInflated);

     mTextElementCharIndex = mFrameIterator.UndisplayedCharacters();

     UpdateGlyphStartTextElementCharIndex();

     if (!MatchesFilter()) {

       Next();

     }

   }

 }

 bool

 CharIterator::Next()

 {

   while (NextCharacter()) {

     if (MatchesFilter()) {

       return true;

     }

   }

   return false;

 }

 bool

 CharIterator::Next(uint32_t aCount)

 {

   if (aCount == 0 && AtEnd()) {

     return false;

   }

   while (aCount) {

     if (!Next()) {

       return false;

     }

     aCount--;

   }

   return true;

 }

 void

 CharIterator::NextWithinSubtree(uint32_t aCount)

 {

   while (IsWithinSubtree() && aCount) {

     --aCount;

     if (!Next()) {

       return;

     }

   }

 }

 bool

 CharIterator::AdvanceToCharacter(uint32_t aTextElementCharIndex)

 {

   while (mTextElementCharIndex < aTextElementCharIndex) {

     if (!Next()) {

       return false;

     }

   }

   return true;

 }

 bool

 CharIterator::AdvancePastCurrentFrame()

 {

   // XXX Can do this better than one character at a time if it matters.

   nsTextFrame* currentFrame = TextFrame();

   do {

     if (!Next()) {

       return false;

     }

   } while (TextFrame() == currentFrame);

   return true;

 }

 bool

 CharIterator::AdvancePastCurrentTextPathFrame()

 {

   nsIFrame* currentTextPathFrame = TextPathFrame();

   NS_ASSERTION(currentTextPathFrame,

                "expected AdvancePastCurrentTextPathFrame to be called only "

                "within a text path frame");

   do {

     if (!AdvancePastCurrentFrame()) {

       return false;

     }

   } while (TextPathFrame() == currentTextPathFrame);

   return true;

 }

 bool

 CharIterator::AdvanceToSubtree()

 {

   while (!IsWithinSubtree()) {

     if (IsAfterSubtree()) {

       return false;

     }

     if (!AdvancePastCurrentFrame()) {

       return false;

     }

   }

   return true;

 }

 bool

 CharIterator::IsClusterAndLigatureGroupStart() const

 {

   return mTextRun->IsLigatureGroupStart(mSkipCharsIterator.GetSkippedOffset()) &&

          mTextRun->IsClusterStart(mSkipCharsIterator.GetSkippedOffset());

 }

 bool

 CharIterator::IsOriginalCharTrimmed() const

 {

   if (mFrameForTrimCheck != TextFrame()) {

     // Since we do a lot of trim checking, we cache the trimmed offsets and

     // lengths while we are in the same frame.

     mFrameForTrimCheck = TextFrame();

     uint32_t offset = mFrameForTrimCheck->GetContentOffset();

     uint32_t length = mFrameForTrimCheck->GetContentLength();

     nsIContent* content = mFrameForTrimCheck->GetContent();

     nsTextFrame::TrimmedOffsets trim =

       mFrameForTrimCheck->GetTrimmedOffsets(content->GetText(), true);

     TrimOffsets(offset, length, trim);

     mTrimmedOffset = offset;

     mTrimmedLength = length;

   }

   // A character is trimmed if it is outside the mTrimmedOffset/mTrimmedLength

   // range and it is not a significant newline character.

   uint32_t index = mSkipCharsIterator.GetOriginalOffset();

   return !((index >= mTrimmedOffset &&

             index < mTrimmedOffset + mTrimmedLength) ||

            (index >= mTrimmedOffset + mTrimmedLength &&

             mFrameForTrimCheck->StyleText()->NewlineIsSignificant() &&

             mFrameForTrimCheck->GetContent()->GetText()->CharAt(index) == '\n'));

 }

 void

 CharIterator::GetOriginalGlyphOffsets(uint32_t& aOriginalOffset,

                                       uint32_t& aOriginalLength) const

 {

   gfxSkipCharsIterator it = TextFrame()->EnsureTextRun(nsTextFrame::eInflated);

   it.SetOriginalOffset(mSkipCharsIterator.GetOriginalOffset() -

                          (mTextElementCharIndex -

                           mGlyphStartTextElementCharIndex -

                           mGlyphUndisplayedCharacters));

   while (it.GetSkippedOffset() > 0 &&

          (!mTextRun->IsClusterStart(it.GetSkippedOffset()) ||

           !mTextRun->IsLigatureGroupStart(it.GetSkippedOffset()))) {

     it.AdvanceSkipped(-1);

   }

   aOriginalOffset = it.GetOriginalOffset();

   // Find the end of the cluster/ligature group.

   it.SetOriginalOffset(mSkipCharsIterator.GetOriginalOffset());

   do {

     it.AdvanceSkipped(1);

   } while (it.GetSkippedOffset() < mTextRun->GetLength() &&

            (!mTextRun->IsClusterStart(it.GetSkippedOffset()) ||

             !mTextRun->IsLigatureGroupStart(it.GetSkippedOffset())));

   aOriginalLength = it.GetOriginalOffset() - aOriginalOffset;

 }

 gfxFloat

 CharIterator::GetGlyphAdvance(nsPresContext* aContext) const

 {

   uint32_t offset, length;

   GetOriginalGlyphOffsets(offset, length);

   gfxSkipCharsIterator it = TextFrame()->EnsureTextRun(nsTextFrame::eInflated);

   ConvertOriginalToSkipped(it, offset, length);

   float cssPxPerDevPx = aContext->

     AppUnitsToFloatCSSPixels(aContext->AppUnitsPerDevPixel());

   gfxFloat advance = mTextRun->GetAdvanceWidth(offset, length, nullptr);

   return aContext->AppUnitsToGfxUnits(advance) *

          mLengthAdjustScaleFactor * cssPxPerDevPx;

 }

 gfxFloat

 CharIterator::GetAdvance(nsPresContext* aContext) const

 {

   float cssPxPerDevPx = aContext->

     AppUnitsToFloatCSSPixels(aContext->AppUnitsPerDevPixel());

   gfxFloat advance =

     mTextRun->GetAdvanceWidth(mSkipCharsIterator.GetSkippedOffset(), 1, nullptr);

   return aContext->AppUnitsToGfxUnits(advance) *

          mLengthAdjustScaleFactor * cssPxPerDevPx;

 }

 gfxFloat

 CharIterator::GetGlyphPartialAdvance(uint32_t aPartLength,

                                      nsPresContext* aContext) const

 {

   uint32_t offset, length;

   GetOriginalGlyphOffsets(offset, length);

   NS_ASSERTION(aPartLength <= length, "invalid aPartLength value");

   length = aPartLength;

   gfxSkipCharsIterator it = TextFrame()->EnsureTextRun(nsTextFrame::eInflated);

   ConvertOriginalToSkipped(it, offset, length);

   float cssPxPerDevPx = aContext->

     AppUnitsToFloatCSSPixels(aContext->AppUnitsPerDevPixel());

   gfxFloat advance = mTextRun->GetAdvanceWidth(offset, length, nullptr);

   return aContext->AppUnitsToGfxUnits(advance) *

          mLengthAdjustScaleFactor * cssPxPerDevPx;

 }

 bool

 CharIterator::NextCharacter()

 {

   if (AtEnd()) {

     return false;

   }

   mTextElementCharIndex++;

   // Advance within the current text run.

   mSkipCharsIterator.AdvanceOriginal(1);

   if (mSkipCharsIterator.GetOriginalOffset() < TextFrame()->GetContentEnd()) {

     // We're still within the part of the text run for the current text frame.

     UpdateGlyphStartTextElementCharIndex();

     return true;

   }

   // Advance to the next frame.

   mFrameIterator.Next();

   // Skip any undisplayed characters.

   uint32_t undisplayed = mFrameIterator.UndisplayedCharacters();

   mGlyphUndisplayedCharacters += undisplayed;

   mTextElementCharIndex += undisplayed;

   if (!TextFrame()) {

     // We're at the end.

     mSkipCharsIterator = gfxSkipCharsIterator();

     return false;

   }

   mSkipCharsIterator = TextFrame()->EnsureTextRun(nsTextFrame::eInflated);

   mTextRun = TextFrame()->GetTextRun(nsTextFrame::eInflated);

   UpdateGlyphStartTextElementCharIndex();

   return true;

 }

 bool

 CharIterator::MatchesFilter() const

 {

   if (mFilter == eOriginal) {

     return true;

   }

   if (IsOriginalCharSkipped()) {

     return false;

   }

   if (mFilter == eAddressable) {