Break LayoutObject dependency for NinePieceImagePainter

third_party/WebKit/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 "core/paint/InlineFlowBoxPainter.h"
 
 #include "core/layout/api/LineLayoutAPIShim.h"
 #include "core/layout/line/RootInlineBox.h"
 #include "core/paint/BoxPainter.h"
+#include "core/paint/NinePieceImagePainter.h"
 #include "core/paint/PaintInfo.h"
 #include "core/paint/PaintLayer.h"
 #include "platform/graphics/GraphicsContextStateSaver.h"
 #include "platform/graphics/paint/DrawingRecorder.h"
 
 namespace blink {
 
 void InlineFlowBoxPainter::Paint(const PaintInfo& paint_info,
                                  const LayoutPoint& paint_offset,
                                  const LayoutUnit line_top,
@@ skipping 214 matching lines @@
       return kPaintBordersWithoutClip;
 
     // We have a border image that spans multiple lines.
     adjusted_clip_rect = PixelSnappedIntRect(ClipRectForNinePieceImageStrip(
         inline_flow_box_, border_image, adjusted_frame_rect));
     return kPaintBordersWithClip;
   }
   return kDontPaintBorders;
 }
 
+static inline Node* GetNode(const LayoutObject* box_model) {
+  Node* node = nullptr;
+  for (const LayoutObject* obj = box_model; obj && !node; obj = obj->Parent())
+    node = obj->GeneratingNode();
+  return node;
+}
+
 void InlineFlowBoxPainter::PaintBoxDecorationBackground(
     const PaintInfo& paint_info,
     const LayoutPoint& paint_offset,
     const LayoutRect& cull_rect) {
   DCHECK(paint_info.phase == kPaintPhaseForeground);
   if (inline_flow_box_.GetLineLayoutItem().Style()->Visibility() !=
       EVisibility::kVisible)
     return;
 
   // You can use p::first-line to specify a background. If so, the root line
@@ skipping 40 matching lines @@
 
   // Shadow comes first and is behind the background and border.
   PaintNormalBoxShadow(paint_info, *style_to_use, adjusted_frame_rect);
 
   Color background_color = inline_flow_box_layout_object->ResolveColor(
       *style_to_use, CSSPropertyBackgroundColor);
   PaintFillLayers(paint_info, background_color,
                   style_to_use->BackgroundLayers(), adjusted_frame_rect);
   PaintInsetBoxShadow(paint_info, *style_to_use, adjusted_frame_rect);
 
+  const LayoutObject* box_model = ToLayoutBoxModelObject(
+      LineLayoutAPIShim::LayoutObjectFrom(inline_flow_box_.BoxModelObject()));
+
   switch (border_painting_type) {
     case kDontPaintBorders:
       break;
     case kPaintBordersWithoutClip:
       BoxPainter::PaintBorder(
-          *ToLayoutBoxModelObject(LineLayoutAPIShim::LayoutObjectFrom(
-              inline_flow_box_.BoxModelObject())),
-          paint_info, adjusted_frame_rect,
+          *box_model, box_model->GetDocument(), GetNode(box_model), paint_info,
+          adjusted_frame_rect,
           inline_flow_box_.GetLineLayoutItem().StyleRef(
               inline_flow_box_.IsFirstLineStyle()),
           kBackgroundBleedNone, inline_flow_box_.IncludeLogicalLeftEdge(),
           inline_flow_box_.IncludeLogicalRightEdge());
       break;
     case kPaintBordersWithClip:
       // FIXME: What the heck do we do with RTL here? The math we're using is
       // obviously not right, but it isn't even clear how this should work at
       // all.
       LayoutRect image_strip_paint_rect = PaintRectForImageStrip(
           adjusted_paint_offset, frame_rect.Size(), TextDirection::kLtr);
       GraphicsContextStateSaver state_saver(paint_info.context);
       paint_info.context.Clip(adjusted_clip_rect);
-      BoxPainter::PaintBorder(
-          *ToLayoutBoxModelObject(LineLayoutAPIShim::LayoutObjectFrom(
-              inline_flow_box_.BoxModelObject())),
-          paint_info, image_strip_paint_rect,
-          inline_flow_box_.GetLineLayoutItem().StyleRef(
-              inline_flow_box_.IsFirstLineStyle()));
+      BoxPainter::PaintBorder(*box_model, box_model->GetDocument(),
+                              GetNode(box_model), paint_info,
+                              image_strip_paint_rect,
+                              inline_flow_box_.GetLineLayoutItem().StyleRef(
+                                  inline_flow_box_.IsFirstLineStyle()));
       break;
   }
 }
 
 void InlineFlowBoxPainter::PaintMask(const PaintInfo& paint_info,
                                      const LayoutPoint& paint_offset) {
   if (inline_flow_box_.GetLineLayoutItem().Style()->Visibility() !=
           EVisibility::kVisible ||
       paint_info.phase != kPaintPhaseMask)
     return;
@@ skipping 50 matching lines @@
     if (push_transparency_layer)
       paint_info.context.EndLayer();
     return;  // Don't paint anything while we wait for the image to load.
   }
 
   LayoutBoxModelObject* box_model = ToLayoutBoxModelObject(
       LineLayoutAPIShim::LayoutObjectFrom(inline_flow_box_.BoxModelObject()));
   // The simple case is where we are the only box for this object. In those
   // cases only a single call to draw is required.
   if (!inline_flow_box_.PrevLineBox() && !inline_flow_box_.NextLineBox()) {
-    BoxPainter::PaintNinePieceImage(
-        *box_model, paint_info.context, paint_rect,
+    NinePieceImagePainter::Paint(
+        paint_info.context, *box_model, box_model->GetDocument(),
+        GetNode(box_model), paint_rect,
         inline_flow_box_.GetLineLayoutItem().StyleRef(), mask_nine_piece_image,
         composite_op);
   } else {
     // We have a mask image that spans multiple lines.
     // FIXME: What the heck do we do with RTL here? The math we're using is
     // obviously not right, but it isn't even clear how this should work at all.
     LayoutRect image_strip_paint_rect = PaintRectForImageStrip(
         adjusted_paint_offset, frame_rect.Size(), TextDirection::kLtr);
     FloatRect clip_rect(ClipRectForNinePieceImageStrip(
         inline_flow_box_, mask_nine_piece_image, paint_rect));
     GraphicsContextStateSaver state_saver(paint_info.context);
     // TODO(chrishtr): this should be pixel-snapped.
     paint_info.context.Clip(clip_rect);
-    BoxPainter::PaintNinePieceImage(
-        *box_model, paint_info.context, image_strip_paint_rect,
+    NinePieceImagePainter::Paint(
+        paint_info.context, *box_model, box_model->GetDocument(),
+        GetNode(box_model), image_strip_paint_rect,
         inline_flow_box_.GetLineLayoutItem().StyleRef(), mask_nine_piece_image,
         composite_op);
   }
 
   if (push_transparency_layer)
     paint_info.context.EndLayer();
 }
 
 // This method should not be needed. See crbug.com/530659.
 LayoutRect InlineFlowBoxPainter::FrameRectClampedToLineTopAndBottomIfNeeded()
@@ skipping 19 matching lines @@
       rect.SetHeight(logical_height);
     } else {
       rect.SetX(logical_top);
       rect.SetWidth(logical_height);
     }
   }
   return rect;
 }
 
 }  // namespace blink