Remove PassRefPtr 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 68 matching lines @@
 #include "platform/graphics/Color.h"
 #include "platform/graphics/TouchAction.h"
 #include "platform/heap/Handle.h"
 #include "platform/scroll/ScrollTypes.h"
 #include "platform/text/TabSize.h"
 #include "platform/text/TextDirection.h"
 #include "platform/text/UnicodeBidi.h"
 #include "platform/transforms/TransformOperations.h"
 #include "platform/wtf/Forward.h"
 #include "platform/wtf/LeakAnnotations.h"
-#include "platform/wtf/PassRefPtr.h"
 #include "platform/wtf/RefCounted.h"
 #include "platform/wtf/RefVector.h"
 #include "platform/wtf/Vector.h"
 #include "platform/wtf/text/AtomicString.h"
 
 template <typename T, typename U>
 inline bool compareEqual(const T& t, const U& u) {
   return t == static_cast<T>(u);
 }
 
@@ skipping 147 matching lines @@
   // list of associated pseudo styles
   std::unique_ptr<PseudoStyleCache> cached_pseudo_styles_;
 
   DataRef<SVGComputedStyle> svg_style_;
 
  private:
   // TODO(sashab): Move these private members to the bottom of ComputedStyle.
   ALWAYS_INLINE ComputedStyle();
   ALWAYS_INLINE ComputedStyle(const ComputedStyle&);
 
-  static PassRefPtr<ComputedStyle> CreateInitialStyle();
+  static RefPtr<ComputedStyle> CreateInitialStyle();
   // TODO(shend): Remove this. Initial style should not be mutable.
   static ComputedStyle& MutableInitialStyle();
 
  public:
-  static PassRefPtr<ComputedStyle> Create();
-  static PassRefPtr<ComputedStyle> CreateAnonymousStyleWithDisplay(
+  static RefPtr<ComputedStyle> Create();
+  static RefPtr<ComputedStyle> CreateAnonymousStyleWithDisplay(
       const ComputedStyle& parent_style,
       EDisplay);
-  static PassRefPtr<ComputedStyle> Clone(const ComputedStyle&);
+  static RefPtr<ComputedStyle> Clone(const ComputedStyle&);
   static const ComputedStyle& InitialStyle() { return MutableInitialStyle(); }
   static void InvalidateInitialStyle();
 
   // Computes how the style change should be propagated down the tree.
   static StyleRecalcChange StylePropagationDiff(const ComputedStyle* old_style,
                                                 const ComputedStyle* new_style);
 
   // Copies the values of any independent inherited properties from the parent
   // that are not explicitly set in this style.
   void PropagateIndependentInheritedProperties(
@@ skipping 1014 matching lines @@
   // -webkit-transform-origin-z
   static float InitialTransformOriginZ() { return 0; }
   float TransformOriginZ() const { return GetTransformOrigin().Z(); }
   void SetTransformOriginZ(float f) {
     SetTransformOrigin(
         TransformOrigin(TransformOriginX(), TransformOriginY(), f));
   }
 
   // Independent transform properties.
   // translate
-  static PassRefPtr<TranslateTransformOperation> InitialTranslate() {
+  static RefPtr<TranslateTransformOperation> InitialTranslate() {
     return nullptr;
   }
   TranslateTransformOperation* Translate() const {
     return rare_non_inherited_data_->transform_->translate_.Get();
   }
   void SetTranslate(RefPtr<TranslateTransformOperation> v) {
     rare_non_inherited_data_.Access()->transform_.Access()->translate_ =
         std::move(v);
   }
 
   // rotate
-  static PassRefPtr<RotateTransformOperation> InitialRotate() {
-    return nullptr;
-  }
+  static RefPtr<RotateTransformOperation> InitialRotate() { return nullptr; }
   RotateTransformOperation* Rotate() const {
     return rare_non_inherited_data_->transform_->rotate_.Get();
   }
   void SetRotate(RefPtr<RotateTransformOperation> v) {
     rare_non_inherited_data_.Access()->transform_.Access()->rotate_ =
         std::move(v);
   }
 
   // scale
-  static PassRefPtr<ScaleTransformOperation> InitialScale() { return nullptr; }
+  static RefPtr<ScaleTransformOperation> InitialScale() { return nullptr; }
   ScaleTransformOperation* Scale() const {
     return rare_non_inherited_data_->transform_->scale_.Get();
   }
   void SetScale(RefPtr<ScaleTransformOperation> v) {
     rare_non_inherited_data_.Access()->transform_.Access()->scale_ =
         std::move(v);
   }
 
   // Scroll properties.
   // scroll-behavior
@@ skipping 2443 matching lines @@
       PseudoBitsInternal() | 1 << (pseudo - kFirstPublicPseudoId)));
 }
 
 inline bool ComputedStyle::HasPseudoElementStyle() const {
   return PseudoBitsInternal() & kElementPseudoIdMask;
 }
 
 }  // namespace blink
 
 #endif  // ComputedStyle_h