Wrapped PassRefPtrs in move where passed to RefPtr constructor.

third_party/WebKit/Source/core/animation/CSSBasicShapeInterpolationType.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/animation/CSSBasicShapeInterpolationType.h"
 
 #include "core/animation/BasicShapeInterpolationFunctions.h"
 #include "core/animation/BasicShapePropertyFunctions.h"
 #include "core/css/CSSValueList.h"
 #include "core/css/resolver/StyleResolverState.h"
@@ skipping 11 matching lines @@
  public:
   static std::unique_ptr<UnderlyingCompatibilityChecker> create(
       PassRefPtr<NonInterpolableValue> underlyingNonInterpolableValue) {
     return WTF::wrapUnique(new UnderlyingCompatibilityChecker(
         std::move(underlyingNonInterpolableValue)));
   }
 
  private:
   UnderlyingCompatibilityChecker(
       PassRefPtr<NonInterpolableValue> underlyingNonInterpolableValue)
-      : m_underlyingNonInterpolableValue(underlyingNonInterpolableValue) {}
+      : m_underlyingNonInterpolableValue(
+            std::move(underlyingNonInterpolableValue)) {}
 
   bool isValid(const InterpolationEnvironment&,
                const InterpolationValue& underlying) const final {
     return BasicShapeInterpolationFunctions::shapesAreCompatible(
         *m_underlyingNonInterpolableValue, *underlying.nonInterpolableValue);
   }
 
   RefPtr<NonInterpolableValue> m_underlyingNonInterpolableValue;
 };
 
 class InheritedShapeChecker : public InterpolationType::ConversionChecker {
  public:
   static std::unique_ptr<InheritedShapeChecker> create(
       CSSPropertyID property,
       PassRefPtr<BasicShape> inheritedShape) {
     return WTF::wrapUnique(
         new InheritedShapeChecker(property, std::move(inheritedShape)));
   }
 
  private:
   InheritedShapeChecker(CSSPropertyID property,
                         PassRefPtr<BasicShape> inheritedShape)
-      : m_property(property), m_inheritedShape(inheritedShape) {}
+      : m_property(property), m_inheritedShape(std::move(inheritedShape)) {}
 
   bool isValid(const InterpolationEnvironment& environment,
                const InterpolationValue&) const final {
     return dataEquivalent(m_inheritedShape.get(),
                           BasicShapePropertyFunctions::getBasicShape(
                               m_property, *environment.state().parentStyle()));
   }
 
   const CSSPropertyID m_property;
   RefPtr<BasicShape> m_inheritedShape;
@@ skipping 87 matching lines @@
     const NonInterpolableValue* nonInterpolableValue,
     StyleResolverState& state) const {
   BasicShapePropertyFunctions::setBasicShape(
       cssProperty(), *state.style(),
       BasicShapeInterpolationFunctions::createBasicShape(
           interpolableValue, *nonInterpolableValue,
           state.cssToLengthConversionData()));
 }
 
 }  // namespace blink