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

chrome/browser/android/dev_tools_server.cc

 // Copyright (c) 2012 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/android/dev_tools_server.h"
 
 #include <pwd.h>
 #include <cstring>
+#include <utility>
 
 #include "base/android/context_utils.h"
 #include "base/android/jni_string.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 129 matching lines @@
         auth_callback_(auth_callback) {
   }
 
  private:
   scoped_ptr<net::ServerSocket> CreateForHttpServer() override {
     scoped_ptr<net::ServerSocket> socket(
         new net::UnixDomainServerSocket(auth_callback_,
                                         true /* use_abstract_namespace */));
 
     if (socket->ListenWithAddressAndPort(socket_name_, 0, kBackLog) == net::OK)
-      return socket.Pass();
+      return socket;
 
     // Try a fallback socket name.
     const std::string fallback_address(
         base::StringPrintf("%s_%d", socket_name_.c_str(), getpid()));
     if (socket->ListenWithAddressAndPort(fallback_address, 0, kBackLog)
         == net::OK)
-      return socket.Pass();
+      return socket;
 
     return scoped_ptr<net::ServerSocket>();
   }
 
   scoped_ptr<net::ServerSocket> CreateForTethering(std::string* name) override {
     *name = base::StringPrintf(
         kTetheringSocketName, getpid(), ++last_tethering_socket_);
-    scoped_ptr<net::UnixDomainServerSocket> socket(
+    scoped_ptr<net::ServerSocket> socket(
         new net::UnixDomainServerSocket(auth_callback_, true));
     if (socket->ListenWithAddressAndPort(*name, 0, kBackLog) != net::OK)
       return scoped_ptr<net::ServerSocket>();
 
-    return socket.Pass();
+    return socket;
   }
 
   std::string socket_name_;
   int last_tethering_socket_;
   net::UnixDomainServerSocket::AuthCallback auth_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(UnixDomainServerSocketFactory);
 };
 
 }  // namespace
@@ skipping 18 matching lines @@
   if (devtools_http_handler_)
     return;
 
   net::UnixDomainServerSocket::AuthCallback auth_callback =
       allow_debug_permission ?
           base::Bind(&AuthorizeSocketAccessWithDebugPermission) :
           base::Bind(&content::CanUserConnectToDevTools);
   scoped_ptr<DevToolsHttpHandler::ServerSocketFactory> factory(
       new UnixDomainServerSocketFactory(socket_name_, auth_callback));
   devtools_http_handler_.reset(new DevToolsHttpHandler(
-      factory.Pass(),
+      std::move(factory),
       base::StringPrintf(kFrontEndURL, content::GetWebKitRevision().c_str()),
-      new DevToolsServerDelegate(),
-      base::FilePath(),
-      base::FilePath(),
-      version_info::GetProductNameAndVersionForUserAgent(),
-      ::GetUserAgent()));
+      new DevToolsServerDelegate(), base::FilePath(), base::FilePath(),
+      version_info::GetProductNameAndVersionForUserAgent(), ::GetUserAgent()));
 }
 
 void DevToolsServer::Stop() {
   devtools_http_handler_.reset();
 }
 
 bool DevToolsServer::IsStarted() const {
   return devtools_http_handler_;
 }
 
@@ skipping 27 matching lines @@
                                       jlong server,
                                       jboolean enabled,
                                       jboolean allow_debug_permission) {
   DevToolsServer* devtools_server = reinterpret_cast<DevToolsServer*>(server);
   if (enabled) {
     devtools_server->Start(allow_debug_permission);
   } else {
     devtools_server->Stop();
   }
 }