Remove references to rare_inherited_data_ in ComputedStyle.

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 893 matching lines @@
   if (!rare_non_inherited_data_.Access()->paint_images_) {
     rare_non_inherited_data_.Access()->paint_images_ =
         WTF::MakeUnique<PaintImages>();
   }
   rare_non_inherited_data_.Access()->paint_images_->push_back(image);
 }
 
 void ComputedStyle::AddCursor(StyleImage* image,
                               bool hot_spot_specified,
                               const IntPoint& hot_spot) {
-  if (!rare_inherited_data_.Access()->cursor_data_)
-    rare_inherited_data_.Access()->cursor_data_ = new CursorList;
-  rare_inherited_data_.Access()->cursor_data_->push_back(
+  if (!CursorDataInternal())
+    SetCursorDataInternal(new CursorList);
+  MutableCursorDataInternal()->push_back(
       CursorData(image, hot_spot_specified, hot_spot));
 }
 
 void ComputedStyle::SetCursorList(CursorList* other) {
-  rare_inherited_data_.Access()->cursor_data_ = other;
+  SetCursorDataInternal(other);
 }
 
 void ComputedStyle::SetQuotes(RefPtr<QuotesData> q) {
-  rare_inherited_data_.Access()->quotes_ = std::move(q);
+  SetQuotesInternal(q);
 }
 
 bool ComputedStyle::QuotesDataEquivalent(const ComputedStyle& other) const {
   return DataEquivalent(Quotes(), other.Quotes());
 }
 
 void ComputedStyle::ClearCursorList() {
-  if (rare_inherited_data_->cursor_data_)
-    rare_inherited_data_.Access()->cursor_data_ = nullptr;
+  if (CursorDataInternal())
+    SetCursorDataInternal(nullptr);
 }
 
 static bool HasPropertyThatCreatesStackingContext(
     const Vector<CSSPropertyID>& properties) {
   for (CSSPropertyID property : properties) {
     switch (property) {
       case CSSPropertyOpacity:
       case CSSPropertyTransform:
       case CSSPropertyAliasWebkitTransform:
       case CSSPropertyTransformStyle:
@@ skipping 255 matching lines @@
   transform.Translate(point.X() - origin_x + origin_shift_x,
                       point.Y() - origin_y + origin_shift_y);
   transform.Rotate(angle + motion_data.rotation_.angle);
 
   if (position.X() != Length(kAuto) || anchor.X() != Length(kAuto))
     // Shift the origin back to transform-origin.
     transform.Translate(-origin_shift_x, -origin_shift_y);
 }
 
 void ComputedStyle::SetTextShadow(RefPtr<ShadowList> s) {
-  rare_inherited_data_.Access()->text_shadow_ = std::move(s);
+  SetTextShadowInternal(s);
 }
 
 bool ComputedStyle::TextShadowDataEquivalent(const ComputedStyle& other) const {
   return DataEquivalent(TextShadow(), other.TextShadow());
 }
 
 void ComputedStyle::SetBoxShadow(RefPtr<ShadowList> s) {
   rare_non_inherited_data_.Access()->box_shadow_ = std::move(s);
 }
 
@@ skipping 11 matching lines @@
           FloatValueForLength(top_right.Height(), size.Height().ToFloat())),
       FloatSize(
           FloatValueForLength(bottom_left.Width(), size.Width().ToFloat()),
           FloatValueForLength(bottom_left.Height(), size.Height().ToFloat())),
       FloatSize(
           FloatValueForLength(bottom_right.Width(), size.Width().ToFloat()),
           FloatValueForLength(bottom_right.Height(), size.Height().ToFloat())));
 }
 
 StyleImage* ComputedStyle::ListStyleImage() const {
-  return rare_inherited_data_->list_style_image_.Get();
+  return ListStyleImageInternal();
 }
 void ComputedStyle::SetListStyleImage(StyleImage* v) {
-  if (rare_inherited_data_->list_style_image_ != v)
-    rare_inherited_data_.Access()->list_style_image_ = v;
+  SetListStyleImageInternal(v);
 }
 
 Color ComputedStyle::GetColor() const {
   return ColorInternal();
 }
 void ComputedStyle::SetColor(const Color& v) {
   SetColorInternal(v);
 }
 
 FloatRoundedRect ComputedStyle::GetRoundedBorderFor(
@@ skipping 143 matching lines @@
   return Locale();
 }
 
 Hyphenation* ComputedStyle::GetHyphenation() const {
   return GetHyphens() == Hyphens::kAuto
              ? GetFontDescription().LocaleOrDefault().GetHyphenation()
              : nullptr;
 }
 
 const AtomicString& ComputedStyle::HyphenString() const {
-  const AtomicString& hyphenation_string =
-      rare_inherited_data_.Get()->hyphenation_string_;
+  const AtomicString& hyphenation_string = HyphenationString();
   if (!hyphenation_string.IsNull())
     return hyphenation_string;
 
   // FIXME: This should depend on locale.
   DEFINE_STATIC_LOCAL(AtomicString, hyphen_minus_string,
                       (&kHyphenMinusCharacter, 1));
   DEFINE_STATIC_LOCAL(AtomicString, hyphen_string, (&kHyphenCharacter, 1));
   const SimpleFontData* primary_font = GetFont().PrimaryFont();
   DCHECK(primary_font);
   return primary_font && primary_font->GlyphForCharacter(kHyphenCharacter)
@@ skipping 101 matching lines @@
 FontWeight ComputedStyle::GetFontWeight() const {
   return GetFontDescription().Weight();
 }
 FontStretch ComputedStyle::GetFontStretch() const {
   return GetFontDescription().Stretch();
 }
 
 TextDecoration ComputedStyle::TextDecorationsInEffect() const {
   if (HasSimpleUnderlineInternal())
     return TextDecoration::kUnderline;
-  if (!rare_inherited_data_->applied_text_decorations_)
+  if (!AppliedTextDecorationsInternal())
     return TextDecoration::kNone;
 
   TextDecoration decorations = TextDecoration::kNone;
 
   const Vector<AppliedTextDecoration>& applied = AppliedTextDecorations();
 
   for (size_t i = 0; i < applied.size(); ++i)
     decorations |= applied[i].Lines();
 
   return decorations;
 }
 
 const Vector<AppliedTextDecoration>& ComputedStyle::AppliedTextDecorations()
     const {
   if (HasSimpleUnderlineInternal()) {
     DEFINE_STATIC_LOCAL(
         Vector<AppliedTextDecoration>, underline,
         (1, AppliedTextDecoration(
                 TextDecoration::kUnderline, kTextDecorationStyleSolid,
                 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;
   }
-  if (!rare_inherited_data_->applied_text_decorations_) {
+  if (!AppliedTextDecorationsInternal()) {
     DEFINE_STATIC_LOCAL(Vector<AppliedTextDecoration>, empty, ());
     return empty;
   }
 
-  return rare_inherited_data_->applied_text_decorations_->GetVector();
+  return AppliedTextDecorationsInternal()->GetVector();
 }
 
 StyleInheritedVariables* ComputedStyle::InheritedVariables() const {
-  return rare_inherited_data_->variables_.Get();
+  return VariablesInternal().Get();
 }
 
 StyleNonInheritedVariables* ComputedStyle::NonInheritedVariables() const {
   return rare_non_inherited_data_->variables_.get();
 }
 
 StyleInheritedVariables& ComputedStyle::MutableInheritedVariables() {
-  RefPtr<StyleInheritedVariables>& variables =
-      rare_inherited_data_.Access()->variables_;
+  RefPtr<StyleInheritedVariables>& variables = MutableVariablesInternal();
   if (!variables)
     variables = StyleInheritedVariables::Create();
   else if (!variables->HasOneRef())
     variables = variables->Copy();
   return *variables;
 }
 
 StyleNonInheritedVariables& ComputedStyle::MutableNonInheritedVariables() {
   std::unique_ptr<StyleNonInheritedVariables>& variables =
       rare_non_inherited_data_.Access()->variables_;
@@ skipping 211 matching lines @@
       TextAutosizer::ComputeAutosizedFontSize(size, multiplier);
   desc.SetComputedSize(std::min(kMaximumAllowedFontSize, autosized_font_size));
 
   SetFontDescription(desc);
   GetFont().Update(current_font_selector);
 }
 
 void ComputedStyle::AddAppliedTextDecoration(
     const AppliedTextDecoration& decoration) {
   RefPtr<AppliedTextDecorationList>& list =
-      rare_inherited_data_.Access()->applied_text_decorations_;
+      MutableAppliedTextDecorationsInternal();
 
   if (!list)
     list = AppliedTextDecorationList::Create();
   else if (!list->HasOneRef())
     list = list->Copy();
 
   list->push_back(decoration);
 }
 
 void ComputedStyle::OverrideTextDecorationColors(Color override_color) {
   RefPtr<AppliedTextDecorationList>& list =
-      rare_inherited_data_.Access()->applied_text_decorations_;
+      MutableAppliedTextDecorationsInternal();
   DCHECK(list);
   if (!list->HasOneRef())
     list = list->Copy();
 
   for (size_t i = 0; i < list->size(); ++i)
     list->at(i).SetColor(override_color);
 }
 
 void ComputedStyle::ApplyTextDecorations(
     const Color& parent_text_decoration_color,
     bool override_existing_colors) {
   if (GetTextDecoration() == TextDecoration::kNone &&
-      !HasSimpleUnderlineInternal() &&
-      !rare_inherited_data_->applied_text_decorations_)
+      !HasSimpleUnderlineInternal() && !AppliedTextDecorationsInternal())
     return;
 
   // If there are any color changes or decorations set by this element, stop
   // using m_hasSimpleUnderline.
   Color current_text_decoration_color =
       VisitedDependentColor(CSSPropertyTextDecorationColor);
   if (HasSimpleUnderlineInternal() &&
       (GetTextDecoration() != TextDecoration::kNone ||
        current_text_decoration_color != parent_text_decoration_color)) {
     SetHasSimpleUnderlineInternal(false);
     AddAppliedTextDecoration(AppliedTextDecoration(
         TextDecoration::kUnderline, kTextDecorationStyleSolid,
         parent_text_decoration_color));
   }
-  if (override_existing_colors &&
-      rare_inherited_data_->applied_text_decorations_)
+  if (override_existing_colors && AppliedTextDecorationsInternal())
     OverrideTextDecorationColors(current_text_decoration_color);
   if (GetTextDecoration() == TextDecoration::kNone)
     return;
   DCHECK(!HasSimpleUnderlineInternal());
   // To save memory, we don't use AppliedTextDecoration objects in the common
   // case of a single simple underline of currentColor.
   TextDecoration decoration_lines = GetTextDecoration();
   TextDecorationStyle decoration_style = GetTextDecorationStyle();
   bool is_simple_underline = decoration_lines == TextDecoration::kUnderline &&
                              decoration_style == kTextDecorationStyleSolid &&
                              TextDecorationColor().IsCurrentColor();
-  if (is_simple_underline && !rare_inherited_data_->applied_text_decorations_) {
+  if (is_simple_underline && !AppliedTextDecorationsInternal()) {
     SetHasSimpleUnderlineInternal(true);
     return;
   }
 
   AddAppliedTextDecoration(AppliedTextDecoration(
       decoration_lines, decoration_style, current_text_decoration_color));
 }
 
 void ComputedStyle::ClearAppliedTextDecorations() {
   SetHasSimpleUnderlineInternal(false);
 
-  if (rare_inherited_data_->applied_text_decorations_)
-    rare_inherited_data_.Access()->applied_text_decorations_ = nullptr;
+  if (AppliedTextDecorationsInternal())
+    SetAppliedTextDecorationsInternal(nullptr);
 }
 
 void ComputedStyle::RestoreParentTextDecorations(
     const ComputedStyle& parent_style) {
   SetHasSimpleUnderlineInternal(parent_style.HasSimpleUnderlineInternal());
-  if (rare_inherited_data_->applied_text_decorations_ !=
-      parent_style.rare_inherited_data_->applied_text_decorations_) {
-    rare_inherited_data_.Access()->applied_text_decorations_ =
-        parent_style.rare_inherited_data_->applied_text_decorations_;
+  if (AppliedTextDecorationsInternal() !=
+      parent_style.AppliedTextDecorationsInternal()) {
+    SetAppliedTextDecorationsInternal(
+        parent_style.AppliedTextDecorationsInternal());
   }
 }
 
 void ComputedStyle::ClearMultiCol() {
   rare_non_inherited_data_.Access()->multi_col_ = nullptr;
   rare_non_inherited_data_.Access()->multi_col_.Init();
 }
 
 StyleColor ComputedStyle::DecorationColorIncludingFallback(
     bool visited_link) const {
@@ skipping 303 matching lines @@
 
 bool ComputedStyle::ColumnRuleEquivalent(
     const ComputedStyle* other_style) const {
   return ColumnRuleStyle() == other_style->ColumnRuleStyle() &&
          ColumnRuleWidth() == other_style->ColumnRuleWidth() &&
          VisitedDependentColor(CSSPropertyColumnRuleColor) ==
              other_style->VisitedDependentColor(CSSPropertyColumnRuleColor);
 }
 
 TextEmphasisMark ComputedStyle::GetTextEmphasisMark() const {
-  TextEmphasisMark mark =
-      static_cast<TextEmphasisMark>(rare_inherited_data_->text_emphasis_mark_);
+  TextEmphasisMark mark = TextEmphasisMarkInternal();
   if (mark != TextEmphasisMark::kAuto)
     return mark;
 
   if (IsHorizontalWritingMode())
     return TextEmphasisMark::kDot;
 
   return TextEmphasisMark::kSesame;
 }
 
 const FilterOperations& ComputedStyle::InitialFilter() {
@@ skipping 132 matching lines @@
     if (value < 0)
       fvalue -= 0.5f;
     else
       fvalue += 0.5f;
   }
 
   return RoundForImpreciseConversion<int>(fvalue / zoom_factor);
 }
 
 }  // namespace blink