[Line Layout API] Convert most of InlineBoxPainter to new API

Source/core/paint/InlineFlowBoxPainter.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 "config.h"
 #include "core/paint/InlineFlowBoxPainter.h"
 
 #include "core/layout/LayoutBlock.h"
 #include "core/layout/LayoutInline.h"
 #include "core/layout/LayoutView.h"
+#include "core/layout/api/LineLayoutBoxModel.h"
 #include "core/layout/api/SelectionState.h"
 #include "core/layout/line/InlineFlowBox.h"
 #include "core/paint/BoxPainter.h"
 #include "core/paint/DeprecatedPaintLayer.h"
 #include "core/paint/PaintInfo.h"
 #include "platform/graphics/GraphicsContextStateSaver.h"
 #include "platform/graphics/paint/DrawingRecorder.h"
 
 namespace blink {
 
@@ skipping 16 matching lines @@
             bool containingBlockPaintsContinuationOutline = inlineFlow.continuation() || inlineFlow.isInlineElementContinuation();
             if (containingBlockPaintsContinuationOutline) {
                 // FIXME: See https://bugs.webkit.org/show_bug.cgi?id=54690. We currently don't reconnect inline continuations
                 // after a child removal. As a result, those merged inlines do not get seperated and hence not get enclosed by
                 // anonymous blocks. In this case, it is better to bail out and paint it ourself.
                 LayoutBlock* enclosingAnonymousBlock = m_inlineFlowBox.layoutObject().containingBlock();
                 if (!enclosingAnonymousBlock->isAnonymousBlock()) {
                     containingBlockPaintsContinuationOutline = false;
                 } else {
                     cb = enclosingAnonymousBlock->containingBlock();
-                    for (LayoutBoxModelObject* box = m_inlineFlowBox.deprecatedBoxModelObject(); box != cb; box = box->parent()->enclosingBoxModelObject()) {
-                        if (box->hasSelfPaintingLayer()) {
+                    for (LineLayoutBoxModel box = m_inlineFlowBox.boxModelObject(); box != cb; box = box.parent().enclosingBoxModelObject()) {
+                        if (box.hasSelfPaintingLayer()) {
                             containingBlockPaintsContinuationOutline = false;
                             break;
                         }
                     }
                 }
             }
 
             if (containingBlockPaintsContinuationOutline) {
                 // Add ourselves to the containing block of the entire continuation so that it can
                 // paint us atomically.
@@ skipping 18 matching lines @@
     if (paintInfo.phase != PaintPhaseSelfOutline) {
         PaintInfo childInfo(paintInfo);
         childInfo.phase = paintInfo.phase == PaintPhaseChildOutlines ? PaintPhaseOutline : paintInfo.phase;
 
         if (childInfo.paintingRoot && childInfo.paintingRoot->isDescendantOf(&m_inlineFlowBox.layoutObject()))
             childInfo.paintingRoot = 0;
         else
             childInfo.updatePaintingRootForChildren(&m_inlineFlowBox.layoutObject());
 
         for (InlineBox* curr = m_inlineFlowBox.firstChild(); curr; curr = curr->nextOnLine()) {
-            if (curr->layoutObject().isText() || !curr->deprecatedBoxModelObject()->hasSelfPaintingLayer())
+            if (curr->lineLayoutItem().isText() || !curr->boxModelObject().hasSelfPaintingLayer())
                 curr->paint(childInfo, paintOffset, lineTop, lineBottom);
         }
     }
 }
 
 void InlineFlowBoxPainter::paintFillLayers(const PaintInfo& paintInfo, const Color& c, const FillLayer& fillLayer, const LayoutRect& rect, SkXfermode::Mode op)
 {
     // FIXME: This should be a for loop or similar. It's a little non-trivial to do so, however, since the layers need to be
     // painted in reverse order.
     if (fillLayer.next())
@@ skipping 144 matching lines @@
     LayoutRect localRect(frameRect);
     m_inlineFlowBox.flipForWritingMode(localRect);
     LayoutPoint adjustedPaintOffset = paintOffset + localRect.location();
 
     LayoutRect adjustedFrameRect = LayoutRect(adjustedPaintOffset, frameRect.size());
 
     LayoutRect adjustedClipRect;
     BorderPaintingType borderPaintingType = getBorderPaintType(adjustedFrameRect, adjustedClipRect);
 
     // Shadow comes first and is behind the background and border.
-    if (!m_inlineFlowBox.deprecatedBoxModelObject()->boxShadowShouldBeAppliedToBackground(BackgroundBleedNone, &m_inlineFlowBox))
+    if (!m_inlineFlowBox.boxModelObject().boxShadowShouldBeAppliedToBackground(BackgroundBleedNone, &m_inlineFlowBox))
         paintBoxShadow(paintInfo, *styleToUse, Normal, adjustedFrameRect);
 
     Color backgroundColor = m_inlineFlowBox.layoutObject().resolveColor(*styleToUse, CSSPropertyBackgroundColor);
     paintFillLayers(paintInfo, backgroundColor, styleToUse->backgroundLayers(), adjustedFrameRect);
     paintBoxShadow(paintInfo, *styleToUse, Inset, adjustedFrameRect);
 
     switch (borderPaintingType) {
     case DontPaintBorders:
         break;
     case PaintBordersWithoutClip:
@@ skipping 21 matching lines @@
     // Move x/y to our coordinates.
     LayoutRect localRect(frameRect);
     m_inlineFlowBox.flipForWritingMode(localRect);
     LayoutPoint adjustedPaintOffset = paintOffset + localRect.location();
 
     const NinePieceImage& maskNinePieceImage = m_inlineFlowBox.layoutObject().style()->maskBoxImage();
     StyleImage* maskBoxImage = m_inlineFlowBox.layoutObject().style()->maskBoxImage().image();
 
     // Figure out if we need to push a transparency layer to render our mask.
     bool pushTransparencyLayer = false;
-    bool compositedMask = m_inlineFlowBox.layoutObject().hasLayer() && m_inlineFlowBox.deprecatedBoxModelObject()->layer()->hasCompositedMask();
+    bool compositedMask = m_inlineFlowBox.layoutObject().hasLayer() && m_inlineFlowBox.boxModelObject().layer()->hasCompositedMask();
     bool flattenCompositingLayers = paintInfo.globalPaintFlags() & GlobalPaintFlattenCompositingLayers;
     SkXfermode::Mode compositeOp = SkXfermode::kSrcOver_Mode;
     if (!compositedMask || flattenCompositingLayers) {
         if ((maskBoxImage && m_inlineFlowBox.layoutObject().style()->maskLayers().hasImage()) || m_inlineFlowBox.layoutObject().style()->maskLayers().next()) {
             pushTransparencyLayer = true;
             paintInfo.context->beginLayer(1.0f, SkXfermode::kDstIn_Mode);
         } else {
             // TODO(fmalita): passing a dst-in xfer mode down to paintFillLayers/paintNinePieceImage
             //   seems dangerous: it is only correct if applied atomically (single draw call). While
             //   the heuristic above presumably ensures that is the case, this approach seems super
@@ skipping 50 matching lines @@
             rect.setHeight(logicalHeight);
         } else {
             rect.setX(logicalTop);
             rect.setWidth(logicalHeight);
         }
     }
     return rect;
 }
 
 } // namespace blink