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

third_party/WebKit/Source/wtf/HashMapTest.cpp

 /*
  * Copyright (C) 2011 Google 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 88 matching lines @@
  private:
   int m_i;
   int* m_destructNumber;
 };
 
 using OwnPtrHashMap = HashMap<int, std::unique_ptr<DestructCounter>>;
 
 TEST(HashMapTest, OwnPtrAsValue) {
   int destructNumber = 0;
   OwnPtrHashMap map;
-  map.add(1, wrapUnique(new DestructCounter(1, &destructNumber)));
-  map.add(2, wrapUnique(new DestructCounter(2, &destructNumber)));
+  map.add(1, WTF::wrapUnique(new DestructCounter(1, &destructNumber)));
+  map.add(2, WTF::wrapUnique(new DestructCounter(2, &destructNumber)));
 
   DestructCounter* counter1 = map.get(1);
   EXPECT_EQ(1, counter1->get());
   DestructCounter* counter2 = map.get(2);
   EXPECT_EQ(2, counter2->get());
   EXPECT_EQ(0, destructNumber);
 
   for (OwnPtrHashMap::iterator iter = map.begin(); iter != map.end(); ++iter) {
     std::unique_ptr<DestructCounter>& ownCounter = iter->value;
     EXPECT_EQ(iter->key, ownCounter->get());
@@ skipping 118 matching lines @@
 using IntSimpleMap = HashMap<int, std::unique_ptr<SimpleClass>>;
 
 TEST(HashMapTest, AddResult) {
   IntSimpleMap map;
   IntSimpleMap::AddResult result = map.add(1, nullptr);
   EXPECT_TRUE(result.isNewEntry);
   EXPECT_EQ(1, result.storedValue->key);
   EXPECT_EQ(0, result.storedValue->value.get());
 
   SimpleClass* simple1 = new SimpleClass(1);
-  result.storedValue->value = wrapUnique(simple1);
+  result.storedValue->value = WTF::wrapUnique(simple1);
   EXPECT_EQ(simple1, map.get(1));
 
-  IntSimpleMap::AddResult result2 = map.add(1, makeUnique<SimpleClass>(2));
+  IntSimpleMap::AddResult result2 = map.add(1, WTF::makeUnique<SimpleClass>(2));
   EXPECT_FALSE(result2.isNewEntry);
   EXPECT_EQ(1, result.storedValue->key);
   EXPECT_EQ(1, result.storedValue->value->v());
   EXPECT_EQ(1, map.get(1)->v());
 }
 
 TEST(HashMapTest, AddResultVectorValue) {
   using IntVectorMap = HashMap<int, Vector<int>>;
   IntVectorMap map;
   IntVectorMap::AddResult result = map.add(1, Vector<int>());
@@ skipping 386 matching lines @@
   EXPECT_EQ(130, oneThirty);
   iter = map.find(Pair(MoveOnly(13), -13));
   EXPECT_TRUE(iter == map.end());
 
   map.clear();
 }
 
 }  // anonymous namespace
 
 }  // namespace WTF