1 files changed, 332 insertions, 0 deletions
diff --git a/layout/generic/TextOverflow.h b/layout/generic/TextOverflow.h
new file mode 100644
index 0000000000..7f0911b93d
--- /dev/null
+++ b/layout/generic/TextOverflow.h
@@ -0,0 +1,332 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef TextOverflow_h_
+#define TextOverflow_h_
+
+#include "nsDisplayList.h"
+#include "nsTHashSet.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/Likely.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/WritingModes.h"
+#include <algorithm>
+
+class nsIScrollableFrame;
+class nsBlockFrame;
+class nsLineBox;
+
+namespace mozilla {
+namespace css {
+
+/**
+ * A class for rendering CSS3 text-overflow.
+ * Usage:
+ *  1. allocate an object using WillProcessLines
+ *  2. then call ProcessLine for each line you are building display lists for
+ *
+ * Note that this class is non-reassignable; we don't want to be making
+ * arbitrary copies. (But we do have a move constructor, since that's required
+ * in order to be stored in Maybe<>).
+ */
+class TextOverflow final {
+ private:
+  /**
+   * Private constructor, for internal use only. Client code should call
+   * WillProcessLines(), which is basically the factory function for
+   * TextOverflow instances.
+   */
+  TextOverflow(nsDisplayListBuilder* aBuilder, nsBlockFrame*);
+
+ public:
+  ~TextOverflow() = default;
+
+  /**
+   * Allocate an object for text-overflow processing. (Factory function.)
+   * @return nullptr if no processing is necessary.  The caller owns the object.
+   */
+  static Maybe<TextOverflow> WillProcessLines(nsDisplayListBuilder* aBuilder,
+                                              nsBlockFrame*);
+
+  /**
+   * This is a factory-constructed non-reassignable class, so we delete nearly
+   * all constructors and reassignment operators.  We only provide a
+   * move-constructor, because that's required for Maybe<TextOverflow> to work
+   * (and that's what our factory method returns).
+   */
+  TextOverflow(TextOverflow&&) = default;
+
+  TextOverflow() = delete;
+  TextOverflow(const TextOverflow&) = delete;
+  TextOverflow& operator=(const TextOverflow&) = delete;
+  TextOverflow& operator=(TextOverflow&&) = delete;
+
+  /**
+   * Analyze the display lists for text overflow and what kind of item is at
+   * the content edges.  Add display items for text-overflow markers as needed
+   * and remove or clip items that would overlap a marker.
+   */
+  void ProcessLine(const nsDisplayListSet& aLists, nsLineBox* aLine,
+                   uint32_t aLineNumber);
+
+  /**
+   * Get the resulting text-overflow markers (the list may be empty).
+   * @return a DisplayList containing any text-overflow markers.
+   */
+  nsDisplayList& GetMarkers() { return mMarkerList; }
+
+  // Returns whether aBlockFrame has text-overflow:clip on both sides.
+  static bool HasClippedTextOverflow(nsIFrame* aBlockFrame);
+
+  // Returns whether aBlockFrame has a block ellipsis on one of its lines.
+  static bool HasBlockEllipsis(nsIFrame* aBlockFrame);
+
+  // Returns whether the given block frame needs analysis for text overflow.
+  // The BeforeReflow flag indicates whether we can be faster and more precise
+  // for line-clamp ellipsis (only returning true iff the block actually uses
+  // it).
+  enum class BeforeReflow : bool { No, Yes };
+  static bool CanHaveOverflowMarkers(nsBlockFrame*,
+                                     BeforeReflow = BeforeReflow::No);
+
+  typedef nsTHashSet<nsIFrame*> FrameHashtable;
+
+ private:
+  typedef mozilla::WritingMode WritingMode;
+  typedef mozilla::LogicalRect LogicalRect;
+
+  // Edges to align the IStart and IEnd markers to.
+  struct AlignmentEdges {
+    AlignmentEdges()
+        : mIStart(0), mIEnd(0), mIEndOuter(0), mAssignedInner(false) {}
+    void AccumulateInner(WritingMode aWM, const LogicalRect& aRect) {
+      if (MOZ_LIKELY(mAssignedInner)) {
+        mIStart = std::min(mIStart, aRect.IStart(aWM));
+        mIEnd = std::max(mIEnd, aRect.IEnd(aWM));
+      } else {
+        mIStart = aRect.IStart(aWM);
+        mIEnd = aRect.IEnd(aWM);
+        mAssignedInner = true;
+      }
+    }
+    void AccumulateOuter(WritingMode aWM, const LogicalRect& aRect) {
+      mIEndOuter = std::max(mIEndOuter, aRect.IEnd(aWM));
+    }
+    nscoord ISize() { return mIEnd - mIStart; }
+
+    // The outermost edges of all text and atomic inline-level frames that are
+    // inside the area between the markers.
+    nscoord mIStart;
+    nscoord mIEnd;
+
+    // The closest IEnd edge of all text and atomic inline-level frames that
+    // fall completely before the IStart edge of the content area.  (Used to
+    // align a block ellipsis when there are no visible frames to align to.)
+    nscoord mIEndOuter;
+
+    bool mAssignedInner;
+  };
+
+  struct InnerClipEdges {
+    InnerClipEdges()
+        : mIStart(0), mIEnd(0), mAssignedIStart(false), mAssignedIEnd(false) {}
+    void AccumulateIStart(WritingMode aWM, const LogicalRect& aRect) {
+      if (MOZ_LIKELY(mAssignedIStart)) {
+        mIStart = std::max(mIStart, aRect.IStart(aWM));
+      } else {
+        mIStart = aRect.IStart(aWM);
+        mAssignedIStart = true;
+      }
+    }
+    void AccumulateIEnd(WritingMode aWM, const LogicalRect& aRect) {
+      if (MOZ_LIKELY(mAssignedIEnd)) {
+        mIEnd = std::min(mIEnd, aRect.IEnd(aWM));
+      } else {
+        mIEnd = aRect.IEnd(aWM);
+        mAssignedIEnd = true;
+      }
+    }
+    nscoord mIStart;
+    nscoord mIEnd;
+    bool mAssignedIStart;
+    bool mAssignedIEnd;
+  };
+
+  LogicalRect GetLogicalScrollableOverflowRectRelativeToBlock(
+      nsIFrame* aFrame) const {
+    return LogicalRect(
+        mBlockWM,
+        aFrame->ScrollableOverflowRect() + aFrame->GetOffsetTo(mBlock),
+        mBlockSize);
+  }
+
+  /**
+   * Examines frames on the line to determine whether we should draw a left
+   * and/or right marker, and if so, which frames should be completely hidden
+   * and the bounds of what will be displayed between the markers.
+   * @param aLine the line we're processing
+   * @param aFramesToHide frames that should have their display items removed
+   * @param aAlignmentEdges edges the markers will be aligned to, including
+   *   the outermost edges of all text and atomic inline-level frames that
+   *   are inside the content area, and the closest IEnd edge of such a frame
+   *   outside the content area
+   * @return the area inside which we should add any markers;
+   *   this is the block's content area narrowed by any floats on this line.
+   */
+  LogicalRect ExamineLineFrames(nsLineBox* aLine, FrameHashtable* aFramesToHide,
+                                AlignmentEdges* aAlignmentEdges);
+
+  /**
+   * LineHasOverflowingText calls this to analyze edges, both the block's
+   * content edges and the hypothetical marker edges aligned at the block edges.
+   * @param aFrame the descendant frame of mBlock that we're analyzing
+   * @param aContentArea the block's content area
+   * @param aInsideMarkersArea the rectangle between the markers
+   * @param aFramesToHide frames that should have their display items removed
+   * @param aAlignmentEdges edges the markers will be aligned to, including
+   *   the outermost edges of all text and atomic inline-level frames that
+   *   are inside the content area, and the closest IEnd edge of such a frame
+   *   outside the content area
+   * @param aFoundVisibleTextOrAtomic is set to true if a text or atomic
+   *   inline-level frame is visible between the marker edges
+   * @param aClippedMarkerEdges the innermost edges of all text and atomic
+   *   inline-level frames that are clipped by the current marker width
+   */
+  void ExamineFrameSubtree(nsIFrame* aFrame, const LogicalRect& aContentArea,
+                           const LogicalRect& aInsideMarkersArea,
+                           FrameHashtable* aFramesToHide,
+                           AlignmentEdges* aAlignmentEdges,
+                           bool* aFoundVisibleTextOrAtomic,
+                           InnerClipEdges* aClippedMarkerEdges);
+
+  /**
+   * ExamineFrameSubtree calls this to analyze a frame against the hypothetical
+   * marker edges (aInsideMarkersArea) for text frames and atomic inline-level
+   * elements.  A text frame adds its extent inside aInsideMarkersArea where
+   * grapheme clusters are fully visible.  An atomic adds its border box if
+   * it's fully inside aInsideMarkersArea, otherwise the frame is added to
+   * aFramesToHide.
+   * @param aFrame the descendant frame of mBlock that we're analyzing
+   * @param aFrameType aFrame's frame type
+   * @param aInsideMarkersArea the rectangle between the markers
+   * @param aFramesToHide frames that should have their display items removed
+   * @param aAlignmentEdges the outermost edges of all text and atomic
+   *   inline-level frames that are inside the area between the markers
+   *                       inside aInsideMarkersArea
+   * @param aAlignmentEdges edges the markers will be aligned to, including
+   *   the outermost edges of all text and atomic inline-level frames that
+   *   are inside aInsideMarkersArea, and the closest IEnd edge of such a frame
+   *   outside the content area
+   * @param aFoundVisibleTextOrAtomic is set to true if a text or atomic
+   *   inline-level frame is visible between the marker edges
+   * @param aClippedMarkerEdges the innermost edges of all text and atomic
+   *   inline-level frames that are clipped by the current marker width
+   */
+  void AnalyzeMarkerEdges(nsIFrame* aFrame, mozilla::LayoutFrameType aFrameType,
+                          const LogicalRect& aInsideMarkersArea,
+                          FrameHashtable* aFramesToHide,
+                          AlignmentEdges* aAlignmentEdges,
+                          bool* aFoundVisibleTextOrAtomic,
+                          InnerClipEdges* aClippedMarkerEdges);
+
+  /**
+   * Clip or remove items given the final marker edges. ("clip" here just means
+   * assigning mVisIStartEdge/mVisIEndEdge for any nsCharClipDisplayItem that
+   * needs it; see nsDisplayList.h for a description of that item).
+   * @param aFramesToHide remove display items for these frames
+   * @param aInsideMarkersArea is the area inside the markers
+   */
+  void PruneDisplayListContents(nsDisplayList* aList,
+                                const FrameHashtable& aFramesToHide,
+                                const LogicalRect& aInsideMarkersArea);
+
+  /**
+   * ProcessLine calls this to create display items for the markers and insert
+   * them into mMarkerList.
+   * @param aLine the line we're processing
+   * @param aCreateIStart if true, create a marker on the inline start side
+   * @param aCreateIEnd if true, create a marker on the inline end side
+   * @param aInsideMarkersArea is the area inside the markers
+   * @param aContentArea is the area inside which we should add the markers;
+   *   this is the block's content area narrowed by any floats on this line.
+   */
+  void CreateMarkers(const nsLineBox* aLine, bool aCreateIStart,
+                     bool aCreateIEnd, const LogicalRect& aInsideMarkersArea,
+                     const LogicalRect& aContentArea, uint32_t aLineNumber);
+
+  LogicalRect mContentArea;
+  nsDisplayListBuilder* mBuilder;
+  nsIFrame* mBlock;
+  nsIScrollableFrame* mScrollableFrame;
+  nsDisplayList mMarkerList;
+  nsSize mBlockSize;
+  WritingMode mBlockWM;
+  bool mCanHaveInlineAxisScrollbar;
+  // When we're in a -webkit-line-clamp context, we should ignore inline-end
+  // text-overflow markers. See nsBlockFrame::IsInLineClampContext.
+  const bool mInLineClampContext;
+  bool mAdjustForPixelSnapping;
+
+  class Marker {
+   public:
+    void Init(const StyleTextOverflowSide& aStyle) {
+      mInitialized = false;
+      mISize = 0;
+      mStyle = &aStyle;
+      mIntrinsicISize = 0;
+      mHasOverflow = false;
+      mHasBlockEllipsis = false;
+      mActive = false;
+      mEdgeAligned = false;
+    }
+
+    /**
+     * Setup the marker string and calculate its size, if not done already.
+     */
+    void SetupString(nsIFrame* aFrame);
+
+    bool IsSuppressed(bool aInLineClampContext) const {
+      if (aInLineClampContext) {
+        return !mHasBlockEllipsis;
+      }
+      return mStyle->IsClip();
+    }
+    bool IsNeeded() const { return mHasOverflow || mHasBlockEllipsis; }
+    void Reset() {
+      mHasOverflow = false;
+      mHasBlockEllipsis = false;
+      mEdgeAligned = false;
+    }
+
+    // The current width of the marker, the range is [0 .. mIntrinsicISize].
+    nscoord mISize;
+    // The intrinsic width of the marker.
+    nscoord mIntrinsicISize;
+    // The text-overflow style for this side.  Ignored if we're rendering a
+    // block ellipsis.
+    const StyleTextOverflowSide* mStyle;
+    // True if there is visible overflowing inline content on this side.
+    bool mHasOverflow;
+    // True if this side has a block ellipsis (from -webkit-line-clamp).
+    bool mHasBlockEllipsis;
+    // True if mISize and mIntrinsicISize have been setup from style.
+    bool mInitialized;
+    // True if the style is not text-overflow:clip on this side and the marker
+    // won't cause the line to become empty.
+    bool mActive;
+    // True if this marker is aligned to the edge of the content box, so that
+    // when scrolling the marker doesn't jump around.
+    bool mEdgeAligned;
+  };
+
+  Marker mIStart;  // the inline start marker
+  Marker mIEnd;    // the inline end marker
+};
+
+}  // namespace css
+}  // namespace mozilla
+
+#endif /* !defined(TextOverflow_h_) */