[Line Layout API] Convert AbstractInlineTextBox to new line layout API

third_party/WebKit/Source/core/layout/line/AbstractInlineTextBox.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 21 matching lines @@
 #include "core/layout/line/AbstractInlineTextBox.h"
 
 #include "core/dom/AXObjectCache.h"
 #include "core/editing/iterators/TextIterator.h"
 #include "platform/text/TextBreakIterator.h"
 
 namespace blink {
 
 AbstractInlineTextBox::InlineToAbstractInlineTextBoxHashMap* AbstractInlineTextBox::gAbstractInlineTextBoxMap = nullptr;
 
-PassRefPtr<AbstractInlineTextBox> AbstractInlineTextBox::getOrCreate(LayoutText* layoutText, InlineTextBox* inlineTextBox)
+PassRefPtr<AbstractInlineTextBox> AbstractInlineTextBox::getOrCreate(LineLayoutText lineLayoutText, InlineTextBox* inlineTextBox)
 {
     if (!inlineTextBox)
         return nullptr;
 
     if (!gAbstractInlineTextBoxMap)
         gAbstractInlineTextBoxMap = new InlineToAbstractInlineTextBoxHashMap();
 
     InlineToAbstractInlineTextBoxHashMap::const_iterator it = gAbstractInlineTextBoxMap->find(inlineTextBox);
     if (it != gAbstractInlineTextBoxMap->end())
         return it->value;
 
-    RefPtr<AbstractInlineTextBox> obj = adoptRef(new AbstractInlineTextBox(layoutText, inlineTextBox));
+    RefPtr<AbstractInlineTextBox> obj = adoptRef(new AbstractInlineTextBox(lineLayoutText, inlineTextBox));
     gAbstractInlineTextBoxMap->set(inlineTextBox, obj);
     return obj;
 }
 
 void AbstractInlineTextBox::willDestroy(InlineTextBox* inlineTextBox)
 {
     if (!gAbstractInlineTextBoxMap)
         return;
 
     InlineToAbstractInlineTextBoxHashMap::const_iterator it = gAbstractInlineTextBoxMap->find(inlineTextBox);
     if (it != gAbstractInlineTextBoxMap->end()) {
         it->value->detach();
         gAbstractInlineTextBoxMap->remove(inlineTextBox);
     }
 }
 
 AbstractInlineTextBox::~AbstractInlineTextBox()
 {
-    ASSERT(!m_layoutText);
+    ASSERT(!m_lineLayoutItem);
     ASSERT(!m_inlineTextBox);
 }
 
 void AbstractInlineTextBox::detach()
 {
-    if (Node* node = m_layoutText->node()) {
+    if (Node* node = m_lineLayoutItem.node()) {
         if (AXObjectCache* cache = node->document().existingAXObjectCache())
             cache->remove(this);
     }
 
-    m_layoutText = 0;
-    m_inlineTextBox = 0;
+    m_lineLayoutItem = LineLayoutText(nullptr);
+    m_inlineTextBox = nullptr;
 }
 
 PassRefPtr<AbstractInlineTextBox> AbstractInlineTextBox::nextInlineTextBox() const
 {
     ASSERT(!m_inlineTextBox || !m_inlineTextBox->lineLayoutItem().needsLayout());
     if (!m_inlineTextBox)
         return nullptr;
 
-    return getOrCreate(m_layoutText, m_inlineTextBox->nextTextBox());
+    return getOrCreate(m_lineLayoutItem, m_inlineTextBox->nextTextBox());
 }
 
 LayoutRect AbstractInlineTextBox::bounds() const
 {
-    if (!m_inlineTextBox || !m_layoutText)
+    if (!m_inlineTextBox || !m_lineLayoutItem)
         return LayoutRect();
 
     FloatRect boundaries(m_inlineTextBox->calculateBoundaries());
-    return LayoutRect(m_layoutText->localToAbsoluteQuad(boundaries).enclosingBoundingBox());
+    return LayoutRect(m_lineLayoutItem.localToAbsoluteQuad(boundaries).enclosingBoundingBox());
 }
 
 unsigned AbstractInlineTextBox::len() const
 {
     if (!m_inlineTextBox)
         return 0;
 
     return m_inlineTextBox->len();
 }
 
 AbstractInlineTextBox::Direction AbstractInlineTextBox::direction() const
 {
-    if (!m_inlineTextBox || !m_layoutText)
+    if (!m_inlineTextBox || !m_lineLayoutItem)
         return LeftToRight;
 
-    if (m_layoutText->style()->isHorizontalWritingMode())
+    if (m_lineLayoutItem.style()->isHorizontalWritingMode())
         return (m_inlineTextBox->direction() == RTL ? RightToLeft : LeftToRight);
     return (m_inlineTextBox->direction() == RTL ? BottomToTop : TopToBottom);
 }
 
 void AbstractInlineTextBox::characterWidths(Vector<float>& widths) const
 {
     if (!m_inlineTextBox)
         return;
 
     m_inlineTextBox->characterWidths(widths);
@@ skipping 16 matching lines @@
     while (pos >= 0 && pos < len) {
         int next = iterator->next();
         if (isWordTextBreak(iterator))
             words.append(WordBoundaries(pos, next));
         pos = next;
     }
 }
 
 String AbstractInlineTextBox::text() const
 {
-    if (!m_inlineTextBox || !m_layoutText)
+    if (!m_inlineTextBox || !m_lineLayoutItem)
         return String();
 
     unsigned start = m_inlineTextBox->start();
     unsigned len = m_inlineTextBox->len();
-    if (Node* node = m_layoutText->node()) {
+    if (Node* node = m_lineLayoutItem.node()) {
         if (node->isTextNode())
             return plainText(EphemeralRange(Position(node, start), Position(node, start + len)), TextIteratorIgnoresStyleVisibility);
         return plainText(EphemeralRange(Position(node, PositionAnchorType::BeforeAnchor), Position(node, PositionAnchorType::AfterAnchor)), TextIteratorIgnoresStyleVisibility);
     }
 
-    String result = m_layoutText->text().substring(start, len).simplifyWhiteSpace(WTF::DoNotStripWhiteSpace);
+    String result = m_lineLayoutItem.text().substring(start, len).simplifyWhiteSpace(WTF::DoNotStripWhiteSpace);
     if (m_inlineTextBox->nextTextBox() && m_inlineTextBox->nextTextBox()->start() > m_inlineTextBox->end() && result.length() && !result.right(1).containsOnlyWhitespace())
         return result + " ";
     return result;
 }
 
 bool AbstractInlineTextBox::isFirst() const
 {
     ASSERT(!m_inlineTextBox || !m_inlineTextBox->lineLayoutItem().needsLayout());
     return !m_inlineTextBox || !m_inlineTextBox->prevTextBox();
 }
 
 bool AbstractInlineTextBox::isLast() const
 {
     ASSERT(!m_inlineTextBox || !m_inlineTextBox->lineLayoutItem().needsLayout());
     return !m_inlineTextBox || !m_inlineTextBox->nextTextBox();
 }
 
 PassRefPtr<AbstractInlineTextBox> AbstractInlineTextBox::nextOnLine() const
 {
     ASSERT(!m_inlineTextBox || !m_inlineTextBox->lineLayoutItem().needsLayout());
     if (!m_inlineTextBox)
         return nullptr;
 
     InlineBox* next = m_inlineTextBox->nextOnLine();
     if (next && next->isInlineTextBox())
-        return getOrCreate(&toInlineTextBox(next)->layoutObject(), toInlineTextBox(next));
+        return getOrCreate(toInlineTextBox(next)->lineLayoutItem(), toInlineTextBox(next));
 
     return nullptr;
 }
 
 PassRefPtr<AbstractInlineTextBox> AbstractInlineTextBox::previousOnLine() const
 {
     ASSERT(!m_inlineTextBox || !m_inlineTextBox->lineLayoutItem().needsLayout());
     if (!m_inlineTextBox)
         return nullptr;
 
     InlineBox* previous = m_inlineTextBox->prevOnLine();
     if (previous && previous->isInlineTextBox())
-        return getOrCreate(&toInlineTextBox(previous)->layoutObject(), toInlineTextBox(previous));
+        return getOrCreate(toInlineTextBox(previous)->lineLayoutItem(), toInlineTextBox(previous));
 
     return nullptr;
 }
 
 } // namespace blink