webkitgtk-2.4.9webkitgtk-2.4.9

1 files changed, 120 insertions, 40 deletions

diff --git a/Source/WebCore/rendering/SimpleLineLayoutResolver.h b/Source/WebCore/rendering/SimpleLineLayoutResolver.h
index 1da4599cd..052f66d0a 100644
--- a/Source/WebCore/rendering/SimpleLineLayoutResolver.h
+++ b/Source/WebCore/rendering/SimpleLineLayoutResolver.h
@@ -28,7 +28,7 @@
 
 #include "LayoutRect.h"
 #include "RenderBlockFlow.h"
-#include "SimpleLineLayoutFlowContents.h"
+#include "RenderText.h"
 #include "SimpleLineLayoutFunctions.h"
 #include <wtf/Vector.h>
 #include <wtf/text/WTFString.h>
@@ -50,7 +50,6 @@ private:
 };
 
 class RunResolver {
-    WTF_MAKE_FAST_ALLOCATED;
 public:
     class Iterator;
 
@@ -61,42 +60,35 @@ public:
         unsigned start() const;
         unsigned end() const;
 
-        FloatRect rect() const;
-        int baselinePosition() const;
-        StringView text() const;
-        bool isEndOfLine() const;
+        LayoutRect rect() const;
+        FloatPoint baseline() const;
+        String text() const;
 
         unsigned lineIndex() const;
 
     private:
-        float computeBaselinePosition() const;
-
         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; }
-        bool inQuirksMode() const { return m_resolver.m_inQuirksMode; }
+        const SimpleLineLayout::Run& simpleRun() const;
+        unsigned lineIndex() const { return m_lineIndex; }
 
+    private:
         const RunResolver& m_resolver;
         unsigned m_runIndex;
         unsigned m_lineIndex;
@@ -104,26 +96,21 @@ public:
 
     RunResolver(const RenderBlockFlow&, const Layout&);
 
-    const RenderBlockFlow& flow() const { return m_flowRenderer; }
     Iterator begin() const;
     Iterator end() const;
 
     Range<Iterator> rangeForRect(const LayoutRect&) const;
-    Range<Iterator> rangeForRenderer(const RenderObject&) const;
 
 private:
-    enum class IndexType { First, Last };
-    unsigned lineIndexForHeight(LayoutUnit, IndexType) const;
+    unsigned lineIndexForHeight(LayoutUnit) const;
 
-    const RenderBlockFlow& m_flowRenderer;
     const Layout& m_layout;
-    const FlowContents m_flowContents;
+    const String m_string;
     const LayoutUnit m_lineHeight;
     const LayoutUnit m_baseline;
     const LayoutUnit m_borderAndPaddingBefore;
     const float m_ascent;
     const float m_descent;
-    const bool m_inQuirksMode;
 };
 
 class LineResolver {
@@ -138,7 +125,7 @@ public:
         bool operator==(const Iterator&) const;
         bool operator!=(const Iterator&) const;
 
-        const FloatRect operator*() const;
+        const LayoutRect operator*() const;
 
     private:
         RunResolver::Iterator m_runIterator;
@@ -159,6 +146,11 @@ 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;
@@ -169,38 +161,48 @@ inline unsigned RunResolver::Run::end() const
     return m_iterator.simpleRun().end;
 }
 
-inline int RunResolver::Run::baselinePosition() const
+inline LayoutRect RunResolver::Run::rect() const
 {
-    return roundToInt(computeBaselinePosition());
+    auto& resolver = m_iterator.resolver();
+    auto& run = m_iterator.simpleRun();
+
+    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 bool RunResolver::Run::isEndOfLine() const
+inline FloatPoint RunResolver::Run::baseline() const
 {
-    return m_iterator.simpleRun().isEndOfLine;
+    auto& resolver = m_iterator.resolver();
+    auto& run = m_iterator.simpleRun();
+
+    float baselinePosition = resolver.m_lineHeight * m_iterator.lineIndex() + resolver.m_baseline;
+    return FloatPoint(run.left, roundToInt(baselinePosition + resolver.m_borderAndPaddingBefore));
 }
 
-inline unsigned RunResolver::Run::lineIndex() const
+inline String RunResolver::Run::text() const
 {
-    return m_iterator.lineIndex();
+    auto& resolver = m_iterator.resolver();
+    auto& run = m_iterator.simpleRun();
+    return resolver.m_string.substringSharingImpl(run.start, run.end - run.start);
 }
 
-inline RunResolver::Iterator& RunResolver::Iterator::operator++()
+inline unsigned RunResolver::Run::lineIndex() const
 {
-    return advance();
+    return m_iterator.lineIndex();
 }
 
-inline float RunResolver::Run::computeBaselinePosition() const
+inline RunResolver::Iterator::Iterator(const RunResolver& resolver, unsigned runIndex, unsigned lineIndex)
+    : m_resolver(resolver)
+    , m_runIndex(runIndex)
+    , m_lineIndex(lineIndex)
 {
-    auto& resolver = m_iterator.resolver();
-    return resolver.m_lineHeight * lineIndex() + resolver.m_baseline + resolver.m_borderAndPaddingBefore;
 }
 
-inline RunResolver::Iterator& RunResolver::Iterator::operator--()
+inline RunResolver::Iterator& RunResolver::Iterator::operator++()
 {
-    --m_runIndex;
-    if (simpleRun().isEndOfLine)
-        --m_lineIndex;
-    return *this;
+    return advance();
 }
 
 inline bool RunResolver::Iterator::operator==(const Iterator& other) const
@@ -219,11 +221,45 @@ 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);
@@ -234,6 +270,34 @@ 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);
@@ -250,6 +314,22 @@ 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());