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

third_party/WebKit/Source/modules/filesystem/FileSystemCallbacks.cpp

 /*
  * Copyright (C) 2010 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 143 matching lines @@
 
 // EntryCallbacks -------------------------------------------------------------
 
 std::unique_ptr<AsyncFileSystemCallbacks> EntryCallbacks::create(
     EntryCallback* successCallback,
     ErrorCallbackBase* errorCallback,
     ExecutionContext* context,
     DOMFileSystemBase* fileSystem,
     const String& expectedPath,
     bool isDirectory) {
-  return wrapUnique(new EntryCallbacks(successCallback, errorCallback, context,
-                                       fileSystem, expectedPath, isDirectory));
+  return WTF::wrapUnique(new EntryCallbacks(successCallback, errorCallback,
+                                            context, fileSystem, expectedPath,
+                                            isDirectory));
 }
 
 EntryCallbacks::EntryCallbacks(EntryCallback* successCallback,
                                ErrorCallbackBase* errorCallback,
                                ExecutionContext* context,
                                DOMFileSystemBase* fileSystem,
                                const String& expectedPath,
                                bool isDirectory)
     : FileSystemCallbacksBase(errorCallback, fileSystem, context),
       m_successCallback(successCallback),
@@ skipping 14 matching lines @@
 }
 
 // EntriesCallbacks -----------------------------------------------------------
 
 std::unique_ptr<AsyncFileSystemCallbacks> EntriesCallbacks::create(
     EntriesCallback* successCallback,
     ErrorCallbackBase* errorCallback,
     ExecutionContext* context,
     DirectoryReaderBase* directoryReader,
     const String& basePath) {
-  return wrapUnique(new EntriesCallbacks(successCallback, errorCallback,
-                                         context, directoryReader, basePath));
+  return WTF::wrapUnique(new EntriesCallbacks(
+      successCallback, errorCallback, context, directoryReader, basePath));
 }
 
 EntriesCallbacks::EntriesCallbacks(EntriesCallback* successCallback,
                                    ErrorCallbackBase* errorCallback,
                                    ExecutionContext* context,
                                    DirectoryReaderBase* directoryReader,
                                    const String& basePath)
     : FileSystemCallbacksBase(errorCallback,
                               directoryReader->filesystem(),
                               context),
@@ skipping 23 matching lines @@
     m_successCallback->handleEvent(entries);
 }
 
 // FileSystemCallbacks --------------------------------------------------------
 
 std::unique_ptr<AsyncFileSystemCallbacks> FileSystemCallbacks::create(
     FileSystemCallback* successCallback,
     ErrorCallbackBase* errorCallback,
     ExecutionContext* context,
     FileSystemType type) {
-  return wrapUnique(
+  return WTF::wrapUnique(
       new FileSystemCallbacks(successCallback, errorCallback, context, type));
 }
 
 FileSystemCallbacks::FileSystemCallbacks(FileSystemCallback* successCallback,
                                          ErrorCallbackBase* errorCallback,
                                          ExecutionContext* context,
                                          FileSystemType type)
     : FileSystemCallbacksBase(errorCallback, nullptr, context),
       m_successCallback(successCallback),
       m_type(type) {}
 
 void FileSystemCallbacks::didOpenFileSystem(const String& name,
                                             const KURL& rootURL) {
   if (m_successCallback)
     handleEventOrScheduleCallback(
         m_successCallback.release(),
         DOMFileSystem::create(m_executionContext.get(), name, m_type, rootURL));
 }
 
 // ResolveURICallbacks --------------------------------------------------------
 
 std::unique_ptr<AsyncFileSystemCallbacks> ResolveURICallbacks::create(
     EntryCallback* successCallback,
     ErrorCallbackBase* errorCallback,
     ExecutionContext* context) {
-  return wrapUnique(
+  return WTF::wrapUnique(
       new ResolveURICallbacks(successCallback, errorCallback, context));
 }
 
 ResolveURICallbacks::ResolveURICallbacks(EntryCallback* successCallback,
                                          ErrorCallbackBase* errorCallback,
                                          ExecutionContext* context)
     : FileSystemCallbacksBase(errorCallback, nullptr, context),
       m_successCallback(successCallback) {}
 
 void ResolveURICallbacks::didResolveURL(const String& name,
@@ skipping 22 matching lines @@
                                   FileEntry::create(filesystem, absolutePath));
 }
 
 // MetadataCallbacks ----------------------------------------------------------
 
 std::unique_ptr<AsyncFileSystemCallbacks> MetadataCallbacks::create(
     MetadataCallback* successCallback,
     ErrorCallbackBase* errorCallback,
     ExecutionContext* context,
     DOMFileSystemBase* fileSystem) {
-  return wrapUnique(new MetadataCallbacks(successCallback, errorCallback,
-                                          context, fileSystem));
+  return WTF::wrapUnique(new MetadataCallbacks(successCallback, errorCallback,
+                                               context, fileSystem));
 }
 
 MetadataCallbacks::MetadataCallbacks(MetadataCallback* successCallback,
                                      ErrorCallbackBase* errorCallback,
                                      ExecutionContext* context,
                                      DOMFileSystemBase* fileSystem)
     : FileSystemCallbacksBase(errorCallback, fileSystem, context),
       m_successCallback(successCallback) {}
 
 void MetadataCallbacks::didReadMetadata(const FileMetadata& metadata) {
   if (m_successCallback)
     handleEventOrScheduleCallback(m_successCallback.release(),
                                   Metadata::create(metadata));
 }
 
 // FileWriterBaseCallbacks ----------------------------------------------------
 
 std::unique_ptr<AsyncFileSystemCallbacks> FileWriterBaseCallbacks::create(
     FileWriterBase* fileWriter,
     FileWriterBaseCallback* successCallback,
     ErrorCallbackBase* errorCallback,
     ExecutionContext* context) {
-  return wrapUnique(new FileWriterBaseCallbacks(fileWriter, successCallback,
-                                                errorCallback, context));
+  return WTF::wrapUnique(new FileWriterBaseCallbacks(
+      fileWriter, successCallback, errorCallback, context));
 }
 
 FileWriterBaseCallbacks::FileWriterBaseCallbacks(
     FileWriterBase* fileWriter,
     FileWriterBaseCallback* successCallback,
     ErrorCallbackBase* errorCallback,
     ExecutionContext* context)
     : FileSystemCallbacksBase(errorCallback, nullptr, context),
       m_fileWriter(fileWriter),
       m_successCallback(successCallback) {}
 
 void FileWriterBaseCallbacks::didCreateFileWriter(
     std::unique_ptr<WebFileWriter> fileWriter,
     long long length) {
   m_fileWriter->initialize(std::move(fileWriter), length);
   if (m_successCallback)
     handleEventOrScheduleCallback(m_successCallback.release(),
                                   m_fileWriter.release());
 }
 
 // SnapshotFileCallback -------------------------------------------------------
 
 std::unique_ptr<AsyncFileSystemCallbacks> SnapshotFileCallback::create(
     DOMFileSystemBase* filesystem,
     const String& name,
     const KURL& url,
     BlobCallback* successCallback,
     ErrorCallbackBase* errorCallback,
     ExecutionContext* context) {
-  return wrapUnique(new SnapshotFileCallback(
+  return WTF::wrapUnique(new SnapshotFileCallback(
       filesystem, name, url, successCallback, errorCallback, context));
 }
 
 SnapshotFileCallback::SnapshotFileCallback(DOMFileSystemBase* filesystem,
                                            const String& name,
                                            const KURL& url,
                                            BlobCallback* successCallback,
                                            ErrorCallbackBase* errorCallback,
                                            ExecutionContext* context)
     : FileSystemCallbacksBase(errorCallback, filesystem, context),
@@ skipping 20 matching lines @@
                                     m_name));
 }
 
 // VoidCallbacks --------------------------------------------------------------
 
 std::unique_ptr<AsyncFileSystemCallbacks> VoidCallbacks::create(
     VoidCallback* successCallback,
     ErrorCallbackBase* errorCallback,
     ExecutionContext* context,
     DOMFileSystemBase* fileSystem) {
-  return wrapUnique(
+  return WTF::wrapUnique(
       new VoidCallbacks(successCallback, errorCallback, context, fileSystem));
 }
 
 VoidCallbacks::VoidCallbacks(VoidCallback* successCallback,
                              ErrorCallbackBase* errorCallback,
                              ExecutionContext* context,
                              DOMFileSystemBase* fileSystem)
     : FileSystemCallbacksBase(errorCallback, fileSystem, context),
       m_successCallback(successCallback) {}
 
 void VoidCallbacks::didSucceed() {
   if (m_successCallback)
     handleEventOrScheduleCallback(m_successCallback.release());
 }
 
 }  // namespace blink