Global conversion of Pass()→std::move() on OS=linux chromecast=1

cloud_print/gcp20/prototype/privet_http_server.cc

 // Copyright 2013 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 "cloud_print/gcp20/prototype/privet_http_server.h"
 
 #include <stddef.h>
 #include <stdint.h>
+#include <utility>
 
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/strings/stringprintf.h"
 #include "cloud_print/gcp20/prototype/gcp20_switches.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/url_util.h"
 #include "net/socket/tcp_server_socket.h"
 #include "url/gurl.h"
 
 namespace {
 
 const int kDeviceBusyTimeout = 30;  // in seconds
 const int kPendingUserActionTimeout = 5;  // in seconds
 
 const char kPrivetInfo[] = "/privet/info";
 const char kPrivetRegister[] = "/privet/register";
 const char kPrivetCapabilities[] = "/privet/capabilities";
 const char kPrivetPrinterCreateJob[] = "/privet/printer/createjob";
 const char kPrivetPrinterSubmitDoc[] = "/privet/printer/submitdoc";
 const char kPrivetPrinterJobState[] = "/privet/printer/jobstate";
 
 // {"error":|error_type|}
 scoped_ptr<base::DictionaryValue> CreateError(const std::string& error_type) {
   scoped_ptr<base::DictionaryValue> error(new base::DictionaryValue);
   error->SetString("error", error_type);
 
-  return error.Pass();
+  return std::move(error);
 }
 
 // {"error":|error_type|, "description":|description|}
 scoped_ptr<base::DictionaryValue> CreateErrorWithDescription(
     const std::string& error_type,
     const std::string& description) {
   scoped_ptr<base::DictionaryValue> error(CreateError(error_type));
   error->SetString("description", description);
-  return error.Pass();
+  return std::move(error);
 }
 
 // {"error":|error_type|, "timeout":|timeout|}
 scoped_ptr<base::DictionaryValue> CreateErrorWithTimeout(
     const std::string& error_type,
     int timeout) {
   scoped_ptr<base::DictionaryValue> error(CreateError(error_type));
   error->SetInteger("timeout", timeout);
-  return error.Pass();
+  return std::move(error);
 }
 
 // Converts state to string.
 std::string LocalPrintJobStateToString(LocalPrintJob::State state) {
   switch (state) {
     case LocalPrintJob::STATE_DRAFT:
       return "draft";
       break;
     case LocalPrintJob::STATE_ABORTED:
       return "done";
@@ skipping 42 matching lines @@
 bool PrivetHttpServer::Start(uint16_t port) {
   if (server_)
     return true;
 
   scoped_ptr<net::ServerSocket> server_socket(
       new net::TCPServerSocket(NULL, net::NetLog::Source()));
   std::string listen_address = "::";
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableIpv6))
     listen_address = "0.0.0.0";
   server_socket->ListenWithAddressAndPort(listen_address, port, 1);
-  server_.reset(new net::HttpServer(server_socket.Pass(), this));
+  server_.reset(new net::HttpServer(std::move(server_socket), this));
 
   net::IPEndPoint address;
   if (server_->GetLocalAddress(&address) != net::OK) {
     NOTREACHED() << "Cannot start HTTP server";
     return false;
   }
 
   VLOG(1) << "Address of HTTP server: " << address.ToString();
   return true;
 }
@@ skipping 141 matching lines @@
   for (size_t i = 0; i < info.api.size(); ++i)
     api.AppendString(info.api[i]);
   response->Set("api", api.DeepCopy());
 
   base::ListValue type;
   for (size_t i = 0; i < info.type.size(); ++i)
     type.AppendString(info.type[i]);
   response->Set("type", type.DeepCopy());
 
   *status_code = net::HTTP_OK;
-  return response.Pass();
+  return std::move(response);
 }
 
 scoped_ptr<base::DictionaryValue> PrivetHttpServer::ProcessCapabilities(
     net::HttpStatusCode* status_code) const {
   if (!delegate_->IsRegistered()) {
     *status_code = net::HTTP_NOT_FOUND;
     return scoped_ptr<base::DictionaryValue>();
   }
   return make_scoped_ptr(delegate_->GetCapabilities().DeepCopy());
 }
