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

components/drive/service/fake_drive_service.cc

 // Copyright (c) 2012 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 "components/drive/service/fake_drive_service.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 530 matching lines @@
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, DRIVE_NO_CONNECTION,
                               base::Passed(std::unique_ptr<FileResource>())));
     return CancelCallback();
   }
 
   EntryInfo* entry = FindEntryByResourceId(resource_id);
   if (entry && entry->change_resource.file()) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, HTTP_SUCCESS,
-                              base::Passed(base::WrapUnique(new FileResource(
-                                  *entry->change_resource.file())))));
+                              base::Passed(base::MakeUnique<FileResource>(
+                                  *entry->change_resource.file()))));
     return CancelCallback();
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND,
                             base::Passed(std::unique_ptr<FileResource>())));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::GetShareUrl(
@@ skipping 266 matching lines @@
         FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND,
                               base::Passed(std::unique_ptr<FileResource>())));
     return CancelCallback();
   }
 
   // Make a copy and set the new resource ID and the new title.
   std::unique_ptr<EntryInfo> copied_entry(new EntryInfo);
   copied_entry->content_data = entry->content_data;
   copied_entry->share_url = entry->share_url;
   copied_entry->change_resource.set_file(
-      base::WrapUnique(new FileResource(*entry->change_resource.file())));
+      base::MakeUnique<FileResource>(*entry->change_resource.file()));
 
   ChangeResource* new_change = &copied_entry->change_resource;
   FileResource* new_file = new_change->mutable_file();
   const std::string new_resource_id = GetNewResourceId();
   new_change->set_file_id(new_resource_id);
   new_file->set_file_id(new_resource_id);
   new_file->set_title(new_title);
 
   ParentReference parent;
   parent.set_file_id(parent_resource_id);
   std::vector<ParentReference> parents;
   parents.push_back(parent);
   *new_file->mutable_parents() = parents;
 
   if (!last_modified.is_null())
     new_file->set_modified_date(last_modified);
 
   AddNewChangestamp(new_change);
   UpdateETag(new_file);
 
   // Add the new entry to the map.
   entries_[new_resource_id] = copied_entry.release();
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback, HTTP_SUCCESS,
-                 base::Passed(base::WrapUnique(new FileResource(*new_file)))));
+                 base::Passed(base::MakeUnique<FileResource>(*new_file))));
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&FakeDriveService::NotifyObservers,
                  weak_ptr_factory_.GetWeakPtr()));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::UpdateResource(
     const std::string& resource_id,
     const std::string& parent_resource_id,
@@ skipping 48 matching lines @@
 
   if (!last_viewed_by_me.is_null())
     file->set_last_viewed_by_me_date(last_viewed_by_me);
 
   AddNewChangestamp(change);
   UpdateETag(file);
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback, HTTP_SUCCESS,
-                 base::Passed(base::WrapUnique(new FileResource(*file)))));
+                 base::Passed(base::MakeUnique<FileResource>(*file))));
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&FakeDriveService::NotifyObservers,
                  weak_ptr_factory_.GetWeakPtr()));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::AddResourceToDirectory(
     const std::string& parent_resource_id,
     const std::string& resource_id,
@@ skipping 266 matching lines @@
         session->parent_resource_id,
         session->title,
         false);  // shared_with_me
     if (!new_entry) {
       completion_callback.Run(HTTP_NOT_FOUND, std::unique_ptr<FileResource>());
       return CancelCallback();
     }
 
     completion_callback.Run(
         HTTP_CREATED,
-        base::WrapUnique(new FileResource(*new_entry->change_resource.file())));
+        base::MakeUnique<FileResource>(*new_entry->change_resource.file()));
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&FakeDriveService::NotifyObservers,
                    weak_ptr_factory_.GetWeakPtr()));
     return CancelCallback();
   }
 
   EntryInfo* entry = FindEntryByResourceId(session->resource_id);
   if (!entry) {
     completion_callback.Run(HTTP_NOT_FOUND, std::unique_ptr<FileResource>());
     return CancelCallback();
   }
 
   ChangeResource* change = &entry->change_resource;
   FileResource* file = change->mutable_file();
   if (file->etag().empty() || session->etag != file->etag()) {
     completion_callback.Run(HTTP_PRECONDITION, std::unique_ptr<FileResource>());
     return CancelCallback();
   }
 
   file->set_md5_checksum(base::MD5String(content_data));
   entry->content_data = content_data;
   file->set_file_size(end_position);
   AddNewChangestamp(change);
   UpdateETag(file);
 
