Add a generated ComputedStyleBase class that ComputedStyle extends

third_party/WebKit/Source/build/scripts/templates/BaseComputedStyle.h.tmpl

+{% from 'macros.tmpl' import license %}

[sashab, 2016/07/27 03:23:19]

Ugh, this is so hard to read with no syntax highlighting... Here's what it
generates if that helps:

// Copyright (c) 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef BaseComputedStyle_h
#define BaseComputedStyle_h

#include "core/BaseComputedStyleConstants.h"
#include "core/CoreExport.h"
#include "wtf/RefCounted.h"


namespace blink {

// The generated portion of ComputedStyle. For more info, see the header comment
// in ComputedStyle.h.
class CORE_EXPORT BaseComputedStyle : public RefCounted<BaseComputedStyle> {
public:
    ALWAYS_INLINE BaseComputedStyle() :
        RefCounted<BaseComputedStyle>(),
        m_visibility(static_cast<unsigned>(EVisibility::Visible))
    {}
    ~BaseComputedStyle() {}

    ALWAYS_INLINE BaseComputedStyle(const BaseComputedStyle& o) :
        m_visibility(o.m_visibility)
    {}

    bool operator==(const BaseComputedStyle& o) const
    {
        return true
            && m_visibility == o.m_visibility
            && true;
    }

    bool operator!=(const BaseComputedStyle& o) const { return !(*this == o); }

    inline bool inheritedEqual(const BaseComputedStyle& o) const
    {
        return true
            && m_visibility == o.m_visibility
            && true;
    }

    inline bool nonInheritedEqual(const BaseComputedStyle& o) const
    {
        return true
            && true;
    }

    void setBitDefaults()
    {
        resetVisibility();
    }

    void inheritFrom(const BaseComputedStyle& inheritParent, IsAtShadowBoundary
isAtShadowBoundary = NotAtShadowBoundary);

    // Fields.
    // TODO(sashab): Remove initialFoo() static methods and update callers to
    // use resetFoo(), which can be more efficient.
    // visibility
    inline static EVisibility initialVisibility() { return EVisibility::Visible;
}
    EVisibility visibility() const { return
static_cast<EVisibility>(m_visibility); }
    void setVisibility(EVisibility v) { m_visibility = static_cast<unsigned>(v);
}
    inline void resetVisibility() { m_visibility =
static_cast<unsigned>(EVisibility::Visible); }

protected:
    // Storage.
    unsigned m_visibility : 2; // EVisibility
};

} // namespace blink

#endif // BaseComputedStyle_h

+{{license()}}
+
+#ifndef BaseComputedStyle_h
+#define BaseComputedStyle_h
+
+#include "core/BaseComputedStyleConstants.h"
+#include "core/CoreExport.h"
+#include "wtf/RefCounted.h"
+
+{# Returns the default value for the field, converted to fit in the storage container. #}
+{% macro default_value(field) %}
+{# We only support enum fields for now. #}
+static_cast<unsigned>({{field.default_value}}){% endmacro %}
+
+namespace blink {
+
+// The generated portion of ComputedStyle. For more info, see the header comment
+// in ComputedStyle.h.
+class CORE_EXPORT BaseComputedStyle : public RefCounted<BaseComputedStyle> {
+public:
+    ALWAYS_INLINE BaseComputedStyle() :
+        RefCounted<BaseComputedStyle>(),
+    {% for field in fields %}
+        {% set trailing_comma = "," if field != fields[-1] else "" %}
+        {{field.name}}({{default_value(field)}}){{trailing_comma}}
+    {% endfor %}
+    {}
+    ~BaseComputedStyle() {}
+
+    ALWAYS_INLINE BaseComputedStyle(const BaseComputedStyle& o) :
+    {% for field in fields %}
+        {% set trailing_comma = "," if field != fields[-1] else "" %}
+        {{field.name}}(o.{{field.name}}){{trailing_comma}}
+    {% endfor %}
+    {}
+
+    bool operator==(const BaseComputedStyle& o) const
+    {
+        return true
+        {% for field in fields %}
+            && {{field.name}} == o.{{field.name}}
+        {% endfor %}
+            && true;

[sashab, 2016/07/27 03:23:19]

This && true stuff was just my not-so-clever way of not having to worry about
trailing/leading stuff. Unfortunately there's no way around it in the
initializer list stuff above, but here the && trues should hopefully be
optimized out by the compiler so it should be OK.

+    }
+
+    bool operator!=(const BaseComputedStyle& o) const { return !(*this == o); }
+
+    inline bool inheritedEqual(const BaseComputedStyle& o) const
+    {
+        return true
+        {% for field in fields if field.property['inherited'] %}
+            && {{field.name}} == o.{{field.name}}
+        {% endfor %}
+            && true;
+    }
+
+    inline bool nonInheritedEqual(const BaseComputedStyle& o) const
+    {
+        return true
+        {% for field in fields if not field.property['inherited'] %}
+            && {{field.name}} == o.{{field.name}}
+        {% endfor %}
+            && true;
+    }
+
+    void setBitDefaults()
+    {
+        {% for field in fields %}
+        reset{{field.property['upper_camel_name']}}();
+        {% endfor %}
+    }
+
+    void inheritFrom(const BaseComputedStyle& inheritParent, IsAtShadowBoundary isAtShadowBoundary = NotAtShadowBoundary);
+
+    // Fields.
+    // TODO(sashab): Remove initialFoo() static methods and update callers to
+    // use resetFoo(), which can be more efficient.
+    {% for field in fields %}
+    // {{field.property['name']}}
+    inline static {{field.type}} initial{{field.property['upper_camel_name']}}() { return {{field.default_value}}; }
+    {{field.type}} {{field.property['lower_camel_name']}}() const { return static_cast<{{field.type}}>({{field.name}}); }
+    void set{{field.property['upper_camel_name']}}({{field.type}} v) { {{field.name}} = static_cast<unsigned>(v); }
+    inline void reset{{field.property['upper_camel_name']}}() { {{field.name}} = {{default_value(field)}}; }
+
+    {% endfor %}
+protected:
+    // Storage.
+    {% for field in fields %}
+    unsigned {{field.name}} : {{field.size}}; // {{field.type}}
+    {% endfor %}
+};
+
+} // namespace blink
+
+#endif // BaseComputedStyle_h