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

chrome/browser/devtools/device/android_device_manager.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/android_device_manager.h"
 
 #include <stddef.h>
 #include <string.h>
+#include <utility>
 
 #include "base/location.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/socket/stream_socket.h"
 
@@ skipping 51 matching lines @@
   typedef AndroidDeviceManager::HttpUpgradeCallback HttpUpgradeCallback;
 
   static void CommandRequest(const std::string& request,
                              const CommandCallback& callback,
                              int result,
                              scoped_ptr<net::StreamSocket> socket) {
     if (result != net::OK) {
       callback.Run(result, std::string());
       return;
     }
-    new HttpRequest(socket.Pass(), request, callback);
+    new HttpRequest(std::move(socket), request, callback);
   }
 
   static void HttpUpgradeRequest(const std::string& request,
                                  const HttpUpgradeCallback& callback,
                                  int result,
                                  scoped_ptr<net::StreamSocket> socket) {
     if (result != net::OK) {
       callback.Run(
           result, std::string(), std::string(),
           make_scoped_ptr<net::StreamSocket>(nullptr));
       return;
     }
-    new HttpRequest(socket.Pass(), request, callback);
+    new HttpRequest(std::move(socket), request, callback);
   }
 
  private:
   HttpRequest(scoped_ptr<net::StreamSocket> socket,
               const std::string& request,
               const CommandCallback& callback)
-      : socket_(socket.Pass()),
+      : socket_(std::move(socket)),
         command_callback_(callback),
         expected_size_(-1),
         header_size_(0) {
     SendRequest(request);
   }
 
   HttpRequest(scoped_ptr<net::StreamSocket> socket,
               const std::string& request,
               const HttpUpgradeCallback& callback)
-    : socket_(socket.Pass()),
-      http_upgrade_callback_(callback),
-      expected_size_(-1),
-      header_size_(0) {
+      : socket_(std::move(socket)),
+        http_upgrade_callback_(callback),
+        expected_size_(-1),
+        header_size_(0) {
     SendRequest(request);
   }
 
   ~HttpRequest() {
   }
 
   void DoSendRequest(int result) {
     while (result != net::ERR_IO_PENDING) {
       if (!CheckNetResultOrDie(result))
         return;
@@ skipping 68 matching lines @@
     // WebSocket handshake doesn't contain the Content-Length. For this case,
     // |expected_size_| is set to the size of the header (handshake).
     // Some WebSocket frames can be already received into |response_|.
     if (static_cast<int>(response_.length()) >= expected_size_) {
       const std::string& body = response_.substr(header_size_);
       if (!command_callback_.is_null()) {
         command_callback_.Run(net::OK, body);
       } else {
         // Pass the WebSocket frames (in |body|), too.
         http_upgrade_callback_.Run(net::OK,
-            ExtractHeader("Sec-WebSocket-Extensions:"), body, socket_.Pass());
+                                   ExtractHeader("Sec-WebSocket-Extensions:"),
+                                   body, std::move(socket_));
       }
       delete this;
       return;
     }
 
     result = socket_->Read(
         response_buffer_.get(),
         kBufferSize,
         base::Bind(&HttpRequest::OnResponseData, base::Unretained(this)));
     if (result != net::ERR_IO_PENDING)
@@ skipping 327 matching lines @@
           new Device(handler_thread_->message_loop(), it->provider, it->serial);
     } else {
       device = found->second.get();
     }
     response.push_back(device);
     new_devices[it->serial] = device->weak_factory_.GetWeakPtr();
   }
   devices_.swap(new_devices);
   callback.Run(response);
 }