Convert Block code to layoutObject.

Source/core/layout/LayoutBlockFlow.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 155 matching lines @@
     static_assert(sizeof(MarginInfo) == sizeof(SameSizeAsMarginInfo), "MarginInfo should stay small");
     setChildrenInline(true);
 }
 
 LayoutBlockFlow::~LayoutBlockFlow()
 {
 }
 
 LayoutBlockFlow* LayoutBlockFlow::createAnonymous(Document* document)
 {
-    LayoutBlockFlow* renderer = new LayoutBlockFlow(0);
-    renderer->setDocumentForAnonymous(document);
-    return renderer;
+    LayoutBlockFlow* layoutBlockFlow = new LayoutBlockFlow(0);
+    layoutBlockFlow->setDocumentForAnonymous(document);
+    return layoutBlockFlow;
 }
 
 LayoutObject* LayoutBlockFlow::layoutSpecialExcludedChild(bool relayoutChildren, SubtreeLayoutScope& layoutScope)
 {
     LayoutMultiColumnFlowThread* flowThread = multiColumnFlowThread();
     if (!flowThread)
         return 0;
     setLogicalTopForChild(*flowThread, borderBefore() + paddingBefore());
     flowThread->layoutColumns(relayoutChildren, layoutScope);
     determineLogicalLeftPositionForChild(*flowThread);
@@ skipping 603 matching lines @@
         // adjustLinePositionForPagination() for more details.
         LayoutRect overflow = line->logicalVisualOverflowRect(line->lineTop(), line->lineBottom());
         lineTop = std::min(line->lineTopWithLeading(), overflow.y());
     }
     return lineBottom - lineTop;
 }
 
 void LayoutBlockFlow::adjustLinePositionForPagination(RootInlineBox& lineBox, LayoutUnit& delta, LayoutFlowThread* flowThread)
 {
     // FIXME: For now we paginate using line overflow. This ensures that lines don't overlap at all when we
-    // put a strut between them for pagination purposes. However, this really isn't the desired rendering, since
+    // put a strut between them for pagination purposes. However, this really isn't the desired layout, since
     // the line on the top of the next page will appear too far down relative to the same kind of line at the top
     // of the first column.
     //
-    // The rendering we would like to see is one where the lineTopWithLeading is at the top of the column, and any line overflow
+    // The layout we would like to see is one where the lineTopWithLeading is at the top of the column, and any line overflow
     // simply spills out above the top of the column. This effect would match what happens at the top of the first column.
-    // We can't achieve this rendering, however, until we stop columns from clipping to the column bounds (thus allowing
+    // We can't achieve this layout, however, until we stop columns from clipping to the column bounds (thus allowing
     // for overflow to occur), and then cache visible overflow for each column rect.
     //
     // Furthermore, the paint we have to do when a column has overflow has to be special. We need to exclude
     // content that paints in a previous column (and content that paints in the following column).
     //
     // For now we'll at least honor the lineTopWithLeading when paginating if it is above the logical top overflow. This will
     // at least make positive leading work in typical cases.
     //
     // FIXME: Another problem with simply moving lines is that the available line width may change (because of floats).
     // Technically if the location we move the line to has a different line width than our old position, then we need to dirty the
@@ skipping 1139 matching lines @@
         LayoutBlockFlow* parentBlockFlow = this;
         const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
         FloatingObjectSetIterator end = floatingObjectSet.end();
 
         for (LayoutObject* curr = parent(); curr && !curr->isLayoutView(); curr = curr->parent()) {
             if (curr->isLayoutBlockFlow()) {
                 LayoutBlockFlow* currBlock = toLayoutBlockFlow(curr);
 
                 if (currBlock->hasOverhangingFloats()) {
                     for (FloatingObjectSetIterator it = floatingObjectSet.begin(); it != end; ++it) {
-                        LayoutBox* renderer = (*it)->layoutObject();
-                        if (currBlock->hasOverhangingFloat(renderer)) {
+                        LayoutBox* layoutBox = (*it)->layoutObject();
+                        if (currBlock->hasOverhangingFloat(layoutBox)) {
                             parentBlockFlow = currBlock;
                             break;
                         }
                     }
                 }
             }
         }
 
         parentBlockFlow->markAllDescendantsWithFloatsForLayout();
         parentBlockFlow->markSiblingsWithFloatsForLayout();
@@ skipping 45 matching lines @@
         return;
     }
     LayoutBlock::addChild(newChild, beforeChild);
 }
 
 void LayoutBlockFlow::moveAllChildrenIncludingFloatsTo(LayoutBlock* toBlock, bool fullRemoveInsert)
 {
     LayoutBlockFlow* toBlockFlow = toLayoutBlockFlow(toBlock);
     moveAllChildrenTo(toBlockFlow, fullRemoveInsert);
 
-    // When a portion of the render tree is being detached, anonymous blocks
+    // When a portion of the layout tree is being detached, anonymous blocks
     // will be combined as their children are deleted. In this process, the
     // anonymous block later in the tree is merged into the one preceeding it.
     // It can happen that the later block (this) contains floats that the
     // previous block (toBlockFlow) did not contain, and thus are not in the
     // floating objects list for toBlockFlow. This can result in toBlockFlow containing
     // floats that are not in it's floating objects list, but are in the
     // floating objects lists of siblings and parents. This can cause problems
     // when the float itself is deleted, since the deletion code assumes that
     // if a float is not in it's containing block's floating objects list, it
     // isn't in any floating objects list. In order to preserve this condition
@@ skipping 34 matching lines @@
     FloatingObjectSetIterator end = floatingObjectSet.end();
     for (FloatingObjectSetIterator it = floatingObjectSet.begin(); it != end; ++it) {
         FloatingObject* floatingObject = it->get();
         // Only issue paint invaldiations for the object if it is overhanging, is not in its own layer, and
         // is our responsibility to paint (m_shouldPaint is set). When paintAllDescendants is true, the latter
         // condition is replaced with being a descendant of us.
         if (logicalBottomForFloat(floatingObject) > logicalHeight()
             && !floatingObject->layoutObject()->hasSelfPaintingLayer()
             && (floatingObject->shouldPaint() || (paintAllDescendants && floatingObject->layoutObject()->isDescendantOf(this)))) {
 
-            LayoutBox* floatingRenderer = floatingObject->layoutObject();
-            floatingRenderer->setShouldDoFullPaintInvalidation();
-            floatingRenderer->invalidatePaintForOverhangingFloats(false);
+            LayoutBox* floatingLayoutBox = floatingObject->layoutObject();
+            floatingLayoutBox->setShouldDoFullPaintInvalidation();
+            floatingLayoutBox->invalidatePaintForOverhangingFloats(false);
         }
     }
 }
 
 void LayoutBlockFlow::invalidatePaintForOverflow()
 {
     // FIXME: We could tighten up the left and right invalidation points if we let layoutInlineChildren fill them in based off the particular lines
     // it had to lay out. We wouldn't need the hasOverflowClip() hack in that case either.
     LayoutUnit paintInvalidationLogicalLeft = logicalLeftVisualOverflow();
     LayoutUnit paintInvalidationLogicalRight = logicalRightVisualOverflow();
@@ skipping 79 matching lines @@
         break;
     case CBOTH:
         newY = lowestFloatLogicalBottom();
     default:
         break;
     }
     if (size().height() < newY)
         setLogicalHeight(newY);
 }
 
