Remove PassRefPtr on setters in 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 278 matching lines @@
   StyleDifference VisualInvalidationDiff(const ComputedStyle&) const;
 
   void InheritFrom(const ComputedStyle& inherit_parent,
                    IsAtShadowBoundary = kNotAtShadowBoundary);
   void CopyNonInheritedFromCached(const ComputedStyle&);
 
   PseudoId StyleType() const { return StyleTypeInternal(); }
   void SetStyleType(PseudoId style_type) { SetStyleTypeInternal(style_type); }
 
   ComputedStyle* GetCachedPseudoStyle(PseudoId) const;
-  ComputedStyle* AddCachedPseudoStyle(PassRefPtr<ComputedStyle>);
+  ComputedStyle* AddCachedPseudoStyle(RefPtr<ComputedStyle>);
   void RemoveCachedPseudoStyle(PseudoId);
 
   const PseudoStyleCache* CachedPseudoStyles() const {
     return cached_pseudo_styles_.get();
   }
 
   bool BorderWidthEquals(float border_width_first,
                          float border_width_second) const {
     return WidthToFixedPoint(border_width_first) ==
            WidthToFixedPoint(border_width_second);
@@ skipping 318 matching lines @@
       SetBorderBottomColorInternal(color.Resolve(Color()));
       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(PassRefPtr<ShadowList>);
+  void SetBoxShadow(RefPtr<ShadowList>);
 
   // 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 231 matching lines @@
   }
   void SetBoxPack(EBoxPack p) {
     SET_NESTED_VAR(rare_non_inherited_data_, deprecated_flexible_box_, pack, p);
   }
 
   // -webkit-box-reflect
   static StyleReflection* InitialBoxReflect() { return 0; }
   StyleReflection* BoxReflect() const {
     return rare_non_inherited_data_->box_reflect_.Get();
   }
-  void SetBoxReflect(PassRefPtr<StyleReflection> reflect) {
+  void SetBoxReflect(RefPtr<StyleReflection> reflect) {
     if (rare_non_inherited_data_->box_reflect_ != reflect)
       rare_non_inherited_data_.Access()->box_reflect_ = std::move(reflect);
   }
 
   // Grid properties.
   static Vector<GridTrackSize> InitialGridAutoRepeatTracks() {
     return Vector<GridTrackSize>(); /* none */
   }
   static size_t InitialGridAutoRepeatInsertionPoint() { return 0; }
   static AutoRepeatType InitialGridAutoRepeatType() { return kNoAutoRepeat; }
@@ skipping 230 matching lines @@
   void SetOffsetDistance(const Length& offset_distance) {
     SET_NESTED_VAR(rare_non_inherited_data_, transform_, motion_.distance_,
                    offset_distance);
   }
 
   // offset-path
   static BasicShape* InitialOffsetPath() { return nullptr; }
   BasicShape* OffsetPath() const {
     return rare_non_inherited_data_->transform_->motion_.path_.Get();
   }
-  void SetOffsetPath(PassRefPtr<BasicShape>);
+  void SetOffsetPath(RefPtr<BasicShape>);
 
   // offset-position
   static LengthPoint InitialOffsetPosition() {
     return LengthPoint(Length(kAuto), Length(kAuto));
   }
   const LengthPoint& OffsetPosition() const {
     return rare_non_inherited_data_->transform_->motion_.position_;
   }
   void SetOffsetPosition(const LengthPoint& offset_position) {
     SET_NESTED_VAR(rare_non_inherited_data_, transform_, motion_.position_,
@@ skipping 173 matching lines @@
   }
 
   // Independent transform properties.
   // translate
   static PassRefPtr<TranslateTransformOperation> InitialTranslate() {
     return nullptr;
   }
   TranslateTransformOperation* Translate() const {
     return rare_non_inherited_data_->transform_->translate_.Get();
   }
-  void SetTranslate(PassRefPtr<TranslateTransformOperation> v) {
+  void SetTranslate(RefPtr<TranslateTransformOperation> v) {
     rare_non_inherited_data_.Access()->transform_.Access()->translate_ =
         std::move(v);
   }
 
   // rotate
   static PassRefPtr<RotateTransformOperation> InitialRotate() {
     return nullptr;
   }
   RotateTransformOperation* Rotate() const {
     return rare_non_inherited_data_->transform_->rotate_.Get();
   }
-  void SetRotate(PassRefPtr<RotateTransformOperation> v) {
+  void SetRotate(RefPtr<RotateTransformOperation> v) {
     rare_non_inherited_data_.Access()->transform_.Access()->rotate_ =
         std::move(v);
   }
 
   // scale
   static PassRefPtr<ScaleTransformOperation> InitialScale() { return nullptr; }
   ScaleTransformOperation* Scale() const {
     return rare_non_inherited_data_->transform_->scale_.Get();
   }
-  void SetScale(PassRefPtr<ScaleTransformOperation> v) {
+  void SetScale(RefPtr<ScaleTransformOperation> v) {
     rare_non_inherited_data_.Access()->transform_.Access()->scale_ =
         std::move(v);
   }
 
   // Scroll properties.
   // scroll-behavior
   static ScrollBehavior InitialScrollBehavior() { return kScrollBehaviorAuto; }
   ScrollBehavior GetScrollBehavior() const {
     return static_cast<ScrollBehavior>(
         rare_non_inherited_data_->scroll_behavior_);
@@ skipping 256 matching lines @@
   }
   void SetAppearance(ControlPart a) {
     SET_VAR(rare_non_inherited_data_, appearance_, a);
   }
 
   // -webkit-clip-path
   static ClipPathOperation* InitialClipPath() { return 0; }
   ClipPathOperation* ClipPath() const {
     return rare_non_inherited_data_->clip_path_.Get();
   }
-  void SetClipPath(PassRefPtr<ClipPathOperation> operation) {
+  void SetClipPath(RefPtr<ClipPathOperation> operation) {
     if (rare_non_inherited_data_->clip_path_ != operation)
       rare_non_inherited_data_.Access()->clip_path_ = std::move(operation);
   }
 
   // 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) {
@@ skipping 73 matching lines @@
   EOverflowWrap OverflowWrap() const {
     return static_cast<EOverflowWrap>(rare_inherited_data_->overflow_wrap_);
   }
   void SetOverflowWrap(EOverflowWrap b) {
     SET_VAR(rare_inherited_data_, overflow_wrap_, b);
   }
 
   // quotes
   static QuotesData* InitialQuotes() { return 0; }
   QuotesData* Quotes() const { return rare_inherited_data_->quotes_.Get(); }
-  void SetQuotes(PassRefPtr<QuotesData>);
+  void SetQuotes(RefPtr<QuotesData>);
 
   bool QuotesDataEquivalent(const ComputedStyle&) const;
 
   // line-height-step
   static uint8_t InitialLineHeightStep() { return 0; }
   uint8_t LineHeightStep() const {
     return rare_inherited_data_->line_height_step_;
   }
   void SetLineHeightStep(uint8_t unit) {
     SET_VAR(rare_inherited_data_, line_height_step_, unit);
@@ skipping 73 matching lines @@
     return static_cast<TextOrientation>(
         rare_inherited_data_->text_orientation_);
   }
   bool SetTextOrientation(TextOrientation);
 
   // text-shadow
   static ShadowList* InitialTextShadow() { return 0; }
   ShadowList* TextShadow() const {
     return rare_inherited_data_->text_shadow_.Get();
   }
-  void SetTextShadow(PassRefPtr<ShadowList>);
+  void SetTextShadow(RefPtr<ShadowList>);
 
   bool TextShadowDataEquivalent(const ComputedStyle&) const;
 
   // text-size-adjust (aka -webkit-text-size-adjust)
   static TextSizeAdjust InitialTextSizeAdjust() {
     return TextSizeAdjust::AdjustAuto();
   }
   TextSizeAdjust GetTextSizeAdjust() const {
     return rare_inherited_data_->text_size_adjust_;
   }
@@ skipping 225 matching lines @@
     svg_style.SetBaselineShiftValue(value);
   }
 
   // cx
   void SetCx(const Length& cx) { AccessSVGStyle().SetCx(cx); }
 
   // cy
   void SetCy(const Length& cy) { AccessSVGStyle().SetCy(cy); }
 
   // d
-  void SetD(PassRefPtr<StylePath> d) { AccessSVGStyle().SetD(std::move(d)); }
+  void SetD(RefPtr<StylePath> d) { AccessSVGStyle().SetD(std::move(d)); }
 
   // x
   void SetX(const Length& x) { AccessSVGStyle().SetX(x); }
 
   // y
   void SetY(const Length& y) { AccessSVGStyle().SetY(y); }
 
   // r
   void SetR(const Length& r) { AccessSVGStyle().SetR(r); }
 
@@ skipping 33 matching lines @@
   void SetStopOpacity(float f) { AccessSVGStyle().SetStopOpacity(f); }
 
   // stroke
   const SVGPaintType& StrokePaintType() const {
     return SvgStyle().StrokePaintType();
   }
   Color StrokePaintColor() const { return SvgStyle().StrokePaintColor(); }
 
   // stroke-dasharray
   SVGDashArray* StrokeDashArray() const { return SvgStyle().StrokeDashArray(); }
-  void SetStrokeDashArray(PassRefPtr<SVGDashArray> array) {
+  void SetStrokeDashArray(RefPtr<SVGDashArray> array) {
     AccessSVGStyle().SetStrokeDashArray(std::move(array));
   }
 
   // stroke-dashoffset
   const Length& StrokeDashOffset() const {
     return SvgStyle().StrokeDashOffset();
   }
   void SetStrokeDashOffset(const Length& d) {
     AccessSVGStyle().SetStrokeDashOffset(d);
   }
@@ skipping 45 matching lines @@
     return nullptr;
   }
   static StyleNonInheritedVariables* InitialNonInheritedVariables() {
     return nullptr;
   }
 
   StyleInheritedVariables* InheritedVariables() const;
   StyleNonInheritedVariables* NonInheritedVariables() const;
 
   void SetUnresolvedInheritedVariable(const AtomicString&,
-                                      PassRefPtr<CSSVariableData>);
+                                      RefPtr<CSSVariableData>);
   void SetUnresolvedNonInheritedVariable(const AtomicString&,
-                                         PassRefPtr<CSSVariableData>);
+                                         RefPtr<CSSVariableData>);
 
   void SetResolvedUnregisteredVariable(const AtomicString&,
-                                       PassRefPtr<CSSVariableData>);
+                                       RefPtr<CSSVariableData>);
   void SetResolvedInheritedVariable(const AtomicString&,
-                                    PassRefPtr<CSSVariableData>,
+                                    RefPtr<CSSVariableData>,
                                     const CSSValue*);
   void SetResolvedNonInheritedVariable(const AtomicString&,
-                                       PassRefPtr<CSSVariableData>,
+                                       RefPtr<CSSVariableData>,
                                        const CSSValue*);
 
   void RemoveVariable(const AtomicString&, bool is_inherited_property);
 
   // Handles both inherited and non-inherited variables
   CSSVariableData* GetVariable(const AtomicString&) const;
 
   CSSVariableData* GetVariable(const AtomicString&,
                                bool is_inherited_property) const;
 
@@ skipping 1589 matching lines @@
       PseudoBitsInternal() | 1 << (pseudo - kFirstPublicPseudoId)));
 }
 
 inline bool ComputedStyle::HasPseudoElementStyle() const {
   return PseudoBitsInternal() & kElementPseudoIdMask;
 }
 
 }  // namespace blink
 
 #endif  // ComputedStyle_h