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

content/browser/storage_partition_impl_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/macros.h"
@@ skipping 283 matching lines @@
 
   // Opens the file created for ClearKey (in kOrigin1) for writing. Caller
   // needs to verify if the file was opened or not.
   base::File OpenClearKeyFileForWrite() {
     AwaitCompletionHelper await_completion;
     base::File file;
     storage::AsyncFileUtil* async_file_util =
         filesystem_context_->GetAsyncFileUtil(
             storage::kFileSystemTypePluginPrivate);
     std::unique_ptr<storage::FileSystemOperationContext> operation_context =
-        base::WrapUnique(
-            new storage::FileSystemOperationContext(filesystem_context_));
+        base::MakeUnique<storage::FileSystemOperationContext>(
+            filesystem_context_);
     async_file_util->CreateOrOpen(
         std::move(operation_context), clearkey_file_,
         base::File::FLAG_OPEN | base::File::FLAG_WRITE,
         base::Bind(&RemovePluginPrivateDataTester::OnFileOpened,
                    base::Unretained(this), &file, &await_completion));
     await_completion.BlockUntilNotified();
     return file;
   }
 
  private:
@@ skipping 24 matching lines @@
                                     const std::string& fsid,
                                     const std::string& file_name) {
     AwaitCompletionHelper await_completion;
     std::string root = storage::GetIsolatedFileSystemRootURIString(
         origin, fsid, ppapi::kPluginPrivateRootName);
     storage::FileSystemURL file_url =
         filesystem_context_->CrackURL(GURL(root + file_name));
     storage::AsyncFileUtil* file_util = filesystem_context_->GetAsyncFileUtil(
         storage::kFileSystemTypePluginPrivate);
     std::unique_ptr<storage::FileSystemOperationContext> operation_context =
-        base::WrapUnique(
-            new storage::FileSystemOperationContext(filesystem_context_));
+        base::MakeUnique<storage::FileSystemOperationContext>(
+            filesystem_context_);
     operation_context->set_allowed_bytes_growth(
         storage::QuotaManager::kNoLimit);
     file_util->EnsureFileExists(
         std::move(operation_context), file_url,
         base::Bind(&RemovePluginPrivateDataTester::OnFileCreated,
                    base::Unretained(this), &await_completion));
     await_completion.BlockUntilNotified();
     return file_url;
   }
 
   // Sets the last_access_time and last_modified_time to |time_stamp| on the
   // file specified by |file_url|. The file must already exist.
   void SetFileTimestamp(const storage::FileSystemURL& file_url,
                         const base::Time& time_stamp) {
     AwaitCompletionHelper await_completion;
     storage::AsyncFileUtil* file_util = filesystem_context_->GetAsyncFileUtil(
         storage::kFileSystemTypePluginPrivate);
     std::unique_ptr<storage::FileSystemOperationContext> operation_context =
-        base::WrapUnique(
-            new storage::FileSystemOperationContext(filesystem_context_));
+        base::MakeUnique<storage::FileSystemOperationContext>(
+            filesystem_context_);
     file_util->Touch(std::move(operation_context), file_url, time_stamp,
                      time_stamp,
                      base::Bind(&RemovePluginPrivateDataTester::OnFileTouched,
                                 base::Unretained(this), &await_completion));
     await_completion.BlockUntilNotified();
   }
 
   void OnFileSystemOpened(AwaitCompletionHelper* await_completion,
                           base::File::Error result) {
     EXPECT_EQ(base::File::FILE_OK, result) << base::File::ErrorToString(result);
@@ skipping 930 matching lines @@
       CanonicalCookie::Create(url2, "A=B;domain=.example.com", now, options));
   invalid_cookies.push_back(CanonicalCookie::Create(url3, "A=B", now, options));
 
   for (const auto& cookie : valid_cookies)
     EXPECT_TRUE(predicate.Run(*cookie)) << cookie->DebugString();
   for (const auto& cookie : invalid_cookies)
     EXPECT_FALSE(predicate.Run(*cookie)) << cookie->DebugString();
 }
 
 }  // namespace content