Convert //chrome/browser/chromeos from scoped_ptr to std::unique_ptr

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

Index: chrome/browser/chromeos/policy/remote_commands/device_command_screenshot_job_unittest.cc
diff --git a/chrome/browser/chromeos/policy/remote_commands/device_command_screenshot_job_unittest.cc b/chrome/browser/chromeos/policy/remote_commands/device_command_screenshot_job_unittest.cc
index 84af7fc7edd9f3a1b1673448a7376a12f96b6aa7..042a256ce6eec1651dd0717f96605585fd314566 100644
--- a/chrome/browser/chromeos/policy/remote_commands/device_command_screenshot_job_unittest.cc
+++ b/chrome/browser/chromeos/policy/remote_commands/device_command_screenshot_job_unittest.cc
@@ -11,6 +11,7 @@
 #include "ash/test/ash_test_base.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/test/test_mock_time_task_runner.h"
@@ -65,14 +66,14 @@ class MockUploadJob : public policy::UploadJob {
   // respective |error_code|.
   MockUploadJob(const GURL& upload_url,
                 UploadJob::Delegate* delegate,
-                scoped_ptr<UploadJob::ErrorCode> error_code);
+                std::unique_ptr<UploadJob::ErrorCode> error_code);
   ~MockUploadJob() override;
 
   // policy::UploadJob:
   void AddDataSegment(const std::string& name,
                       const std::string& filename,
                       const std::map<std::string, std::string>& header_entries,
-                      scoped_ptr<std::string> data) override;
+                      std::unique_ptr<std::string> data) override;
   void Start() override;
 
   const GURL& GetUploadUrl() const;
@@ -80,13 +81,13 @@ class MockUploadJob : public policy::UploadJob {
  protected:
   const GURL upload_url_;
   UploadJob::Delegate* delegate_;
-  scoped_ptr<UploadJob::ErrorCode> error_code_;
+  std::unique_ptr<UploadJob::ErrorCode> error_code_;
   bool add_datasegment_succeeds_;
 };
 
 MockUploadJob::MockUploadJob(const GURL& upload_url,
                              UploadJob::Delegate* delegate,
-                             scoped_ptr<UploadJob::ErrorCode> error_code)
+                             std::unique_ptr<UploadJob::ErrorCode> error_code)
     : upload_url_(upload_url),
       delegate_(delegate),
       error_code_(std::move(error_code)) {}
