Add a generated ComputedStyleBase class that ComputedStyle extends

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

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * 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.
  *
  */
 
 #ifndef ComputedStyle_h
 #define ComputedStyle_h
 
 #include "core/CSSPropertyNames.h"
+#include "core/ComputedStyleBase.h"
 #include "core/CoreExport.h"
 #include "core/style/BorderValue.h"
 #include "core/style/ComputedStyleConstants.h"
 #include "core/style/CounterDirectives.h"
 #include "core/style/DataRef.h"
 #include "core/style/LineClampValue.h"
 #include "core/style/NinePieceImage.h"
 #include "core/style/SVGComputedStyle.h"
 #include "core/style/StyleBackgroundData.h"
 #include "core/style/StyleBoxData.h"
@@ skipping 25 matching lines @@
 #include "platform/fonts/FontDescription.h"
 #include "platform/geometry/FloatRoundedRect.h"
 #include "platform/geometry/LayoutRectOutsets.h"
 #include "platform/graphics/Color.h"
 #include "platform/scroll/ScrollTypes.h"
 #include "platform/text/TextDirection.h"
 #include "platform/text/UnicodeBidi.h"
 #include "platform/transforms/TransformOperations.h"
 #include "wtf/Forward.h"
 #include "wtf/LeakAnnotations.h"
-#include "wtf/RefCounted.h"
 #include "wtf/Vector.h"
 #include <memory>
 
 template<typename T, typename U> inline bool compareEqual(const T& t, const U& u) { return t == static_cast<T>(u); }
 
 #define SET_VAR(group, variable, value) \
     if (!compareEqual(group->variable, value)) \
         group.access()->variable = value
 
 #define SET_NESTED_VAR(group, base, variable, value)            \
@@ skipping 31 matching lines @@
 class StyleInheritedData;
 class StylePath;
 class StyleResolver;
 class TransformationMatrix;
 class TranslateTransformOperation;
 
 class ContentData;
 
 typedef Vector<RefPtr<ComputedStyle>, 4> PseudoStyleCache;
 
