Move RareNonInheritedData::*DataEquivalent to ComputedStyle.

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 19 matching lines @@
 #include "core/CSSPropertyNames.h"
 #include "core/ComputedStyleBase.h"
 #include "core/CoreExport.h"
 #include "core/css/StyleAutoColor.h"
 #include "core/css/StyleColor.h"
 #include "core/layout/LayoutTheme.h"
 #include "core/style/AppliedTextDecoration.h"
 #include "core/style/AppliedTextDecorationList.h"
 #include "core/style/BorderValue.h"
 #include "core/style/ComputedStyleConstants.h"
+#include "core/style/ContentData.h"
 #include "core/style/CounterDirectives.h"
 #include "core/style/CursorData.h"
 #include "core/style/CursorList.h"
 #include "core/style/DataRef.h"
 #include "core/style/LineClampValue.h"
 #include "core/style/NinePieceImage.h"
 #include "core/style/QuotesData.h"
 #include "core/style/SVGComputedStyle.h"
 #include "core/style/ShadowData.h"
 #include "core/style/ShadowList.h"
@@ skipping 499 matching lines @@
       SetBorderBottomColorIsCurrentColor(color.IsCurrentColor());
     }
   }
 
   // box-shadow (aka -webkit-box-shadow)
   static ShadowList* InitialBoxShadow() { return 0; }
   ShadowList* BoxShadow() const {
     return rare_non_inherited_data_->box_shadow_.Get();
   }
   void SetBoxShadow(RefPtr<ShadowList>);
+  bool BoxShadowDataEquivalent(const ComputedStyle& other) const {
+    return DataEquivalent(BoxShadow(), other.BoxShadow());
+  }
 
   // clip
   static LengthBox InitialClip() { return LengthBox(); }
   const LengthBox& Clip() const { return ClipInternal(); }
   void SetClip(const LengthBox& box) {
     SetHasAutoClipInternal(false);
     SetClipInternal(box);
   }
   bool HasAutoClip() const { return HasAutoClipInternal(); }
   void SetHasAutoClip() {
@@ skipping 801 matching lines @@
   // shape-outside (aka -webkit-shape-outside)
   static ShapeValue* InitialShapeOutside() { return 0; }
   ShapeValue* ShapeOutside() const {
     return rare_non_inherited_data_->shape_outside_.Get();
   }
   void SetShapeOutside(ShapeValue* value) {
     if (rare_non_inherited_data_->shape_outside_ == value)
       return;
     rare_non_inherited_data_.Access()->shape_outside_ = value;
   }
+  bool ShapeOutsideDataEquivalent(const ComputedStyle& other) const {
+    return DataEquivalent(ShapeOutside(), other.ShapeOutside());
+  }
 
   // size
   const FloatSize& PageSize() const {
     return rare_non_inherited_data_->page_size_;
   }
   PageSizeType GetPageSizeType() const {
     return static_cast<PageSizeType>(rare_non_inherited_data_->page_size_type_);
   }
   void SetPageSize(const FloatSize& s) {
     SET_VAR(rare_non_inherited_data_, page_size_, s);
@@ skipping 152 matching lines @@
 
   // -webkit-clip-path
   static ClipPathOperation* InitialClipPath() { return 0; }
   ClipPathOperation* ClipPath() const {
     return rare_non_inherited_data_->clip_path_.Get();
   }
   void SetClipPath(RefPtr<ClipPathOperation> operation) {
     if (rare_non_inherited_data_->clip_path_ != operation)
       rare_non_inherited_data_.Access()->clip_path_ = std::move(operation);
   }
+  bool ClipPathDataEquivalent(const ComputedStyle& other) const {
+    return DataEquivalent(ClipPath(), other.ClipPath());
+  }
 
   // Mask properties.
   // -webkit-mask-box-image-outset
   const BorderImageLengthBox& MaskBoxImageOutset() const {
     return rare_non_inherited_data_->mask_box_image_.Outset();
   }
   void SetMaskBoxImageOutset(const BorderImageLengthBox& outset) {
     rare_non_inherited_data_.Access()->mask_box_image_.SetOutset(outset);
   }
 
@@ skipping 708 matching lines @@
   bool IsColumnFlexDirection() const {
     return FlexDirection() == kFlowColumn ||
            FlexDirection() == kFlowColumnReverse;
   }
   bool IsReverseFlexDirection() const {
     return FlexDirection() == kFlowRowReverse ||
            FlexDirection() == kFlowColumnReverse;
   }
   bool HasBoxReflect() const { return BoxReflect(); }
   bool ReflectionDataEquivalent(const ComputedStyle& other) const {
-    return rare_non_inherited_data_->ReflectionDataEquivalent(
-        *other.rare_non_inherited_data_);
+    return DataEquivalent(BoxReflect(), other.BoxReflect());
   }
 
   // Mask utility functions.
   bool HasMask() const {
     return rare_non_inherited_data_->mask_.HasImage() ||
            rare_non_inherited_data_->mask_box_image_.HasImage();
   }
   StyleImage* MaskImage() const {
     return rare_non_inherited_data_->mask_.GetImage();
   }
@@ skipping 759 matching lines @@
   }
   bool HasStaticInlinePosition(bool horizontal) const {
     return horizontal ? HasAutoLeftAndRight() : HasAutoTopAndBottom();
   }
   bool HasStaticBlockPosition(bool horizontal) const {
     return horizontal ? HasAutoTopAndBottom() : HasAutoLeftAndRight();
   }
 
   // Content utility functions.
   bool ContentDataEquivalent(const ComputedStyle& other) const {
-    return rare_non_inherited_data_->ContentDataEquivalent(
-        *other.rare_non_inherited_data_);
+    return DataEquivalent(GetContentData(), other.GetContentData());
   }
 
   // Contain utility functions.
   bool ContainsPaint() const {
     return rare_non_inherited_data_->contain_ & kContainsPaint;
   }
   bool ContainsStyle() const {
     return rare_non_inherited_data_->contain_ & kContainsStyle;
   }
   bool ContainsLayout() const {
@@ skipping 671 matching lines @@
       PseudoBitsInternal() | 1 << (pseudo - kFirstPublicPseudoId)));
 }
 
 inline bool ComputedStyle::HasPseudoElementStyle() const {
   return PseudoBitsInternal() & kElementPseudoIdMask;
 }
 
 }  // namespace blink
 
 #endif  // ComputedStyle_h