Add a generated ComputedStyleBase class that ComputedStyle extends

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 35 matching lines @@
 #include "platform/fonts/Font.h"
 #include "platform/fonts/FontSelector.h"
 #include "platform/geometry/FloatRoundedRect.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/transforms/RotateTransformOperation.h"
 #include "platform/transforms/ScaleTransformOperation.h"
 #include "platform/transforms/TranslateTransformOperation.h"
 #include "wtf/MathExtras.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/SaturatedArithmetic.h"
+#include "wtf/SizeAssertions.h"
 #include <algorithm>
 #include <memory>
 
 namespace blink {
 
 struct SameSizeAsBorderValue {
     RGBA32 m_color;
     unsigned m_width;
 };
 
-static_assert(sizeof(BorderValue) == sizeof(SameSizeAsBorderValue), "BorderValue should stay small");
+ASSERT_SIZE(BorderValue, SameSizeAsBorderValue);
 
 // Since different compilers/architectures pack ComputedStyle differently,
 // re-create the same structure for an accurate size comparison.
-struct SameSizeAsComputedStyle : public RefCounted<SameSizeAsComputedStyle> {
+struct SameSizeAsComputedStyle : public ComputedStyleBase, public RefCounted<ComputedStyle> {
     void* dataRefs[7];
     void* ownPtrs[1];
     void* dataRefSvgStyle;
 
     struct InheritedData {
         unsigned m_bitfields[2];
     } m_inheritedData;
 
     struct NonInheritedData {
         unsigned m_bitfields[3];
     } m_nonInheritedData;
 };
 
-static_assert(sizeof(ComputedStyle) == sizeof(SameSizeAsComputedStyle), "ComputedStyle should stay small");
+ASSERT_SIZE(ComputedStyle, SameSizeAsComputedStyle);
 
 PassRefPtr<ComputedStyle> ComputedStyle::create()
 {
     return adoptRef(new ComputedStyle());
 }
 
 PassRefPtr<ComputedStyle> ComputedStyle::createInitialStyle()
 {
     return adoptRef(new ComputedStyle(InitialStyle));
 }
@@ skipping 11 matching lines @@
     newStyle->setDisplay(display);
     return newStyle;
 }
 
 PassRefPtr<ComputedStyle> ComputedStyle::clone(const ComputedStyle& other)
 {
     return adoptRef(new ComputedStyle(other));
 }
 
 ALWAYS_INLINE ComputedStyle::ComputedStyle()
-    : m_box(initialStyle().m_box)
+    : ComputedStyleBase()
+    , RefCounted<ComputedStyle>()
+    , m_box(initialStyle().m_box)
     , m_visual(initialStyle().m_visual)
     , m_background(initialStyle().m_background)
     , m_surround(initialStyle().m_surround)
     , m_rareNonInheritedData(initialStyle().m_rareNonInheritedData)
     , m_rareInheritedData(initialStyle().m_rareInheritedData)
     , m_styleInheritedData(initialStyle().m_styleInheritedData)
     , m_svgStyle(initialStyle().m_svgStyle)
 {
     setBitDefaults(); // Would it be faster to copy this from the default style?
     static_assert((sizeof(InheritedData) <= 8), "InheritedData should not grow");
     static_assert((sizeof(NonInheritedData) <= 12), "NonInheritedData should not grow");
 }
 
 ALWAYS_INLINE ComputedStyle::ComputedStyle(InitialStyleTag)
+    : ComputedStyleBase()
+    , RefCounted<ComputedStyle>()
 {
     setBitDefaults();
 
     m_box.init();
     m_visual.init();
     m_background.init();
     m_surround.init();
     m_rareNonInheritedData.init();
     m_rareNonInheritedData.access()->m_deprecatedFlexibleBox.init();
     m_rareNonInheritedData.access()->m_flexibleBox.init();
     m_rareNonInheritedData.access()->m_multiCol.init();
     m_rareNonInheritedData.access()->m_transform.init();
     m_rareNonInheritedData.access()->m_willChange.init();
     m_rareNonInheritedData.access()->m_filter.init();
     m_rareNonInheritedData.access()->m_backdropFilter.init();
     m_rareNonInheritedData.access()->m_grid.init();
     m_rareNonInheritedData.access()->m_gridItem.init();
     m_rareNonInheritedData.access()->m_scrollSnap.init();
     m_rareInheritedData.init();
     m_styleInheritedData.init();
     m_svgStyle.init();
 }
 
 ALWAYS_INLINE ComputedStyle::ComputedStyle(const ComputedStyle& o)
-    : RefCounted<ComputedStyle>()
+    : ComputedStyleBase(o)
+    , RefCounted<ComputedStyle>()
     , m_box(o.m_box)
     , m_visual(o.m_visual)
     , m_background(o.m_background)
     , m_surround(o.m_surround)
     , m_rareNonInheritedData(o.m_rareNonInheritedData)
     , m_rareInheritedData(o.m_rareInheritedData)
     , m_styleInheritedData(o.m_styleInheritedData)
     , m_svgStyle(o.m_svgStyle)
     , m_inheritedData(o.m_inheritedData)
     , m_nonInheritedData(o.m_nonInheritedData)
@@ skipping 133 matching lines @@
     return resolvedContentAlignmentPosition(alignContent(), normalValueBehavior);
 }
 
 ContentDistributionType ComputedStyle::resolvedAlignContentDistribution(const StyleContentAlignmentData& normalValueBehavior) const
 {
     return resolvedContentAlignmentDistribution(alignContent(), normalValueBehavior);
 }
 
 void ComputedStyle::inheritFrom(const ComputedStyle& inheritParent, IsAtShadowBoundary isAtShadowBoundary)
 {
+    ComputedStyleBase::inheritFrom(inheritParent, isAtShadowBoundary);
     if (isAtShadowBoundary == AtShadowBoundary) {
         // Even if surrounding content is user-editable, shadow DOM should act as a single unit, and not necessarily be editable
         EUserModify currentUserModify = userModify();
         m_rareInheritedData = inheritParent.m_rareInheritedData;
         setUserModify(currentUserModify);
     } else {
         m_rareInheritedData = inheritParent.m_rareInheritedData;
     }
     m_styleInheritedData = inheritParent.m_styleInheritedData;
     m_inheritedData = inheritParent.m_inheritedData;
@@ skipping 144 matching lines @@
 }
 
 bool ComputedStyle::inheritedEqual(const ComputedStyle& other) const
 {
     return independentInheritedEqual(other)
         && nonIndependentInheritedEqual(other);
 }
 
 bool ComputedStyle::independentInheritedEqual(const ComputedStyle& other) const
 {
-    return m_inheritedData.compareEqualIndependent(other.m_inheritedData);
+    return ComputedStyleBase::independentInheritedEqual(other)
+        && m_inheritedData.compareEqualIndependent(other.m_inheritedData);
 }
 
 bool ComputedStyle::nonIndependentInheritedEqual(const ComputedStyle& other) const
 {
-    return m_inheritedData.compareEqualNonIndependent(other.m_inheritedData)
+    return ComputedStyleBase::nonIndependentInheritedEqual(other)
+        && m_inheritedData.compareEqualNonIndependent(other.m_inheritedData)
         && m_styleInheritedData == other.m_styleInheritedData
         && m_svgStyle->inheritedEqual(*other.m_svgStyle)
         && m_rareInheritedData == other.m_rareInheritedData;
 }
 
 bool ComputedStyle::loadingCustomFontsEqual(const ComputedStyle& other) const
 {
     return font().loadingCustomFonts() == other.font().loadingCustomFonts();
 }
 
 bool ComputedStyle::nonInheritedEqual(const ComputedStyle& other) const
 {
     // compare everything except the pseudoStyle pointer
     return m_nonInheritedData == other.m_nonInheritedData
         && m_box == other.m_box
         && m_visual == other.m_visual
         && m_background == other.m_background
         && m_surround == other.m_surround
         && m_rareNonInheritedData == other.m_rareNonInheritedData
         && m_svgStyle->nonInheritedEqual(*other.m_svgStyle);
 }
 
 bool ComputedStyle::inheritedDataShared(const ComputedStyle& other) const
 {
     // This is a fast check that only looks if the data structures are shared.
-    return m_inheritedData == other.m_inheritedData
+    // TODO(sashab): Should ComputedStyleBase have an inheritedDataShared method?
+    return ComputedStyleBase::inheritedEqual(other)
+        && m_inheritedData == other.m_inheritedData
         && m_styleInheritedData.get() == other.m_styleInheritedData.get()
         && m_svgStyle.get() == other.m_svgStyle.get()
         && m_rareInheritedData.get() == other.m_rareInheritedData.get();
 }
 
 static bool dependenceOnContentHeightHasChanged(const ComputedStyle& a, const ComputedStyle& b)
 {
     // If top or bottom become auto/non-auto then it means we either have to solve height based
     // on the content or stop doing so (http://www.w3.org/TR/CSS2/visudet.html#abs-non-replaced-height)
     // - either way requires a layout.
@@ skipping 288 matching lines @@
     }
 
     return false;
 }
 
 bool ComputedStyle::diffNeedsPaintInvalidationObject(const ComputedStyle& other) const
 {
     if (!m_background->outline().visuallyEqual(other.m_background->outline()))
         return true;
 
-    if (m_inheritedData.m_visibility != other.m_inheritedData.m_visibility
+    if (visibility() != other.visibility()
         || m_inheritedData.m_printColorAdjust != other.m_inheritedData.m_printColorAdjust
         || m_inheritedData.m_insideLink != other.m_inheritedData.m_insideLink
         || !m_surround->border.visuallyEqual(other.m_surround->border)
         || !m_background->visuallyEqual(*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 1218 matching lines @@
         if (value < 0)
             fvalue -= 0.5f;
         else
             fvalue += 0.5f;
     }
 
     return roundForImpreciseConversion<int>(fvalue / zoomFactor);
 }
 
 } // namespace blink