Convert Pass()→std::move() in //chrome

chrome/test/chromedriver/server/http_handler.cc

 // Copyright (c) 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 "chrome/test/chromedriver/server/http_handler.h"
 
 #include <stddef.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"  // For CHECK macros.
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_split.h"
@@ skipping 60 matching lines @@
       url_base_(url_base),
       received_shutdown_(false),
       weak_ptr_factory_(this) {
 #if defined(OS_MACOSX)
   base::mac::ScopedNSAutoreleasePool autorelease_pool;
 #endif
   context_getter_ = new URLRequestContextGetter(io_task_runner);
   socket_factory_ = CreateSyncWebSocketFactory(context_getter_.get());
   adb_.reset(new AdbImpl(io_task_runner, adb_port));
   device_manager_.reset(new DeviceManager(adb_.get()));
-  port_server_ = port_server.Pass();
+  port_server_ = std::move(port_server);
   port_manager_.reset(new PortManager(12000, 13000));
 
   CommandMapping commands[] = {
       CommandMapping(
           kPost,
           internal::kNewSessionPathPattern,
           base::Bind(&ExecuteCreateSession,
                      &session_thread_map_,
                      WrapToCommand(
                          "InitSession",
@@ skipping 484 matching lines @@
   CHECK(thread_checker_.CalledOnValidThread());
 
   if (received_shutdown_)
     return;
 
   std::string path = request.path;
   if (!base::StartsWith(path, url_base_, base::CompareCase::SENSITIVE)) {
     scoped_ptr<net::HttpServerResponseInfo> response(
         new net::HttpServerResponseInfo(net::HTTP_BAD_REQUEST));
     response->SetBody("unhandled request", "text/plain");
-    send_response_func.Run(response.Pass());
+    send_response_func.Run(std::move(response));
     return;
   }
 
   path.erase(0, url_base_.length());
 
   HandleCommand(request, path, send_response_func);
 
   if (path == kShutdownPath)
     received_shutdown_ = true;
 }
@@ skipping 26 matching lines @@
     const std::string& trimmed_path,
     const HttpResponseSenderFunc& send_response_func) {
   base::DictionaryValue params;
   std::string session_id;
   CommandMap::const_iterator iter = command_map_->begin();
   while (true) {
     if (iter == command_map_->end()) {
       scoped_ptr<net::HttpServerResponseInfo> response(
           new net::HttpServerResponseInfo(net::HTTP_NOT_FOUND));
       response->SetBody("unknown command: " + trimmed_path, "text/plain");
-      send_response_func.Run(response.Pass());
+      send_response_func.Run(std::move(response));
       return;
     }
     if (internal::MatchesCommand(
             request.method, trimmed_path, *iter, &session_id, &params)) {
       break;
     }
     ++iter;
   }
 
   if (request.data.length()) {
     base::DictionaryValue* body_params;
     scoped_ptr<base::Value> parsed_body = base::JSONReader::Read(request.data);
     if (!parsed_body || !parsed_body->GetAsDictionary(&body_params)) {
       scoped_ptr<net::HttpServerResponseInfo> response(
           new net::HttpServerResponseInfo(net::HTTP_BAD_REQUEST));
       response->SetBody("missing command parameters", "text/plain");
-      send_response_func.Run(response.Pass());
+      send_response_func.Run(std::move(response));
       return;
     }
     params.MergeDictionary(body_params);
   }
 
   iter->command.Run(params,
                     session_id,
                     base::Bind(&HttpHandler::PrepareResponse,
                                weak_ptr_factory_.GetWeakPtr(),
                                trimmed_path,
                                send_response_func));
 }
 
 void HttpHandler::PrepareResponse(
     const std::string& trimmed_path,
     const HttpResponseSenderFunc& send_response_func,
     const Status& status,
     scoped_ptr<base::Value> value,
     const std::string& session_id) {
   CHECK(thread_checker_.CalledOnValidThread());
   scoped_ptr<net::HttpServerResponseInfo> response =
-      PrepareResponseHelper(trimmed_path, status, value.Pass(), session_id);
-  send_response_func.Run(response.Pass());
+      PrepareResponseHelper(trimmed_path, status, std::move(value), session_id);
+  send_response_func.Run(std::move(response));
   if (trimmed_path == kShutdownPath)
     quit_func_.Run();
 }
 
 scoped_ptr<net::HttpServerResponseInfo> HttpHandler::PrepareResponseHelper(
     const std::string& trimmed_path,
     const Status& status,
     scoped_ptr<base::Value> value,
     const std::string& session_id) {
   if (status.code() == kUnknownCommand) {
     scoped_ptr<net::HttpServerResponseInfo> response(
         new net::HttpServerResponseInfo(net::HTTP_NOT_IMPLEMENTED));
     response->SetBody("unimplemented command: " + trimmed_path, "text/plain");
-    return response.Pass();
+    return response;
   }
 
   if (status.IsError()) {
     Status full_status(status);
     full_status.AddDetails(base::StringPrintf(
         "Driver info: chromedriver=%s,platform=%s %s %s",
         kChromeDriverVersion,
         base::SysInfo::OperatingSystemName().c_str(),
         base::SysInfo::OperatingSystemVersion().c_str(),
         base::SysInfo::OperatingSystemArchitecture().c_str()));
     scoped_ptr<base::DictionaryValue> error(new base::DictionaryValue());
     error->SetString("message", full_status.message());
     value.reset(error.release());
   }
   if (!value)
     value = base::Value::CreateNullValue();
 
   base::DictionaryValue body_params;
   body_params.SetInteger("status", status.code());
   body_params.Set("value", value.release());
   body_params.SetString("sessionId", session_id);
   std::string body;
   base::JSONWriter::WriteWithOptions(
       body_params, base::JSONWriter::OPTIONS_OMIT_DOUBLE_TYPE_PRESERVATION,
       &body);
   scoped_ptr<net::HttpServerResponseInfo> response(
       new net::HttpServerResponseInfo(net::HTTP_OK));
   response->SetBody(body, "application/json; charset=utf-8");
-  return response.Pass();
+  return response;
 }
 
 namespace internal {
 
 const char kNewSessionPathPattern[] = "session";
 
 bool MatchesMethod(HttpMethod command_method, const std::string& method) {
   std::string lower_method = base::ToLowerASCII(method);
   switch (command_method) {
     case kGet:
@@ skipping 43 matching lines @@
         params.SetString(name, decoded);
     } else if (command_path_parts[i] != path_parts[i]) {
       return false;
     }
   }
   out_params->MergeDictionary(&params);
   return true;
 }
 
 }  // namespace internal