Move rendering/RenderObject to layout/LayoutObject.

Source/core/rendering/TextAutosizer.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 53 matching lines @@
     virtual void performTask(ExecutionContext*)
     {
         m_element->setAttribute("data-autosizing", m_value, ASSERT_NO_EXCEPTION);
     }
 
 private:
     RefPtrWillBePersistent<Element> m_element;
     AtomicString m_value;
 };
 
-static void writeDebugInfo(RenderObject* renderer, const AtomicString& output)
+static void writeDebugInfo(LayoutObject* renderer, const AtomicString& output)
 {
     Node* node = renderer->node();
     if (!node)
         return;
     if (node->isDocumentNode())
         node = toDocument(node)->documentElement();
     if (!node->isElementNode())
         return;
     node->document().postTask(adoptPtr(new WriteDebugInfoTask(toElement(node), output)));
 }
@@ skipping 23 matching lines @@
         pageInfo = String::format("; pageinfo: bm %f * (lw %d / fw %d)",
             m_pageInfo.m_baseMultiplier, m_pageInfo.m_layoutWidth, m_pageInfo.m_frameWidth);
     }
     float multiplier = cluster->m_flags & SUPPRESSING ? 1.0 : cluster->m_multiplier;
     writeDebugInfo(const_cast<RenderBlock*>(cluster->m_root),
         AtomicString(String::format("cluster: %f %s%s", multiplier,
             explanation.utf8().data(), pageInfo.utf8().data())));
 }
 #endif
 
-static const RenderObject* parentElementRenderer(const RenderObject* renderer)
+static const LayoutObject* parentElementRenderer(const LayoutObject* renderer)
 {
     // At style recalc, the renderer's parent may not be attached,
     // so we need to obtain this from the DOM tree.
     const Node* node = renderer->node();
     if (!node)
         return 0;
 
     // FIXME: This should be using NodeRenderingTraversal::parent().
     if (Element* parent = node->parentElement())
         return parent->renderer();
     return 0;
 }
 
-static bool isNonTextAreaFormControl(const RenderObject* renderer)
+static bool isNonTextAreaFormControl(const LayoutObject* renderer)
 {
     const Node* node = renderer ? renderer->node() : 0;
     if (!node || !node->isElementNode())
         return false;
     const Element* element = toElement(node);
 
     return (element->isFormControlElement() && !isHTMLTextAreaElement(element));
 }
 
-static bool isPotentialClusterRoot(const RenderObject* renderer)
+static bool isPotentialClusterRoot(const LayoutObject* renderer)
 {
     // "Potential cluster roots" are the smallest unit for which we can
     // enable/disable text autosizing.
     // - Must not be inline, as different multipliers on one line looks terrible.
     //   Exceptions are inline-block and alike elements (inline-table, -webkit-inline-*),
     //   as they often contain entire multi-line columns of text.
     // - Must not be normal list items, as items in the same list should look
     //   consistent, unless they are floating or position:absolute/fixed.
     Node* node = renderer->generatingNode();
     if (node && !node->hasChildren())
@@ skipping 29 matching lines @@
 static bool blockIsRowOfLinks(const RenderBlock* block)
 {
     // A "row of links" is a block for which:
     //  1. It does not contain non-link text elements longer than 3 characters
     //  2. It contains a minimum of 3 inline links and all links should
     //     have the same specified font size.
     //  3. It should not contain <br> elements.
     //  4. It should contain only inline elements unless they are containers,
     //     children of link elements or children of sub-containers.
     int linkCount = 0;
-    RenderObject* renderer = block->firstChild();
+    LayoutObject* renderer = block->firstChild();
     float matchingFontSize = -1;
 
     while (renderer) {
         if (!isPotentialClusterRoot(renderer)) {
             if (renderer->isText() && toRenderText(renderer)->text().stripWhiteSpace().length() > 3)
                 return false;
             if (!renderer->isInline() || renderer->isBR())
                 return false;
         }
         if (renderer->style()->isLink()) {
@@ skipping 30 matching lines @@
         if (block->isFloating())
             return false;
     }
     return false;
 }
 
 static bool blockOrImmediateChildrenAreFormControls(const RenderBlock* block)
 {
     if (isNonTextAreaFormControl(block))
         return true;
-    const RenderObject* renderer = block->firstChild();
+    const LayoutObject* renderer = block->firstChild();
     while (renderer) {
         if (isNonTextAreaFormControl(renderer))
             return true;
         renderer = renderer->nextSibling();
     }
 
     return false;
 }
 
 // Some blocks are not autosized even if their parent cluster wants them to.
@@ skipping 79 matching lines @@
         prepareClusterStack(block->parent());
     } else if (block == currentCluster()->m_root) {
         // Ignore beginLayout on the same block twice.
         // This can happen with paginated overflow.
         return StopLayout;
     }
 
     return ContinueLayout;
 }
 
