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

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>
 
 #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"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "policy/proto/device_management_backend.pb.h"
@@ skipping 34 matching lines @@
   return command_proto;
 }
 
 class MockUploadJob : public policy::UploadJob {
  public:
   // If |error_code| is a null pointer OnSuccess() will be invoked when the
   // Start() method is called, otherwise OnFailure() will be invoked with the
   // 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;
 
  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)) {}
 
 MockUploadJob::~MockUploadJob() {
 }
 
 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_);
   EXPECT_EQ(kMockUploadUrl, upload_url_.spec());
   if (error_code_) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&UploadJob::Delegate::OnFailure,
                               base::Unretained(delegate_), *error_code_));
     return;
   }
@@ skipping 19 matching lines @@
           gfx::Size(bmp.width(), bmp.height()),
           static_cast<int>(bmp.rowBytes()), false,
           std::vector<gfx::PNGCodec::Comment>(), &png_bytes->data())) {
     LOG(ERROR) << "Failed to encode image";
   }
   return png_bytes;
 }
 
 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;
   void TakeSnapshot(
       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) {}
 
 MockScreenshotDelegate::~MockScreenshotDelegate() {
 }
 
 bool MockScreenshotDelegate::IsScreenshotAllowed() {
   return screenshot_allowed_;
 }
 
 void MockScreenshotDelegate::TakeSnapshot(
     gfx::NativeWindow window,
     const gfx::Rect& source_rect,
     const ui::GrabWindowSnapshotAsyncPNGCallback& callback) {
   const int width = source_rect.width();
   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));
 }
 
-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
 
 class DeviceCommandScreenshotTest : public ash::test::AshTestBase {
  public:
   void VerifyResults(RemoteCommandJob* job,
                      RemoteCommandJob::Status expected_status,
                      std::string expected_payload);
 
@@ skipping 51 matching lines @@
   base::JSONWriter::Write(root_dict, &payload);
   return payload;
 }
 
 void DeviceCommandScreenshotTest::VerifyResults(
     RemoteCommandJob* job,
     RemoteCommandJob::Status expected_status,
     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);
   }
   run_loop_.Quit();
 }
 
 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(
       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) {
-  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 =
       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;
-  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);
   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