Re-write many calls to WrapUnique() with MakeUnique()

chrome/browser/chromeos/file_system_provider/provided_file_system.cc

 // Copyright 2014 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 "chrome/browser/chromeos/file_system_provider/provided_file_system.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/files/file.h"
@@ skipping 498 matching lines @@
     const base::FilePath& entry_path,
     bool recursive,
     storage::WatcherManager::ChangeType change_type,
     std::unique_ptr<ProvidedFileSystemObserver::Changes> changes,
     const std::string& tag,
     const storage::AsyncFileUtil::StatusCallback& callback) {
   const size_t token = watcher_queue_.NewToken();
   watcher_queue_.Enqueue(
       token, base::Bind(&ProvidedFileSystem::NotifyInQueue,
                         base::Unretained(this),  // Outlived by the queue.
-                        base::Passed(base::WrapUnique(new NotifyInQueueArgs(
+                        base::Passed(base::MakeUnique<NotifyInQueueArgs>(
                             token, entry_path, recursive, change_type,
-                            std::move(changes), tag, callback)))));
+                            std::move(changes), tag, callback))));
 }
 
 void ProvidedFileSystem::Configure(
     const storage::AsyncFileUtil::StatusCallback& callback) {
   const int request_id = request_manager_->CreateRequest(
       CONFIGURE, std::unique_ptr<RequestManager::HandlerInterface>(
                      new operations::Configure(event_router_, file_system_info_,
                                                callback)));
   if (!request_id)
     callback.Run(base::File::FILE_ERROR_SECURITY);
@@ skipping 17 matching lines @@
                                           base::File::Error result) {
   if (result != base::File::FILE_OK) {
     // If an error in aborting happens, then do not abort the request in the
     // request manager, as the operation is supposed to complete. The only case
     // it wouldn't complete is if there is a bug in the extension code, and
     // the extension never calls the callback. We consiously *do not* handle
     // bugs in extensions here.
     return;
   }
   request_manager_->RejectRequest(operation_request_id,
-                                  base::WrapUnique(new RequestValue()),
+                                  base::MakeUnique<RequestValue>(),
                                   base::File::FILE_ERROR_ABORT);
 }
 
 AbortCallback ProvidedFileSystem::AddWatcherInQueue(
     const AddWatcherInQueueArgs& args) {
   if (args.persistent && (!file_system_info_.supports_notify_tag() ||
                           !args.notification_callback.is_null())) {
     OnAddWatcherInQueueCompleted(args.token, args.entry_path, args.recursive,
                                  Subscriber(), args.callback,
                                  base::File::FILE_ERROR_INVALID_OPERATION);
@@ skipping 256 matching lines @@
     const storage::AsyncFileUtil::StatusCallback& callback,
     base::File::Error result) {
   // Closing files is final. Even if an error happened, we remove it from the
   // list of opened files.
   opened_files_.erase(file_handle);
   callback.Run(result);
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos