Break LayoutObject dependency for NinePieceImagePainter

third_party/WebKit/Source/core/paint/BoxPainter.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/BoxPainter.h"
 
 #include "core/HTMLNames.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/LocalFrameView.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/layout/BackgroundBleedAvoidance.h"
 #include "core/layout/ImageQualityController.h"
 #include "core/layout/LayoutBox.h"
 #include "core/layout/LayoutBoxModelObject.h"
 #include "core/layout/LayoutObject.h"
 #include "core/layout/LayoutTable.h"
 #include "core/layout/LayoutTheme.h"
 #include "core/layout/compositing/CompositedLayerMapping.h"
 #include "core/layout/line/RootInlineBox.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
 #include "core/paint/BackgroundImageGeometry.h"
-#include "core/paint/BoxBorderPainter.h"
 #include "core/paint/BoxDecorationData.h"
 #include "core/paint/LayoutObjectDrawingRecorder.h"
 #include "core/paint/NinePieceImagePainter.h"
 #include "core/paint/ObjectPainter.h"
 #include "core/paint/PaintInfo.h"
 #include "core/paint/PaintLayer.h"
 #include "core/paint/ScrollRecorder.h"
 #include "core/paint/ThemePainter.h"
 #include "core/style/ShadowList.h"
 #include "platform/LengthFunctions.h"
 #include "platform/geometry/LayoutPoint.h"
 #include "platform/geometry/LayoutRectOutsets.h"
 #include "platform/graphics/GraphicsContextStateSaver.h"
 #include "platform/graphics/paint/CompositingDisplayItem.h"
+#include "platform/wtf/Optional.h"
 
 namespace blink {
 
 bool BoxPainter::IsPaintingBackgroundOfPaintContainerIntoScrollingContentsLayer(
     const LayoutBoxModelObject* obj,
     const PaintInfo& paint_info) {
   return paint_info.PaintFlags() & kPaintLayerPaintingOverflowContents &&
          !(paint_info.PaintFlags() &
            kPaintLayerPaintingCompositingBackgroundPhase) &&
          obj == paint_info.PaintContainer();
@@ skipping 135 matching lines @@
 
     // The theme will tell us whether or not we should also paint the CSS
     // border.
     if (box_decoration_data.has_border_decoration &&
         (!box_decoration_data.has_appearance ||
          (!theme_painted &&
           LayoutTheme::GetTheme().Painter().PaintBorderOnly(
               layout_box_, paint_info, snapped_paint_rect))) &&
         !(layout_box_.IsTable() &&
           ToLayoutTable(&layout_box_)->ShouldCollapseBorders())) {
-      PaintBorder(layout_box_, paint_info, paint_rect, style,
-                  box_decoration_data.bleed_avoidance);
+      PaintBorder(layout_box_, layout_box_.GetDocument(), GetNode(), paint_info,
+                  paint_rect, style, box_decoration_data.bleed_avoidance);
     }
   }
 
   if (box_decoration_data.bleed_avoidance == kBackgroundBleedClipLayer)
     paint_info.context.EndLayer();
 }
 
 void BoxPainter::PaintBackground(const PaintInfo& paint_info,
                                  const LayoutRect& paint_rect,
                                  const Color& background_color,
@@ skipping 430 matching lines @@
       all_mask_images_loaded &= mask_box_image->IsLoaded();
 
     all_mask_images_loaded &= mask_layers.ImagesAreLoaded();
 
     paint_info.context.BeginLayer(1, SkBlendMode::kDstIn);
   }
 
   if (all_mask_images_loaded) {
     PaintFillLayers(paint_info, Color::kTransparent,
                     layout_box_.Style()->MaskLayers(), paint_rect);
-    PaintNinePieceImage(layout_box_, paint_info.context, paint_rect,
-                        layout_box_.StyleRef(),
-                        layout_box_.Style()->MaskBoxImage());
+    NinePieceImagePainter::Paint(paint_info.context, layout_box_,
+                                 layout_box_.GetDocument(), GetNode(),
+                                 paint_rect, layout_box_.StyleRef(),
+                                 layout_box_.StyleRef().MaskBoxImage());
   }
 
   if (push_transparency_layer)
     paint_info.context.EndLayer();
 }
 
 void BoxPainter::PaintClippingMask(const PaintInfo& paint_info,
                                    const LayoutPoint& paint_offset) {
   DCHECK(paint_info.phase == kPaintPhaseClippingMask);
 
   if (layout_box_.Style()->Visibility() != EVisibility::kVisible)
     return;
 
   if (!layout_box_.Layer() ||
       layout_box_.Layer()->GetCompositingState() != kPaintsIntoOwnBacking)
     return;
 
   if (LayoutObjectDrawingRecorder::UseCachedDrawingIfPossible(
           paint_info.context, layout_box_, paint_info.phase))
     return;
 
   IntRect paint_rect =
       PixelSnappedIntRect(LayoutRect(paint_offset, layout_box_.Size()));
   LayoutObjectDrawingRecorder drawing_recorder(paint_info.context, layout_box_,
                                                paint_info.phase, paint_rect);
   paint_info.context.FillRect(paint_rect, Color::kBlack);
 }
 
-bool BoxPainter::PaintNinePieceImage(const LayoutBoxModelObject& obj,
-                                     GraphicsContext& graphics_context,
-                                     const LayoutRect& rect,
-                                     const ComputedStyle& style,
-                                     const NinePieceImage& nine_piece_image,
-                                     SkBlendMode op) {
-  return NinePieceImagePainter().Paint(graphics_context, obj, rect, style,
-                                       nine_piece_image, op);
-}
-
-void BoxPainter::PaintBorder(const LayoutBoxModelObject& obj,
-                             const PaintInfo& info,
-                             const LayoutRect& rect,
-                             const ComputedStyle& style,
-                             BackgroundBleedAvoidance bleed_avoidance,
-                             bool include_logical_left_edge,
-                             bool include_logical_right_edge) {
-  // border-image is not affected by border-radius.
-  if (PaintNinePieceImage(obj, info.context, rect, style, style.BorderImage()))
-    return;
-
-  const BoxBorderPainter border_painter(rect, style, bleed_avoidance,
-                                        include_logical_left_edge,
-                                        include_logical_right_edge);
-  border_painter.PaintBorder(info, rect);
+Node* BoxPainter::GetNode() {
+  Node* node = nullptr;
+  const LayoutObject* layout_object = &layout_box_;
+  for (; layout_object && !node; layout_object = layout_object->Parent()) {
+    node = layout_object->GeneratingNode();
+  }
+  return node;
 }
 
 }  // namespace blink