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

chrome/browser/devtools/device/port_forwarding_controller.cc

 // Copyright 2014 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/devtools/device/port_forwarding_controller.h"
 
 #include <map>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
@@ skipping 29 matching lines @@
 
 static const char kDevToolsRemoteBrowserTarget[] = "/devtools/browser";
 
 class SocketTunnel : public base::NonThreadSafe {
  public:
   static void StartTunnel(const std::string& host,
                           int port,
                           int result,
                           scoped_ptr<net::StreamSocket> socket) {
     if (result == net::OK)
-      new SocketTunnel(socket.Pass(), host, port);
+      new SocketTunnel(std::move(socket), host, port);
   }
 
  private:
   SocketTunnel(scoped_ptr<net::StreamSocket> socket,
                const std::string& host,
                int port)
-      : remote_socket_(socket.Pass()),
+      : remote_socket_(std::move(socket)),
         pending_writes_(0),
         pending_destruction_(false) {
     host_resolver_ = net::HostResolver::CreateDefaultResolver(nullptr);
     net::HostResolver::RequestInfo request_info(net::HostPortPair(host, port));
     int result = host_resolver_->Resolve(
         request_info,
         net::DEFAULT_PRIORITY,
         &address_list_,
         base::Bind(&SocketTunnel::OnResolved, base::Unretained(this)),
         nullptr,
@@ skipping 254 matching lines @@
 
     pending_responses_[id] =
         base::Bind(&Connection::ProcessUnbindResponse,
                    base::Unretained(this), port);
 #if defined(DEBUG_DEVTOOLS)
     port_status_[port] = kStatusDisconnecting;
 #endif  // defined(DEBUG_DEVTOOLS)
   }
 
   web_socket_->SendFrame(
-      DevToolsProtocol::SerializeCommand(id, method, params.Pass()));
+      DevToolsProtocol::SerializeCommand(id, method, std::move(params)));
 }
 
 bool PortForwardingController::Connection::ProcessResponse(
     const std::string& message) {
   int id = 0;
   int error_code = 0;
   if (!DevToolsProtocol::ParseResponse(message, &id, &error_code))
     return false;
 
   CommandCallbackMap::iterator it = pending_responses_.find(id);
@@ skipping 142 matching lines @@
       registry_copy.push_back(it->second);
     }
     STLDeleteElements(&registry_copy);
   }
 }
 
 void PortForwardingController::UpdateConnections() {
   for (Registry::iterator it = registry_.begin(); it != registry_.end(); ++it)
     it->second->UpdateForwardingMap(forwarding_map_);
 }