webkitgtk-2.16.5HEADwebkitgtk-2.16.5master

1 files changed, 85 insertions, 142 deletions

diff --git a/Source/WebCore/rendering/SimpleLineLayoutResolver.h b/Source/WebCore/rendering/SimpleLineLayoutResolver.h
index 052f66d0a..62d2f3348 100644
--- a/Source/WebCore/rendering/SimpleLineLayoutResolver.h
+++ b/Source/WebCore/rendering/SimpleLineLayoutResolver.h
@@ -23,33 +23,20 @@
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SimpleLineLayoutResolver_h
-#define SimpleLineLayoutResolver_h
+#pragma once
 
 #include "LayoutRect.h"
 #include "RenderBlockFlow.h"
-#include "RenderText.h"
+#include "SimpleLineLayoutFlowContents.h"
 #include "SimpleLineLayoutFunctions.h"
-#include <wtf/Vector.h>
+#include <wtf/IteratorRange.h>
 #include <wtf/text/WTFString.h>
 
 namespace WebCore {
 namespace SimpleLineLayout {
 
-template <class IteratorType>
-class Range {
-public:
-    Range(IteratorType begin, IteratorType end) : m_begin(begin), m_end(end) { }
-
-    IteratorType begin() const { return m_begin; }
-    IteratorType end() const { return m_end; }
-
-private:
-    IteratorType m_begin;
-    IteratorType m_end;
-};
-
 class RunResolver {
+    WTF_MAKE_FAST_ALLOCATED;
 public:
     class Iterator;
 
@@ -59,36 +46,50 @@ public:
 
         unsigned start() const;
         unsigned end() const;
-
-        LayoutRect rect() const;
-        FloatPoint baseline() const;
-        String text() const;
+        float logicalLeft() const;
+        float logicalRight() const;
+
+        FloatRect rect() const;
+        float expansion() const;
+        ExpansionBehavior expansionBehavior() const;
+        int baselinePosition() const;
+        StringView text() const;
+        String textWithHyphen() const;
+        bool isEndOfLine() const;
+        bool hasHyphen() const { return m_iterator.simpleRun().hasHyphen; }
 
         unsigned lineIndex() const;
 
     private:
+        float computeBaselinePosition() const;
+        void constructStringForHyphenIfNeeded();
+
         const Iterator& m_iterator;
     };
 
     class Iterator {
+    friend class Run;
+    friend class RunResolver;
+    friend class LineResolver;
     public:
         Iterator(const RunResolver&, unsigned runIndex, unsigned lineIndex);
 
         Iterator& operator++();
+        Iterator& operator--();
 
         bool operator==(const Iterator&) const;
         bool operator!=(const Iterator&) const;
 
         Run operator*() const;
 
+    private:
+        const SimpleLineLayout::Run& simpleRun() const;
+        unsigned lineIndex() const { return m_lineIndex; }
         Iterator& advance();
         Iterator& advanceLines(unsigned);
-
         const RunResolver& resolver() const { return m_resolver; }
-        const SimpleLineLayout::Run& simpleRun() const;
-        unsigned lineIndex() const { return m_lineIndex; }
+        bool inQuirksMode() const { return m_resolver.m_inQuirksMode; }
 
-    private:
         const RunResolver& m_resolver;
         unsigned m_runIndex;
         unsigned m_lineIndex;
@@ -96,27 +97,35 @@ public:
 
     RunResolver(const RenderBlockFlow&, const Layout&);
 
+    const RenderBlockFlow& flow() const { return m_flowRenderer; }
+    const FlowContents& flowContents() const { return m_flowContents; }
     Iterator begin() const;
     Iterator end() const;
 
-    Range<Iterator> rangeForRect(const LayoutRect&) const;
+    WTF::IteratorRange<Iterator> rangeForRect(const LayoutRect&) const;
+    WTF::IteratorRange<Iterator> rangeForRenderer(const RenderObject&) const;
+    Iterator runForPoint(const LayoutPoint&) const;
+    WTF::IteratorRange<Iterator> rangeForRendererWithOffsets(const RenderObject&, unsigned start, unsigned end) const;
 
 private:
-    unsigned lineIndexForHeight(LayoutUnit) const;
+    enum class IndexType { First, Last };
+    unsigned lineIndexForHeight(LayoutUnit, IndexType) const;
+    unsigned adjustLineIndexForStruts(LayoutUnit, unsigned lineIndexCandidate) const;
 
+    const RenderBlockFlow& m_flowRenderer;
     const Layout& m_layout;
-    const String m_string;
+    const FlowContents m_flowContents;
     const LayoutUnit m_lineHeight;
     const LayoutUnit m_baseline;
     const LayoutUnit m_borderAndPaddingBefore;
     const float m_ascent;
     const float m_descent;
+    const float m_visualOverflowOffset;
+    const bool m_inQuirksMode;
 };
 
 class LineResolver {
 public:
-    class Iterator;
-
     class Iterator {
     public:
         explicit Iterator(RunResolver::Iterator);
@@ -125,11 +134,12 @@ public:
         bool operator==(const Iterator&) const;
         bool operator!=(const Iterator&) const;
 
-        const LayoutRect operator*() const;
+        FloatRect operator*() const;
+        // FIXME: Use a list to support multiple renderers per line.
+        const RenderObject& renderer() const;
 
     private:
         RunResolver::Iterator m_runIterator;
-        LayoutRect m_rect;
     };
 
     LineResolver(const RenderBlockFlow&, const Layout&);
@@ -137,7 +147,7 @@ public:
     Iterator begin() const;
     Iterator end() const;
 
-    Range<Iterator> rangeForRect(const LayoutRect&) const;
+    WTF::IteratorRange<Iterator> rangeForRect(const LayoutRect&) const;
 
 private:
     RunResolver m_runResolver;
@@ -146,11 +156,6 @@ private:
 RunResolver runResolver(const RenderBlockFlow&, const Layout&);
 LineResolver lineResolver(const RenderBlockFlow&, const Layout&);
 
-inline RunResolver::Run::Run(const Iterator& iterator)
-    : m_iterator(iterator)
-{
-}
-
 inline unsigned RunResolver::Run::start() const
 {
     return m_iterator.simpleRun().start;
@@ -161,43 +166,39 @@ inline unsigned RunResolver::Run::end() const
     return m_iterator.simpleRun().end;
 }
 
-inline LayoutRect RunResolver::Run::rect() const
+inline float RunResolver::Run::logicalLeft() const
 {
-    auto& resolver = m_iterator.resolver();
-    auto& run = m_iterator.simpleRun();
+    return m_iterator.simpleRun().logicalLeft;
+}
 
-    float baselinePosition = resolver.m_lineHeight * m_iterator.lineIndex() + resolver.m_baseline;
-    LayoutPoint linePosition(LayoutUnit::fromFloatFloor(run.left), roundToInt(baselinePosition - resolver.m_ascent + resolver.m_borderAndPaddingBefore));
-    LayoutSize lineSize(LayoutUnit::fromFloatCeil(run.right) - LayoutUnit::fromFloatFloor(run.left), resolver.m_ascent + resolver.m_descent);
-    return LayoutRect(linePosition, lineSize);
+inline float RunResolver::Run::logicalRight() const
+{
+    return m_iterator.simpleRun().logicalRight;
 }
 
-inline FloatPoint RunResolver::Run::baseline() const
+inline float RunResolver::Run::expansion() const
 {
-    auto& resolver = m_iterator.resolver();
-    auto& run = m_iterator.simpleRun();
+    return m_iterator.simpleRun().expansion;
+}
 
-    float baselinePosition = resolver.m_lineHeight * m_iterator.lineIndex() + resolver.m_baseline;
-    return FloatPoint(run.left, roundToInt(baselinePosition + resolver.m_borderAndPaddingBefore));
+inline ExpansionBehavior RunResolver::Run::expansionBehavior() const
+{
+    return m_iterator.simpleRun().expansionBehavior;
 }
 
-inline String RunResolver::Run::text() const
+inline int RunResolver::Run::baselinePosition() const
 {
-    auto& resolver = m_iterator.resolver();
-    auto& run = m_iterator.simpleRun();
-    return resolver.m_string.substringSharingImpl(run.start, run.end - run.start);
+    return roundToInt(computeBaselinePosition());
 }
 
-inline unsigned RunResolver::Run::lineIndex() const
+inline bool RunResolver::Run::isEndOfLine() const
 {
-    return m_iterator.lineIndex();
+    return m_iterator.simpleRun().isEndOfLine;
 }
 
-inline RunResolver::Iterator::Iterator(const RunResolver& resolver, unsigned runIndex, unsigned lineIndex)
-    : m_resolver(resolver)
-    , m_runIndex(runIndex)
-    , m_lineIndex(lineIndex)
+inline unsigned RunResolver::Run::lineIndex() const
 {
+    return m_iterator.lineIndex();
 }
 
 inline RunResolver::Iterator& RunResolver::Iterator::operator++()
@@ -205,6 +206,28 @@ inline RunResolver::Iterator& RunResolver::Iterator::operator++()
     return advance();
 }
 
+inline float RunResolver::Run::computeBaselinePosition() const
+{
+    auto& resolver = m_iterator.resolver();
+    auto offset = resolver.m_borderAndPaddingBefore + resolver.m_lineHeight * lineIndex();
+    if (!resolver.m_layout.hasLineStruts())
+        return offset + resolver.m_baseline;
+    for (auto& strutEntry : resolver.m_layout.struts()) {
+        if (strutEntry.lineBreak > lineIndex())
+            break;
+        offset += strutEntry.offset;
+    }
+    return offset + resolver.m_baseline;
+}
+
+inline RunResolver::Iterator& RunResolver::Iterator::operator--()
+{
+    --m_runIndex;
+    if (simpleRun().isEndOfLine)
+        --m_lineIndex;
+    return *this;
+}
+
 inline bool RunResolver::Iterator::operator==(const Iterator& other) const
 {
     ASSERT(&m_resolver == &other.m_resolver);
@@ -221,45 +244,11 @@ inline RunResolver::Run RunResolver::Iterator::operator*() const
     return Run(*this);
 }
 
-inline RunResolver::Iterator& RunResolver::Iterator::advance()
-{
-    if (simpleRun().isEndOfLine)
-        ++m_lineIndex;
-    ++m_runIndex;
-    return *this;
-}
-
-inline RunResolver::Iterator& RunResolver::Iterator::advanceLines(unsigned lineCount)
-{
-    unsigned runCount = m_resolver.m_layout.runCount();
-    if (runCount == m_resolver.m_layout.lineCount()) {
-        m_runIndex = std::min(runCount, m_runIndex + lineCount);
-        m_lineIndex = m_runIndex;
-        return *this;
-    }
-    unsigned target = m_lineIndex + lineCount;
-    while (m_lineIndex < target && m_runIndex < runCount)
-        advance();
-
-    return *this;
-}
-
 inline const SimpleLineLayout::Run& RunResolver::Iterator::simpleRun() const
 {
     return m_resolver.m_layout.runAt(m_runIndex);
 }
 
-inline RunResolver::RunResolver(const RenderBlockFlow& flow, const Layout& layout)
-    : m_layout(layout)
-    , m_string(toRenderText(*flow.firstChild()).text())
-    , m_lineHeight(lineHeightFromFlow(flow))
-    , m_baseline(baselineFromFlow(flow))
-    , m_borderAndPaddingBefore(flow.borderAndPaddingBefore())
-    , m_ascent(flow.style().font().fontMetrics().ascent())
-    , m_descent(flow.style().font().fontMetrics().descent())
-{
-}
-
 inline RunResolver::Iterator RunResolver::begin() const
 {
     return Iterator(*this, 0, 0);
@@ -270,34 +259,6 @@ inline RunResolver::Iterator RunResolver::end() const
     return Iterator(*this, m_layout.runCount(), m_layout.lineCount());
 }
 
-inline unsigned RunResolver::lineIndexForHeight(LayoutUnit height) const
-{
-    ASSERT(m_lineHeight);
-    float y = std::max<float>(height - m_borderAndPaddingBefore - m_baseline + m_ascent, 0);
-    return std::min<unsigned>(y / m_lineHeight, m_layout.lineCount() - 1);
-}
-
-inline Range<RunResolver::Iterator> RunResolver::rangeForRect(const LayoutRect& rect) const
-{
-    if (!m_lineHeight)
-        return Range<Iterator>(begin(), end());
-
-    unsigned firstLine = lineIndexForHeight(rect.y());
-    unsigned lastLine = lineIndexForHeight(rect.maxY());
-
-    auto rangeBegin = begin().advanceLines(firstLine);
-    if (rangeBegin == end())
-        return Range<Iterator>(end(), end());
-    auto rangeEnd = rangeBegin;
-    rangeEnd.advanceLines(lastLine - firstLine + 1);
-    return Range<Iterator>(rangeBegin, rangeEnd);
-}
-
-inline LineResolver::Iterator::Iterator(RunResolver::Iterator runIterator)
-    : m_runIterator(runIterator)
-{
-}
-
 inline LineResolver::Iterator& LineResolver::Iterator::operator++()
 {
     m_runIterator.advanceLines(1);
@@ -314,22 +275,6 @@ inline bool LineResolver::Iterator::operator!=(const Iterator& other) const
     return m_runIterator != other.m_runIterator;
 }
 
-inline const LayoutRect LineResolver::Iterator::operator*() const
-{
-    unsigned currentLine = m_runIterator.lineIndex();
-    auto it = m_runIterator;
-    LayoutRect rect = (*it).rect();
-    while (it.advance().lineIndex() == currentLine)
-        rect.unite((*it).rect());
-
-    return rect;
-}
-
-inline LineResolver::LineResolver(const RenderBlockFlow& flow, const Layout& layout)
-    : m_runResolver(flow, layout)
-{
-}
-
 inline LineResolver::Iterator LineResolver::begin() const
 {
     return Iterator(m_runResolver.begin());
@@ -340,10 +285,10 @@ inline LineResolver::Iterator LineResolver::end() const
     return Iterator(m_runResolver.end());
 }
 
-inline Range<LineResolver::Iterator> LineResolver::rangeForRect(const LayoutRect& rect) const
+inline WTF::IteratorRange<LineResolver::Iterator> LineResolver::rangeForRect(const LayoutRect& rect) const
 {
     auto runRange = m_runResolver.rangeForRect(rect);
-    return Range<Iterator>(Iterator(runRange.begin()), Iterator(runRange.end()));
+    return { Iterator(runRange.begin()), Iterator(runRange.end()) };
 }
 
 inline RunResolver runResolver(const RenderBlockFlow& flow, const Layout& layout)
@@ -358,5 +303,3 @@ inline LineResolver lineResolver(const RenderBlockFlow& flow, const Layout& layo
 
 }
 }
-
-#endif