Move line painting to BlockFlowPainter.

third_party/WebKit/Source/core/paint/BlockPainter.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/paint/BlockPainter.h"
 
 #include "core/editing/DragCaretController.h"
 #include "core/editing/FrameSelection.h"
-#include "core/frame/Settings.h"
-#include "core/layout/LayoutBlockFlow.h"
 #include "core/layout/LayoutFlexibleBox.h"
 #include "core/layout/LayoutInline.h"
 #include "core/layout/api/LineLayoutAPIShim.h"
 #include "core/layout/api/LineLayoutBox.h"
 #include "core/page/Page.h"
 #include "core/paint/BoxClipper.h"
 #include "core/paint/BoxPainter.h"
-#include "core/paint/InlinePainter.h"
 #include "core/paint/LayoutObjectDrawingRecorder.h"
-#include "core/paint/LineBoxListPainter.h"
 #include "core/paint/ObjectPaintProperties.h"
 #include "core/paint/PaintInfo.h"
 #include "core/paint/PaintLayer.h"
-#include "core/paint/ScopeRecorder.h"
 #include "core/paint/ScrollRecorder.h"
 #include "core/paint/ScrollableAreaPainter.h"
 #include "platform/graphics/paint/ClipRecorder.h"
 #include "wtf/Optional.h"
 
 namespace blink {
 
 void BlockPainter::paint(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     LayoutPoint adjustedPaintOffset = paintOffset + m_layoutBlock.location();
@@ skipping 139 matching lines @@
                 scrollRecorder.emplace(paintInfo.context, m_layoutBlock, paintPhase, scrollOffset);
                 scrolledPaintInfo.emplace(paintInfo);
                 AffineTransform transform;
                 transform.translate(-scrollOffset.width(), -scrollOffset.height());
                 scrolledPaintInfo->updateCullRect(transform);
             }
         }
 
         const PaintInfo& contentsPaintInfo = scrolledPaintInfo ? *scrolledPaintInfo : paintInfo;
 
-        paintContents(contentsPaintInfo, paintOffset);
-
-        if (paintPhase == PaintPhaseFloat || paintPhase == PaintPhaseSelection || paintPhase == PaintPhaseTextClip)
-            m_layoutBlock.paintFloats(contentsPaintInfo, paintOffset);
+        m_layoutBlock.paintContentsAndFloats(contentsPaintInfo, paintOffset);

[mstensho (USE GERRIT), 2016/05/18 15:12:34]

Not sure how you prefer this. We could just as well have both paintContents()
and paintFloats() as virtual methods on LayoutBlock. Or we could just have
paintContents(), and have the LayoutBlockFlow override do floats as well. Floats
are LayoutBlockFlow-specific anyway, and other parts of the code may very well
just consider them to be "content".

[chrishtr, 2016/05/18 16:50:42]

It would be good to avoid having a method related to painting floats on
LayoutBlock. What do you think of:

if (isLayoutBlockFlow(m_layoutBlock))
  toLayoutBlockFlow(m_layoutBlock).paintFloats(...)


This at least localizes the differences and seems pretty clear.

[mstensho (USE GERRIT), 2016/05/18 18:51:08]

Hmm... is it okay to initialize a BlockFlowPainter from BlockPainter? If so, the
patch can be simplified by a lot, instead of spaghettiing in and out of layout
and paint code. :) Please take a look.

     }
 
     if (shouldPaintSelfOutline(paintPhase))
         ObjectPainter(m_layoutBlock).paintOutline(paintInfo, paintOffset);
 
     // If the caret's node's layout object's containing block is this block, and the paint action is PaintPhaseForeground,
     // then paint the caret.
     if (paintPhase == PaintPhaseForeground && m_layoutBlock.hasCaret() && !LayoutObjectDrawingRecorder::useCachedDrawingIfPossible(paintInfo.context, m_layoutBlock, DisplayItem::Caret)) {
         LayoutRect bounds = m_layoutBlock.visualOverflowRect();
         bounds.moveBy(paintOffset);
@@ skipping 32 matching lines @@
         overflowRect.unite(m_layoutBlock.layoutOverflowRect());
         overflowRect.move(-m_layoutBlock.scrolledContentOffset());
     }
     m_layoutBlock.flipForWritingMode(overflowRect);
     overflowRect.moveBy(adjustedPaintOffset);
     return paintInfo.cullRect().intersectsCullRect(overflowRect);
 }
 
 void BlockPainter::paintContents(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
-    // Avoid painting descendants of the root element when stylesheets haven't loaded. This eliminates FOUC.
-    // It's ok not to draw, because later on, when all the stylesheets do load, styleResolverMayHaveChanged()
-    // on Document will trigger a full paint invalidation.
-    if (m_layoutBlock.document().didLayoutWithPendingStylesheets() && !m_layoutBlock.isLayoutView())
-        return;
-
-    if (m_layoutBlock.childrenInline()) {
-        if (shouldPaintDescendantOutlines(paintInfo.phase))
-            ObjectPainter(m_layoutBlock).paintInlineChildrenOutlines(paintInfo, paintOffset);
-        else
-            LineBoxListPainter(m_layoutBlock.lineBoxes()).paint(m_layoutBlock, paintInfo, paintOffset);
-    } else {
-        PaintInfo paintInfoForDescendants = paintInfo.forDescendants();
-        m_layoutBlock.paintChildren(paintInfoForDescendants, paintOffset);
-    }
+    DCHECK(!m_layoutBlock.childrenInline());
+    PaintInfo paintInfoForDescendants = paintInfo.forDescendants();
+    m_layoutBlock.paintChildren(paintInfoForDescendants, paintOffset);
 }
 
 } // namespace blink