Remove needless move() calls in cloud_print/gcp20

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>
 
@@ skipping 17 matching lines @@
 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 std::move(error);
+  return 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 std::move(error);
+  return 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 std::move(error);
+  return 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 204 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 std::move(response);
+  return 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 78 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 std::move(response);
+      return 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 std::move(response);
+  return 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 std::move(response);
+  return 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();
   };
 }