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

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

 // Copyright 2015 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 PrimitiveInterpolation_h
 #define PrimitiveInterpolation_h
 
 #include "core/animation/TypedInterpolationValue.h"
 #include "platform/animation/AnimationUtilities.h"
 #include "platform/heap/Handle.h"
@@ skipping 30 matching lines @@
 // eg. "0px" and "100px".
 class PairwisePrimitiveInterpolation : public PrimitiveInterpolation {
  public:
   ~PairwisePrimitiveInterpolation() override {}
 
   static std::unique_ptr<PairwisePrimitiveInterpolation> create(
       const InterpolationType& type,
       std::unique_ptr<InterpolableValue> start,
       std::unique_ptr<InterpolableValue> end,
       PassRefPtr<NonInterpolableValue> nonInterpolableValue) {
-    return wrapUnique(new PairwisePrimitiveInterpolation(
+    return WTF::wrapUnique(new PairwisePrimitiveInterpolation(
         type, std::move(start), std::move(end),
         std::move(nonInterpolableValue)));
   }
 
   const InterpolationType& type() const { return m_type; }
 
   std::unique_ptr<TypedInterpolationValue> initialValue() const {
     return TypedInterpolationValue::create(m_type, m_start->clone(),
                                            m_nonInterpolableValue);
   }
@@ skipping 36 matching lines @@
 
 // Represents a pair of incompatible keyframes that fall back to 50% flip
 // behaviour eg. "auto" and "0px".
 class FlipPrimitiveInterpolation : public PrimitiveInterpolation {
  public:
   ~FlipPrimitiveInterpolation() override {}
 
   static std::unique_ptr<FlipPrimitiveInterpolation> create(
       std::unique_ptr<TypedInterpolationValue> start,
       std::unique_ptr<TypedInterpolationValue> end) {
-    return wrapUnique(
+    return WTF::wrapUnique(
         new FlipPrimitiveInterpolation(std::move(start), std::move(end)));
   }
 
  private:
   FlipPrimitiveInterpolation(std::unique_ptr<TypedInterpolationValue> start,
                              std::unique_ptr<TypedInterpolationValue> end)
       : m_start(std::move(start)),
         m_end(std::move(end)),
         m_lastFraction(std::numeric_limits<double>::quiet_NaN()) {}
 
@@ skipping 18 matching lines @@
   bool isFlip() const final { return true; }
 
   std::unique_ptr<TypedInterpolationValue> m_start;
   std::unique_ptr<TypedInterpolationValue> m_end;
   mutable double m_lastFraction;
 };
 
 }  // namespace blink
 
 #endif  // PrimitiveInterpolation_h