Rename LayoutStyle to papayawhip

Source/core/layout/style/SVGComputedStyle.cpp

 /*
     Copyright (C) 2004, 2005, 2007 Nikolas Zimmermann <zimmermann@kde.org>
                   2004, 2005, 2010 Rob Buis <buis@kde.org>
     Copyright (C) Research In Motion Limited 2010. All rights reserved.
 
     Based on khtml code by:
     Copyright (C) 1999 Antti Koivisto (koivisto@kde.org)
     Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org)
     Copyright (C) 2002-2003 Dirk Mueller (mueller@kde.org)
     Copyright (C) 2002 Apple Computer, Inc.
 
     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.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */
 
 #include "config.h"
 
-#include "core/layout/style/SVGLayoutStyle.h"
+#include "core/layout/style/SVGComputedStyle.h"
 
 namespace blink {
 
-SVGLayoutStyle::SVGLayoutStyle()
+SVGComputedStyle::SVGComputedStyle()
 {
-    static SVGLayoutStyle* initialStyle = new SVGLayoutStyle(CreateInitial);
+    static SVGComputedStyle* initialStyle = new SVGComputedStyle(CreateInitial);
 
     fill = initialStyle->fill;
     stroke = initialStyle->stroke;
     stops = initialStyle->stops;
     misc = initialStyle->misc;
     inheritedResources = initialStyle->inheritedResources;
     layout = initialStyle->layout;
     resources = initialStyle->resources;
 
     setBitDefaults();
 }
 
-SVGLayoutStyle::SVGLayoutStyle(CreateInitialType)
+SVGComputedStyle::SVGComputedStyle(CreateInitialType)
 {
     setBitDefaults();
 
     fill.init();
     stroke.init();
     stops.init();
     misc.init();
     inheritedResources.init();
     layout.init();
     resources.init();
 }
 
-SVGLayoutStyle::SVGLayoutStyle(const SVGLayoutStyle& other)
-    : RefCounted<SVGLayoutStyle>()
+SVGComputedStyle::SVGComputedStyle(const SVGComputedStyle& other)
+    : RefCounted<SVGComputedStyle>()
 {
     fill = other.fill;
     stroke = other.stroke;
     stops = other.stops;
     misc = other.misc;
     inheritedResources = other.inheritedResources;
     layout = other.layout;
     resources = other.resources;
 
     svg_inherited_flags = other.svg_inherited_flags;
     svg_noninherited_flags = other.svg_noninherited_flags;
 }
 
-SVGLayoutStyle::~SVGLayoutStyle()
+SVGComputedStyle::~SVGComputedStyle()
 {
 }
 
-bool SVGLayoutStyle::operator==(const SVGLayoutStyle& other) const
+bool SVGComputedStyle::operator==(const SVGComputedStyle& other) const
 {
     return fill == other.fill
         && stroke == other.stroke
         && stops == other.stops
         && misc == other.misc
         && inheritedResources == other.inheritedResources
         && layout == other.layout
         && resources == other.resources
         && svg_inherited_flags == other.svg_inherited_flags
         && svg_noninherited_flags == other.svg_noninherited_flags;
 }
 
-bool SVGLayoutStyle::inheritedNotEqual(const SVGLayoutStyle* other) const
+bool SVGComputedStyle::inheritedNotEqual(const SVGComputedStyle* other) const
 {
     return fill != other->fill
         || stroke != other->stroke
         || inheritedResources != other->inheritedResources
         || svg_inherited_flags != other->svg_inherited_flags;
 }
 
-void SVGLayoutStyle::inheritFrom(const SVGLayoutStyle* svgInheritParent)
+void SVGComputedStyle::inheritFrom(const SVGComputedStyle* svgInheritParent)
 {
     if (!svgInheritParent)
         return;
 
     fill = svgInheritParent->fill;
     stroke = svgInheritParent->stroke;
     inheritedResources = svgInheritParent->inheritedResources;
 
     svg_inherited_flags = svgInheritParent->svg_inherited_flags;
 }
 
-void SVGLayoutStyle::copyNonInheritedFromCached(const SVGLayoutStyle* other)
+void SVGComputedStyle::copyNonInheritedFromCached(const SVGComputedStyle* other)
 {
     svg_noninherited_flags = other->svg_noninherited_flags;
     stops = other->stops;
     misc = other->misc;
     layout = other->layout;
     resources = other->resources;
 }
 
-PassRefPtr<SVGDashArray> SVGLayoutStyle::initialStrokeDashArray()
+PassRefPtr<SVGDashArray> SVGComputedStyle::initialStrokeDashArray()
 {
     DEFINE_STATIC_REF(SVGDashArray, initialDashArray, SVGDashArray::create());
     return initialDashArray;
 }
 
-StyleDifference SVGLayoutStyle::diff(const SVGLayoutStyle* other) const
+StyleDifference SVGComputedStyle::diff(const SVGComputedStyle* other) const
 {
     StyleDifference styleDifference;
 
     if (diffNeedsLayoutAndPaintInvalidation(other)) {
         styleDifference.setNeedsFullLayout();
         styleDifference.setNeedsPaintInvalidationObject();
     } else if (diffNeedsPaintInvalidation(other)) {
         styleDifference.setNeedsPaintInvalidationObject();
     }
 
     return styleDifference;
 }
 
-bool SVGLayoutStyle::diffNeedsLayoutAndPaintInvalidation(const SVGLayoutStyle* other) const
+bool SVGComputedStyle::diffNeedsLayoutAndPaintInvalidation(const SVGComputedStyle* other) const
 {
     // If resources change, we need a relayout, as the presence of resources influences the paint invalidation rect.
     if (resources != other->resources)
         return true;
 
     // If markers change, we need a relayout, as marker boundaries are cached in LayoutSVGPath.
     if (inheritedResources != other->inheritedResources)
         return true;
 
     // All text related properties influence layout.
@@ skipping 42 matching lines @@
             || layout->rx != other->layout->rx
             || layout->ry != other->layout->ry
             || layout->cx != other->layout->cx
             || layout->cy != other->layout->cy)
             return true;
     }
 
     return false;
 }
 
-bool SVGLayoutStyle::diffNeedsPaintInvalidation(const SVGLayoutStyle* other) const
+bool SVGComputedStyle::diffNeedsPaintInvalidation(const SVGComputedStyle* other) const
 {
     if (stroke->opacity != other->stroke->opacity)
         return true;
 
     // Painting related properties only need paint invalidation.
     if (misc.get() != other->misc.get()) {
         if (misc->floodColor != other->misc->floodColor
             || misc->floodOpacity != other->misc->floodOpacity
             || misc->lightingColor != other->misc->lightingColor)
             return true;
@@ skipping 24 matching lines @@
 
     if (svg_noninherited_flags.f.bufferedRendering != other->svg_noninherited_flags.f.bufferedRendering)
         return true;
 
     if (svg_noninherited_flags.f.maskType != other->svg_noninherited_flags.f.maskType)
         return true;
 
     return false;
 }
 
-EPaintOrderType SVGLayoutStyle::paintOrderType(unsigned index) const
+EPaintOrderType SVGComputedStyle::paintOrderType(unsigned index) const
 {
     ASSERT(index < ((1 << kPaintOrderBitwidth)-1));
     unsigned pt = (paintOrder() >> (kPaintOrderBitwidth*index)) & ((1u << kPaintOrderBitwidth) - 1);
     return (EPaintOrderType)pt;
 }
 
 }