-void TextAutosizer::prepareClusterStack(const RenderObject* renderer)
+void TextAutosizer::prepareClusterStack(const LayoutObject* renderer)
 {
     if (!renderer)
         return;
     prepareClusterStack(renderer->parent());
 
     if (renderer->isRenderBlock()) {
         const RenderBlock* block = toRenderBlock(renderer);
 #if ENABLE(ASSERT)
         m_blocksThatHaveBegunLayout.add(block);
 #endif
@@ skipping 41 matching lines @@
     ASSERT(table);
     ASSERT(!table->style()->isFixedTableLayout());
     ASSERT(table->containingBlock());
 
     Cluster* cluster = currentCluster();
     if (cluster->m_root != table)
         return;
 
     // Pre-inflate cells that have enough text so that their inflated preferred widths will be used
     // for column sizing.
-    for (RenderObject* section = table->firstChild(); section; section = section->nextSibling()) {
+    for (LayoutObject* section = table->firstChild(); section; section = section->nextSibling()) {
         if (!section->isTableSection())
             continue;
         for (LayoutTableRow* row = toLayoutTableSection(section)->firstRow(); row; row = row->nextRow()) {
             for (LayoutTableCell* cell = row->firstCell(); cell; cell = cell->nextCell()) {
                 if (!cell->needsLayout())
                     continue;
 
                 beginLayout(cell);
                 inflate(cell, DescendToInnerBlocks);
                 endLayout(cell);
@@ skipping 14 matching lines @@
 #if ENABLE(ASSERT)
         m_blocksThatHaveBegunLayout.clear();
 #endif
     // Tables can create two layout scopes for the same block so the isEmpty
     // check below is needed to guard against endLayout being called twice.
     } else if (!m_clusterStack.isEmpty() && currentCluster()->m_root == block) {
         m_clusterStack.removeLast();
     }
 }
 
-float TextAutosizer::inflate(RenderObject* parent, InflateBehavior behavior, float multiplier)
+float TextAutosizer::inflate(LayoutObject* parent, InflateBehavior behavior, float multiplier)
 {
     Cluster* cluster = currentCluster();
     bool hasTextChild = false;
 
-    RenderObject* child = 0;
+    LayoutObject* child = 0;
     if (parent->isRenderBlock() && (parent->childrenInline() || behavior == DescendToInnerBlocks))
         child = toRenderBlock(parent)->firstChild();
     else if (parent->isRenderInline())
         child = toRenderInline(parent)->firstChild();
 
     while (child) {
         if (child->isText()) {
             hasTextChild = true;
             // We only calculate this multiplier on-demand to ensure the parent block of this text
             // has entered layout.
@@ skipping 106 matching lines @@
 {
     Page * page = m_document->page();
     ASSERT(page);
     return page->settings().pinchVirtualViewportEnabled() ?
         page->frameHost().pinchViewport().size() :
         page->deprecatedLocalMainFrame()->view()->unscaledVisibleContentSize(IncludeScrollbars);
 }
 
 void TextAutosizer::resetMultipliers()
 {
-    RenderObject* renderer = m_document->renderView();
+    LayoutObject* renderer = m_document->renderView();
     while (renderer) {
         if (RenderStyle* style = renderer->style()) {
             if (style->textAutosizingMultiplier() != 1)
                 applyMultiplier(renderer, 1, LayoutNeeded);
         }
         renderer = renderer->nextInPreOrder();
     }
 }
 
 void TextAutosizer::setAllTextNeedsLayout()
 {
-    RenderObject* renderer = m_document->renderView();
+    LayoutObject* renderer = m_document->renderView();
     while (renderer) {
         if (renderer->isText())
             renderer->setNeedsLayoutAndFullPaintInvalidation();
         renderer = renderer->nextInPreOrder();
     }
 }
 
-TextAutosizer::BlockFlags TextAutosizer::classifyBlock(const RenderObject* renderer, BlockFlags mask) const
+TextAutosizer::BlockFlags TextAutosizer::classifyBlock(const LayoutObject* renderer, BlockFlags mask) const
 {
     if (!renderer->isRenderBlock())
         return 0;
 
     const RenderBlock* block = toRenderBlock(renderer);
     BlockFlags flags = 0;
 
     if (isPotentialClusterRoot(block)) {
         if (mask & POTENTIAL_ROOT)
             flags |= POTENTIAL_ROOT;
@@ skipping 33 matching lines @@
 
     if (cluster->m_flags & SUPPRESSING) {
         cluster->m_hasEnoughTextToAutosize = NotEnoughText;
         return false;
     }
 
     // 4 lines of text is considered enough to autosize.
     float minimumTextLengthToAutosize = widthFromBlock(widthProvider) * 4;
 
     float length = 0;
-    RenderObject* descendant = root->firstChild();
+    LayoutObject* descendant = root->firstChild();
     while (descendant) {
         if (descendant->isRenderBlock()) {
             if (classifyBlock(descendant, INDEPENDENT | SUPPRESSING)) {
                 descendant = descendant->nextInPreOrderAfterChildren(root);
                 continue;
             }
         } else if (descendant->isText()) {
             // Note: Using text().stripWhiteSpace().length() instead of renderedTextLength() because
             // the lineboxes will not be built until layout. These values can be different.
             // Note: This is an approximation assuming each character is 1em wide.
             length += toRenderText(descendant)->text().stripWhiteSpace().length() * descendant->style()->specifiedFontSize();
 
             if (length >= minimumTextLengthToAutosize) {
                 cluster->m_hasEnoughTextToAutosize = HasEnoughText;
                 return true;
             }
         }
         descendant = descendant->nextInPreOrder(root);
     }
 
     cluster->m_hasEnoughTextToAutosize = NotEnoughText;
     return false;
 }
 
-TextAutosizer::Fingerprint TextAutosizer::getFingerprint(const RenderObject* renderer)
+TextAutosizer::Fingerprint TextAutosizer::getFingerprint(const LayoutObject* renderer)
 {
     Fingerprint result = m_fingerprintMapper.get(renderer);
     if (!result) {
         result = computeFingerprint(renderer);
         m_fingerprintMapper.add(renderer, result);
     }
     return result;
 }
 
-TextAutosizer::Fingerprint TextAutosizer::computeFingerprint(const RenderObject* renderer)
+TextAutosizer::Fingerprint TextAutosizer::computeFingerprint(const LayoutObject* renderer)
 {
     Node* node = renderer->generatingNode();
     if (!node || !node->isElementNode())
         return 0;
 
     FingerprintSourceData data;
-    if (const RenderObject* parent = parentElementRenderer(renderer))
+    if (const LayoutObject* parent = parentElementRenderer(renderer))
         data.m_parentHash = getFingerprint(parent);
 
     data.m_qualifiedNameHash = QualifiedNameHash::hash(toElement(node)->tagQName());
 
     if (RenderStyle* style = renderer->style()) {
         data.m_packedStyleProperties = style->direction();
         data.m_packedStyleProperties |= (style->position() << 1);
         data.m_packedStyleProperties |= (style->floating() << 4);
         data.m_packedStyleProperties |= (style->display() << 6);
         data.m_packedStyleProperties |= (style->width().type() << 11);
@@ skipping 193 matching lines @@
     if (!cluster->m_deepestBlockContainingAllText)
         cluster->m_deepestBlockContainingAllText = deepestBlockContainingAllText(cluster->m_root);
 
     return cluster->m_deepestBlockContainingAllText;
 }
 
 // FIXME: Refactor this to look more like TextAutosizer::deepestCommonAncestor.
 const RenderBlock* TextAutosizer::deepestBlockContainingAllText(const RenderBlock* root) const
 {
     size_t firstDepth = 0;
-    const RenderObject* firstTextLeaf = findTextLeaf(root, firstDepth, First);
+    const LayoutObject* firstTextLeaf = findTextLeaf(root, firstDepth, First);
     if (!firstTextLeaf)
         return root;
 
     size_t lastDepth = 0;
-    const RenderObject* lastTextLeaf = findTextLeaf(root, lastDepth, Last);
+    const LayoutObject* lastTextLeaf = findTextLeaf(root, lastDepth, Last);
     ASSERT(lastTextLeaf);
 
     // Equalize the depths if necessary. Only one of the while loops below will get executed.
-    const RenderObject* firstNode = firstTextLeaf;
-    const RenderObject* lastNode = lastTextLeaf;
+    const LayoutObject* firstNode = firstTextLeaf;
+    const LayoutObject* lastNode = lastTextLeaf;
     while (firstDepth > lastDepth) {
         firstNode = firstNode->parent();
         --firstDepth;
     }
     while (lastDepth > firstDepth) {
         lastNode = lastNode->parent();
         --lastDepth;
     }
 
     // Go up from both nodes until the parent is the same. Both pointers will point to the LCA then.
@@ skipping 10 matching lines @@
     // its text node's lowest common ancestor as isAutosizingCluster would have made them into their
     // own independent cluster.
     const RenderBlock* containingBlock = firstNode->containingBlock();
     if (!containingBlock)
         return root;
 
     ASSERT(containingBlock->isDescendantOf(root));
     return containingBlock;
 }
 
-const RenderObject* TextAutosizer::findTextLeaf(const RenderObject* parent, size_t& depth, TextLeafSearch firstOrLast) const
+const LayoutObject* TextAutosizer::findTextLeaf(const LayoutObject* parent, size_t& depth, TextLeafSearch firstOrLast) const
 {
     // List items are treated as text due to the marker.
     // The actual renderer for the marker (RenderListMarker) may not be in the tree yet since it is added during layout.
     if (parent->isListItem())
         return parent;
 
     if (parent->isText())
         return parent;
 
     ++depth;
-    const RenderObject* child = (firstOrLast == First) ? parent->slowFirstChild() : parent->slowLastChild();
+    const LayoutObject* child = (firstOrLast == First) ? parent->slowFirstChild() : parent->slowLastChild();
     while (child) {
         // Note: At this point clusters may not have been created for these blocks so we cannot rely
         //       on m_clusters. Instead, we use a best-guess about whether the block will become a cluster.
         if (!classifyBlock(child, INDEPENDENT)) {
-            if (const RenderObject* leaf = findTextLeaf(child, depth, firstOrLast))
+            if (const LayoutObject* leaf = findTextLeaf(child, depth, firstOrLast))
                 return leaf;
         }
         child = (firstOrLast == First) ? child->nextSibling() : child->previousSibling();
     }
     --depth;
 
     return 0;
 }
 
-void TextAutosizer::applyMultiplier(RenderObject* renderer, float multiplier, RelayoutBehavior relayoutBehavior)
+void TextAutosizer::applyMultiplier(LayoutObject* renderer, float multiplier, RelayoutBehavior relayoutBehavior)
 {
     ASSERT(renderer && renderer->style());
     RenderStyle* currentStyle = renderer->style();
     if (currentStyle->textAutosizingMultiplier() == multiplier)
         return;
 
     // We need to clone the render style to avoid breaking style sharing.
     RefPtr<RenderStyle> style = RenderStyle::clone(currentStyle);
     style->setTextAutosizingMultiplier(multiplier);
     style->setUnique();
@@ skipping 60 matching lines @@
         Fingerprint fingerprint = fingerprintIt->key;
         BlockSet* blocks = fingerprintIt->value.get();
         for (BlockSet::iterator blockIt = blocks->begin(); blockIt != blocks->end(); ++blockIt) {
             const RenderBlock* block = (*blockIt);
             ASSERT(m_fingerprints.get(block) == fingerprint);
         }
     }
 }
 #endif
 
-void TextAutosizer::FingerprintMapper::add(const RenderObject* renderer, Fingerprint fingerprint)
+void TextAutosizer::FingerprintMapper::add(const LayoutObject* renderer, Fingerprint fingerprint)
 {
     remove(renderer);
 
     m_fingerprints.set(renderer, fingerprint);
 #if ENABLE(ASSERT)
     assertMapsAreConsistent();
 #endif
 }
 
 void TextAutosizer::FingerprintMapper::addTentativeClusterRoot(const RenderBlock* block, Fingerprint fingerprint)
 {
     add(block, fingerprint);
 
     ReverseFingerprintMap::AddResult addResult = m_blocksForFingerprint.add(fingerprint, PassOwnPtr<BlockSet>());
     if (addResult.isNewEntry)
         addResult.storedValue->value = adoptPtr(new BlockSet);
     addResult.storedValue->value->add(block);
 #if ENABLE(ASSERT)
     assertMapsAreConsistent();
 #endif
 }
 
-bool TextAutosizer::FingerprintMapper::remove(const RenderObject* renderer)
+bool TextAutosizer::FingerprintMapper::remove(const LayoutObject* renderer)
 {
     Fingerprint fingerprint = m_fingerprints.take(renderer);
     if (!fingerprint || !renderer->isRenderBlock())
         return false;
 
     ReverseFingerprintMap::iterator blocksIter = m_blocksForFingerprint.find(fingerprint);
     if (blocksIter == m_blocksForFingerprint.end())
         return false;
 
     BlockSet& blocks = *blocksIter->value;
     blocks.remove(toRenderBlock(renderer));
     if (blocks.isEmpty())
         m_blocksForFingerprint.remove(blocksIter);
 #if ENABLE(ASSERT)
     assertMapsAreConsistent();
 #endif
     return true;
 }
 
-TextAutosizer::Fingerprint TextAutosizer::FingerprintMapper::get(const RenderObject* renderer)
+TextAutosizer::Fingerprint TextAutosizer::FingerprintMapper::get(const LayoutObject* renderer)
 {
     return m_fingerprints.get(renderer);
 }
 
 TextAutosizer::BlockSet* TextAutosizer::FingerprintMapper::getTentativeClusterRoots(Fingerprint fingerprint)
 {
     return m_blocksForFingerprint.get(fingerprint);
 }
 
 TextAutosizer::LayoutScope::LayoutScope(RenderBlock* block)
@@ skipping 70 matching lines @@
     }
     return computedSize;
 }
 
 void TextAutosizer::trace(Visitor* visitor)
 {
     visitor->trace(m_document);
 }
 
 } // namespace blink