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

chrome/browser/chromeos/policy/remote_commands/device_command_screenshot_job.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 <fstream>
 #include <utility>
 
 #include "ash/shell.h"
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/policy/upload_job_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/http/http_request_headers.h"
 #include "policy/proto/device_management_backend.pb.h"
 
@@ skipping 40 matching lines @@
 
 }  // namespace
 
 class DeviceCommandScreenshotJob::Payload
     : public RemoteCommandJob::ResultPayload {
  public:
   explicit Payload(ResultCode result_code);
   ~Payload() override {}
 
   // RemoteCommandJob::ResultPayload:
-  scoped_ptr<std::string> Serialize() override;
+  std::unique_ptr<std::string> Serialize() override;
 
  private:
   std::string payload_;
 
   DISALLOW_COPY_AND_ASSIGN(Payload);
 };
 
 DeviceCommandScreenshotJob::Payload::Payload(ResultCode result_code) {
   base::DictionaryValue root_dict;
   if (result_code != SUCCESS)
     root_dict.SetInteger(kResultFieldName, result_code);
   base::JSONWriter::Write(root_dict, &payload_);
 }
 
-scoped_ptr<std::string> DeviceCommandScreenshotJob::Payload::Serialize() {
-  return make_scoped_ptr(new std::string(payload_));
+std::unique_ptr<std::string> DeviceCommandScreenshotJob::Payload::Serialize() {
+  return base::WrapUnique(new std::string(payload_));
 }
 
 DeviceCommandScreenshotJob::DeviceCommandScreenshotJob(
-    scoped_ptr<Delegate> screenshot_delegate)
+    std::unique_ptr<Delegate> screenshot_delegate)
     : num_pending_screenshots_(0),
       screenshot_delegate_(std::move(screenshot_delegate)),
       weak_ptr_factory_(this) {
   DCHECK(screenshot_delegate_);
 }
 
 DeviceCommandScreenshotJob::~DeviceCommandScreenshotJob() {
 }
 
 enterprise_management::RemoteCommand_Type DeviceCommandScreenshotJob::GetType()
     const {
   return enterprise_management::RemoteCommand_Type_DEVICE_SCREENSHOT;
 }
 
 void DeviceCommandScreenshotJob::OnSuccess() {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(succeeded_callback_,
-                 base::Passed(make_scoped_ptr(new Payload(SUCCESS)))));
+                 base::Passed(base::WrapUnique(new Payload(SUCCESS)))));
 }
 
 void DeviceCommandScreenshotJob::OnFailure(UploadJob::ErrorCode error_code) {
   ResultCode result_code = FAILURE_CLIENT;
   switch (error_code) {
     case UploadJob::AUTHENTICATION_ERROR:
       result_code = FAILURE_AUTHENTICATION;
       break;
     case UploadJob::NETWORK_ERROR:
     case UploadJob::SERVER_ERROR:
       result_code = FAILURE_SERVER;
       break;
   }
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(failed_callback_,
-                 base::Passed(make_scoped_ptr(new Payload(result_code)))));
+                 base::Passed(base::WrapUnique(new Payload(result_code)))));
 }
 
 bool DeviceCommandScreenshotJob::IsExpired(base::TimeTicks now) {
   return now > issued_time() + base::TimeDelta::FromMinutes(
                                    kCommandExpirationTimeInMinutes);
 }
 
 bool DeviceCommandScreenshotJob::ParseCommandPayload(
     const std::string& command_payload) {
-  scoped_ptr<base::Value> root(base::JSONReader().ReadToValue(command_payload));
+  std::unique_ptr<base::Value> root(
+      base::JSONReader().ReadToValue(command_payload));
   if (!root.get())
     return false;
   base::DictionaryValue* payload = nullptr;
   if (!root->GetAsDictionary(&payload))
     return false;
   std::string upload_url;
   if (!payload->GetString(kUploadUrlFieldName, &upload_url))
     return false;
   upload_url_ = GURL(upload_url);
   return true;
@@ skipping 12 matching lines @@
 
 void DeviceCommandScreenshotJob::StartScreenshotUpload() {
   for (const auto& screenshot_entry : screenshots_) {
     std::map<std::string, std::string> header_fields;
     header_fields.insert(
         std::make_pair(kFileTypeHeaderName, kFileTypeScreenshotFile));
     header_fields.insert(std::make_pair(net::HttpRequestHeaders::kContentType,
                                         kContentTypeImagePng));
     header_fields.insert(std::make_pair(kCommandIdHeaderName,
                                         base::Uint64ToString(unique_id())));
-    scoped_ptr<std::string> data = make_scoped_ptr(
+    std::unique_ptr<std::string> data = base::WrapUnique(
         new std::string((const char*)screenshot_entry.second->front(),
                         screenshot_entry.second->size()));
     upload_job_->AddDataSegment(
         base::StringPrintf(kNameFieldTemplate, screenshot_entry.first),
         base::StringPrintf(kFilenameFieldTemplate, screenshot_entry.first),
         header_fields, std::move(data));
   }
   upload_job_->Start();
 }
 
 void DeviceCommandScreenshotJob::RunImpl(
     const CallbackWithResult& succeeded_callback,
     const CallbackWithResult& failed_callback) {
   succeeded_callback_ = succeeded_callback;
   failed_callback_ = failed_callback;
 
   // Fail if the delegate says screenshots are not allowed in this session.
   if (!screenshot_delegate_->IsScreenshotAllowed()) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
-        base::Bind(failed_callback_, base::Passed(make_scoped_ptr(
+        base::Bind(failed_callback_, base::Passed(base::WrapUnique(
                                          new Payload(FAILURE_USER_INPUT)))));
   }
 
   aura::Window::Windows root_windows = ash::Shell::GetAllRootWindows();
 
   // Immediately fail if the upload url is invalid.
   if (!upload_url_.is_valid()) {
     LOG(ERROR) << upload_url_ << " is not a valid URL.";
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
-        base::Bind(failed_callback_, base::Passed(make_scoped_ptr(
+        base::Bind(failed_callback_, base::Passed(base::WrapUnique(
                                          new Payload(FAILURE_INVALID_URL)))));
     return;
   }
 
   // Immediately fail if there are no attached screens.
   if (root_windows.size() == 0) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
-        base::Bind(failed_callback_, base::Passed(make_scoped_ptr(new Payload(
+        base::Bind(failed_callback_, base::Passed(base::WrapUnique(new Payload(
                                          FAILURE_SCREENSHOT_ACQUISITION)))));
     return;
   }
 
   upload_job_ = screenshot_delegate_->CreateUploadJob(upload_url_, this);
   DCHECK(upload_job_);
 
   // Post tasks to the sequenced worker pool for taking screenshots on each
   // attached screen.
   num_pending_screenshots_ = root_windows.size();
   for (size_t screen = 0; screen < root_windows.size(); ++screen) {
     aura::Window* root_window = root_windows[screen];
     gfx::Rect rect = root_window->bounds();
     screenshot_delegate_->TakeSnapshot(
         root_window, rect,
         base::Bind(&RunStoreScreenshotOnTaskRunner,
                    base::Bind(&DeviceCommandScreenshotJob::StoreScreenshot,
                               weak_ptr_factory_.GetWeakPtr(), screen),
                    base::ThreadTaskRunnerHandle::Get()));
   }
 }
 
 void DeviceCommandScreenshotJob::TerminateImpl() {
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
 }  // namespace policy