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

third_party/WebKit/Source/wtf/Functional.h

 /*
  * Copyright (C) 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 69 matching lines @@
 // because there needs to be at least one intermediary function call taking an
 // argument of type "Argument" (i.e. passed by value). The former case does not
 // require any move constructions inbetween.
 //
 // For bound parameters (arguments supplied on the creation of a functor), you
 // can move your argument into the internal storage of the functor by supplying
 // an rvalue to that argument (this is done in wrap() of ParamStorageTraits).
 // However, to make the functor be able to get called multiple times, the
 // stored object does not get moved out automatically when the underlying
 // function is actually invoked. If you want to make an argument "auto-passed",
-// you can do so by wrapping your bound argument with passed() function, as
+// you can do so by wrapping your bound argument with WTF::passed() function, as
 // shown below:
 //
 //     void yourFunction(Argument argument)
 //     {
 //         // |argument| is passed from the internal storage of functor.
 //         ...
 //     }
 //
 //     ...
 //     std::unique_ptr<Function<void()>> functor = bind(yourFunction,
-//         passed(Argument()));
+//         WTF::passed(Argument()));
 //     ...
 //     (*functor)();
 //
-// The underlying function must receive the argument wrapped by passed() by
+// The underlying function must receive the argument wrapped by WTF::passed() by
 // rvalue reference or by value.
 //
 // Obviously, if you create a functor this way, you shouldn't call the functor
 // twice or more; after the second call, the passed argument may be invalid.
 
 enum FunctionThreadAffinity { CrossThreadAffinity, SameThreadAffinity };
 
 template <typename T>
 class PassedWrapper final {
  public:
   explicit PassedWrapper(T&& scoper) : m_scoper(std::move(scoper)) {}
   PassedWrapper(PassedWrapper&& other) : m_scoper(std::move(other.m_scoper)) {}
   T moveOut() const { return std::move(m_scoper); }
 
  private:
   mutable T m_scoper;
 };
 
 template <typename T>
 PassedWrapper<T> passed(T&& value) {
-  static_assert(!std::is_reference<T>::value,
-                "You must pass an rvalue to passed() so it can be moved. Add "
-                "std::move() if necessary.");
+  static_assert(
+      !std::is_reference<T>::value,
+      "You must pass an rvalue to WTF::passed() so it can be moved. Add "
+      "std::move() if necessary.");
   static_assert(!std::is_const<T>::value,
                 "|value| must not be const so it can be moved.");
   return PassedWrapper<T>(std::move(value));
 }
 
 template <typename T, FunctionThreadAffinity threadAffinity>
 class UnretainedWrapper final {
  public:
   explicit UnretainedWrapper(T* ptr) : m_ptr(ptr) {}
   T* value() const { return m_ptr; }
 
  private:
   T* m_ptr;
 };
 
 template <typename T>
 UnretainedWrapper<T, SameThreadAffinity> unretained(T* value) {
   static_assert(!WTF::IsGarbageCollectedType<T>::value,
-                "unretained() + GCed type is forbidden");
+                "WTF::unretained() + GCed type is forbidden");
   return UnretainedWrapper<T, SameThreadAffinity>(value);
 }
 
 template <typename T>
 UnretainedWrapper<T, CrossThreadAffinity> crossThreadUnretained(T* value) {
   static_assert(!WTF::IsGarbageCollectedType<T>::value,
                 "crossThreadUnretained() + GCed type is forbidden");
   return UnretainedWrapper<T, CrossThreadAffinity>(value);
 }
 
@@ skipping 82 matching lines @@
 
 template <FunctionThreadAffinity threadAffinity,
           typename FunctionType,
           typename... BoundParameters>
 std::unique_ptr<
     Function<base::MakeUnboundRunType<FunctionType, BoundParameters...>,
              threadAffinity>>
 bindInternal(FunctionType function, BoundParameters&&... boundParameters) {
   using UnboundRunType =
       base::MakeUnboundRunType<FunctionType, BoundParameters...>;
-  return wrapUnique(new Function<UnboundRunType, threadAffinity>(base::Bind(
+  return WTF::wrapUnique(new Function<UnboundRunType,
+                                      threadAffinity>(base::Bind(
       function,
       typename ParamStorageTraits<typename std::decay<BoundParameters>::type>::
           StorageType(std::forward<BoundParameters>(boundParameters))...)));
 }
 
 template <typename FunctionType, typename... BoundParameters>
 std::unique_ptr<
     Function<base::MakeUnboundRunType<FunctionType, BoundParameters...>,
              SameThreadAffinity>>
 bind(FunctionType function, BoundParameters&&... boundParameters) {
@@ skipping 22 matching lines @@
 
 template <typename T, WTF::FunctionThreadAffinity threadAffinity>
 struct BindUnwrapTraits<WTF::UnretainedWrapper<T, threadAffinity>> {
   static T* Unwrap(const WTF::UnretainedWrapper<T, threadAffinity>& wrapped) {
     return wrapped.value();
   }
 };
 
 }  // namespace base
 
-using WTF::passed;
-using WTF::unretained;
 using WTF::crossThreadUnretained;
 
 using WTF::Function;
 using WTF::CrossThreadClosure;
 
 #endif  // WTF_Functional_h