@@ skipping 18 matching lines @@
       delegate_->CreateJob(body, &job_id, &expires_in,
                            &error_timeout, &error_description);
 
   scoped_ptr<base::DictionaryValue> response;
   *status_code = net::HTTP_OK;
   switch (result) {
     case LocalPrintJob::CREATE_SUCCESS:
       response.reset(new base::DictionaryValue);
       response->SetString("job_id", job_id);
       response->SetInteger("expires_in", expires_in);
-      return response.Pass();
+      return std::move(response);
 
     case LocalPrintJob::CREATE_INVALID_TICKET:
       return CreateError("invalid_ticket");
     case LocalPrintJob::CREATE_PRINTER_BUSY:
       return CreateErrorWithTimeout("printer_busy", error_timeout);
     case LocalPrintJob::CREATE_PRINTER_ERROR:
       return CreateErrorWithDescription("printer_error", error_description);
   }
   return scoped_ptr<base::DictionaryValue>();
 }
@@ skipping 39 matching lines @@
   switch (status) {
     case LocalPrintJob::SAVE_SUCCESS:
       response->SetString("job_id", job_id);
       response->SetInteger("expires_in", expires_in);
       response->SetString("job_type", job.content_type);
       response->SetString(
           "job_size",
           base::StringPrintf("%u", static_cast<uint32_t>(job.content.size())));
       if (job_name_present)
         response->SetString("job_name", job.job_name);
-      return response.Pass();
+      return std::move(response);
 
     case LocalPrintJob::SAVE_INVALID_PRINT_JOB:
       return CreateErrorWithTimeout("invalid_print_job", timeout);
     case LocalPrintJob::SAVE_INVALID_DOCUMENT_TYPE:
       return CreateError("invalid_document_type");
     case LocalPrintJob::SAVE_INVALID_DOCUMENT:
       return CreateError("invalid_document");
     case LocalPrintJob::SAVE_DOCUMENT_TOO_LARGE:
       return CreateError("document_too_large");
     case LocalPrintJob::SAVE_PRINTER_BUSY:
@@ skipping 17 matching lines @@
   std::string job_id;
   net::GetValueForKeyInQuery(url, "job_id", &job_id);
   LocalPrintJob::Info info;
   if (!delegate_->GetJobState(job_id, &info))
     return CreateError("invalid_print_job");
 
   scoped_ptr<base::DictionaryValue> response(new base::DictionaryValue);
   response->SetString("job_id", job_id);
   response->SetString("state", LocalPrintJobStateToString(info.state));
   response->SetInteger("expires_in", info.expires_in);
-  return response.Pass();
+  return std::move(response);
 }
 
 scoped_ptr<base::DictionaryValue> PrivetHttpServer::ProcessRegister(
     const GURL& url,
     net::HttpStatusCode* status_code) const {
   if (delegate_->IsRegistered()) {
     *status_code = net::HTTP_NOT_FOUND;
     return scoped_ptr<base::DictionaryValue>();
   }
 
@@ skipping 30 matching lines @@
 
     if (action == "cancel")
       status = delegate_->RegistrationCancel(user);
   }
 
   if (status != REG_ERROR_OK)
     response.reset();
 
   ProcessRegistrationStatus(status, &response);
   *status_code = net::HTTP_OK;
-  return response.Pass();
+  return std::move(response);
 }
 
 void PrivetHttpServer::ProcessRegistrationStatus(
     RegistrationErrorStatus status,
     scoped_ptr<base::DictionaryValue>* current_response) const {
   switch (status) {
     case REG_ERROR_OK:
       DCHECK(*current_response) << "Response shouldn't be empty.";
       break;
 
@@ skipping 26 matching lines @@
       delegate_->GetRegistrationServerError(&description);
       *current_response = CreateErrorWithDescription("server_error",
                                                      description);
       break;
     }
 
     default:
       NOTREACHED();
   };
 }