Store border-image-* on SurroundData in ComputedStyle

third_party/WebKit/Source/core/style/ComputedStyle.cpp

 /*
  * Copyright (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights
  * reserved.
  * Copyright (C) 2011 Adobe Systems Incorporated. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 991 matching lines @@
             *other.rare_non_inherited_data_.Get()))
       diff.SetFilterChanged();
   }
 
   if (rare_non_inherited_data_.Get() != other.rare_non_inherited_data_.Get()) {
     if (!rare_non_inherited_data_->outline_.VisuallyEqual(
             other.rare_non_inherited_data_->outline_))
       diff.SetNeedsRecomputeOverflow();
   }
 
-  if (!Border().VisualOverflowEqual(other.Border()))
+  if (!BorderVisualOverflowEqual(other))
     diff.SetNeedsRecomputeOverflow();
 
   if (!diff.NeedsFullPaintInvalidation()) {
     if (inherited_data_->color_ != other.inherited_data_->color_ ||
         inherited_data_->visited_link_color_ !=
             other.inherited_data_->visited_link_color_ ||
         HasSimpleUnderlineInternal() != other.HasSimpleUnderlineInternal() ||
         visual_data_->text_decoration_ !=
             other.visual_data_->text_decoration_) {
       diff.SetTextDecorationOrColorChanged();
@@ skipping 348 matching lines @@
 }
 
 bool ComputedStyle::TextShadowDataEquivalent(const ComputedStyle& other) const {
   return DataEquivalent(TextShadow(), other.TextShadow());
 }
 
 void ComputedStyle::SetBoxShadow(RefPtr<ShadowList> s) {
   rare_non_inherited_data_.Access()->box_shadow_ = std::move(s);
 }
 
-static FloatRoundedRect::Radii CalcRadiiFor(const BorderData& border,
-                                            const LengthSize& top_left,
+static FloatRoundedRect::Radii CalcRadiiFor(const LengthSize& top_left,
                                             const LengthSize& top_right,
                                             const LengthSize& bottom_left,
                                             const LengthSize& bottom_right,
                                             LayoutSize size) {
   return FloatRoundedRect::Radii(
       FloatSize(
           FloatValueForLength(top_left.Width(), size.Width().ToFloat()),
           FloatValueForLength(top_left.Height(), size.Height().ToFloat())),
       FloatSize(
           FloatValueForLength(top_right.Width(), size.Width().ToFloat()),
@@ skipping 20 matching lines @@
 void ComputedStyle::SetColor(const Color& v) {
   SET_VAR(inherited_data_, color_, v);
 }
 
 FloatRoundedRect ComputedStyle::GetRoundedBorderFor(
     const LayoutRect& border_rect,
     bool include_logical_left_edge,
     bool include_logical_right_edge) const {
   FloatRoundedRect rounded_rect(PixelSnappedIntRect(border_rect));
   if (HasBorderRadius()) {
-    FloatRoundedRect::Radii radii =
-        CalcRadiiFor(Border(), BorderTopLeftRadius(), BorderTopRightRadius(),
-                     BorderBottomLeftRadius(), BorderBottomRightRadius(),
-                     border_rect.Size());
+    FloatRoundedRect::Radii radii = CalcRadiiFor(
+        BorderTopLeftRadius(), BorderTopRightRadius(), BorderBottomLeftRadius(),
+        BorderBottomRightRadius(), border_rect.Size());
     rounded_rect.IncludeLogicalEdges(radii, IsHorizontalWritingMode(),
                                      include_logical_left_edge,
                                      include_logical_right_edge);
     rounded_rect.ConstrainRadii();
   }
   return rounded_rect;
 }
 
 FloatRoundedRect ComputedStyle::GetRoundedInnerBorderFor(
     const LayoutRect& border_rect,
@@ skipping 925 matching lines @@
     const NinePieceImage& image) const {
   return LayoutRectOutsets(
       NinePieceImage::ComputeOutset(image.Outset().Top(), BorderTopWidth()),
       NinePieceImage::ComputeOutset(image.Outset().Right(), BorderRightWidth()),
       NinePieceImage::ComputeOutset(image.Outset().Bottom(),
                                     BorderBottomWidth()),
       NinePieceImage::ComputeOutset(image.Outset().Left(), BorderLeftWidth()));
 }
 
 void ComputedStyle::SetBorderImageSource(StyleImage* image) {
-  if (Border().image_.GetImage() == image)
+  if (BorderImage().GetImage() == image)
     return;
-  surround_data_.Access()->border_.image_.SetImage(image);
+  MutableBorderImageInternal().SetImage(image);
 }
 
 void ComputedStyle::SetBorderImageSlices(const LengthBox& slices) {
-  if (Border().image_.ImageSlices() == slices)
+  if (BorderImage().ImageSlices() == slices)
     return;
-  surround_data_.Access()->border_.image_.SetImageSlices(slices);
+  MutableBorderImageInternal().SetImageSlices(slices);
 }
 
 void ComputedStyle::SetBorderImageSlicesFill(bool fill) {
-  if (Border().image_.Fill() == fill)
+  if (BorderImage().Fill() == fill)
     return;
-  surround_data_.Access()->border_.image_.SetFill(fill);
+  MutableBorderImageInternal().SetFill(fill);
 }
 
 void ComputedStyle::SetBorderImageWidth(const BorderImageLengthBox& slices) {
-  if (Border().image_.BorderSlices() == slices)
+  if (BorderImage().BorderSlices() == slices)
     return;
-  surround_data_.Access()->border_.image_.SetBorderSlices(slices);
+  MutableBorderImageInternal().SetBorderSlices(slices);
 }
 
 void ComputedStyle::SetBorderImageOutset(const BorderImageLengthBox& outset) {
-  if (Border().image_.Outset() == outset)
+  if (BorderImage().Outset() == outset)
     return;
-  surround_data_.Access()->border_.image_.SetOutset(outset);
+  MutableBorderImageInternal().SetOutset(outset);
 }
 
 bool ComputedStyle::BorderObscuresBackground() const {
   if (!HasBorder())
     return false;
 
   // Bail if we have any border-image for now. We could look at the image alpha
   // to improve this.
   if (BorderImage().GetImage())
     return false;
@@ skipping 73 matching lines @@
     if (value < 0)
       fvalue -= 0.5f;
     else
       fvalue += 0.5f;
   }
 
   return RoundForImpreciseConversion<int>(fvalue / zoom_factor);
 }
 
 }  // namespace blink