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

third_party/WebKit/Source/modules/webdatabase/DatabaseTask.h

 /*
  * Copyright (C) 2007, 2008, 2013 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
@@ skipping 60 matching lines @@
 };
 
 class Database::DatabaseOpenTask final : public DatabaseTask {
  public:
   static std::unique_ptr<DatabaseOpenTask> create(Database* db,
                                                   bool setVersionInNewDatabase,
                                                   WaitableEvent* completeEvent,
                                                   DatabaseError& error,
                                                   String& errorMessage,
                                                   bool& success) {
-    return wrapUnique(new DatabaseOpenTask(db, setVersionInNewDatabase,
-                                           completeEvent, error, errorMessage,
-                                           success));
+    return WTF::wrapUnique(new DatabaseOpenTask(db, setVersionInNewDatabase,
+                                                completeEvent, error,
+                                                errorMessage, success));
   }
 
  private:
   DatabaseOpenTask(Database*,
                    bool setVersionInNewDatabase,
                    WaitableEvent*,
                    DatabaseError&,
                    String& errorMessage,
                    bool& success);
 
   void doPerformTask() override;
 #if DCHECK_IS_ON()
   const char* debugTaskName() const override;
 #endif
 
   bool m_setVersionInNewDatabase;
   DatabaseError& m_error;
   String& m_errorMessage;
   bool& m_success;
 };
 
 class Database::DatabaseCloseTask final : public DatabaseTask {
  public:
   static std::unique_ptr<DatabaseCloseTask> create(
       Database* db,
       WaitableEvent* synchronizer) {
-    return wrapUnique(new DatabaseCloseTask(db, synchronizer));
+    return WTF::wrapUnique(new DatabaseCloseTask(db, synchronizer));
   }
 
  private:
   DatabaseCloseTask(Database*, WaitableEvent*);
 
   void doPerformTask() override;
 #if DCHECK_IS_ON()
   const char* debugTaskName() const override;
 #endif
 };
 
 class Database::DatabaseTransactionTask final : public DatabaseTask {
  public:
   ~DatabaseTransactionTask() override;
 
   // Transaction task is never synchronous, so no 'synchronizer' parameter.
   static std::unique_ptr<DatabaseTransactionTask> create(
       SQLTransactionBackend* transaction) {
-    return wrapUnique(new DatabaseTransactionTask(transaction));
+    return WTF::wrapUnique(new DatabaseTransactionTask(transaction));
   }
 
   SQLTransactionBackend* transaction() const { return m_transaction.get(); }
 
  private:
   explicit DatabaseTransactionTask(SQLTransactionBackend*);
 
   void doPerformTask() override;
   void taskCancelled() override;
 #if DCHECK_IS_ON()
   const char* debugTaskName() const override;
 #endif
 
   CrossThreadPersistent<SQLTransactionBackend> m_transaction;
 };
 
 class Database::DatabaseTableNamesTask final : public DatabaseTask {
  public:
   static std::unique_ptr<DatabaseTableNamesTask>
   create(Database* db, WaitableEvent* synchronizer, Vector<String>& names) {
-    return wrapUnique(new DatabaseTableNamesTask(db, synchronizer, names));
+    return WTF::wrapUnique(new DatabaseTableNamesTask(db, synchronizer, names));
   }
 
  private:
   DatabaseTableNamesTask(Database*, WaitableEvent*, Vector<String>& names);
 
   void doPerformTask() override;
 #if DCHECK_IS_ON()
   const char* debugTaskName() const override;
 #endif
 
   Vector<String>& m_tableNames;
 };
 
 }  // namespace blink
 
 #endif  // DatabaseTask_h