s/ passed(...) / WTF::passed(...) / to avoid future ambiguity w/ base::Passed.

third_party/WebKit/Source/core/animation/InterpolableValue.h

 // Copyright 2014 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.
 
 #ifndef InterpolableValue_h
 #define InterpolableValue_h
 
 #include "core/CoreExport.h"
 #include "core/animation/animatable/AnimatableValue.h"
 #include "platform/heap/Handle.h"
@@ skipping 35 matching lines @@
   friend class InterpolableNumber;
   friend class InterpolableBool;
   friend class InterpolableList;
 
   friend class AnimationInterpolableValueTest;
 };
 
 class CORE_EXPORT InterpolableNumber final : public InterpolableValue {
  public:
   static std::unique_ptr<InterpolableNumber> create(double value) {
-    return wrapUnique(new InterpolableNumber(value));
+    return WTF::wrapUnique(new InterpolableNumber(value));
   }
 
   bool isNumber() const final { return true; }
   double value() const { return m_value; }
   bool equals(const InterpolableValue& other) const final;
   std::unique_ptr<InterpolableValue> clone() const final {
     return create(m_value);
   }
   std::unique_ptr<InterpolableValue> cloneAndZero() const final {
     return create(0);
@@ skipping 16 matching lines @@
   // Explicitly delete operator= because MSVC automatically generate
   // copy constructors and operator= for dll-exported classes.
   // Since InterpolableList is not copyable, automatically generated
   // operator= causes MSVC compiler error.
   // However, we cannot use WTF_MAKE_NONCOPYABLE because InterpolableList
   // has its own copy constructor. So just delete operator= here.
   InterpolableList& operator=(const InterpolableList&) = delete;
 
   static std::unique_ptr<InterpolableList> create(
       const InterpolableList& other) {
-    return wrapUnique(new InterpolableList(other));
+    return WTF::wrapUnique(new InterpolableList(other));
   }
 
   static std::unique_ptr<InterpolableList> create(size_t size) {
-    return wrapUnique(new InterpolableList(size));
+    return WTF::wrapUnique(new InterpolableList(size));
   }
 
   bool isList() const final { return true; }
   void set(size_t position, std::unique_ptr<InterpolableValue> value) {
     m_values[position] = std::move(value);
   }
   const InterpolableValue* get(size_t position) const {
     return m_values[position].get();
   }
   std::unique_ptr<InterpolableValue>& getMutable(size_t position) {
@@ skipping 20 matching lines @@
   }
 
   Vector<std::unique_ptr<InterpolableValue>> m_values;
 };
 
 // FIXME: Remove this when we can.
 class InterpolableAnimatableValue : public InterpolableValue {
  public:
   static std::unique_ptr<InterpolableAnimatableValue> create(
       PassRefPtr<AnimatableValue> value) {
-    return wrapUnique(new InterpolableAnimatableValue(std::move(value)));
+    return WTF::wrapUnique(new InterpolableAnimatableValue(std::move(value)));
   }
 
   bool isAnimatableValue() const final { return true; }
   AnimatableValue* value() const { return m_value.get(); }
   bool equals(const InterpolableValue&) const final {
     NOTREACHED();
     return false;
   }
   std::unique_ptr<InterpolableValue> clone() const final {
     return create(m_value);
@@ skipping 29 matching lines @@
                   value.isList());
 DEFINE_TYPE_CASTS(InterpolableAnimatableValue,
                   InterpolableValue,
                   value,
                   value->isAnimatableValue(),
                   value.isAnimatableValue());
 
 }  // namespace blink
 
 #endif