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

chrome/browser/chromeos/policy/upload_job_impl.cc

 // Copyright (c) 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/upload_job_impl.h"
 
 #include <stddef.h>
 #include <set>
 #include <utility>
 
@@ skipping 33 matching lines @@
 
 UploadJobImpl::RandomMimeBoundaryGenerator::~RandomMimeBoundaryGenerator() {
 }
 
 // multipart/form-data POST request to upload the data. A DataSegment
 // corresponds to one "Content-Disposition" in the "multipart" request.
 class DataSegment {
  public:
   DataSegment(const std::string& name,
               const std::string& filename,
-              scoped_ptr<std::string> data,
+              std::unique_ptr<std::string> data,
               const std::map<std::string, std::string>& header_entries);
 
   // Returns the header entries for this DataSegment.
   const std::map<std::string, std::string>& GetHeaderEntries() const;
 
   // Returns the string that will be assigned to the |name| field in the header.
   // |name| must be unique throughout the multipart message. This is enforced in
   // SetUpMultipart().
   const std::string& GetName() const;
 
   // Returns the string that will be assigned to the |filename| field in the
   // header. If the |filename| is the empty string, the header field will be
   // omitted.
   const std::string& GetFilename() const;
 
   // Returns the data contained in this DataSegment. Ownership is passed.
-  scoped_ptr<std::string> GetData();
+  std::unique_ptr<std::string> GetData();
 
   // Returns the size in bytes of the blob in |data_|.
   size_t GetDataSize() const;
 
  private:
   const std::string name_;
   const std::string filename_;
-  scoped_ptr<std::string> data_;
+  std::unique_ptr<std::string> data_;
   std::map<std::string, std::string> header_entries_;
 
   DISALLOW_COPY_AND_ASSIGN(DataSegment);
 };
 
 DataSegment::DataSegment(
     const std::string& name,
     const std::string& filename,
-    scoped_ptr<std::string> data,
+    std::unique_ptr<std::string> data,
     const std::map<std::string, std::string>& header_entries)
     : name_(name),
       filename_(filename),
       data_(std::move(data)),
       header_entries_(header_entries) {
   DCHECK(data_);
 }
 
 const std::map<std::string, std::string>& DataSegment::GetHeaderEntries()
     const {
   return header_entries_;
 }
 
 const std::string& DataSegment::GetName() const {
   return name_;
 }
 
 const std::string& DataSegment::GetFilename() const {
   return filename_;
 }
 
-scoped_ptr<std::string> DataSegment::GetData() {
+std::unique_ptr<std::string> DataSegment::GetData() {
   return std::move(data_);
 }
 
 size_t DataSegment::GetDataSize() const {
   DCHECK(data_);
   return data_->size();
 }
 
 std::string UploadJobImpl::RandomMimeBoundaryGenerator::GenerateBoundary()
     const {
   return net::GenerateMimeMultipartBoundary();
 }
 
 UploadJobImpl::UploadJobImpl(
     const GURL& upload_url,
     const std::string& account_id,
     OAuth2TokenService* token_service,
     scoped_refptr<net::URLRequestContextGetter> url_context_getter,
     Delegate* delegate,
-    scoped_ptr<MimeBoundaryGenerator> boundary_generator)
+    std::unique_ptr<MimeBoundaryGenerator> boundary_generator)
     : OAuth2TokenService::Consumer("cros_upload_job"),
       upload_url_(upload_url),
       account_id_(account_id),
       token_service_(token_service),
       url_context_getter_(url_context_getter),
       delegate_(delegate),
       boundary_generator_(std::move(boundary_generator)),
       state_(IDLE),
       retry_(0) {
   DCHECK(token_service_);
   DCHECK(url_context_getter_);
   DCHECK(delegate_);
   if (!upload_url_.is_valid()) {
     state_ = ERROR;
     NOTREACHED() << upload_url_ << " is not a valid URL.";
   }
 }
 
 UploadJobImpl::~UploadJobImpl() {
 }
 
 void UploadJobImpl::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) {
   // Cannot add data to busy or failed instance.
   DCHECK_EQ(IDLE, state_);
   if (state_ != IDLE)
     return;
 
-  scoped_ptr<DataSegment> data_segment(
+  std::unique_ptr<DataSegment> data_segment(
       new DataSegment(name, filename, std::move(data), header_entries));
   data_segments_.push_back(std::move(data_segment));
 }
 
 void UploadJobImpl::Start() {
   // Cannot start an upload on a busy or failed instance.
   DCHECK_EQ(IDLE, state_);
   if (state_ != IDLE)
     return;
   RequestAccessToken();
@@ skipping 49 matching lines @@
                        data_segment->GetName() + "\"");
     if (!data_segment->GetFilename().empty()) {
       post_data_->append("; filename=\"" + data_segment->GetFilename() + "\"");
     }
     post_data_->append("\r\n");
 
     // Add custom header fields.
     for (const auto& entry : data_segment->GetHeaderEntries()) {
       post_data_->append(entry.first + ": " + entry.second + "\r\n");
     }
-    scoped_ptr<std::string> data = data_segment->GetData();
+    std::unique_ptr<std::string> data = data_segment->GetData();
     post_data_->append("\r\n" + *data + "\r\n");
   }
   post_data_->append("--" + *mime_boundary_.get() + "--\r\n");
 
   // Issues a warning if our buffer size estimate was too small.
   if (post_data_->size() > size) {
     LOG(WARNING)
         << "Reallocation needed in POST data buffer. Expected maximum size "
         << size << " bytes, actual size " << post_data_->size() << " bytes.";
   }
@@ skipping 99 matching lines @@
   if (success) {
     state_ = SUCCESS;
     delegate_->OnSuccess();
   } else {
     state_ = ERROR;
     delegate_->OnFailure(SERVER_ERROR);
   }
 }
 
 }  // namespace policy