Moved pointer-events to be generated in ComputedStyleBase

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
@@ skipping 180 matching lines @@
   std::unique_ptr<PseudoStyleCache> m_cachedPseudoStyles;
 
   DataRef<SVGComputedStyle> m_svgStyle;
 
   // !START SYNC!: Keep this in sync with the copy constructor in
   // ComputedStyle.cpp and implicitlyInherited() in StyleResolver.cpp
 
   // inherit
   struct InheritedData {
     bool operator==(const InheritedData& other) const {
-      return compareEqualIndependent(other) &&
-             compareEqualNonIndependent(other);
+      return compareEqualNonIndependent(other);

[sashab, 2016/12/12 01:52:56]

Move all checks into here, delete compareEqualNonIndependent() function too

[napper, 2016/12/12 05:31:41]

Done.

     }
 
     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.

[sashab, 2016/12/12 01:52:56]

Move this comment to the generated compareEqualIndependent() method

[napper, 2016/12/12 05:31:41]

Not sure what you mean here. The compareEqualIndependent() method doesn't exist
anymore.

-      // TODO(napper): Remove this once all independent properties are
-      // generated and replace with a private function used only in
-      // stylePropagationDiff().
-      return (m_pointerEvents == other.m_pointerEvents);
-    }
-
     inline bool compareEqualNonIndependent(const InheritedData& other) const {
       return (m_listStyleType == other.m_listStyleType) &&
              (m_textAlign == other.m_textAlign) &&
              (m_hasSimpleUnderline == other.m_hasSimpleUnderline) &&
              (m_cursorStyle == other.m_cursorStyle) &&
              (m_direction == other.m_direction) &&
              (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_listStyleType : 7;      // EListStyleType
     unsigned m_textAlign : 4;          // ETextAlign
     unsigned m_hasSimpleUnderline : 1;  // True if 'underline solid' is the only
                                         // text decoration on this element.
     unsigned m_cursorStyle : 6;     // ECursor
     unsigned m_direction : 1;       // TextDirection
     unsigned m_boxDirection : 1;  // EBoxDirection (CSS3 box_direction property,
                                   // flexible box layout module)
     // 32 bits
 
     // non CSS2 inherited
     unsigned m_rtlOrdering : 1;       // EOrder
     unsigned m_printColorAdjust : 1;  // PrintColorAdjust
-    unsigned m_pointerEvents : 4;  // EPointerEvents
     unsigned m_insideLink : 2;     // EInsideLink
 
     // CSS Text Layout Module Level 3: Vertical writing support
     unsigned m_writingMode : 2;  // WritingMode
                                  // 42 bits
   } m_inheritedData;
 
   // don't inherit
   struct NonInheritedData {
     // Compare computed styles, differences in inherited bits or other flags
@@ skipping 65 matching lines @@
     unsigned m_affectedByHover : 1;
     unsigned m_affectedByActive : 1;
     unsigned m_affectedByDrag : 1;
 
     // 64 bits
 
     unsigned m_isLink : 1;
 
     mutable unsigned m_hasRemUnits : 1;
 
-    // For each independent inherited property, store a 1 if the stored
-    // value was inherited from its parent, or 0 if it is explicitly set on
-    // this element.
-    // Eventually, all properties will have a bit in here to store whether
-    // they were inherited from their parent or not.
-    // Although two ComputedStyles are equal if their nonInheritedData is
-    // equal regardless of the isInherited flags, this struct is stored next
-    // to the existing flags to take advantage of packing as much as possible.

[sashab, 2016/12/12 01:52:56]

Move this comment somewhere... Maybe into make_computed_style_base.py

[napper, 2016/12/12 05:31:41]

As discussed offline, I have reviewed the relevance of this comment.

1. The first 2 sentences are already documented in make_computed_style_base.py
2. The remainder is not required now there are no independent but not generated
properties.

-    // TODO(sashab): Move these flags closer to inheritedData so that it's
-    // clear which inherited properties have a flag stored and which don't.
-    // Keep this list of fields in sync with:
-    // - setBitDefaults()
-    // - The ComputedStyle setter, which must take an extra boolean parameter
-    //   and set this - propagateIndependentInheritedProperties() in
-    //   ComputedStyle.cpp
-    // - The compareEqual() methods in the corresponding class
-    // InheritedFlags
-    unsigned m_isPointerEventsInherited : 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_listStyleType =
         static_cast<unsigned>(initialListStyleType());
     m_inheritedData.m_textAlign = static_cast<unsigned>(initialTextAlign());
     m_inheritedData.m_hasSimpleUnderline = false;
     m_inheritedData.m_cursorStyle = static_cast<unsigned>(initialCursor());
     m_inheritedData.m_direction = initialDirection();
     m_inheritedData.m_rtlOrdering = static_cast<unsigned>(initialRTLOrdering());
     m_inheritedData.m_boxDirection =
         static_cast<unsigned>(initialBoxDirection());
     m_inheritedData.m_printColorAdjust =
         static_cast<unsigned>(initialPrintColorAdjust());
-    m_inheritedData.m_pointerEvents =
-        static_cast<unsigned>(initialPointerEvents());
     m_inheritedData.m_insideLink = NotInsideLink;
     m_inheritedData.m_writingMode = initialWritingMode();
 
     m_nonInheritedData.m_effectiveDisplay =
         m_nonInheritedData.m_originalDisplay =
             static_cast<unsigned>(initialDisplay());
     m_nonInheritedData.m_overflowAnchor = initialOverflowAnchor();
     m_nonInheritedData.m_overflowX = initialOverflowX();
     m_nonInheritedData.m_overflowY = initialOverflowY();
     m_nonInheritedData.m_verticalAlign = initialVerticalAlign();
@@ skipping 10 matching lines @@
     m_nonInheritedData.m_variableReference = false;
     m_nonInheritedData.m_unique = false;
     m_nonInheritedData.m_emptyState = false;
     m_nonInheritedData.m_hasViewportUnits = false;
     m_nonInheritedData.m_affectedByFocus = false;
     m_nonInheritedData.m_affectedByHover = false;
     m_nonInheritedData.m_affectedByActive = false;
     m_nonInheritedData.m_affectedByDrag = false;
     m_nonInheritedData.m_isLink = false;
     m_nonInheritedData.m_hasRemUnits = false;
-
-    // All independently inherited properties default to being inherited.
-    m_nonInheritedData.m_isPointerEventsInherited = true;
   }
 
  private:
   // TODO(sashab): Move these to the bottom of ComputedStyle.
   ALWAYS_INLINE ComputedStyle();
 
   enum InitialStyleTag { InitialStyle };
   ALWAYS_INLINE explicit ComputedStyle(InitialStyleTag);
   ALWAYS_INLINE ComputedStyle(const ComputedStyle&);
 
@@ skipping 1712 matching lines @@
 
   // overflow-wrap (aka word-wrap)
   static EOverflowWrap initialOverflowWrap() { return NormalOverflowWrap; }
   EOverflowWrap overflowWrap() const {
     return static_cast<EOverflowWrap>(m_rareInheritedData->overflowWrap);
   }
   void setOverflowWrap(EOverflowWrap b) {
     SET_VAR(m_rareInheritedData, overflowWrap, b);
   }
 
-  // pointer-events
-  static EPointerEvents initialPointerEvents() { return EPointerEvents::Auto; }
-  EPointerEvents pointerEvents() const {
-    return static_cast<EPointerEvents>(m_inheritedData.m_pointerEvents);
-  }
-  void setPointerEvents(EPointerEvents p) {
-    m_inheritedData.m_pointerEvents = static_cast<unsigned>(p);
-  }
-  void setPointerEventsIsInherited(bool isInherited) {
-    m_nonInheritedData.m_isPointerEventsInherited = isInherited;
-  }
-
   // quotes
   static QuotesData* initialQuotes() { return 0; }
   QuotesData* quotes() const { return m_rareInheritedData->quotes.get(); }
   void setQuotes(PassRefPtr<QuotesData>);
 
   // snap-height
   uint8_t snapHeightPosition() const {
     return m_rareInheritedData->m_snapHeightPosition;
   }
   uint8_t snapHeightUnit() const {
@@ skipping 1919 matching lines @@
   m_nonInheritedData.m_pseudoBits |= 1 << (pseudo - 1);
 }
 
 inline bool ComputedStyle::hasPseudoElementStyle() const {
   return m_nonInheritedData.m_pseudoBits & ElementPseudoIdMask;
 }
 
 }  // namespace blink
 
 #endif  // ComputedStyle_h