-bool LayoutBlockFlow::containsFloat(LayoutBox* renderer) const
+bool LayoutBlockFlow::containsFloat(LayoutBox* layoutBox) const
 {
-    return m_floatingObjects && m_floatingObjects->set().contains<FloatingObjectHashTranslator>(renderer);
+    return m_floatingObjects && m_floatingObjects->set().contains<FloatingObjectHashTranslator>(layoutBox);
 }
 
 void LayoutBlockFlow::removeFloatingObjects()
 {
     if (!m_floatingObjects)
         return;
 
     markSiblingsWithFloatsForLayout();
 
     m_floatingObjects->clear();
@@ skipping 295 matching lines @@
 
         if (ShapeOutsideInfo* shapeOutside = childBox->shapeOutsideInfo())
             shapeOutside->setReferenceBoxLogicalSize(logicalSizeForChild(*childBox));
 
         if (width)
             width->shrinkAvailableWidthForNewFloatIfNeeded(floatingObject);
     }
     return true;
 }
 
-bool LayoutBlockFlow::hasOverhangingFloat(LayoutBox* renderer)
+bool LayoutBlockFlow::hasOverhangingFloat(LayoutBox* layoutBox)
 {
     if (!m_floatingObjects || hasColumns() || !parent())
         return false;
 
     const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
-    FloatingObjectSetIterator it = floatingObjectSet.find<FloatingObjectHashTranslator>(renderer);
+    FloatingObjectSetIterator it = floatingObjectSet.find<FloatingObjectHashTranslator>(layoutBox);
     if (it == floatingObjectSet.end())
         return false;
 
     return logicalBottomForFloat(it->get()) > logicalHeight();
 }
 
 void LayoutBlockFlow::addIntrudingFloats(LayoutBlockFlow* prev, LayoutUnit logicalLeftOffset, LayoutUnit logicalTopOffset)
 {
     ASSERT(!avoidsFloats());
 
@@ skipping 633 matching lines @@
         if (isAnonymousBlock())
             return "LayoutBlockFlow (anonymous)";
     }
     if (isAnonymous())
         return "LayoutBlockFlow (anonymous)";
     return "LayoutBlockFlow";
 }
 
 
 } // namespace blink