-class CORE_EXPORT ComputedStyle: public RefCounted<ComputedStyle> {
+// ComputedStyle stores the final style for an element and provides the
+// interface between the style engine and the rest of Blink.
+//
+// It contains all the resolved styles for an element, and is densely packed and
+// optimized for memory and performance. Enums and small fields are packed in
+// bit fields, while large fields are stored in pointers and shared where not
+// modified from their parent value (see the DataRef class).
+//
+// Currently, ComputedStyle is hand-written and ComputedStyleBase is generated.
+// Over time, methods will be moved to ComputedStyleBase and the generator will
+// be expanded to handle more and more types of properties. Eventually, all
+// methods will be on ComputedStyleBase (with custom methods defined in a class
+// such as ComputedStyleBase.cpp) and ComputedStyle will be removed.
+class CORE_EXPORT ComputedStyle: public ComputedStyleBase {
     friend class AnimatedStyleBuilder; // Used by Web Animations CSS. Sets the color styles
     friend class CSSAnimatableValueFactory; // Used by Web Animations CSS. Gets visited and unvisited colors separately.
     friend class CSSPropertyEquality; // Used by CSS animations. We can't allow them to animate based off visited colors.
     friend class ApplyStyleCommand; // Editing has to only reveal unvisited info.
     friend class EditingStyle; // Editing has to only reveal unvisited info.
     friend class ComputedStyleCSSValueMapping; // Needs to be able to see visited and unvisited colors for devtools.
     friend class StyleBuilderFunctions; // Sets color styles
     friend class CachedUAStyle; // Saves Border/Background information for later comparison.
     friend class ColorPropertyFunctions; // Accesses visited and unvisited colors.
 
@@ skipping 31 matching lines @@
                 && compareEqualNonIndependent(other);
         }
 
         bool operator!=(const InheritedData& other) const { return !(*this == other); }
 
         inline bool compareEqualIndependent(const InheritedData& other) const
         {
             // These must match the properties tagged 'independent' in
             // CSSProperties.in.
             // TODO(sashab): Generate this function.
-            return (m_visibility == other.m_visibility)
-                && (m_pointerEvents == other.m_pointerEvents);
+            return (m_pointerEvents == other.m_pointerEvents);
         }
 
         inline bool compareEqualNonIndependent(const InheritedData& other) const
         {
             return (m_emptyCells == other.m_emptyCells)
                 && (m_captionSide == other.m_captionSide)
                 && (m_listStyleType == other.m_listStyleType)
                 && (m_listStylePosition == other.m_listStylePosition)
                 && (m_textAlign == other.m_textAlign)
                 && (m_textTransform == other.m_textTransform)
                 && (m_textUnderline == other.m_textUnderline)
                 && (m_cursorStyle == other.m_cursorStyle)
                 && (m_direction == other.m_direction)
                 && (m_whiteSpace == other.m_whiteSpace)
                 && (m_borderCollapse == other.m_borderCollapse)
                 && (m_boxDirection == other.m_boxDirection)
                 && (m_rtlOrdering == other.m_rtlOrdering)
                 && (m_printColorAdjust == other.m_printColorAdjust)
                 && (m_insideLink == other.m_insideLink)
                 && (m_writingMode == other.m_writingMode);
         }
 
         unsigned m_emptyCells : 1; // EEmptyCells
         unsigned m_captionSide : 2; // ECaptionSide
         unsigned m_listStyleType : 7; // EListStyleType
         unsigned m_listStylePosition : 1; // EListStylePosition
-        unsigned m_visibility : 2; // EVisibility
         unsigned m_textAlign : 4; // ETextAlign
         unsigned m_textTransform : 2; // ETextTransform
         unsigned m_textUnderline : 1;
         unsigned m_cursorStyle : 6; // ECursor
         unsigned m_direction : 1; // TextDirection
         unsigned m_whiteSpace : 3; // EWhiteSpace
         unsigned m_borderCollapse : 1; // EBorderCollapse
         unsigned m_boxDirection : 1; // EBoxDirection (CSS3 box_direction property, flexible box layout module)
         // 32 bits
 
@@ skipping 106 matching lines @@
         unsigned m_isVisibilityInherited : 1;
 
         // If you add more style bits here, you will also need to update ComputedStyle::copyNonInheritedFromCached()
         // 68 bits
     } m_nonInheritedData;
 
 // !END SYNC!
 
     void setBitDefaults()
     {
+        ComputedStyleBase::setBitDefaults();
         m_inheritedData.m_emptyCells = initialEmptyCells();
         m_inheritedData.m_captionSide = initialCaptionSide();
         m_inheritedData.m_listStyleType = initialListStyleType();
         m_inheritedData.m_listStylePosition = initialListStylePosition();
-        m_inheritedData.m_visibility = static_cast<unsigned>(initialVisibility());
         m_inheritedData.m_textAlign = initialTextAlign();
         m_inheritedData.m_textTransform = initialTextTransform();
         m_inheritedData.m_textUnderline = false;
         m_inheritedData.m_cursorStyle = initialCursor();
         m_inheritedData.m_direction = initialDirection();
         m_inheritedData.m_whiteSpace = initialWhiteSpace();
         m_inheritedData.m_borderCollapse = initialBorderCollapse();
         m_inheritedData.m_rtlOrdering = initialRTLOrdering();
         m_inheritedData.m_boxDirection = initialBoxDirection();
         m_inheritedData.m_printColorAdjust = initialPrintColorAdjust();
@@ skipping 69 matching lines @@
     ContentDistributionType resolvedJustifyContentDistribution(const StyleContentAlignmentData& normalValueBehavior) const;
     ContentPosition resolvedAlignContentPosition(const StyleContentAlignmentData& normalValueBehavior) const;
     ContentDistributionType resolvedAlignContentDistribution(const StyleContentAlignmentData& normalValueBehavior) const;
     StyleSelfAlignmentData resolvedAlignItems(ItemPosition normalValueBehaviour) const;
     StyleSelfAlignmentData resolvedAlignSelf(ItemPosition normalValueBehaviour, const ComputedStyle* parentStyle = nullptr) const;
     StyleSelfAlignmentData resolvedJustifyItems(ItemPosition normalValueBehaviour) const;
     StyleSelfAlignmentData resolvedJustifySelf(ItemPosition normalValueBehaviour, const ComputedStyle* parentStyle = nullptr) const;
 
     StyleDifference visualInvalidationDiff(const ComputedStyle&) const;
 
-    enum IsAtShadowBoundary {
-        AtShadowBoundary,
-        NotAtShadowBoundary,
-    };
-
     void inheritFrom(const ComputedStyle& inheritParent, IsAtShadowBoundary = NotAtShadowBoundary);
     void copyNonInheritedFromCached(const ComputedStyle&);
 
     PseudoId styleType() const { return static_cast<PseudoId>(m_nonInheritedData.m_styleType); }
     void setStyleType(PseudoId styleType) { m_nonInheritedData.m_styleType = styleType; }
 
     ComputedStyle* getCachedPseudoStyle(PseudoId) const;
     ComputedStyle* addCachedPseudoStyle(PassRefPtr<ComputedStyle>);
     void removeCachedPseudoStyle(PseudoId);
 
@@ skipping 807 matching lines @@
     EUnicodeBidi unicodeBidi() const { return static_cast<EUnicodeBidi>(m_nonInheritedData.m_unicodeBidi); }
     void setUnicodeBidi(EUnicodeBidi b) { m_nonInheritedData.m_unicodeBidi = b; }
 
     // vertical-align
     static EVerticalAlign initialVerticalAlign() { return VerticalAlignBaseline; }
     EVerticalAlign verticalAlign() const { return static_cast<EVerticalAlign>(m_nonInheritedData.m_verticalAlign); }
     const Length& getVerticalAlignLength() const { return m_box->verticalAlign(); }
     void setVerticalAlign(EVerticalAlign v) { m_nonInheritedData.m_verticalAlign = v; }
     void setVerticalAlignLength(const Length& length) { setVerticalAlign(VerticalAlignLength); SET_VAR(m_box, m_verticalAlign, length); }
 
+    // visibility
+    // TODO(sashab): Move this to ComputedStyleBase.
+    void setVisibilityIsInherited(bool isInherited) { m_nonInheritedData.m_isVisibilityInherited = isInherited; }
+
     // will-change
     const Vector<CSSPropertyID>& willChangeProperties() const { return m_rareNonInheritedData->m_willChange->m_properties; }
     bool willChangeContents() const { return m_rareNonInheritedData->m_willChange->m_contents; }
     bool willChangeScrollPosition() const { return m_rareNonInheritedData->m_willChange->m_scrollPosition; }
     bool subtreeWillChangeContents() const { return m_rareInheritedData->m_subtreeWillChangeContents; }
     void setWillChangeProperties(const Vector<CSSPropertyID>& properties) { SET_NESTED_VAR(m_rareNonInheritedData, m_willChange, m_properties, properties); }
     void setWillChangeContents(bool b) { SET_NESTED_VAR(m_rareNonInheritedData, m_willChange, m_contents, b); }
     void setWillChangeScrollPosition(bool b) { SET_NESTED_VAR(m_rareNonInheritedData, m_willChange, m_scrollPosition, b); }
     void setSubtreeWillChangeContents(bool b) { SET_VAR(m_rareInheritedData, m_subtreeWillChangeContents, b); }
 
@@ skipping 214 matching lines @@
     // text-size-adjust (aka -webkit-text-size-adjust)
     static TextSizeAdjust initialTextSizeAdjust() { return TextSizeAdjust::adjustAuto(); }
     TextSizeAdjust getTextSizeAdjust() const { return m_rareInheritedData->m_textSizeAdjust; }
     void setTextSizeAdjust(TextSizeAdjust sizeAdjust) { SET_VAR(m_rareInheritedData, m_textSizeAdjust, sizeAdjust); }
 
     // text-transform (aka -epub-text-transform)
     static ETextTransform initialTextTransform() { return TTNONE; }
     ETextTransform textTransform() const { return static_cast<ETextTransform>(m_inheritedData.m_textTransform); }
     void setTextTransform(ETextTransform v) { m_inheritedData.m_textTransform = v; }
 
-    // visibility
-    static EVisibility initialVisibility() { return EVisibility::Visible; }
-    EVisibility visibility() const { return static_cast<EVisibility>(m_inheritedData.m_visibility); }
-    void setVisibility(EVisibility v) { m_inheritedData.m_visibility = static_cast<unsigned>(v); }
-    void setVisibilityIsInherited(bool isInherited) { m_nonInheritedData.m_isVisibilityInherited = isInherited; }
-
     // white-space inherited
     static EWhiteSpace initialWhiteSpace() { return NORMAL; }
     EWhiteSpace whiteSpace() const { return static_cast<EWhiteSpace>(m_inheritedData.m_whiteSpace); }
     void setWhiteSpace(EWhiteSpace v) { m_inheritedData.m_whiteSpace = v; }
 
     // word-break inherited (aka -epub-word-break)
     static EWordBreak initialWordBreak() { return NormalWordBreak; }
     EWordBreak wordBreak() const { return static_cast<EWordBreak>(m_rareInheritedData->wordBreak); }
     void setWordBreak(EWordBreak b) { SET_VAR(m_rareInheritedData, wordBreak, b); }
 
@@ skipping 1104 matching lines @@
 }
 
 inline bool ComputedStyle::hasPseudoElementStyle() const
 {
     return m_nonInheritedData.m_pseudoBits & ElementPseudoIdMask;
 }
 
 } // namespace blink
 
 #endif // ComputedStyle_h