-  completion_callback.Run(HTTP_SUCCESS,
-                          base::WrapUnique(new FileResource(*file)));
+  completion_callback.Run(HTTP_SUCCESS, base::MakeUnique<FileResource>(*file));
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&FakeDriveService::NotifyObservers,
                  weak_ptr_factory_.GetWeakPtr()));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::MultipartUploadNewFile(
     const std::string& content_type,
     int64_t content_length,
@@ skipping 141 matching lines @@
                                            shared_with_me);
   if (!new_entry) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND,
                               base::Passed(std::unique_ptr<FileResource>())));
     return;
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback, HTTP_CREATED,
-                            base::Passed(base::WrapUnique(new FileResource(
-                                *new_entry->change_resource.file())))));
+                            base::Passed(base::MakeUnique<FileResource>(
+                                *new_entry->change_resource.file()))));
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&FakeDriveService::NotifyObservers,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 CancelCallback FakeDriveService::AddNewDirectoryWithResourceId(
     const std::string& resource_id,
     const std::string& parent_resource_id,
     const std::string& directory_title,
@@ skipping 22 matching lines @@
     return CancelCallback();
   }
 
   const google_apis::DriveApiErrorCode result =
       SetFileVisibility(new_entry->change_resource.file_id(),
                         options.visibility);
   DCHECK_EQ(HTTP_SUCCESS, result);
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback, HTTP_CREATED,
-                            base::Passed(base::WrapUnique(new FileResource(
-                                *new_entry->change_resource.file())))));
+                            base::Passed(base::MakeUnique<FileResource>(
+                                *new_entry->change_resource.file()))));
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&FakeDriveService::NotifyObservers,
                  weak_ptr_factory_.GetWeakPtr()));
   return CancelCallback();
 }
 
 void FakeDriveService::SetLastModifiedTime(
     const std::string& resource_id,
     const base::Time& last_modified_time,
@@ skipping 16 matching lines @@
     return;
   }
 
   ChangeResource* change = &entry->change_resource;
   FileResource* file = change->mutable_file();
   file->set_modified_date(last_modified_time);
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback, HTTP_SUCCESS,
-                 base::Passed(base::WrapUnique(new FileResource(*file)))));
+                 base::Passed(base::MakeUnique<FileResource>(*file))));
 }
 
 google_apis::DriveApiErrorCode FakeDriveService::SetUserPermission(
     const std::string& resource_id,
     google_apis::drive::PermissionRole user_permission) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   EntryInfo* entry = FindEntryByResourceId(resource_id);
   if (!entry)
     return HTTP_NOT_FOUND;
@@ skipping 207 matching lines @@
     // already incremented.
     if (start_offset > 0 && num_entries_matched <= start_offset)
       should_exclude = true;
 
     if (!should_exclude) {
       std::unique_ptr<ChangeResource> entry_copied(new ChangeResource);
       entry_copied->set_change_id(entry.change_id());
       entry_copied->set_file_id(entry.file_id());
       entry_copied->set_deleted(entry.is_deleted());
       if (entry.file()) {
-        entry_copied->set_file(
-            base::WrapUnique(new FileResource(*entry.file())));
+        entry_copied->set_file(base::MakeUnique<FileResource>(*entry.file()));
       }
       entry_copied->set_modification_date(entry.modification_date());
       entries.push_back(entry_copied.release());
     }
   }
 
   std::unique_ptr<ChangeList> change_list(new ChangeList);
   if (start_changestamp > 0 && start_offset == 0) {
     change_list->set_largest_change_id(about_resource_->largest_change_id());
   }
@@ skipping 58 matching lines @@
 
   NOTREACHED();
   return std::unique_ptr<BatchRequestConfiguratorInterface>();
 }
 
 void FakeDriveService::NotifyObservers() {
   FOR_EACH_OBSERVER(ChangeObserver, change_observers_, OnNewChangeAvailable());
 }
 
 }  // namespace drive