Remove PassRefPtr on setters 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 396 matching lines @@
   for (size_t i = 0; i < cached_pseudo_styles_->size(); ++i) {
     ComputedStyle* pseudo_style = cached_pseudo_styles_->at(i).Get();
     if (pseudo_style->StyleType() == pid)
       return pseudo_style;
   }
 
   return 0;
 }
 
 ComputedStyle* ComputedStyle::AddCachedPseudoStyle(
-    PassRefPtr<ComputedStyle> pseudo) {
+    RefPtr<ComputedStyle> pseudo) {
   if (!pseudo)
     return 0;
 
   DCHECK_GT(pseudo->StyleType(), kPseudoIdNone);
 
   ComputedStyle* result = pseudo.Get();
 
   if (!cached_pseudo_styles_)
     cached_pseudo_styles_ = WTF::WrapUnique(new PseudoStyleCache);
 
@@ skipping 656 matching lines @@
   if (!rare_inherited_data_.Access()->cursor_data_)
     rare_inherited_data_.Access()->cursor_data_ = new CursorList;
   rare_inherited_data_.Access()->cursor_data_->push_back(
       CursorData(image, hot_spot_specified, hot_spot));
 }
 
 void ComputedStyle::SetCursorList(CursorList* other) {
   rare_inherited_data_.Access()->cursor_data_ = other;
 }
 
-void ComputedStyle::SetQuotes(PassRefPtr<QuotesData> q) {
+void ComputedStyle::SetQuotes(RefPtr<QuotesData> q) {
   rare_inherited_data_.Access()->quotes_ = std::move(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;
@@ skipping 259 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(PassRefPtr<ShadowList> s) {
+void ComputedStyle::SetTextShadow(RefPtr<ShadowList> s) {
   rare_inherited_data_.Access()->text_shadow_ = std::move(s);
 }
 
 bool ComputedStyle::TextShadowDataEquivalent(const ComputedStyle& other) const {
   return DataEquivalent(TextShadow(), other.TextShadow());
 }
 
-void ComputedStyle::SetBoxShadow(PassRefPtr<ShadowList> s) {
+void ComputedStyle::SetBoxShadow(RefPtr<ShadowList> s) {
   rare_non_inherited_data_.Access()->box_shadow_ = std::move(s);
 }
 
 static FloatRoundedRect::Radii CalcRadiiFor(const BorderData& border,
                                             const LengthSize& top_left,
                                             const LengthSize& top_right,
                                             const LengthSize& bottom_left,
                                             const LengthSize& bottom_right,
                                             LayoutSize size) {
   return FloatRoundedRect::Radii(
@@ skipping 366 matching lines @@
 StyleNonInheritedVariables& ComputedStyle::MutableNonInheritedVariables() {
   std::unique_ptr<StyleNonInheritedVariables>& variables =
       rare_non_inherited_data_.Access()->variables_;
   if (!variables)
     variables = StyleNonInheritedVariables::Create();
   return *variables;
 }
 
 void ComputedStyle::SetUnresolvedInheritedVariable(
     const AtomicString& name,
-    PassRefPtr<CSSVariableData> value) {
+    RefPtr<CSSVariableData> value) {
   DCHECK(value && value->NeedsVariableResolution());
   MutableInheritedVariables().SetVariable(name, std::move(value));
 }
 
 void ComputedStyle::SetUnresolvedNonInheritedVariable(
     const AtomicString& name,
-    PassRefPtr<CSSVariableData> value) {
+    RefPtr<CSSVariableData> value) {
   DCHECK(value && value->NeedsVariableResolution());
   MutableNonInheritedVariables().SetVariable(name, std::move(value));
 }
 
 void ComputedStyle::SetResolvedUnregisteredVariable(
     const AtomicString& name,
-    PassRefPtr<CSSVariableData> value) {
+    RefPtr<CSSVariableData> value) {
   DCHECK(value && !value->NeedsVariableResolution());
   MutableInheritedVariables().SetVariable(name, std::move(value));
 }
 
-void ComputedStyle::SetResolvedInheritedVariable(
-    const AtomicString& name,
-    PassRefPtr<CSSVariableData> value,
-    const CSSValue* parsed_value) {
+void ComputedStyle::SetResolvedInheritedVariable(const AtomicString& name,
+                                                 RefPtr<CSSVariableData> value,
+                                                 const CSSValue* parsed_value) {
   DCHECK(!!value == !!parsed_value);
   DCHECK(!(value && value->NeedsVariableResolution()));
 
   StyleInheritedVariables& variables = MutableInheritedVariables();
   variables.SetVariable(name, std::move(value));
   variables.SetRegisteredVariable(name, parsed_value);
 }
 
 void ComputedStyle::SetResolvedNonInheritedVariable(
     const AtomicString& name,
-    PassRefPtr<CSSVariableData> value,
+    RefPtr<CSSVariableData> value,
     const CSSValue* parsed_value) {
   DCHECK(!!value == !!parsed_value);
   DCHECK(!(value && value->NeedsVariableResolution()));
 
   StyleNonInheritedVariables& variables = MutableNonInheritedVariables();
   variables.SetVariable(name, std::move(value));
   variables.SetRegisteredVariable(name, parsed_value);
 }
 
 void ComputedStyle::RemoveVariable(const AtomicString& name,
@@ skipping 489 matching lines @@
     else
       SetMarginLeft(margin);
   } else {
     if (IsLeftToRightDirection())
       SetMarginBottom(margin);
     else
       SetMarginTop(margin);
   }
 }
 
-void ComputedStyle::SetOffsetPath(PassRefPtr<BasicShape> path) {
+void ComputedStyle::SetOffsetPath(RefPtr<BasicShape> path) {
   rare_non_inherited_data_.Access()->transform_.Access()->motion_.path_ =
       std::move(path);
 }
 
 int ComputedStyle::OutlineOutsetExtent() const {
   if (!HasOutline())
     return 0;
   if (OutlineStyleIsAuto()) {
     return GraphicsContext::FocusRingOutsetExtent(
         OutlineOffset(), std::ceil(GetOutlineStrokeWidthForFocusRing()));
@@ skipping 171 matching lines @@
     if (value < 0)
       fvalue -= 0.5f;
     else
       fvalue += 0.5f;
   }
 
   return RoundForImpreciseConversion<int>(fvalue / zoom_factor);
 }
 
 }  // namespace blink