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

third_party/WebKit/Source/wtf/FunctionalTest.cpp

 /*
  * 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 199 matching lines @@
       bind(sixArgFunc, 3, 3.5);
   (*twoBound)('d', &a, &b, &c);
   assertArgs(a, b, c, 3, 3.5, 'd');
 
   std::unique_ptr<Function<void(int*, double*, char*)>> threeBound =
       bind(sixArgFunc, 4, 4.5, 'e');
   (*threeBound)(&a, &b, &c);
   assertArgs(a, b, c, 4, 4.5, 'e');
 
   std::unique_ptr<Function<void(double*, char*)>> fourBound =
-      bind(sixArgFunc, 5, 5.5, 'f', unretained(&a));
+      bind(sixArgFunc, 5, 5.5, 'f', WTF::unretained(&a));
   (*fourBound)(&b, &c);
   assertArgs(a, b, c, 5, 5.5, 'f');
 
   std::unique_ptr<Function<void(char*)>> fiveBound =
-      bind(sixArgFunc, 6, 6.5, 'g', unretained(&a), unretained(&b));
+      bind(sixArgFunc, 6, 6.5, 'g', WTF::unretained(&a), WTF::unretained(&b));
   (*fiveBound)(&c);
   assertArgs(a, b, c, 6, 6.5, 'g');
 
-  std::unique_ptr<Function<void()>> sixBound = bind(
-      sixArgFunc, 7, 7.5, 'h', unretained(&a), unretained(&b), unretained(&c));
+  std::unique_ptr<Function<void()>> sixBound =
+      bind(sixArgFunc, 7, 7.5, 'h', WTF::unretained(&a), WTF::unretained(&b),
+           WTF::unretained(&c));
   (*sixBound)();
   assertArgs(a, b, c, 7, 7.5, 'h');
 }
 
 class A {
  public:
   explicit A(int i) : m_i(i) {}
 
   int f() { return m_i; }
   int addF(int j) { return m_i + j; }
   virtual int overridden() { return 42; }
 
  private:
   int m_i;
 };
 
 class B : public A {
  public:
   explicit B(int i) : A(i) {}
 
   int f() { return A::f() + 1; }
   int addF(int j) { return A::addF(j) + 1; }
   int overridden() override { return 43; }
 };
 
 TEST(FunctionalTest, MemberFunctionBind) {
   A a(10);
-  std::unique_ptr<Function<int()>> function1 = bind(&A::f, unretained(&a));
+  std::unique_ptr<Function<int()>> function1 = bind(&A::f, WTF::unretained(&a));
   EXPECT_EQ(10, (*function1)());
 
   std::unique_ptr<Function<int()>> function2 =
-      bind(&A::addF, unretained(&a), 15);
+      bind(&A::addF, WTF::unretained(&a), 15);
   EXPECT_EQ(25, (*function2)());
 
   std::unique_ptr<Function<int()>> function3 =
-      bind(&A::overridden, unretained(&a));
+      bind(&A::overridden, WTF::unretained(&a));
   EXPECT_EQ(42, (*function3)());
 }
 
 TEST(FunctionalTest, MemberFunctionBindWithSubclassPointer) {
   B b(10);
-  std::unique_ptr<Function<int()>> function1 = bind(&A::f, unretained(&b));
+  std::unique_ptr<Function<int()>> function1 = bind(&A::f, WTF::unretained(&b));
   EXPECT_EQ(10, (*function1)());
 
   std::unique_ptr<Function<int()>> function2 =
-      bind(&A::addF, unretained(&b), 15);
+      bind(&A::addF, WTF::unretained(&b), 15);
   EXPECT_EQ(25, (*function2)());
 
   std::unique_ptr<Function<int()>> function3 =
-      bind(&A::overridden, unretained(&b));
+      bind(&A::overridden, WTF::unretained(&b));
   EXPECT_EQ(43, (*function3)());
 
-  std::unique_ptr<Function<int()>> function4 = bind(&B::f, unretained(&b));
+  std::unique_ptr<Function<int()>> function4 = bind(&B::f, WTF::unretained(&b));
   EXPECT_EQ(11, (*function4)());
 
   std::unique_ptr<Function<int()>> function5 =
-      bind(&B::addF, unretained(&b), 15);
+      bind(&B::addF, WTF::unretained(&b), 15);
   EXPECT_EQ(26, (*function5)());
 }
 
 TEST(FunctionalTest, MemberFunctionBindWithSubclassPointerWithCast) {
   B b(10);
   std::unique_ptr<Function<int()>> function1 =
-      bind(&A::f, unretained(static_cast<A*>(&b)));
+      bind(&A::f, WTF::unretained(static_cast<A*>(&b)));
   EXPECT_EQ(10, (*function1)());
 
   std::unique_ptr<Function<int()>> function2 =
-      bind(&A::addF, unretained(static_cast<A*>(&b)), 15);
+      bind(&A::addF, WTF::unretained(static_cast<A*>(&b)), 15);
   EXPECT_EQ(25, (*function2)());
 
   std::unique_ptr<Function<int()>> function3 =
-      bind(&A::overridden, unretained(static_cast<A*>(&b)));
+      bind(&A::overridden, WTF::unretained(static_cast<A*>(&b)));
   EXPECT_EQ(43, (*function3)());
 }
 
 TEST(FunctionalTest, MemberFunctionPartBind) {
   A a(10);
   std::unique_ptr<Function<int(class A*)>> function1 = bind(&A::f);
   EXPECT_EQ(10, (*function1)(&a));
 
   std::unique_ptr<Function<int(class A*, int)>> unboundFunction2 =
       bind(&A::addF);
   EXPECT_EQ(25, (*unboundFunction2)(&a, 15));
   std::unique_ptr<Function<int(int)>> objectBoundFunction2 =
-      bind(&A::addF, unretained(&a));
+      bind(&A::addF, WTF::unretained(&a));
   EXPECT_EQ(25, (*objectBoundFunction2)(15));
 }
 
 TEST(FunctionalTest, MemberFunctionBindByUniquePtr) {
   std::unique_ptr<Function<int()>> function1 =
-      WTF::bind(&A::f, makeUnique<A>(10));
+      WTF::bind(&A::f, WTF::makeUnique<A>(10));
   EXPECT_EQ(10, (*function1)());
 }
 
 TEST(FunctionalTest, MemberFunctionBindByPassedUniquePtr) {
   std::unique_ptr<Function<int()>> function1 =
-      WTF::bind(&A::f, passed(makeUnique<A>(10)));
+      WTF::bind(&A::f, WTF::passed(WTF::makeUnique<A>(10)));
   EXPECT_EQ(10, (*function1)());
 }
 
 class Number : public RefCounted<Number> {
  public:
   static PassRefPtr<Number> create(int value) {
     return adoptRef(new Number(value));
   }
 
   ~Number() { m_value = 0; }
@@ skipping 27 matching lines @@
   std::unique_ptr<Function<int()>> multiplySixByTwoFunction =
       bind(multiplyNumberByTwo, six.release());
   EXPECT_FALSE(six);
   EXPECT_EQ(12, (*multiplySixByTwoFunction)());
 }
 
 TEST(FunctionalTest, UnretainedWithRefCounted) {
   RefPtr<Number> five = Number::create(5);
   EXPECT_EQ(1, five->refCount());
   std::unique_ptr<Function<int()>> multiplyFiveByTwoFunction =
-      bind(multiplyNumberByTwo, unretained(five.get()));
+      bind(multiplyNumberByTwo, WTF::unretained(five.get()));
   EXPECT_EQ(1, five->refCount());
   EXPECT_EQ(10, (*multiplyFiveByTwoFunction)());
   EXPECT_EQ(1, five->refCount());
 }
 
 int processUnwrappedClass(const UnwrappedClass& u, int v) {
   return u.value() * v;
 }
 
 // Tests that:
@@ skipping 82 matching lines @@
   return moveOnly.value();
 }
 
 int tripleMoveOnlysByValues(MoveOnly first, MoveOnly second, MoveOnly third) {
   return first.value() + second.value() + third.value();
 }
 
 TEST(FunctionalTest, BindMoveOnlyObjects) {
   MoveOnly one(1);
   std::unique_ptr<Function<int()>> bound =
-      bind(singleMoveOnlyByRvalueReference, passed(std::move(one)));
+      bind(singleMoveOnlyByRvalueReference, WTF::passed(std::move(one)));
   EXPECT_EQ(0, one.value());  // Should be moved away.
   EXPECT_EQ(1, (*bound)());
   // The stored value must be cleared in the first function call.
   EXPECT_EQ(0, (*bound)());
 
-  bound = bind(singleMoveOnlyByValue, passed(MoveOnly(1)));
+  bound = bind(singleMoveOnlyByValue, WTF::passed(MoveOnly(1)));
   EXPECT_EQ(1, (*bound)());
   EXPECT_EQ(0, (*bound)());
 
-  bound = bind(tripleMoveOnlysByRvalueReferences, passed(MoveOnly(1)),
-               passed(MoveOnly(2)), passed(MoveOnly(3)));
+  bound = bind(tripleMoveOnlysByRvalueReferences, WTF::passed(MoveOnly(1)),
+               WTF::passed(MoveOnly(2)), WTF::passed(MoveOnly(3)));
   EXPECT_EQ(6, (*bound)());
   EXPECT_EQ(0, (*bound)());
 
-  bound = bind(tripleMoveOnlysByValues, passed(MoveOnly(1)),
-               passed(MoveOnly(2)), passed(MoveOnly(3)));
+  bound = bind(tripleMoveOnlysByValues, WTF::passed(MoveOnly(1)),
+               WTF::passed(MoveOnly(2)), WTF::passed(MoveOnly(3)));
   EXPECT_EQ(6, (*bound)());
   EXPECT_EQ(0, (*bound)());
 }
 
 class CountCopy {
  public:
   CountCopy() : m_copies(0) {}
   CountCopy(const CountCopy& other) : m_copies(other.m_copies + 1) {}
 
   int copies() const { return m_copies; }
@@ skipping 79 matching lines @@
 
   obj.revokeAll();
   EXPECT_TRUE(bound->isCancelled());
   (*bound)();
   EXPECT_EQ(1, counter);
 }
 
 }  // anonymous namespace
 
 }  // namespace WTF