@@ -98,8 +99,7 @@ void MockUploadJob::AddDataSegment(
     const std::string& name,
     const std::string& filename,
     const std::map<std::string, std::string>& header_entries,
-    scoped_ptr<std::string> data) {
-}
+    std::unique_ptr<std::string> data) {}
 
 void MockUploadJob::Start() {
   DCHECK(delegate_);
@@ -139,8 +139,9 @@ scoped_refptr<base::RefCountedBytes> GenerateTestPNG(const int& width,
 
 class MockScreenshotDelegate : public DeviceCommandScreenshotJob::Delegate {
  public:
-  MockScreenshotDelegate(scoped_ptr<UploadJob::ErrorCode> upload_job_error_code,
-                         bool screenshot_allowed);
+  MockScreenshotDelegate(
+      std::unique_ptr<UploadJob::ErrorCode> upload_job_error_code,
+      bool screenshot_allowed);
   ~MockScreenshotDelegate() override;
 
   bool IsScreenshotAllowed() override;
@@ -148,16 +149,16 @@ class MockScreenshotDelegate : public DeviceCommandScreenshotJob::Delegate {
       gfx::NativeWindow window,
       const gfx::Rect& source_rect,
       const ui::GrabWindowSnapshotAsyncPNGCallback& callback) override;
-  scoped_ptr<UploadJob> CreateUploadJob(const GURL&,
-                                        UploadJob::Delegate*) override;
+  std::unique_ptr<UploadJob> CreateUploadJob(const GURL&,
+                                             UploadJob::Delegate*) override;
 
  private:
-  scoped_ptr<UploadJob::ErrorCode> upload_job_error_code_;
+  std::unique_ptr<UploadJob::ErrorCode> upload_job_error_code_;
   bool screenshot_allowed_;
 };
 
 MockScreenshotDelegate::MockScreenshotDelegate(
-    scoped_ptr<UploadJob::ErrorCode> upload_job_error_code,
+    std::unique_ptr<UploadJob::ErrorCode> upload_job_error_code,
     bool screenshot_allowed)
     : upload_job_error_code_(std::move(upload_job_error_code)),
       screenshot_allowed_(screenshot_allowed) {}
@@ -181,11 +182,11 @@ void MockScreenshotDelegate::TakeSnapshot(
                                                 base::Bind(callback, test_png));
 }
 
-scoped_ptr<UploadJob> MockScreenshotDelegate::CreateUploadJob(
+std::unique_ptr<UploadJob> MockScreenshotDelegate::CreateUploadJob(
     const GURL& upload_url,
     UploadJob::Delegate* delegate) {
-  return make_scoped_ptr(new MockUploadJob(upload_url, delegate,
-                                           std::move(upload_job_error_code_)));
+  return base::WrapUnique(new MockUploadJob(upload_url, delegate,
+                                            std::move(upload_job_error_code_)));
 }
 
 }  // namespace
@@ -257,7 +258,7 @@ void DeviceCommandScreenshotTest::VerifyResults(
     std::string expected_payload) {
   EXPECT_EQ(expected_status, job->status());
   if (job->status() == RemoteCommandJob::SUCCEEDED) {
-    scoped_ptr<std::string> payload = job->GetResultPayload();
+    std::unique_ptr<std::string> payload = job->GetResultPayload();
     EXPECT_TRUE(payload);
     EXPECT_EQ(expected_payload, *payload);
   }
@@ -265,8 +266,8 @@ void DeviceCommandScreenshotTest::VerifyResults(
 }
 
 TEST_F(DeviceCommandScreenshotTest, Success) {
-  scoped_ptr<RemoteCommandJob> job(new DeviceCommandScreenshotJob(
-      make_scoped_ptr(new MockScreenshotDelegate(nullptr, true))));
+  std::unique_ptr<RemoteCommandJob> job(new DeviceCommandScreenshotJob(
+      base::WrapUnique(new MockScreenshotDelegate(nullptr, true))));
   InitializeScreenshotJob(job.get(), kUniqueID, test_start_time_,
                           kMockUploadUrl);
   bool success = job->Run(
@@ -280,8 +281,8 @@ TEST_F(DeviceCommandScreenshotTest, Success) {
 }
 
 TEST_F(DeviceCommandScreenshotTest, FailureUserInput) {
-  scoped_ptr<RemoteCommandJob> job(new DeviceCommandScreenshotJob(
-      make_scoped_ptr(new MockScreenshotDelegate(nullptr, false))));
+  std::unique_ptr<RemoteCommandJob> job(new DeviceCommandScreenshotJob(
+      base::WrapUnique(new MockScreenshotDelegate(nullptr, false))));
   InitializeScreenshotJob(job.get(), kUniqueID, test_start_time_,
                           kMockUploadUrl);
   bool success =
@@ -297,10 +298,10 @@ TEST_F(DeviceCommandScreenshotTest, FailureUserInput) {
 
 TEST_F(DeviceCommandScreenshotTest, Failure) {
   using ErrorCode = UploadJob::ErrorCode;
-  scoped_ptr<ErrorCode> error_code(
+  std::unique_ptr<ErrorCode> error_code(
       new ErrorCode(UploadJob::AUTHENTICATION_ERROR));
-  scoped_ptr<RemoteCommandJob> job(
-      new DeviceCommandScreenshotJob(make_scoped_ptr(
+  std::unique_ptr<RemoteCommandJob> job(
+      new DeviceCommandScreenshotJob(base::WrapUnique(
           new MockScreenshotDelegate(std::move(error_code), true))));
   InitializeScreenshotJob(job.get(), kUniqueID, test_start_time_,
                           kMockUploadUrl);