Remove base::Tuple

content/child/fileapi/webfilesystem_impl.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/child/fileapi/webfilesystem_impl.h"
 
 #include <stddef.h>
+#include <tuple>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread_local.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/child/child_thread_impl.h"
 #include "content/child/file_info_util.h"
 #include "content/child/fileapi/file_system_dispatcher.h"
 #include "content/child/fileapi/webfilewriter_impl.h"
 #include "content/common/fileapi/file_system_messages.h"
 #include "storage/common/fileapi/directory_entry.h"
 #include "storage/common/fileapi/file_system_util.h"
 #include "third_party/WebKit/public/platform/WebFileInfo.h"
 #include "third_party/WebKit/public/platform/WebFileSystemCallbacks.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/web/WebHeap.h"
 #include "url/gurl.h"
 
-using base::MakeTuple;
 using blink::WebFileInfo;
 using blink::WebFileSystemCallbacks;
 using blink::WebFileSystemEntry;
 using blink::WebString;
 using blink::WebURL;
 using blink::WebVector;
 
 namespace content {
 
 class WebFileSystemImpl::WaitableCallbackResults
@@ skipping 370 matching lines @@
 
 void WebFileSystemImpl::openFileSystem(
     const blink::WebURL& storage_partition,
     blink::WebFileSystemType type,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_task_runner_, &FileSystemDispatcher::OpenFileSystem,
-      MakeTuple(GURL(storage_partition),
-                static_cast<storage::FileSystemType>(type),
-                base::Bind(&OpenFileSystemCallbackAdapter,
-                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           base::RetainedRef(waitable_results)),
-                base::Bind(&StatusCallbackAdapter,
-                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           base::RetainedRef(waitable_results))),
+      std::make_tuple(
+          GURL(storage_partition), static_cast<storage::FileSystemType>(type),
+          base::Bind(&OpenFileSystemCallbackAdapter,
+                     base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                     base::RetainedRef(waitable_results)),
+          base::Bind(&StatusCallbackAdapter,
+                     base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                     base::RetainedRef(waitable_results))),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::resolveURL(
     const blink::WebURL& filesystem_url,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_task_runner_, &FileSystemDispatcher::ResolveURL,
-      MakeTuple(GURL(filesystem_url),
-                base::Bind(&ResolveURLCallbackAdapter,
-                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           base::RetainedRef(waitable_results)),
-                base::Bind(&StatusCallbackAdapter,
-                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           base::RetainedRef(waitable_results))),
+      std::make_tuple(
+          GURL(filesystem_url),
+          base::Bind(&ResolveURLCallbackAdapter,
+                     base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                     base::RetainedRef(waitable_results)),
+          base::Bind(&StatusCallbackAdapter,
+                     base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                     base::RetainedRef(waitable_results))),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::deleteFileSystem(
     const blink::WebURL& storage_partition,
     blink::WebFileSystemType type,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_task_runner_, &FileSystemDispatcher::DeleteFileSystem,
-      MakeTuple(GURL(storage_partition),
-                static_cast<storage::FileSystemType>(type),
-                base::Bind(&StatusCallbackAdapter,
-                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           base::RetainedRef(waitable_results))),
+      std::make_tuple(
+          GURL(storage_partition), static_cast<storage::FileSystemType>(type),
+          base::Bind(&StatusCallbackAdapter,
+                     base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                     base::RetainedRef(waitable_results))),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::move(
     const blink::WebURL& src_path,
     const blink::WebURL& dest_path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_task_runner_, &FileSystemDispatcher::Move,
-      MakeTuple(GURL(src_path), GURL(dest_path),
-                base::Bind(&StatusCallbackAdapter,
-                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           base::RetainedRef(waitable_results))),
+      std::make_tuple(
+          GURL(src_path), GURL(dest_path),
+          base::Bind(&StatusCallbackAdapter,
+                     base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                     base::RetainedRef(waitable_results))),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::copy(
     const blink::WebURL& src_path,
     const blink::WebURL& dest_path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_task_runner_, &FileSystemDispatcher::Copy,
-      MakeTuple(GURL(src_path), GURL(dest_path),
-                base::Bind(&StatusCallbackAdapter,
-                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           base::RetainedRef(waitable_results))),
+      std::make_tuple(
+          GURL(src_path), GURL(dest_path),
+          base::Bind(&StatusCallbackAdapter,
+                     base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                     base::RetainedRef(waitable_results))),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::remove(
     const blink::WebURL& path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_task_runner_, &FileSystemDispatcher::Remove,
-      MakeTuple(GURL(path), false /* recursive */,
-                base::Bind(&StatusCallbackAdapter,
-                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           base::RetainedRef(waitable_results))),
+      std::make_tuple(
+          GURL(path), false /* recursive */,
+          base::Bind(&StatusCallbackAdapter,
+                     base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                     base::RetainedRef(waitable_results))),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::removeRecursively(
     const blink::WebURL& path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_task_runner_, &FileSystemDispatcher::Remove,
-      MakeTuple(GURL(path), true /* recursive */,
-                base::Bind(&StatusCallbackAdapter,
-                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           base::RetainedRef(waitable_results))),
+      std::make_tuple(
+          GURL(path), true /* recursive */,
+          base::Bind(&StatusCallbackAdapter,
+                     base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                     base::RetainedRef(waitable_results))),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::readMetadata(
     const blink::WebURL& path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_task_runner_, &FileSystemDispatcher::ReadMetadata,
-      MakeTuple(GURL(path),
-                base::Bind(&ReadMetadataCallbackAdapter,
-                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           base::RetainedRef(waitable_results)),
-                base::Bind(&StatusCallbackAdapter,
-                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           base::RetainedRef(waitable_results))),
+      std::make_tuple(
+          GURL(path),
+          base::Bind(&ReadMetadataCallbackAdapter,
+                     base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                     base::RetainedRef(waitable_results)),
+          base::Bind(&StatusCallbackAdapter,
+                     base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                     base::RetainedRef(waitable_results))),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::createFile(
     const blink::WebURL& path,
     bool exclusive,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_task_runner_, &FileSystemDispatcher::CreateFile,
-      MakeTuple(GURL(path), exclusive,
-                base::Bind(&StatusCallbackAdapter,
-                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           base::RetainedRef(waitable_results))),
+      std::make_tuple(
+          GURL(path), exclusive,
+          base::Bind(&StatusCallbackAdapter,
+                     base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                     base::RetainedRef(waitable_results))),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::createDirectory(
     const blink::WebURL& path,
     bool exclusive,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_task_runner_, &FileSystemDispatcher::CreateDirectory,
-      MakeTuple(GURL(path), exclusive, false /* recursive */,
-                base::Bind(&StatusCallbackAdapter,
-                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           base::RetainedRef(waitable_results))),
+      std::make_tuple(
+          GURL(path), exclusive, false /* recursive */,
+          base::Bind(&StatusCallbackAdapter,
+                     base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                     base::RetainedRef(waitable_results))),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::fileExists(
     const blink::WebURL& path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_task_runner_, &FileSystemDispatcher::Exists,
-      MakeTuple(GURL(path), false /* directory */,
-                base::Bind(&StatusCallbackAdapter,
-                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           base::RetainedRef(waitable_results))),
+      std::make_tuple(
+          GURL(path), false /* directory */,
+          base::Bind(&StatusCallbackAdapter,
+                     base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                     base::RetainedRef(waitable_results))),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::directoryExists(
     const blink::WebURL& path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_task_runner_, &FileSystemDispatcher::Exists,
-      MakeTuple(GURL(path), true /* directory */,
-                base::Bind(&StatusCallbackAdapter,
-                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           base::RetainedRef(waitable_results))),
+      std::make_tuple(
+          GURL(path), true /* directory */,
+          base::Bind(&StatusCallbackAdapter,
+                     base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                     base::RetainedRef(waitable_results))),
       waitable_results.get());
 }
 
 int WebFileSystemImpl::readDirectory(
     const blink::WebURL& path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_task_runner_, &FileSystemDispatcher::ReadDirectory,
-      MakeTuple(GURL(path),
-                base::Bind(&ReadDirectoryCallbackAdapter,
-                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           base::RetainedRef(waitable_results)),
-                base::Bind(&StatusCallbackAdapter,
-                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           base::RetainedRef(waitable_results))),
+      std::make_tuple(
+          GURL(path),
+          base::Bind(&ReadDirectoryCallbackAdapter,
+                     base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                     base::RetainedRef(waitable_results)),
+          base::Bind(&StatusCallbackAdapter,
+                     base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                     base::RetainedRef(waitable_results))),
       waitable_results.get());
   return callbacks_id;
 }
 
 void WebFileSystemImpl::createFileWriter(
     const WebURL& path,
     blink::WebFileWriterClient* client,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_task_runner_, &FileSystemDispatcher::ReadMetadata,
-      MakeTuple(GURL(path),
-                base::Bind(&CreateFileWriterCallbackAdapter,
-                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           base::RetainedRef(waitable_results),
-                           main_thread_task_runner_, GURL(path), client),
-                base::Bind(&StatusCallbackAdapter,
-                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           base::RetainedRef(waitable_results))),
+      std::make_tuple(
+          GURL(path),
+          base::Bind(&CreateFileWriterCallbackAdapter,
+                     base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                     base::RetainedRef(waitable_results),
+                     main_thread_task_runner_, GURL(path), client),
+          base::Bind(&StatusCallbackAdapter,
+                     base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                     base::RetainedRef(waitable_results))),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::createSnapshotFileAndReadMetadata(
     const blink::WebURL& path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_task_runner_, &FileSystemDispatcher::CreateSnapshotFile,
-      MakeTuple(GURL(path),
-                base::Bind(&CreateSnapshotFileCallbackAdapter,
-                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           base::RetainedRef(waitable_results),
-                           main_thread_task_runner_),
-                base::Bind(&StatusCallbackAdapter,
-                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           base::RetainedRef(waitable_results))),
+      std::make_tuple(
+          GURL(path),
+          base::Bind(&CreateSnapshotFileCallbackAdapter,
+                     base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                     base::RetainedRef(waitable_results),
+                     main_thread_task_runner_),
+          base::Bind(&StatusCallbackAdapter,
+                     base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                     base::RetainedRef(waitable_results))),
       waitable_results.get());
 }
 
 bool WebFileSystemImpl::waitForAdditionalResult(int callbacksId) {
   WaitableCallbackResultsMap::iterator found =
       waitable_results_.find(callbacksId);
   if (found == waitable_results_.end())
     return false;
 
   found->second->WaitAndRun();
@@ skipping 27 matching lines @@
 WaitableCallbackResults* WebFileSystemImpl::MaybeCreateWaitableResults(
     const WebFileSystemCallbacks& callbacks, int callbacks_id) {
   if (!callbacks.shouldBlockUntilCompletion())
     return NULL;
   WaitableCallbackResults* results = new WaitableCallbackResults();
   waitable_results_[callbacks_id] = results;
   return results;
 }
 
 }  // namespace content