Rename members of StyleSurroundData and 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 514 matching lines @@
   if ((!diff.needsFullLayout() || !diff.needsFullPaintInvalidation()) &&
       diffNeedsFullLayoutAndPaintInvalidation(other)) {
     diff.setNeedsFullLayout();
     diff.setNeedsPaintInvalidationObject();
   }
 
   if (!diff.needsFullLayout() && diffNeedsFullLayout(other))
     diff.setNeedsFullLayout();
 
   if (!diff.needsFullLayout() &&
-      m_surround->margin != other.m_surround->margin) {
+      m_surround->m_margin != other.m_surround->m_margin) {
     // Relative-positioned elements collapse their margins so need a full
     // layout.
     if (hasOutOfFlowPosition())
       diff.setNeedsPositionedMovementLayout();
     else
       diff.setNeedsFullLayout();
   }
 
   if (!diff.needsFullLayout() && position() != EPosition::kStatic &&
       !offsetEqual(other)) {
@@ skipping 41 matching lines @@
     if (m_box->width() != other.m_box->width() ||
         m_box->minWidth() != other.m_box->minWidth() ||
         m_box->maxWidth() != other.m_box->maxWidth() ||
         m_box->height() != other.m_box->height() ||
         m_box->minHeight() != other.m_box->minHeight() ||
         m_box->maxHeight() != other.m_box->maxHeight())
       return true;
   }
 
   if (m_surround.get() != other.m_surround.get()) {
-    if (m_surround->margin != other.m_surround->margin || !offsetEqual(other) ||
-        m_surround->padding != other.m_surround->padding)
+    if (m_surround->m_margin != other.m_surround->m_margin ||
+        !offsetEqual(other) ||
+        m_surround->m_padding != other.m_surround->m_padding)
       return true;
   }
 
   if (diff.transformChanged())
     return true;
 
   return false;
 }
 
 bool ComputedStyle::diffNeedsFullLayoutAndPaintInvalidation(
     const ComputedStyle& other) const {
   // FIXME: Not all cases in this method need both full layout and paint
   // invalidation.
   // Should move cases into diffNeedsFullLayout() if
   // - don't need paint invalidation at all;
   // - or the layoutObject knows how to exactly invalidate paints caused by the
   //   layout change instead of forced full paint invalidation.
 
   if (m_surround.get() != other.m_surround.get()) {
     // If our border widths change, then we need to layout. Other changes to
     // borders only necessitate a paint invalidation.
     if (borderLeftWidth() != other.borderLeftWidth() ||
         borderTopWidth() != other.borderTopWidth() ||
         borderBottomWidth() != other.borderBottomWidth() ||
         borderRightWidth() != other.borderRightWidth())
       return true;
 
-    if (m_surround->padding != other.m_surround->padding)
+    if (m_surround->m_padding != other.m_surround->m_padding)
       return true;
   }
 
   if (m_rareNonInheritedData.get() != other.m_rareNonInheritedData.get()) {
     if (m_rareNonInheritedData->m_appearance !=
             other.m_rareNonInheritedData->m_appearance ||
         m_rareNonInheritedData->marginBeforeCollapse !=
             other.m_rareNonInheritedData->marginBeforeCollapse ||
         m_rareNonInheritedData->marginAfterCollapse !=
             other.m_rareNonInheritedData->marginAfterCollapse ||
@@ skipping 266 matching lines @@
   }
 
   return false;
 }
 
 bool ComputedStyle::diffNeedsPaintInvalidationObject(
     const ComputedStyle& other) const {
   if (visibility() != other.visibility() ||
       printColorAdjust() != other.printColorAdjust() ||
       insideLink() != other.insideLink() ||
-      !m_surround->border.visuallyEqual(other.m_surround->border) ||
+      !m_surround->m_border.visuallyEqual(other.m_surround->m_border) ||
       *m_background != *other.m_background)
     return true;
 
   if (m_rareInheritedData.get() != other.m_rareInheritedData.get()) {
     if (m_rareInheritedData->userModify !=
             other.m_rareInheritedData->userModify ||
         m_rareInheritedData->userSelect !=
             other.m_rareInheritedData->userSelect ||
         m_rareInheritedData->m_imageRendering !=
             other.m_rareInheritedData->m_imageRendering)
@@ skipping 127 matching lines @@
 
     if (!m_rareNonInheritedData->reflectionDataEquivalent(
             *other.m_rareNonInheritedData.get()))
       diff.setFilterChanged();
 
     if (!m_rareNonInheritedData->m_outline.visuallyEqual(
             other.m_rareNonInheritedData->m_outline))
       diff.setNeedsRecomputeOverflow();
   }
 
-  if (!m_surround->border.visualOverflowEqual(other.m_surround->border))
+  if (!m_surround->m_border.visualOverflowEqual(other.m_surround->m_border))
     diff.setNeedsRecomputeOverflow();
 
   if (!diff.needsFullPaintInvalidation()) {
     if (m_styleInheritedData->color != other.m_styleInheritedData->color ||
         m_styleInheritedData->visitedLinkColor !=
             other.m_styleInheritedData->visitedLinkColor ||
         m_hasSimpleUnderline != other.m_hasSimpleUnderline ||
         m_visual->textDecoration != other.m_visual->textDecoration) {
       diff.setTextDecorationOrColorChanged();
     } else if (m_rareNonInheritedData.get() !=
@@ skipping 391 matching lines @@
   SET_VAR(m_styleInheritedData, vertical_border_spacing, v);
 }
 
 FloatRoundedRect ComputedStyle::getRoundedBorderFor(
     const LayoutRect& borderRect,
     bool includeLogicalLeftEdge,
     bool includeLogicalRightEdge) const {
   FloatRoundedRect roundedRect(pixelSnappedIntRect(borderRect));
   if (hasBorderRadius()) {
     FloatRoundedRect::Radii radii =
-        calcRadiiFor(m_surround->border, borderRect.size());
+        calcRadiiFor(m_surround->m_border, borderRect.size());
     roundedRect.includeLogicalEdges(radii, isHorizontalWritingMode(),
                                     includeLogicalLeftEdge,
                                     includeLogicalRightEdge);
     roundedRect.constrainRadii();
   }
   return roundedRect;
 }
 
 FloatRoundedRect ComputedStyle::getRoundedInnerBorderFor(
     const LayoutRect& borderRect,
@@ skipping 890 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 (m_surround->border.m_image.image() == image)
+  if (m_surround->m_border.m_image.image() == image)
     return;
-  m_surround.access()->border.m_image.setImage(image);
+  m_surround.access()->m_border.m_image.setImage(image);
 }
 
 void ComputedStyle::setBorderImageSlices(const LengthBox& slices) {
-  if (m_surround->border.m_image.imageSlices() == slices)
+  if (m_surround->m_border.m_image.imageSlices() == slices)
     return;
-  m_surround.access()->border.m_image.setImageSlices(slices);
+  m_surround.access()->m_border.m_image.setImageSlices(slices);
 }
 
 void ComputedStyle::setBorderImageSlicesFill(bool fill) {
-  if (m_surround->border.m_image.fill() == fill)
+  if (m_surround->m_border.m_image.fill() == fill)
     return;
-  m_surround.access()->border.m_image.setFill(fill);
+  m_surround.access()->m_border.m_image.setFill(fill);
 }
 
 void ComputedStyle::setBorderImageWidth(const BorderImageLengthBox& slices) {
-  if (m_surround->border.m_image.borderSlices() == slices)
+  if (m_surround->m_border.m_image.borderSlices() == slices)
     return;
-  m_surround.access()->border.m_image.setBorderSlices(slices);
+  m_surround.access()->m_border.m_image.setBorderSlices(slices);
 }
 
 void ComputedStyle::setBorderImageOutset(const BorderImageLengthBox& outset) {
-  if (m_surround->border.m_image.outset() == outset)
+  if (m_surround->m_border.m_image.outset() == outset)
     return;
-  m_surround.access()->border.m_image.setOutset(outset);
+  m_surround.access()->m_border.m_image.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().image())
     return false;
@@ skipping 73 matching lines @@
     if (value < 0)
       fvalue -= 0.5f;
     else
       fvalue += 0.5f;
   }
 
   return roundForImpreciseConversion<int>(fvalue / zoomFactor);
 }
 
 }  // namespace blink