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

chrome/browser/chromeos/policy/remote_commands/device_command_screenshot_job_unittest.cc

 // Copyright 2015 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/policy/remote_commands/device_command_screenshot_job.h"
 
 #include <map>
 #include <utility>
 #include <vector>
 
@@ skipping 167 matching lines @@
   const int height = source_rect.height();
   scoped_refptr<base::RefCountedBytes> test_png =
       GenerateTestPNG(width, height);
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                 base::Bind(callback, test_png));
 }
 
 std::unique_ptr<UploadJob> MockScreenshotDelegate::CreateUploadJob(
     const GURL& upload_url,
     UploadJob::Delegate* delegate) {
-  return base::WrapUnique(new MockUploadJob(upload_url, delegate,
-                                            std::move(upload_job_error_code_)));
+  return base::MakeUnique<MockUploadJob>(upload_url, delegate,
+                                         std::move(upload_job_error_code_));
 }
 
 }  // namespace
 
 class DeviceCommandScreenshotTest : public ash::test::AshTestBase {
  public:
   void VerifyResults(RemoteCommandJob* job,
                      RemoteCommandJob::Status expected_status,
                      std::string expected_payload);
 
@@ skipping 60 matching lines @@
   if (job->status() == RemoteCommandJob::SUCCEEDED) {
     std::unique_ptr<std::string> payload = job->GetResultPayload();
     EXPECT_TRUE(payload);
     EXPECT_EQ(expected_payload, *payload);
   }
   run_loop_.Quit();
 }
 
 TEST_F(DeviceCommandScreenshotTest, Success) {
   std::unique_ptr<RemoteCommandJob> job(new DeviceCommandScreenshotJob(
-      base::WrapUnique(new MockScreenshotDelegate(nullptr, true))));
+      base::MakeUnique<MockScreenshotDelegate>(nullptr, true)));
   InitializeScreenshotJob(job.get(), kUniqueID, test_start_time_,
                           kMockUploadUrl);
   bool success = job->Run(
       base::TimeTicks::Now(),
       base::Bind(
           &DeviceCommandScreenshotTest::VerifyResults, base::Unretained(this),
           base::Unretained(job.get()), RemoteCommandJob::SUCCEEDED,
           CreatePayloadFromResultCode(DeviceCommandScreenshotJob::SUCCESS)));
   EXPECT_TRUE(success);
   run_loop_.Run();
 }
 
 TEST_F(DeviceCommandScreenshotTest, FailureUserInput) {
   std::unique_ptr<RemoteCommandJob> job(new DeviceCommandScreenshotJob(
-      base::WrapUnique(new MockScreenshotDelegate(nullptr, false))));
+      base::MakeUnique<MockScreenshotDelegate>(nullptr, false)));
   InitializeScreenshotJob(job.get(), kUniqueID, test_start_time_,
                           kMockUploadUrl);
   bool success =
       job->Run(base::TimeTicks::Now(),
                base::Bind(&DeviceCommandScreenshotTest::VerifyResults,
                           base::Unretained(this), base::Unretained(job.get()),
                           RemoteCommandJob::FAILED,
                           CreatePayloadFromResultCode(
                               DeviceCommandScreenshotJob::FAILURE_USER_INPUT)));
   EXPECT_TRUE(success);
   run_loop_.Run();
 }
 
 TEST_F(DeviceCommandScreenshotTest, Failure) {
   using ErrorCode = UploadJob::ErrorCode;
   std::unique_ptr<ErrorCode> error_code(
       new ErrorCode(UploadJob::AUTHENTICATION_ERROR));
-  std::unique_ptr<RemoteCommandJob> job(
-      new DeviceCommandScreenshotJob(base::WrapUnique(
-          new MockScreenshotDelegate(std::move(error_code), true))));
+  std::unique_ptr<RemoteCommandJob> job(new DeviceCommandScreenshotJob(
+      base::MakeUnique<MockScreenshotDelegate>(std::move(error_code), true)));
   InitializeScreenshotJob(job.get(), kUniqueID, test_start_time_,
                           kMockUploadUrl);
   bool success = job->Run(
       base::TimeTicks::Now(),
       base::Bind(&DeviceCommandScreenshotTest::VerifyResults,
                  base::Unretained(this), base::Unretained(job.get()),
                  RemoteCommandJob::FAILED,
                  CreatePayloadFromResultCode(
                      DeviceCommandScreenshotJob::FAILURE_AUTHENTICATION)));
   EXPECT_TRUE(success);
   run_loop_.Run();
 }
 
 }  // namespace policy