Generate inherited nonproperties insideLink and hasSimpleUnderline.

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 61 matching lines @@
 // re-create the same structure for an accurate size comparison.
 struct SameSizeAsComputedStyle : public RefCounted<SameSizeAsComputedStyle> {
   struct ComputedStyleBase {
     unsigned m_bitfields[4];
   } m_base;
 
   void* dataRefs[7];
   void* ownPtrs[1];
   void* dataRefSvgStyle;
 
-  struct InheritedData {
-    unsigned m_bitfields[1];
-  } m_inheritedData;
-
   struct NonInheritedData {
     unsigned m_bitfields[1];
   } m_nonInheritedData;
 };
 
 // If this assert fails, it means that size of ComputedStyle has changed. Please
 // check that you really *do* what to increase the size of ComputedStyle, then
 // update the SameSizeAsComputedStyle struct to match the updated storage of
 // ComputedStyle.
 ASSERT_SIZE(ComputedStyle, SameSizeAsComputedStyle);
@@ skipping 50 matching lines @@
     : 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) {}
 
 static StyleRecalcChange diffPseudoStyles(const ComputedStyle& oldStyle,
                                           const ComputedStyle& newStyle) {
   // If the pseudoStyles have changed, ensure layoutObject triggers setStyle.
   if (!oldStyle.hasAnyPublicPseudoStyles() &&
       !newStyle.hasAnyPublicPseudoStyles())
     return NoChange;
   for (PseudoId pseudoId = FirstPublicPseudoId;
        pseudoId < FirstInternalPseudoId;
@@ skipping 161 matching lines @@
   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;
   if (m_svgStyle != inheritParent.m_svgStyle)
     m_svgStyle.access()->inheritFrom(inheritParent.m_svgStyle.get());
 }
 
 void ComputedStyle::copyNonInheritedFromCached(const ComputedStyle& other) {
   ComputedStyleBase::copyNonInheritedFromCached(other);
   m_box = other.m_box;
   m_visual = other.m_visual;
   m_background = other.m_background;
   m_surround = other.m_surround;
@@ skipping 121 matching lines @@
 }
 
 bool ComputedStyle::independentInheritedEqual(
     const ComputedStyle& other) const {
   return ComputedStyleBase::independentInheritedEqual(other);
 }
 
 bool ComputedStyle::nonIndependentInheritedEqual(
     const ComputedStyle& other) const {
   return ComputedStyleBase::nonIndependentInheritedEqual(other) &&
-         m_inheritedData == 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 ComputedStyleBase::nonInheritedEqual(other) &&
          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.
   // 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)
@@ skipping 392 matching lines @@
       return true;
   }
 
   return false;
 }
 
 bool ComputedStyle::diffNeedsPaintInvalidationObject(
     const ComputedStyle& other) const {
   if (visibility() != other.visibility() ||
       printColorAdjust() != other.printColorAdjust() ||
-      m_inheritedData.m_insideLink != other.m_inheritedData.m_insideLink ||
+      insideLink() != other.insideLink() ||
       !m_surround->border.visuallyEqual(other.m_surround->border) ||
       *m_background != *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 !=
@@ skipping 131 matching lines @@
       diff.setNeedsRecomputeOverflow();
   }
 
   if (!m_surround->border.visualOverflowEqual(other.m_surround->border))
     diff.setNeedsRecomputeOverflow();
 
   if (!diff.needsFullPaintInvalidation()) {
     if (m_styleInheritedData->color != other.m_styleInheritedData->color ||
         m_styleInheritedData->visitedLinkColor !=
             other.m_styleInheritedData->visitedLinkColor ||
-        m_inheritedData.m_hasSimpleUnderline !=
-            other.m_inheritedData.m_hasSimpleUnderline ||
+        m_hasSimpleUnderline != other.m_hasSimpleUnderline ||
         m_visual->textDecoration != other.m_visual->textDecoration) {
       diff.setTextDecorationOrColorChanged();
     } else if (m_rareNonInheritedData.get() !=
                    other.m_rareNonInheritedData.get() &&
                (m_rareNonInheritedData->m_textDecorationStyle !=
                     other.m_rareNonInheritedData->m_textDecorationStyle ||
                 m_rareNonInheritedData->m_textDecorationColor !=
                     other.m_rareNonInheritedData->m_textDecorationColor ||
                 m_rareNonInheritedData->m_visitedLinkTextDecorationColor !=
                     other.m_rareNonInheritedData
@@ skipping 622 matching lines @@
   return getFontDescription().hasSizeAdjust();
 }
 FontWeight ComputedStyle::fontWeight() const {
   return getFontDescription().weight();
 }
 FontStretch ComputedStyle::fontStretch() const {
   return getFontDescription().stretch();
 }
 
 TextDecoration ComputedStyle::textDecorationsInEffect() const {
-  if (m_inheritedData.m_hasSimpleUnderline)
+  if (m_hasSimpleUnderline)
     return TextDecorationUnderline;
   if (!m_rareInheritedData->appliedTextDecorations)
     return TextDecorationNone;
 
   int decorations = 0;
 
   const Vector<AppliedTextDecoration>& applied = appliedTextDecorations();
 
   for (size_t i = 0; i < applied.size(); ++i)
     decorations |= applied[i].lines();
 
   return static_cast<TextDecoration>(decorations);
 }
 
 const Vector<AppliedTextDecoration>& ComputedStyle::appliedTextDecorations()
     const {
-  if (m_inheritedData.m_hasSimpleUnderline) {
+  if (m_hasSimpleUnderline) {
     DEFINE_STATIC_LOCAL(
         Vector<AppliedTextDecoration>, underline,
         (1, AppliedTextDecoration(
                 TextDecorationUnderline, TextDecorationStyleSolid,
                 visitedDependentColor(CSSPropertyTextDecorationColor))));
     // Since we only have one of these in memory, just update the color before
     // returning.
     underline.at(0).setColor(
         visitedDependentColor(CSSPropertyTextDecorationColor));
     return underline;
@@ skipping 264 matching lines @@
   DCHECK(list);
   if (!list->hasOneRef())
     list = list->copy();
 
   for (size_t i = 0; i < list->size(); ++i)
     list->at(i).setColor(overrideColor);
 }
 
 void ComputedStyle::applyTextDecorations(const Color& parentTextDecorationColor,
                                          bool overrideExistingColors) {
-  if (getTextDecoration() == TextDecorationNone &&
-      !m_inheritedData.m_hasSimpleUnderline &&
+  if (getTextDecoration() == TextDecorationNone && !m_hasSimpleUnderline &&
       !m_rareInheritedData->appliedTextDecorations)
     return;
 
   // If there are any color changes or decorations set by this element, stop
   // using m_hasSimpleUnderline.
   Color currentTextDecorationColor =
       visitedDependentColor(CSSPropertyTextDecorationColor);
-  if (m_inheritedData.m_hasSimpleUnderline &&
+  if (m_hasSimpleUnderline &&
       (getTextDecoration() != TextDecorationNone ||
        currentTextDecorationColor != parentTextDecorationColor)) {
-    m_inheritedData.m_hasSimpleUnderline = false;
+    m_hasSimpleUnderline = false;
     addAppliedTextDecoration(AppliedTextDecoration(TextDecorationUnderline,
                                                    TextDecorationStyleSolid,
                                                    parentTextDecorationColor));
   }
   if (overrideExistingColors && m_rareInheritedData->appliedTextDecorations)
     overrideTextDecorationColors(currentTextDecorationColor);
   if (getTextDecoration() == TextDecorationNone)
     return;
-  DCHECK(!m_inheritedData.m_hasSimpleUnderline);
+  DCHECK(!m_hasSimpleUnderline);
   // To save memory, we don't use AppliedTextDecoration objects in the common
   // case of a single simple underline of currentColor.
   TextDecoration decorationLines = getTextDecoration();
   TextDecorationStyle decorationStyle = getTextDecorationStyle();
   bool isSimpleUnderline = decorationLines == TextDecorationUnderline &&
                            decorationStyle == TextDecorationStyleSolid &&
                            textDecorationColor().isCurrentColor();
   if (isSimpleUnderline && !m_rareInheritedData->appliedTextDecorations) {
-    m_inheritedData.m_hasSimpleUnderline = true;
+    m_hasSimpleUnderline = true;
     return;
   }
 
   addAppliedTextDecoration(AppliedTextDecoration(
       decorationLines, decorationStyle, currentTextDecorationColor));
 }
 
 void ComputedStyle::clearAppliedTextDecorations() {
-  m_inheritedData.m_hasSimpleUnderline = false;
+  m_hasSimpleUnderline = false;
 
   if (m_rareInheritedData->appliedTextDecorations)
     m_rareInheritedData.access()->appliedTextDecorations = nullptr;
 }
 
 void ComputedStyle::restoreParentTextDecorations(
     const ComputedStyle& parentStyle) {
-  m_inheritedData.m_hasSimpleUnderline =
-      parentStyle.m_inheritedData.m_hasSimpleUnderline;
+  m_hasSimpleUnderline = parentStyle.m_hasSimpleUnderline;
   if (m_rareInheritedData->appliedTextDecorations !=
       parentStyle.m_rareInheritedData->appliedTextDecorations)
     m_rareInheritedData.access()->appliedTextDecorations =
         parentStyle.m_rareInheritedData->appliedTextDecorations;
 }
 
 void ComputedStyle::clearMultiCol() {
   m_rareNonInheritedData.access()->m_multiCol = nullptr;
   m_rareNonInheritedData.access()->m_multiCol.init();
 }
@@ skipping 424 matching lines @@
     if (value < 0)
       fvalue -= 0.5f;
     else
       fvalue += 0.5f;
   }
 
   return roundForImpreciseConversion<int>(fvalue / zoomFactor);
 }
 
 }  // namespace blink