Convert Pass()→std::move() in //chrome/browser/chromeos/policy

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 <set>
+#include <utility>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/rand_util.h"
 #include "base/strings/stringprintf.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_request_status.h"
 
@@ skipping 89 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(DataSegment);
 };
 
 DataSegment::DataSegment(
     const std::string& name,
     const std::string& filename,
     scoped_ptr<std::string> data,
     const std::map<std::string, std::string>& header_entries)
     : name_(name),
       filename_(filename),
-      data_(data.Pass()),
+      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() {
-  return data_.Pass();
+  return std::move(data_);
 }
 
 bool DataSegment::CheckIfDataContains(const std::string& chunk) {
   DCHECK(data_);
   return data_->find(chunk) != std::string::npos;
 }
 
 size_t DataSegment::GetDataSize() const {
   DCHECK(data_);
   return data_->size();
@@ skipping 19 matching lines @@
     OAuth2TokenService* token_service,
     scoped_refptr<net::URLRequestContextGetter> url_context_getter,
     Delegate* delegate,
     scoped_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_(boundary_generator.Pass()),
+      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) {
   // Cannot add data to busy or failed instance.
   DCHECK_EQ(IDLE, state_);
   if (state_ != IDLE)
     return;
 
   scoped_ptr<DataSegment> data_segment(
-      new DataSegment(name, filename, data.Pass(), header_entries));
-  data_segments_.push_back(data_segment.Pass());
+      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 189 matching lines @@
   if (success) {
     state_ = SUCCESS;
     delegate_->OnSuccess();
   } else {
     state_ = ERROR;
     delegate_->OnFailure(SERVER_ERROR);
   }
 }
 
 }  // namespace policy