Replace base::Tuple in //storage with std::tuple

storage/browser/fileapi/file_system_operation_runner.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 "storage/browser/fileapi/file_system_operation_runner.h"
 
 #include <stdint.h>
+#include <tuple>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/stl_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "net/url_request/url_request_context.h"
 #include "storage/browser/blob/blob_url_request_job_factory.h"
 #include "storage/browser/blob/shareable_file_reference.h"
 #include "storage/browser/fileapi/file_observers.h"
@@ skipping 612 matching lines @@
             AsWeakPtr(), handle, callback, type, source_url, dest_url, size));
     return;
   }
   callback.Run(type, source_url, dest_url, size);
 }
 
 void FileSystemOperationRunner::PrepareForWrite(OperationID id,
                                                 const FileSystemURL& url) {
   if (file_system_context_->GetUpdateObservers(url.type())) {
     file_system_context_->GetUpdateObservers(url.type())->Notify(
-        &FileUpdateObserver::OnStartUpdate, base::MakeTuple(url));
+        &FileUpdateObserver::OnStartUpdate, std::make_tuple(url));
   }
   write_target_urls_[id].insert(url);
 }
 
 void FileSystemOperationRunner::PrepareForRead(OperationID id,
                                                const FileSystemURL& url) {
   if (file_system_context_->GetAccessObservers(url.type())) {
     file_system_context_->GetAccessObservers(url.type())->Notify(
-        &FileAccessObserver::OnAccess, base::MakeTuple(url));
+        &FileAccessObserver::OnAccess, std::make_tuple(url));
   }
 }
 
 FileSystemOperationRunner::OperationHandle
 FileSystemOperationRunner::BeginOperation(
     FileSystemOperation* operation,
     base::WeakPtr<BeginOperationScoper> scope) {
   OperationHandle handle;
   handle.id = operations_.Add(operation);
   handle.scope = scope;
   return handle;
 }
 
 void FileSystemOperationRunner::FinishOperation(OperationID id) {
   OperationToURLSet::iterator found = write_target_urls_.find(id);
   if (found != write_target_urls_.end()) {
     const FileSystemURLSet& urls = found->second;
     for (FileSystemURLSet::const_iterator iter = urls.begin();
         iter != urls.end(); ++iter) {
       if (file_system_context_->GetUpdateObservers(iter->type())) {
         file_system_context_->GetUpdateObservers(iter->type())->Notify(
-            &FileUpdateObserver::OnEndUpdate, base::MakeTuple(*iter));
+            &FileUpdateObserver::OnEndUpdate, std::make_tuple(*iter));
       }
     }
     write_target_urls_.erase(found);
   }
 
   // IDMap::Lookup fails if the operation is NULL, so we don't check
   // operations_.Lookup(id) here.
 
   operations_.Remove(id);
   finished_operations_.erase(id);
 
   // Dispatch stray cancel callback if exists.
   std::map<OperationID, StatusCallback>::iterator found_cancel =
       stray_cancel_callbacks_.find(id);
   if (found_cancel != stray_cancel_callbacks_.end()) {
     // This cancel has been requested after the operation has finished,
     // so report that we failed to stop it.
     found_cancel->second.Run(base::File::FILE_ERROR_INVALID_OPERATION);
     stray_cancel_callbacks_.erase(found_cancel);
   }
 }
 
 }  // namespace storage