Convert Pass()→std::move() in //mojo/services

BUG=557422
R=avi@chromium.org
TBR=ben@chromium.org

Review URL: https://codereview.chromium.org/1539863002

Cr-Commit-Position: refs/heads/master@{#366165}

32 files changed, 293 insertions, 253 deletions

diff --git a/mojo/services/network/cookie_store_impl.cc b/mojo/services/network/cookie_store_impl.cc
index b921ddc..acee535 100644
--- a/mojo/services/network/cookie_store_impl.cc
+++ b/mojo/services/network/cookie_store_impl.cc
@@ -4,6 +4,8 @@
 
 #include "mojo/services/network/cookie_store_impl.h"
 
+#include <utility>
+
 #include "mojo/common/url_type_converters.h"
 #include "mojo/services/network/network_context.h"
 #include "net/cookies/cookie_store.h"
@@ -24,16 +26,14 @@ void AdaptSetCookieCallback(const Callback<void(bool)>& callback,
 
 }  // namespace
 
-CookieStoreImpl::CookieStoreImpl(
-    NetworkContext* context,
-    const GURL& origin,
-    scoped_ptr<mojo::AppRefCount> app_refcount,
-    InterfaceRequest<CookieStore> request)
+CookieStoreImpl::CookieStoreImpl(NetworkContext* context,
+                                 const GURL& origin,
+                                 scoped_ptr<mojo::AppRefCount> app_refcount,
+                                 InterfaceRequest<CookieStore> request)
     : context_(context),
       origin_(origin),
-      app_refcount_(app_refcount.Pass()),
-      binding_(this, request.Pass()) {
-}
+      app_refcount_(std::move(app_refcount)),
+      binding_(this, std::move(request)) {}
 
 CookieStoreImpl::~CookieStoreImpl() {
 }
diff --git a/mojo/services/network/http_connection_impl.cc b/mojo/services/network/http_connection_impl.cc
index 2d23f5f..d94034e 100644
--- a/mojo/services/network/http_connection_impl.cc
+++ b/mojo/services/network/http_connection_impl.cc
@@ -5,6 +5,7 @@
 #include "mojo/services/network/http_connection_impl.h"
 
 #include <limits>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ -42,7 +43,7 @@ class HttpConnectionImpl::SimpleDataPipeReader {
   void Start(ScopedDataPipeConsumerHandle consumer,
              const CompletionCallback& completion_callback) {
     DCHECK(consumer.is_valid() && !consumer_.is_valid());
-    consumer_ = consumer.Pass();
+    consumer_ = std::move(consumer);
     completion_callback_ = completion_callback;
     buffer_.reset(new std::string);
     ReadMore();
@@ -62,7 +63,7 @@ class HttpConnectionImpl::SimpleDataPipeReader {
       WaitToReadMore();
     } else if (rv == MOJO_RESULT_FAILED_PRECONDITION) {
       // We reached end-of-file.
-      completion_callback_.Run(this, buffer_.Pass());
+      completion_callback_.Run(this, std::move(buffer_));
       // Note: This object may have been destroyed in the callback.
     } else {
       CHECK(false);
@@ -94,9 +95,9 @@ class HttpConnectionImpl::WebSocketImpl : public WebSocket {
                 ScopedDataPipeConsumerHandle send_stream,
                 WebSocketClientPtr client)
       : connection_(connection),
-        binding_(this, request.Pass()),
-        client_(client.Pass()),
-        send_stream_(send_stream.Pass()),
+        binding_(this, std::move(request)),
+        client_(std::move(client)),
+        send_stream_(std::move(send_stream)),
         read_send_stream_(new WebSocketReadQueue(send_stream_.get())),
         pending_send_count_(0) {
     DCHECK(binding_.is_bound());
@@ -107,10 +108,10 @@ class HttpConnectionImpl::WebSocketImpl : public WebSocket {
     client_.set_connection_error_handler([this]() { Close(); });
 
     DataPipe data_pipe;
-    receive_stream_ = data_pipe.producer_handle.Pass();
+    receive_stream_ = std::move(data_pipe.producer_handle);
     write_receive_stream_.reset(new WebSocketWriteQueue(receive_stream_.get()));
 
-    client_->DidConnect("", "", data_pipe.consumer_handle.Pass());
+    client_->DidConnect("", "", std::move(data_pipe.consumer_handle));
   }
 
   ~WebSocketImpl() override {}
@@ -231,7 +232,7 @@ struct TypeConverter<HttpRequestPtr, net::HttpServerRequestInfo> {
       HttpHeaderPtr header(HttpHeader::New());
       header->name = item.first;
       header->value = item.second;
-      request->headers[index++] = header.Pass();
+      request->headers[index++] = std::move(header);
     }
     if (!obj.data.empty()) {
       uint32_t num_bytes = static_cast<uint32_t>(obj.data.size());
@@ -241,13 +242,13 @@ struct TypeConverter<HttpRequestPtr, net::HttpServerRequestInfo> {
       options.element_num_bytes = 1;
       options.capacity_num_bytes = num_bytes;
       DataPipe data_pipe(options);
-      request->body = data_pipe.consumer_handle.Pass();
+      request->body = std::move(data_pipe.consumer_handle);
       MojoResult result =
           WriteDataRaw(data_pipe.producer_handle.get(), obj.data.data(),
                        &num_bytes, MOJO_WRITE_DATA_FLAG_ALL_OR_NONE);
       CHECK_EQ(MOJO_RESULT_OK, result);
     }
-    return request.Pass();
+    return request;
   }
 };
 
@@ -257,7 +258,7 @@ HttpConnectionImpl::HttpConnectionImpl(int connection_id,
                                        HttpConnectionPtr* connection)
     : connection_id_(connection_id),
       server_(server),
-      delegate_(delegate.Pass()),
+      delegate_(std::move(delegate)),
       binding_(this, connection) {
   DCHECK(delegate_);
   binding_.set_connection_error_handler([this]() { Close(); });
@@ -278,13 +279,13 @@ void HttpConnectionImpl::OnReceivedHttpRequest(
         if (response->body.is_valid()) {
           SimpleDataPipeReader* reader = new SimpleDataPipeReader;
           response_body_readers_.insert(reader);
-          ScopedDataPipeConsumerHandle body = response->body.Pass();
+          ScopedDataPipeConsumerHandle body = std::move(response->body);
           reader->Start(
-              body.Pass(),
+              std::move(body),
               base::Bind(&HttpConnectionImpl::OnFinishedReadingResponseBody,
                          base::Unretained(this), base::Passed(&response)));
         } else {
-          OnFinishedReadingResponseBody(response.Pass(), nullptr, nullptr);
+          OnFinishedReadingResponseBody(std::move(response), nullptr, nullptr);
         }
       });
 }
@@ -305,9 +306,9 @@ void HttpConnectionImpl::OnReceivedWebSocketRequest(
           return;
         }
 
-        web_socket_.reset(new WebSocketImpl(this, web_socket.Pass(),
-                                            send_stream.Pass(),
-                                            web_socket_client.Pass()));
+        web_socket_.reset(new WebSocketImpl(this, std::move(web_socket),
+                                            std::move(send_stream),
+                                            std::move(web_socket_client)));
         server_->server()->AcceptWebSocket(connection_id_, info);
       });
 }
diff --git a/mojo/services/network/http_server_apptest.cc b/mojo/services/network/http_server_apptest.cc
index ae04031..6e5f2bc 100644
--- a/mojo/services/network/http_server_apptest.cc
+++ b/mojo/services/network/http_server_apptest.cc
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <utility>
+
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
@@ -48,7 +50,7 @@ NetAddressPtr GetLocalHostWithAnyPort() {
   addr->ipv4->addr[2] = 0;
   addr->ipv4->addr[3] = 1;
 
-  return addr.Pass();
+  return addr;
 }
 
 using TestHeaders = std::vector<std::pair<std::string, std::string>>;
@@ -86,7 +88,7 @@ HttpResponsePtr MakeResponseStruct(const TestResponse& data) {
     HttpHeaderPtr header(HttpHeader::New());
     header->name = item.first;
     header->value = item.second;
-    response->headers[index++] = header.Pass();
+    response->headers[index++] = std::move(header);
   }
 
   if (data.body) {
@@ -97,14 +99,14 @@ HttpResponsePtr MakeResponseStruct(const TestResponse& data) {
     options.element_num_bytes = 1;
     options.capacity_num_bytes = num_bytes;
     DataPipe data_pipe(options);
-    response->body = data_pipe.consumer_handle.Pass();
+    response->body = std::move(data_pipe.consumer_handle);
     MojoResult result =
         WriteDataRaw(data_pipe.producer_handle.get(), data.body->data(),
                      &num_bytes, MOJO_WRITE_DATA_FLAG_ALL_OR_NONE);
     EXPECT_EQ(MOJO_RESULT_OK, result);
   }
 
-  return response.Pass();
+  return response;
 }
 
 void CheckHeaders(const TestHeaders& expected,
@@ -132,7 +134,7 @@ void CheckRequest(const TestRequest& expected, HttpRequestPtr request) {
   if (expected.body) {
     EXPECT_TRUE(request->body.is_valid());
     std::string body;
-    common::BlockingCopyToString(request->body.Pass(), &body);
+    common::BlockingCopyToString(std::move(request->body), &body);
     EXPECT_EQ(*expected.body, body);
   } else {
     EXPECT_FALSE(request->body.is_valid());
@@ -280,14 +282,15 @@ class WebSocketClientImpl : public WebSocketClient {
 
   // Establishes a connection from the client side.
   void Connect(WebSocketPtr web_socket, const std::string& url) {
-    web_socket_ = web_socket.Pass();
+    web_socket_ = std::move(web_socket);
 
     DataPipe data_pipe;
-    send_stream_ = data_pipe.producer_handle.Pass();
+    send_stream_ = std::move(data_pipe.producer_handle);
     write_send_stream_.reset(new WebSocketWriteQueue(send_stream_.get()));
 
     web_socket_->Connect(url, Array<String>(0), "http://example.com",
-                         data_pipe.consumer_handle.Pass(), client_ptr_.Pass());
+                         std::move(data_pipe.consumer_handle),
+                         std::move(client_ptr_));
   }
 
   // Establishes a connection from the server side.
@@ -297,11 +300,11 @@ class WebSocketClientImpl : public WebSocketClient {
     InterfaceRequest<WebSocket> web_socket_request = GetProxy(&web_socket_);
 
     DataPipe data_pipe;
-    send_stream_ = data_pipe.producer_handle.Pass();
+    send_stream_ = std::move(data_pipe.producer_handle);
     write_send_stream_.reset(new WebSocketWriteQueue(send_stream_.get()));
 
-    callback.Run(web_socket_request.Pass(), data_pipe.consumer_handle.Pass(),
-                 client_ptr_.Pass());
+    callback.Run(std::move(web_socket_request),
+                 std::move(data_pipe.consumer_handle), std::move(client_ptr_));
   }
 
   void WaitForConnectCompletion() {
@@ -345,7 +348,7 @@ class WebSocketClientImpl : public WebSocketClient {
   void DidConnect(const String& selected_subprotocol,
                   const String& extensions,
                   ScopedDataPipeConsumerHandle receive_stream) override {
-    receive_stream_ = receive_stream.Pass();
+    receive_stream_ = std::move(receive_stream);
     read_receive_stream_.reset(new WebSocketReadQueue(receive_stream_.get()));
 
     web_socket_->FlowControl(2048);
@@ -414,8 +417,8 @@ class HttpConnectionDelegateImpl : public HttpConnectionDelegate {
 
   HttpConnectionDelegateImpl(HttpConnectionPtr connection,
                              InterfaceRequest<HttpConnectionDelegate> request)
-      : connection_(connection.Pass()),
-        binding_(this, request.Pass()),
+      : connection_(std::move(connection)),
+        binding_(this, std::move(request)),
         wait_for_request_count_(0),
         run_loop_(nullptr) {}
   ~HttpConnectionDelegateImpl() override {}
@@ -424,7 +427,7 @@ class HttpConnectionDelegateImpl : public HttpConnectionDelegate {
   void OnReceivedRequest(HttpRequestPtr request,
                          const OnReceivedRequestCallback& callback) override {
     linked_ptr<PendingRequest> pending_request(new PendingRequest);
-    pending_request->request = request.Pass();
+    pending_request->request = std::move(request);
     pending_request->callback = callback;
     pending_requests_.push_back(pending_request);
     if (run_loop_ && pending_requests_.size() >= wait_for_request_count_) {
@@ -448,7 +451,7 @@ class HttpConnectionDelegateImpl : public HttpConnectionDelegate {
     ASSERT_FALSE(pending_requests_.empty());
     linked_ptr<PendingRequest> request = pending_requests_[0];
     pending_requests_.erase(pending_requests_.begin());
-    request->callback.Run(response.Pass());
+    request->callback.Run(std::move(response));
   }
 
   void WaitForRequest(size_t count) {
@@ -506,8 +509,8 @@ class HttpServerDelegateImpl : public HttpServerDelegate {
   // HttpServerDelegate implementation.
   void OnConnected(HttpConnectionPtr connection,
                    InterfaceRequest<HttpConnectionDelegate> delegate) override {
-    connections_.push_back(make_linked_ptr(
-        new HttpConnectionDelegateImpl(connection.Pass(), delegate.Pass())));
+    connections_.push_back(make_linked_ptr(new HttpConnectionDelegateImpl(
+        std::move(connection), std::move(delegate))));
     if (run_loop_ && connections_.size() >= wait_for_connection_count_) {
       wait_for_connection_count_ = 0;
       run_loop_->Quit();
@@ -561,11 +564,11 @@ class HttpServerAppTest : public test::ApplicationTestBase {
   void CreateHttpServer(HttpServerDelegatePtr delegate,
                         NetAddressPtr* out_bound_to) {
     network_service_->CreateHttpServer(
-        GetLocalHostWithAnyPort(), delegate.Pass(),
+        GetLocalHostWithAnyPort(), std::move(delegate),
         [out_bound_to](NetworkErrorPtr result, NetAddressPtr bound_to) {
           ASSERT_EQ(net::OK, result->code);
           EXPECT_NE(0u, bound_to->ipv4->port);
-          *out_bound_to = bound_to.Pass();
+          *out_bound_to = std::move(bound_to);
         });
     network_service_.WaitForIncomingResponse();
   }
@@ -585,7 +588,7 @@ TEST_F(HttpServerAppTest, BasicHttpRequestResponse) {
   NetAddressPtr bound_to;
   HttpServerDelegatePtr server_delegate_ptr;
   HttpServerDelegateImpl server_delegate_impl(&server_delegate_ptr);
-  CreateHttpServer(server_delegate_ptr.Pass(), &bound_to);
+  CreateHttpServer(std::move(server_delegate_ptr), &bound_to);
 
   TestHttpClient client;
   client.Connect(bound_to.To<net::IPEndPoint>());
@@ -599,7 +602,8 @@ TEST_F(HttpServerAppTest, BasicHttpRequestResponse) {
 
   connection.WaitForRequest(1);
 
-  CheckRequest(request_data, connection.pending_requests()[0]->request.Pass());
+  CheckRequest(request_data,
+               std::move(connection.pending_requests()[0]->request));
 
   TestResponse response_data = {200, {{"Content-Length", "4"}}, nullptr};
   connection.SendResponse(MakeResponseStruct(response_data));
@@ -617,7 +621,7 @@ TEST_F(HttpServerAppTest, HttpRequestResponseWithBody) {
   NetAddressPtr bound_to;
   HttpServerDelegatePtr server_delegate_ptr;
   HttpServerDelegateImpl server_delegate_impl(&server_delegate_ptr);
-  CreateHttpServer(server_delegate_ptr.Pass(), &bound_to);
+  CreateHttpServer(std::move(server_delegate_ptr), &bound_to);
 
   TestHttpClient client;
   client.Connect(bound_to.To<net::IPEndPoint>());
@@ -637,7 +641,8 @@ TEST_F(HttpServerAppTest, HttpRequestResponseWithBody) {
 
   connection.WaitForRequest(1);
 
-  CheckRequest(request_data, connection.pending_requests()[0]->request.Pass());
+  CheckRequest(request_data,
+               std::move(connection.pending_requests()[0]->request));
 
   TestResponse response_data = {
       200,
@@ -655,13 +660,13 @@ TEST_F(HttpServerAppTest, WebSocket) {
   NetAddressPtr bound_to;
   HttpServerDelegatePtr server_delegate_ptr;
   HttpServerDelegateImpl server_delegate_impl(&server_delegate_ptr);
-  CreateHttpServer(server_delegate_ptr.Pass(), &bound_to);
+  CreateHttpServer(std::move(server_delegate_ptr), &bound_to);
 
   WebSocketPtr web_socket_ptr;
   web_socket_factory_->CreateWebSocket(GetProxy(&web_socket_ptr));
   WebSocketClientImpl socket_0;
   socket_0.Connect(
-      web_socket_ptr.Pass(),
+      std::move(web_socket_ptr),
       base::StringPrintf("ws://127.0.0.1:%d/hello", bound_to->ipv4->port));
 
   server_delegate_impl.WaitForConnection(1);
diff --git a/mojo/services/network/http_server_impl.cc b/mojo/services/network/http_server_impl.cc
index ada77f3..cc14221 100644
--- a/mojo/services/network/http_server_impl.cc
+++ b/mojo/services/network/http_server_impl.cc
@@ -4,6 +4,8 @@
 
 #include "mojo/services/network/http_server_impl.h"
 
+#include <utility>
+
 #include "base/logging.h"
 #include "mojo/services/network/http_connection_impl.h"
 #include "mojo/services/network/net_adapters.h"
@@ -27,10 +29,10 @@ void HttpServerImpl::Create(
     HttpServerDelegatePtr delegate,
     scoped_ptr<mojo::AppRefCount> app_refcount,
     const Callback<void(NetworkErrorPtr, NetAddressPtr)>& callback) {
-  HttpServerImpl* http_server = new HttpServerImpl(
-      delegate.Pass(), app_refcount.Pass());
+  HttpServerImpl* http_server =
+      new HttpServerImpl(std::move(delegate), std::move(app_refcount));
 
-  int net_error = http_server->Start(local_address.Pass());
+  int net_error = http_server->Start(std::move(local_address));
   if (net_error != net::OK) {
     callback.Run(MakeNetworkError(net_error), nullptr);
     delete http_server;
@@ -39,10 +41,9 @@ void HttpServerImpl::Create(
   callback.Run(MakeNetworkError(net::OK), http_server->GetLocalAddress());
 }
 
-HttpServerImpl::HttpServerImpl(
-    HttpServerDelegatePtr delegate,
-    scoped_ptr<mojo::AppRefCount> app_refcount)
-    : delegate_(delegate.Pass()), app_refcount_(app_refcount.Pass()) {
+HttpServerImpl::HttpServerImpl(HttpServerDelegatePtr delegate,
+                               scoped_ptr<mojo::AppRefCount> app_refcount)
+    : delegate_(std::move(delegate)), app_refcount_(std::move(app_refcount)) {
   DCHECK(delegate_);
   delegate_.set_connection_error_handler([this]() { delete this; });
 }
@@ -59,7 +60,7 @@ int HttpServerImpl::Start(NetAddressPtr local_address) {
   if (net_result != net::OK)
     return net_result;
 
-  server_.reset(new net::HttpServer(socket.Pass(), this));
+  server_.reset(new net::HttpServer(std::move(socket), this));
 
   return net::OK;
 }
@@ -83,13 +84,12 @@ void HttpServerImpl::OnConnect(int connection_id) {
   HttpConnectionDelegatePtr connection_delegate;
   InterfaceRequest<HttpConnectionDelegate> delegate_request =
       GetProxy(&connection_delegate);
-  linked_ptr<HttpConnectionImpl> connection_impl(
-      new HttpConnectionImpl(connection_id, this, connection_delegate.Pass(),
-                             &connection));
+  linked_ptr<HttpConnectionImpl> connection_impl(new HttpConnectionImpl(
+      connection_id, this, std::move(connection_delegate), &connection));
 
   connections_[connection_id] = connection_impl;
 
-  delegate_->OnConnected(connection.Pass(), delegate_request.Pass());
+  delegate_->OnConnected(std::move(connection), std::move(delegate_request));
 }
 
 void HttpServerImpl::OnHttpRequest(int connection_id,
diff --git a/mojo/services/network/net_adapters.cc b/mojo/services/network/net_adapters.cc
index 551481d..8c2a877 100644
--- a/mojo/services/network/net_adapters.cc
+++ b/mojo/services/network/net_adapters.cc
@@ -4,6 +4,8 @@
 
 #include "mojo/services/network/net_adapters.h"
 
+#include <utility>
+
 #include "net/base/net_errors.h"
 
 namespace mojo {
@@ -17,9 +19,7 @@ const uint32_t kMaxBufSize = 64 * 1024;
 NetToMojoPendingBuffer::NetToMojoPendingBuffer(
     ScopedDataPipeProducerHandle handle,
     void* buffer)
-    : handle_(handle.Pass()),
-      buffer_(buffer) {
-}
+    : handle_(std::move(handle)), buffer_(buffer) {}
 
 NetToMojoPendingBuffer::~NetToMojoPendingBuffer() {
   if (handle_.is_valid())
@@ -39,7 +39,7 @@ MojoResult NetToMojoPendingBuffer::BeginWrite(
   if (result == MOJO_RESULT_OK) {
     if (*num_bytes > kMaxBufSize)
       *num_bytes = kMaxBufSize;
-    *pending = new NetToMojoPendingBuffer(handle->Pass(), buf);
+    *pending = new NetToMojoPendingBuffer(std::move(*handle), buf);
   }
   return result;
 }
@@ -48,7 +48,7 @@ ScopedDataPipeProducerHandle NetToMojoPendingBuffer::Complete(
     uint32_t num_bytes) {
   EndWriteDataRaw(handle_.get(), num_bytes);
   buffer_ = NULL;
-  return handle_.Pass();
+  return std::move(handle_);
 }
 
 // -----------------------------------------------------------------------------
@@ -67,9 +67,7 @@ NetToMojoIOBuffer::~NetToMojoIOBuffer() {
 MojoToNetPendingBuffer::MojoToNetPendingBuffer(
     ScopedDataPipeConsumerHandle handle,
     const void* buffer)
-    : handle_(handle.Pass()),
-      buffer_(buffer) {
-}
+    : handle_(std::move(handle)), buffer_(buffer) {}
 
 MojoToNetPendingBuffer::~MojoToNetPendingBuffer() {
 }
@@ -84,7 +82,7 @@ MojoResult MojoToNetPendingBuffer::BeginRead(
   MojoResult result = BeginReadDataRaw(handle->get(), &buffer, num_bytes,
                                        MOJO_READ_DATA_FLAG_NONE);
   if (result == MOJO_RESULT_OK)
-    *pending = new MojoToNetPendingBuffer(handle->Pass(), buffer);
+    *pending = new MojoToNetPendingBuffer(std::move(*handle), buffer);
   return result;
 }
 
@@ -92,7 +90,7 @@ ScopedDataPipeConsumerHandle MojoToNetPendingBuffer::Complete(
     uint32_t num_bytes) {
   EndReadDataRaw(handle_.get(), num_bytes);
   buffer_ = NULL;
-  return handle_.Pass();
+  return std::move(handle_);
 }
 
 // -----------------------------------------------------------------------------
@@ -112,7 +110,7 @@ NetworkErrorPtr MakeNetworkError(int error_code) {
   error->code = error_code;
   if (error_code <= 0)
     error->description = net::ErrorToString(error_code);
-  return error.Pass();
+  return error;
 }
 
 }  // namespace mojo
diff --git a/mojo/services/network/net_address_type_converters.cc b/mojo/services/network/net_address_type_converters.cc
index 31dc9d9..a50f423 100644
--- a/mojo/services/network/net_address_type_converters.cc
+++ b/mojo/services/network/net_address_type_converters.cc
@@ -52,7 +52,7 @@ NetAddressPtr TypeConverter<NetAddressPtr, net::IPEndPoint>::Convert(
       break;
   }
 
-  return net_address.Pass();
+  return net_address;
 }
 
 }  // namespace mojo
diff --git a/mojo/services/network/network_context.cc b/mojo/services/network/network_context.cc
index 3b333fd..39cd87a 100644
--- a/mojo/services/network/network_context.cc
+++ b/mojo/services/network/network_context.cc
@@ -5,6 +5,7 @@
 #include "mojo/services/network/network_context.h"
 
 #include <algorithm>
+#include <utility>
 #include <vector>
 
 #include "base/base_paths.h"
@@ -79,7 +80,7 @@ class NetworkContext::MojoNetLog : public net::NetLog {
       write_to_file_observer_.reset(new net::WriteToFileNetLogObserver());
       write_to_file_observer_->set_capture_mode(
           net::NetLogCaptureMode::IncludeCookiesAndCredentials());
-      write_to_file_observer_->StartObserving(this, file.Pass(), nullptr,
+      write_to_file_observer_->StartObserving(this, std::move(file), nullptr,
                                               nullptr);
     }
   }
@@ -98,7 +99,7 @@ class NetworkContext::MojoNetLog : public net::NetLog {
 NetworkContext::NetworkContext(
     scoped_ptr<net::URLRequestContext> url_request_context)
     : net_log_(new MojoNetLog),
-      url_request_context_(url_request_context.Pass()),
+      url_request_context_(std::move(url_request_context)),
       in_shutdown_(false) {
   url_request_context_->set_net_log(net_log_.get());
 }
@@ -165,10 +166,10 @@ scoped_ptr<net::URLRequestContext> NetworkContext::MakeURLRequestContext(
     scoped_ptr<net::HostResolver> host_resolver(
         net::HostResolver::CreateDefaultResolver(nullptr));
     scoped_ptr<net::MappedHostResolver> remapped_host_resolver(
-        new net::MappedHostResolver(host_resolver.Pass()));
+        new net::MappedHostResolver(std::move(host_resolver)));
     remapped_host_resolver->SetRulesFromString(
         command_line->GetSwitchValueASCII(kHostResolverRules));
-    builder.set_host_resolver(remapped_host_resolver.Pass());
+    builder.set_host_resolver(std::move(remapped_host_resolver));
   }
 
   builder.set_accept_language("en-us,en");
@@ -209,7 +210,7 @@ scoped_ptr<net::URLRequestContext> NetworkContext::MakeURLRequestContext(
         new net::CookieMonster(cookie_store, nullptr), nullptr);
   }
 
-  return builder.Build().Pass();
+  return builder.Build();
 }
 
 }  // namespace mojo
diff --git a/mojo/services/network/network_service_delegate.cc b/mojo/services/network/network_service_delegate.cc
index d5b90db..9eea2f8 100644
--- a/mojo/services/network/network_service_delegate.cc
+++ b/mojo/services/network/network_service_delegate.cc
@@ -4,6 +4,8 @@
 
 #include "mojo/services/network/network_service_delegate.h"
 
+#include <utility>
+
 #include "base/at_exit.h"
 #include "base/base_paths.h"
 #include "base/bind.h"
@@ -32,7 +34,7 @@ class SQLThread : public base::Thread {
  public:
   SQLThread(filesystem::DirectoryPtr directory)
       : base::Thread(kSQLThreadName),
-        directory_info_(directory.PassInterface().Pass()) {
+        directory_info_(directory.PassInterface()) {
     base::Thread::Options options;
     options.message_pump_factory =
         base::Bind(&mojo::common::MessagePumpMojo::Create);
@@ -42,8 +44,8 @@ class SQLThread : public base::Thread {
 
   void Init() override {
     filesystem::DirectoryPtr directory;
-    directory.Bind(directory_info_.Pass());
-    vfs_.reset(new sql::ScopedMojoFilesystemVFS(directory.Pass()));
+    directory.Bind(std::move(directory_info_));
+    vfs_.reset(new sql::ScopedMojoFilesystemVFS(std::move(directory)));
   }
 
   void CleanUp() override {
@@ -100,11 +102,11 @@ void NetworkServiceDelegate::Initialize(ApplicationImpl* app) {
 
   filesystem::FileError error = filesystem::FILE_ERROR_FAILED;
   filesystem::DirectoryPtr directory;
-  files_->OpenFileSystem("origin", GetProxy(&directory), client.Pass(),
+  files_->OpenFileSystem("origin", GetProxy(&directory), std::move(client),
                          Capture(&error));
   files_.WaitForIncomingResponse();
 
-  io_worker_thread_.reset(new SQLThread(directory.Pass()));
+  io_worker_thread_.reset(new SQLThread(std::move(directory)));
 #endif
 
   // TODO(erg): Find everything else that writes to the filesystem and
@@ -157,15 +159,14 @@ void NetworkServiceDelegate::Quit() {
 void NetworkServiceDelegate::Create(ApplicationConnection* connection,
                                     InterfaceRequest<NetworkService> request) {
   new NetworkServiceImpl(app_->app_lifetime_helper()->CreateAppRefCount(),
-                         request.Pass());
+                         std::move(request));
 }
 
 void NetworkServiceDelegate::Create(ApplicationConnection* connection,
                                     InterfaceRequest<CookieStore> request) {
-  new CookieStoreImpl(context_.get(),
-                      GURL(connection->GetRemoteApplicationURL()).GetOrigin(),
-                      app_->app_lifetime_helper()->CreateAppRefCount(),
-                      request.Pass());
+  new CookieStoreImpl(
+      context_.get(), GURL(connection->GetRemoteApplicationURL()).GetOrigin(),
+      app_->app_lifetime_helper()->CreateAppRefCount(), std::move(request));
 }
 
 void NetworkServiceDelegate::Create(
@@ -173,7 +174,7 @@ void NetworkServiceDelegate::Create(
     InterfaceRequest<WebSocketFactory> request) {
   new WebSocketFactoryImpl(context_.get(),
                            app_->app_lifetime_helper()->CreateAppRefCount(),
-                           request.Pass());
+                           std::move(request));
 }
 
 void NetworkServiceDelegate::Create(
@@ -181,7 +182,7 @@ void NetworkServiceDelegate::Create(
     InterfaceRequest<URLLoaderFactory> request) {
   new URLLoaderFactoryImpl(context_.get(),
                            app_->app_lifetime_helper()->CreateAppRefCount(),
-                           request.Pass());
+                           std::move(request));
 }
 
 void NetworkServiceDelegate::OnFileSystemShutdown() {
diff --git a/mojo/services/network/network_service_impl.cc b/mojo/services/network/network_service_impl.cc
index 011afde..cacaf83 100644
--- a/mojo/services/network/network_service_impl.cc
+++ b/mojo/services/network/network_service_impl.cc
@@ -4,6 +4,8 @@
 
 #include "mojo/services/network/network_service_impl.h"
 
+#include <utility>
+
 #include "mojo/services/network/http_server_impl.h"
 #include "mojo/services/network/net_adapters.h"
 #include "mojo/services/network/tcp_bound_socket_impl.h"
@@ -16,9 +18,8 @@ namespace mojo {
 NetworkServiceImpl::NetworkServiceImpl(
     scoped_ptr<mojo::AppRefCount> app_refcount,
     InterfaceRequest<NetworkService> request)
-    : app_refcount_(app_refcount.Pass()),
-      binding_(this, request.Pass()) {
-}
+    : app_refcount_(std::move(app_refcount)),
+      binding_(this, std::move(request)) {}
 
 NetworkServiceImpl::~NetworkServiceImpl() {
 }
@@ -27,16 +28,16 @@ void NetworkServiceImpl::CreateTCPBoundSocket(
     NetAddressPtr local_address,
     InterfaceRequest<TCPBoundSocket> bound_socket,
     const CreateTCPBoundSocketCallback& callback) {
-  scoped_ptr<TCPBoundSocketImpl> bound(new TCPBoundSocketImpl(
-      app_refcount_->Clone(), bound_socket.Pass()));
-  int net_error = bound->Bind(local_address.Pass());
+  scoped_ptr<TCPBoundSocketImpl> bound(
+      new TCPBoundSocketImpl(app_refcount_->Clone(), std::move(bound_socket)));
+  int net_error = bound->Bind(std::move(local_address));
   if (net_error != net::OK) {
     callback.Run(MakeNetworkError(net_error), NetAddressPtr());
     return;
   }
   ignore_result(bound.release());  // Strongly owned by the message pipe.
   NetAddressPtr resulting_local_address(bound->GetLocalAddress());
-  callback.Run(MakeNetworkError(net::OK), resulting_local_address.Pass());
+  callback.Run(MakeNetworkError(net::OK), std::move(resulting_local_address));
 }
 
 void NetworkServiceImpl::CreateTCPConnectedSocket(
@@ -53,14 +54,14 @@ void NetworkServiceImpl::CreateTCPConnectedSocket(
 
 void NetworkServiceImpl::CreateUDPSocket(InterfaceRequest<UDPSocket> request) {
   // The lifetime of this UDPSocketImpl is bound to that of the underlying pipe.
-  new UDPSocketImpl(request.Pass(), app_refcount_->Clone());
+  new UDPSocketImpl(std::move(request), app_refcount_->Clone());
 }
 
 void NetworkServiceImpl::CreateHttpServer(
     NetAddressPtr local_address,
     HttpServerDelegatePtr delegate,
     const CreateHttpServerCallback& callback) {
-  HttpServerImpl::Create(local_address.Pass(), delegate.Pass(),
+  HttpServerImpl::Create(std::move(local_address), std::move(delegate),
                          app_refcount_->Clone(), callback);
 }
 
diff --git a/mojo/services/network/public/cpp/udp_socket_wrapper.cc b/mojo/services/network/public/cpp/udp_socket_wrapper.cc
index a9c5c11..ede03f0 100644
--- a/mojo/services/network/public/cpp/udp_socket_wrapper.cc
+++ b/mojo/services/network/public/cpp/udp_socket_wrapper.cc
@@ -2,11 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "network/public/cpp/udp_socket_wrapper.h"
-
 #include <assert.h>
+#include <utility>
 
 #include "mojo/public/cpp/environment/logging.h"
+#include "network/public/cpp/udp_socket_wrapper.h"
 
 namespace mojo {
 namespace {
@@ -37,7 +37,7 @@ UDPSocketWrapper::SendCallbackHandler::SendCallbackHandler(
 UDPSocketWrapper::SendCallbackHandler::~SendCallbackHandler() {}
 
 void UDPSocketWrapper::SendCallbackHandler::Run(NetworkErrorPtr result) const {
-  delegate_->OnSendToCompleted(result.Pass(), forward_callback_);
+  delegate_->OnSendToCompleted(std::move(result), forward_callback_);
 }
 
 UDPSocketWrapper::ReceiverBindingCallback::ReceiverBindingCallback(
@@ -53,8 +53,8 @@ void UDPSocketWrapper::ReceiverBindingCallback::Run(
     NetworkErrorPtr result,
     NetAddressPtr addr,
     InterfaceRequest<UDPSocketReceiver> request) const {
-  delegate_->StartReceivingData(request.Pass());
-  wrapper_callback_.Run(result.Pass(), addr.Pass());
+  delegate_->StartReceivingData(std::move(request));
+  wrapper_callback_.Run(std::move(result), std::move(addr));
 }
 
 UDPSocketWrapper::ReceivedData::ReceivedData() {}
@@ -65,7 +65,7 @@ UDPSocketWrapper::SendRequest::~SendRequest() {}
 
 UDPSocketWrapper::UDPSocketWrapper(UDPSocketPtr socket)
     : binding_(this),
-      socket_(socket.Pass()),
+      socket_(std::move(socket)),
       max_receive_queue_size_(kDefaultReceiveQueueSlots),
       max_pending_sends_(1),
       current_pending_sends_(0) {
@@ -76,7 +76,7 @@ UDPSocketWrapper::UDPSocketWrapper(UDPSocketPtr socket,
                                    uint32_t receive_queue_slots,
                                    uint32_t requested_max_pending_sends)
     : binding_(this),
-      socket_(socket.Pass()),
+      socket_(std::move(socket)),
       max_receive_queue_size_(receive_queue_slots),
       max_pending_sends_(1),
       current_pending_sends_(0) {
@@ -102,7 +102,7 @@ void UDPSocketWrapper::Bind(
     NetAddressPtr addr,
     const Callback<void(NetworkErrorPtr, NetAddressPtr)>& callback) {
   socket_->Bind(
-      addr.Pass(),
+      std::move(addr),
       BindOrConnectCallback(static_cast<BindOrConnectCallback::Runnable*>(
           new ReceiverBindingCallback(this, callback))));
 }
@@ -111,7 +111,7 @@ void UDPSocketWrapper::Connect(
     NetAddressPtr remote_addr,
     const Callback<void(NetworkErrorPtr, NetAddressPtr)>& callback) {
   socket_->Connect(
-      remote_addr.Pass(),
+      std::move(remote_addr),
       BindOrConnectCallback(static_cast<BindOrConnectCallback::Runnable*>(
           new ReceiverBindingCallback(this, callback))));
 }
@@ -135,7 +135,8 @@ bool UDPSocketWrapper::ReceiveFrom(const ReceiveCallback& callback) {
   ReceivedData* data = receive_queue_.front();
   receive_queue_.pop();
   socket_->ReceiveMore(1);
-  callback.Run(data->result.Pass(), data->src_addr.Pass(), data->data.Pass());
+  callback.Run(std::move(data->result), std::move(data->src_addr),
+               std::move(data->data));
   delete data;
   return true;
 }
@@ -145,8 +146,8 @@ void UDPSocketWrapper::SendTo(NetAddressPtr dest_addr,
                               const ErrorCallback& callback) {
   if (current_pending_sends_ >= max_pending_sends_) {
     SendRequest* request = new SendRequest();
-    request->dest_addr = dest_addr.Pass();
-    request->data = data.Pass();
+    request->dest_addr = std::move(dest_addr);
+    request->data = std::move(data);
     request->callback = callback;
     send_requests_.push(request);
     return;
@@ -154,7 +155,7 @@ void UDPSocketWrapper::SendTo(NetAddressPtr dest_addr,
 
   MOJO_DCHECK(send_requests_.empty());
   current_pending_sends_++;
-  socket_->SendTo(dest_addr.Pass(), data.Pass(),
+  socket_->SendTo(std::move(dest_addr), std::move(data),
                   ErrorCallback(static_cast<ErrorCallback::Runnable*>(
                       new SendCallbackHandler(this, callback))));
 }
@@ -171,15 +172,15 @@ void UDPSocketWrapper::OnReceived(NetworkErrorPtr result,
     ReceiveCallback callback = receive_requests_.front();
     receive_requests_.pop();
 
-    callback.Run(result.Pass(), src_addr.Pass(), data.Pass());
+    callback.Run(std::move(result), std::move(src_addr), std::move(data));
     return;
   }
 
   MOJO_DCHECK(receive_queue_.size() < max_receive_queue_size_);
   ReceivedData* received_data = new ReceivedData();
-  received_data->result = result.Pass();
-  received_data->src_addr = src_addr.Pass();
-  received_data->data = data.Pass();
+  received_data->result = std::move(result);
+  received_data->src_addr = std::move(src_addr);
+  received_data->data = std::move(data);
   receive_queue_.push(received_data);
 }
 
@@ -211,7 +212,7 @@ void UDPSocketWrapper::OnSendToCompleted(
   current_pending_sends_--;
   ProcessNextSendRequest();
 
-  forward_callback.Run(result.Pass());
+  forward_callback.Run(std::move(result));
 }
 
 bool UDPSocketWrapper::ProcessNextSendRequest() {
@@ -223,10 +224,9 @@ bool UDPSocketWrapper::ProcessNextSendRequest() {
 
   current_pending_sends_++;
 
-  socket_->SendTo(
-      request->dest_addr.Pass(), request->data.Pass(),
-      ErrorCallback(static_cast<ErrorCallback::Runnable*>(
-          new SendCallbackHandler(this, request->callback))));
+  socket_->SendTo(std::move(request->dest_addr), std::move(request->data),
+                  ErrorCallback(static_cast<ErrorCallback::Runnable*>(
+                      new SendCallbackHandler(this, request->callback))));
 
   delete request;
 
@@ -235,7 +235,7 @@ bool UDPSocketWrapper::ProcessNextSendRequest() {
 
 void UDPSocketWrapper::StartReceivingData(
     InterfaceRequest<UDPSocketReceiver> request) {
-  binding_.Bind(request.Pass());
+  binding_.Bind(std::move(request));
   socket_->ReceiveMore(max_receive_queue_size_);
 }
 
diff --git a/mojo/services/network/tcp_bound_socket_impl.cc b/mojo/services/network/tcp_bound_socket_impl.cc
index 27f4c63..d8a60b7 100644
--- a/mojo/services/network/tcp_bound_socket_impl.cc
+++ b/mojo/services/network/tcp_bound_socket_impl.cc
@@ -4,6 +4,8 @@
 
 #include "mojo/services/network/tcp_bound_socket_impl.h"
 
+#include <utility>
+
 #include "mojo/services/network/net_adapters.h"
 #include "mojo/services/network/net_address_type_converters.h"
 #include "mojo/services/network/tcp_connected_socket_impl.h"
@@ -15,8 +17,8 @@ namespace mojo {
 TCPBoundSocketImpl::TCPBoundSocketImpl(
     scoped_ptr<mojo::AppRefCount> app_refcount,
     InterfaceRequest<TCPBoundSocket> request)
-    : app_refcount_(app_refcount.Pass()), binding_(this, request.Pass()) {
-}
+    : app_refcount_(std::move(app_refcount)),
+      binding_(this, std::move(request)) {}
 
 TCPBoundSocketImpl::~TCPBoundSocketImpl() {
 }
@@ -66,8 +68,8 @@ void TCPBoundSocketImpl::StartListening(
   }
 
   // The server socket object takes ownership of the socket.
-  new TCPServerSocketImpl(socket_.Pass(), app_refcount_->Clone(),
-                          server.Pass());
+  new TCPServerSocketImpl(std::move(socket_), app_refcount_->Clone(),
+                          std::move(server));
   callback.Run(MakeNetworkError(net::OK));
 }
 
@@ -87,9 +89,9 @@ void TCPBoundSocketImpl::Connect(
 
   net::IPEndPoint end_point = remote_address.To<net::IPEndPoint>();
 
-  pending_connect_send_stream_ = send_stream.Pass();
-  pending_connect_receive_stream_ = receive_stream.Pass();
-  pending_connect_socket_ = client_socket.Pass();
+  pending_connect_send_stream_ = std::move(send_stream);
+  pending_connect_receive_stream_ = std::move(receive_stream);
+  pending_connect_socket_ = std::move(client_socket);
   pending_connect_callback_ = callback;
   int result = socket_->Connect(
       end_point,
@@ -109,9 +111,9 @@ void TCPBoundSocketImpl::Connect(
 void TCPBoundSocketImpl::OnConnected(int result) {
   if (result == net::OK) {
     new TCPConnectedSocketImpl(
-        socket_.Pass(), pending_connect_send_stream_.Pass(),
-        pending_connect_receive_stream_.Pass(), pending_connect_socket_.Pass(),
-        app_refcount_->Clone());
+        std::move(socket_), std::move(pending_connect_send_stream_),
+        std::move(pending_connect_receive_stream_),
+        std::move(pending_connect_socket_), app_refcount_->Clone());
   } else {
     pending_connect_send_stream_.reset();
     pending_connect_receive_stream_.reset();
diff --git a/mojo/services/network/tcp_connected_socket_impl.cc b/mojo/services/network/tcp_connected_socket_impl.cc
index 44fba13..e210d81 100644
--- a/mojo/services/network/tcp_connected_socket_impl.cc
+++ b/mojo/services/network/tcp_connected_socket_impl.cc
@@ -4,6 +4,8 @@
 
 #include "mojo/services/network/tcp_connected_socket_impl.h"
 
+#include <utility>
+
 #include "base/message_loop/message_loop.h"
 #include "mojo/services/network/net_adapters.h"
 #include "net/base/net_errors.h"
@@ -16,11 +18,11 @@ TCPConnectedSocketImpl::TCPConnectedSocketImpl(
     ScopedDataPipeProducerHandle receive_stream,
     InterfaceRequest<TCPConnectedSocket> request,
     scoped_ptr<mojo::AppRefCount> app_refcount)
-    : socket_(socket.Pass()),
-      send_stream_(send_stream.Pass()),
-      receive_stream_(receive_stream.Pass()),
-      binding_(this, request.Pass()),
-      app_refcount_(app_refcount.Pass()),
+    : socket_(std::move(socket)),
+      send_stream_(std::move(send_stream)),
+      receive_stream_(std::move(receive_stream)),
+      binding_(this, std::move(request)),
+      app_refcount_(std::move(app_refcount)),
       weak_ptr_factory_(this) {
   // Queue up async communication.
   binding_.set_connection_error_handler([this]() { OnConnectionError(); });
diff --git a/mojo/services/network/tcp_server_socket_impl.cc b/mojo/services/network/tcp_server_socket_impl.cc
index ace2a38..2762964 100644
--- a/mojo/services/network/tcp_server_socket_impl.cc
+++ b/mojo/services/network/tcp_server_socket_impl.cc
@@ -4,6 +4,8 @@
 
 #include "mojo/services/network/tcp_server_socket_impl.h"
 
+#include <utility>
+
 #include "mojo/services/network/net_adapters.h"
 #include "mojo/services/network/net_address_type_converters.h"
 #include "mojo/services/network/tcp_connected_socket_impl.h"
@@ -15,9 +17,9 @@ TCPServerSocketImpl::TCPServerSocketImpl(
     scoped_ptr<net::TCPSocket> socket,
     scoped_ptr<mojo::AppRefCount> app_refcount,
     InterfaceRequest<TCPServerSocket> request)
-    : socket_(socket.Pass()), app_refcount_(app_refcount.Pass()),
-      binding_(this, request.Pass()) {
-}
+    : socket_(std::move(socket)),
+      app_refcount_(std::move(app_refcount)),
+      binding_(this, std::move(request)) {}
 
 TCPServerSocketImpl::~TCPServerSocketImpl() {
 }
@@ -42,9 +44,9 @@ void TCPServerSocketImpl::Accept(
                  base::Unretained(this)));
   if (result == net::OK || result == net::ERR_IO_PENDING) {
     pending_callback_ = callback;
-    pending_send_stream_ = send_stream.Pass();
-    pending_receive_stream_ = receive_stream.Pass();
-    pending_client_socket_ = client_socket.Pass();
+    pending_send_stream_ = std::move(send_stream);
+    pending_receive_stream_ = std::move(receive_stream);
+    pending_client_socket_ = std::move(client_socket);
     if (result == net::OK)
       OnAcceptCompleted(net::OK);
   } else {
@@ -60,8 +62,8 @@ void TCPServerSocketImpl::OnAcceptCompleted(int result) {
     pending_client_socket_ = InterfaceRequest<TCPConnectedSocket>();
   } else {
     new TCPConnectedSocketImpl(
-        accepted_socket_.Pass(), pending_send_stream_.Pass(),
-        pending_receive_stream_.Pass(), pending_client_socket_.Pass(),
+        std::move(accepted_socket_), std::move(pending_send_stream_),
+        std::move(pending_receive_stream_), std::move(pending_client_socket_),
         app_refcount_->Clone());
     pending_callback_.Run(MakeNetworkError(net::OK),
                           NetAddress::From(accepted_address_));
diff --git a/mojo/services/network/udp_socket_apptest.cc b/mojo/services/network/udp_socket_apptest.cc
index d55e32a..7e70eef 100644
--- a/mojo/services/network/udp_socket_apptest.cc
+++ b/mojo/services/network/udp_socket_apptest.cc
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <utility>
+
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
@@ -30,14 +32,14 @@ NetAddressPtr GetLocalHostWithAnyPort() {
   addr->ipv4->addr[2] = 0;
   addr->ipv4->addr[3] = 1;
 
-  return addr.Pass();
+  return addr;
 }
 
 Array<uint8_t> CreateTestMessage(uint8_t initial, size_t size) {
   Array<uint8_t> array(size);
   for (size_t i = 0; i < size; ++i)
     array[i] = static_cast<uint8_t>((i + initial) % 256);
-  return array.Pass();
+  return array;
 }
 
 template <typename CallbackType>
@@ -120,7 +122,7 @@ class TestCallback : public TestCallbackBase<Callback<void(NetworkErrorPtr)>> {
     void Run(NetworkErrorPtr result) const override {
       if (test_callback_) {
         TestCallback* callback = static_cast<TestCallback*>(test_callback_);
-        callback->result_ = result.Pass();
+        callback->result_ = std::move(result);
       }
       NotifyRun();
     }
@@ -152,9 +154,9 @@ class TestCallbackWithAddressAndReceiver
       if (test_callback_) {
         TestCallbackWithAddressAndReceiver* callback =
             static_cast<TestCallbackWithAddressAndReceiver*>(test_callback_);
-        callback->result_ = result.Pass();
-        callback->net_address_ = net_address.Pass();
-        callback->receiver_ = receiver.Pass();
+        callback->result_ = std::move(result);
+        callback->net_address_ = std::move(net_address);
+        callback->receiver_ = std::move(receiver);
       }
       NotifyRun();
     }
@@ -184,8 +186,8 @@ class TestCallbackWithAddress
       if (test_callback_) {
         TestCallbackWithAddress* callback =
             static_cast<TestCallbackWithAddress*>(test_callback_);
-        callback->result_ = result.Pass();
-        callback->net_address_ = net_address.Pass();
+        callback->result_ = std::move(result);
+        callback->net_address_ = std::move(net_address);
       }
       NotifyRun();
     }
@@ -245,9 +247,9 @@ class TestReceiveCallback
       if (test_callback_) {
         TestReceiveCallback* callback =
             static_cast<TestReceiveCallback*>(test_callback_);
-        callback->result_ = result.Pass();
-        callback->src_addr_ = src_addr.Pass();
-        callback->data_ = data.Pass();
+        callback->result_ = std::move(result);
+        callback->src_addr_ = std::move(src_addr);
+        callback->data_ = std::move(data);
       }
       NotifyRun();
     }
@@ -295,9 +297,9 @@ class UDPSocketReceiverImpl : public UDPSocketReceiver {
                   NetAddressPtr src_addr,
                   Array<uint8_t> data) override {
     ReceiveResult* entry = new ReceiveResult();
-    entry->result = result.Pass();
-    entry->addr = src_addr.Pass();
-    entry->data = data.Pass();
+    entry->result = std::move(result);
+    entry->addr = std::move(src_addr);
+    entry->data = std::move(data);
 
     results_.push(entry);
 
@@ -395,7 +397,7 @@ TEST_F(UDPSocketAppTest, TestReadWrite) {
   ASSERT_EQ(net::OK, callback1.result()->code);
   ASSERT_NE(0u, callback1.net_address()->ipv4->port);
 
-  receiver_binding_.Bind(callback1.receiver().Pass());
+  receiver_binding_.Bind(std::move(callback1.receiver()));
 
   NetAddressPtr server_addr = callback1.net_address().Clone();
 
@@ -443,7 +445,7 @@ TEST_F(UDPSocketAppTest, TestConnectedReadWrite) {
   ASSERT_EQ(net::OK, callback1.result()->code);
   ASSERT_NE(0u, callback1.net_address()->ipv4->port);
 
-  receiver_binding_.Bind(callback1.receiver().Pass());
+  receiver_binding_.Bind(std::move(callback1.receiver()));
 
   NetAddressPtr server_addr = callback1.net_address().Clone();
 
@@ -458,7 +460,7 @@ TEST_F(UDPSocketAppTest, TestConnectedReadWrite) {
 
   UDPSocketReceiverImpl client_socket_receiver;
   Binding<UDPSocketReceiver> client_receiver_binding(
-      &client_socket_receiver, callback2.receiver().Pass());
+      &client_socket_receiver, std::move(callback2.receiver()));
 
   NetAddressPtr client_addr = callback2.net_address().Clone();
 
@@ -515,7 +517,7 @@ TEST_F(UDPSocketAppTest, TestConnectedReadWrite) {
 }
 
 TEST_F(UDPSocketAppTest, TestWrapperReadWrite) {
-  UDPSocketWrapper socket(socket_.Pass(), 4, 4);
+  UDPSocketWrapper socket(std::move(socket_), 4, 4);
 
   TestCallbackWithAddress callback1;
   socket.Bind(GetLocalHostWithAnyPort(), callback1.callback());
@@ -527,7 +529,7 @@ TEST_F(UDPSocketAppTest, TestWrapperReadWrite) {
 
   UDPSocketPtr raw_client_socket;
   network_service_->CreateUDPSocket(GetProxy(&raw_client_socket));
-  UDPSocketWrapper client_socket(raw_client_socket.Pass(), 4, 4);
+  UDPSocketWrapper client_socket(std::move(raw_client_socket), 4, 4);
 
   TestCallbackWithAddress callback2;
   client_socket.Bind(GetLocalHostWithAnyPort(), callback2.callback());
@@ -567,7 +569,7 @@ TEST_F(UDPSocketAppTest, TestWrapperReadWrite) {
 }
 
 TEST_F(UDPSocketAppTest, TestWrapperConnectedReadWrite) {
-  UDPSocketWrapper socket(socket_.Pass(), 4, 4);
+  UDPSocketWrapper socket(std::move(socket_), 4, 4);
 
   TestCallbackWithAddress callback1;
   socket.Bind(GetLocalHostWithAnyPort(), callback1.callback());
@@ -579,10 +581,10 @@ TEST_F(UDPSocketAppTest, TestWrapperConnectedReadWrite) {
 
   UDPSocketPtr raw_client_socket;
   network_service_->CreateUDPSocket(GetProxy(&raw_client_socket));
-  UDPSocketWrapper client_socket(raw_client_socket.Pass(), 4, 4);
+  UDPSocketWrapper client_socket(std::move(raw_client_socket), 4, 4);
 
   TestCallbackWithAddress callback2;
-  client_socket.Connect(server_addr.Pass(), callback2.callback());
+  client_socket.Connect(std::move(server_addr), callback2.callback());
   callback2.WaitForResult();
   ASSERT_EQ(net::OK, callback2.result()->code);
   ASSERT_NE(0u, callback2.net_address()->ipv4->port);
diff --git a/mojo/services/network/udp_socket_impl.cc b/mojo/services/network/udp_socket_impl.cc
index 83b480f..6958b6d 100644
--- a/mojo/services/network/udp_socket_impl.cc
+++ b/mojo/services/network/udp_socket_impl.cc
@@ -5,9 +5,9 @@
 #include "mojo/services/network/udp_socket_impl.h"
 
 #include <string.h>
-
 #include <algorithm>
 #include <limits>
+#include <utility>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ -36,7 +36,7 @@ UDPSocketImpl::PendingSendRequest::~PendingSendRequest() {}
 
 UDPSocketImpl::UDPSocketImpl(InterfaceRequest<UDPSocket> request,
                              scoped_ptr<mojo::AppRefCount> app_refcount)
-    : binding_(this, request.Pass()),
+    : binding_(this, std::move(request)),
       socket_(net::DatagramSocket::DEFAULT_BIND,
               net::RandIntCallback(),
               nullptr,
@@ -45,8 +45,7 @@ UDPSocketImpl::UDPSocketImpl(InterfaceRequest<UDPSocket> request,
       allow_address_reuse_(false),
       remaining_recv_slots_(0),
       max_pending_send_requests_(kDefaultMaxPendingSendRequests),
-      app_refcount_(app_refcount.Pass()) {
-}
+      app_refcount_(std::move(app_refcount)) {}
 
 UDPSocketImpl::~UDPSocketImpl() {
   STLDeleteElements(&pending_send_requests_);
@@ -261,8 +260,8 @@ void UDPSocketImpl::SendTo(NetAddressPtr dest_addr,
     }
 
     PendingSendRequest* request = new PendingSendRequest;
-    request->addr = dest_addr.Pass();
-    request->data = data.Pass();
+    request->addr = std::move(dest_addr);
+    request->data = std::move(data);
     request->callback = callback;
     pending_send_requests_.push_back(request);
     return;
@@ -270,7 +269,7 @@ void UDPSocketImpl::SendTo(NetAddressPtr dest_addr,
 
   DCHECK_EQ(0u, pending_send_requests_.size());
 
-  DoSendTo(dest_addr.Pass(), data.Pass(), callback);
+  DoSendTo(std::move(dest_addr), std::move(data), callback);
 }
 
 void UDPSocketImpl::DoRecvFrom() {
@@ -349,8 +348,8 @@ void UDPSocketImpl::OnRecvFromCompleted(int net_result) {
   }
   recvfrom_buffer_ = nullptr;
 
-  receiver_->OnReceived(MakeNetworkError(net_result), net_address.Pass(),
-                        array.Pass());
+  receiver_->OnReceived(MakeNetworkError(net_result), std::move(net_address),
+                        std::move(array));
   DCHECK_GT(remaining_recv_slots_, 0u);
   remaining_recv_slots_--;
   if (remaining_recv_slots_ > 0)
@@ -372,7 +371,8 @@ void UDPSocketImpl::OnSendToCompleted(
   scoped_ptr<PendingSendRequest> request(pending_send_requests_.front());
   pending_send_requests_.pop_front();
 
-  DoSendTo(request->addr.Pass(), request->data.Pass(), request->callback);
+  DoSendTo(std::move(request->addr), std::move(request->data),
+           request->callback);
 }
 
 }  // namespace mojo
diff --git a/mojo/services/network/url_loader_factory_impl.cc b/mojo/services/network/url_loader_factory_impl.cc
index 5d2df32..b14183c 100644
--- a/mojo/services/network/url_loader_factory_impl.cc
+++ b/mojo/services/network/url_loader_factory_impl.cc
@@ -4,6 +4,8 @@
 
 #include "mojo/services/network/url_loader_factory_impl.h"
 
+#include <utility>
+
 #include "mojo/services/network/url_loader_impl.h"
 
 namespace mojo {
@@ -13,9 +15,8 @@ URLLoaderFactoryImpl::URLLoaderFactoryImpl(
     scoped_ptr<mojo::AppRefCount> app_refcount,
     InterfaceRequest<URLLoaderFactory> request)
     : context_(context),
-      app_refcount_(app_refcount.Pass()),
-      binding_(this, request.Pass()) {
-}
+      app_refcount_(std::move(app_refcount)),
+      binding_(this, std::move(request)) {}
 
 URLLoaderFactoryImpl::~URLLoaderFactoryImpl() {
 }
@@ -26,7 +27,7 @@ void URLLoaderFactoryImpl::CreateURLLoader(InterfaceRequest<URLLoader> loader) {
   // The loader will delete itself when the pipe is closed, unless a request is
   // in progress. In which case, the loader will delete itself when the request
   // is finished.
-  new URLLoaderImpl(context_, loader.Pass(), app_refcount_->Clone());
+  new URLLoaderImpl(context_, std::move(loader), app_refcount_->Clone());
 }
 
 }  // namespace mojo
diff --git a/mojo/services/network/url_loader_impl.cc b/mojo/services/network/url_loader_impl.cc
index ab264cb..38973f1 100644
--- a/mojo/services/network/url_loader_impl.cc
+++ b/mojo/services/network/url_loader_impl.cc
@@ -4,6 +4,7 @@
 
 #include "mojo/services/network/url_loader_impl.h"
 
+#include <utility>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
@@ -78,7 +79,7 @@ URLResponsePtr MakeURLResponse(const net::URLRequest* url_request) {
       HttpHeaderPtr header = HttpHeader::New();
       header->name = name;
       header->value = value;
-      response->headers.push_back(header.Pass());
+      response->headers.push_back(std::move(header));
     }
   }
 
@@ -90,14 +91,14 @@ URLResponsePtr MakeURLResponse(const net::URLRequest* url_request) {
   url_request->GetCharset(&charset);
   response->charset = charset;
 
-  return response.Pass();
+  return response;
 }
 
 // Reads the request body upload data from a DataPipe.
 class UploadDataPipeElementReader : public net::UploadElementReader {
  public:
   UploadDataPipeElementReader(ScopedDataPipeConsumerHandle pipe)
-      : pipe_(pipe.Pass()), num_bytes_(0) {}
+      : pipe_(std::move(pipe)), num_bytes_(0) {}
   ~UploadDataPipeElementReader() override {}
 
   // UploadElementReader overrides:
@@ -142,8 +143,8 @@ URLLoaderImpl::URLLoaderImpl(NetworkContext* context,
       response_body_bytes_read_(0),
       auto_follow_redirects_(true),
       connected_(true),
-      binding_(this, request.Pass()),
-      app_refcount_(app_refcount.Pass()),
+      binding_(this, std::move(request)),
+      app_refcount_(std::move(app_refcount)),
       weak_ptr_factory_(this) {
   binding_.set_connection_error_handler([this]() { OnConnectionError(); });
   context_->RegisterURLLoader(this);
@@ -196,7 +197,7 @@ void URLLoaderImpl::Start(URLRequestPtr request,
     std::vector<scoped_ptr<net::UploadElementReader>> element_readers;
     for (size_t i = 0; i < request->body.size(); ++i) {
       element_readers.push_back(make_scoped_ptr(
-          new UploadDataPipeElementReader(request->body[i].Pass())));
+          new UploadDataPipeElementReader(std::move(request->body[i]))));
     }
     url_request_->set_upload(make_scoped_ptr<net::UploadDataStream>(
         new net::ElementsUploadDataStream(std::move(element_readers), 0)));
@@ -245,7 +246,7 @@ void URLLoaderImpl::QueryStatus(
     status->is_loading = false;
   }
   // TODO(darin): Populate more status fields.
-  callback.Run(status.Pass());
+  callback.Run(std::move(status));
 }
 
 void URLLoaderImpl::OnConnectionError() {
@@ -271,7 +272,7 @@ void URLLoaderImpl::OnReceivedRedirect(net::URLRequest* url_request,
   response->redirect_url = String::From(redirect_info.new_url);
   response->redirect_referrer = redirect_info.new_referrer;
 
-  SendResponse(response.Pass());
+  SendResponse(std::move(response));
 
   DeleteIfNeeded();
 }
@@ -292,11 +293,11 @@ void URLLoaderImpl::OnResponseStarted(net::URLRequest* url_request) {
   // TODO(darin): Honor given buffer size.
 
   URLResponsePtr response = MakeURLResponse(url_request);
-  response->body = data_pipe.consumer_handle.Pass();
-  response_body_stream_ = data_pipe.producer_handle.Pass();
+  response->body = std::move(data_pipe.consumer_handle);
+  response_body_stream_ = std::move(data_pipe.producer_handle);
   ListenForPeerClosed();
 
-  SendResponse(response.Pass());
+  SendResponse(std::move(response));
 
   // Start reading...
   ReadMore();
@@ -323,13 +324,13 @@ void URLLoaderImpl::SendError(
   if (url_request_)
     response->url = String::From(url_request_->url());
   response->error = MakeNetworkError(error_code);
-  callback.Run(response.Pass());
+  callback.Run(std::move(response));
 }
 
 void URLLoaderImpl::SendResponse(URLResponsePtr response) {
   Callback<void(URLResponsePtr)> callback;
   std::swap(callback_, callback);
-  callback.Run(response.Pass());
+  callback.Run(std::move(response));
 }
 
 void URLLoaderImpl::OnResponseBodyStreamReady(MojoResult result) {
diff --git a/mojo/services/network/url_loader_impl_apptest.cc b/mojo/services/network/url_loader_impl_apptest.cc
index 0b9de67..d3d68c6 100644
--- a/mojo/services/network/url_loader_impl_apptest.cc
+++ b/mojo/services/network/url_loader_impl_apptest.cc
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/memory/weak_ptr.h"
@@ -27,7 +29,7 @@ TestURLRequestJob* g_current_job = nullptr;
 
 template <class A>
 void PassA(A* destination, A value) {
-  *destination = value.Pass();
+  *destination = std::move(value);
 }
 
 class TestURLRequestJob : public net::URLRequestJob {
@@ -123,7 +125,7 @@ class UrlLoaderImplTest : public test::ApplicationTestBase {
             wait_for_request_.QuitClosure()))));
     url_request_context->set_job_factory(&url_request_job_factory_);
     url_request_context->Init();
-    network_context_.reset(new NetworkContext(url_request_context.Pass()));
+    network_context_.reset(new NetworkContext(std::move(url_request_context)));
     MessagePipe pipe;
     new URLLoaderImpl(network_context_.get(),
                       GetProxy(&url_loader_proxy_),
@@ -155,7 +157,7 @@ TEST_F(UrlLoaderImplTest, ClosedWhileWaitingOnTheNetwork) {
   request->url = "http://example.com";
 
   URLResponsePtr response;
-  url_loader_proxy_->Start(request.Pass(),
+  url_loader_proxy_->Start(std::move(request),
                            base::Bind(&PassA<URLResponsePtr>, &response));
   wait_for_request_.Run();
 
@@ -186,7 +188,7 @@ TEST_F(UrlLoaderImplTest, ClosedWhileWaitingOnThePipeToBeWriteable) {
   request->url = "http://example.com";
 
   URLResponsePtr response;
-  url_loader_proxy_->Start(request.Pass(),
+  url_loader_proxy_->Start(std::move(request),
                            base::Bind(&PassA<URLResponsePtr>, &response));
   wait_for_request_.Run();
 
@@ -227,7 +229,7 @@ TEST_F(UrlLoaderImplTest, RequestCompleted) {
   request->url = "http://example.com";
 
   URLResponsePtr response;
-  url_loader_proxy_->Start(request.Pass(),
+  url_loader_proxy_->Start(std::move(request),
                            base::Bind(&PassA<URLResponsePtr>, &response));
   wait_for_request_.Run();
 
@@ -258,7 +260,7 @@ TEST_F(UrlLoaderImplTest, RequestFailed) {
   request->url = "http://example.com";
 
   URLResponsePtr response;
-  url_loader_proxy_->Start(request.Pass(),
+  url_loader_proxy_->Start(std::move(request),
                            base::Bind(&PassA<URLResponsePtr>, &response));
   wait_for_request_.Run();
 
diff --git a/mojo/services/network/web_socket_factory_impl.cc b/mojo/services/network/web_socket_factory_impl.cc
index 90895e9..ecd7272 100644
--- a/mojo/services/network/web_socket_factory_impl.cc
+++ b/mojo/services/network/web_socket_factory_impl.cc
@@ -4,6 +4,8 @@
 
 #include "mojo/services/network/web_socket_factory_impl.h"
 
+#include <utility>
+
 #include "mojo/services/network/web_socket_impl.h"
 
 namespace mojo {
@@ -13,15 +15,14 @@ WebSocketFactoryImpl::WebSocketFactoryImpl(
     scoped_ptr<AppRefCount> app_refcount,
     InterfaceRequest<WebSocketFactory> request)
     : context_(context),
-      app_refcount_(app_refcount.Pass()),
-      binding_(this, request.Pass()) {
-}
+      app_refcount_(std::move(app_refcount)),
+      binding_(this, std::move(request)) {}
 
 WebSocketFactoryImpl::~WebSocketFactoryImpl() {
 }
 
 void WebSocketFactoryImpl::CreateWebSocket(InterfaceRequest<WebSocket> socket) {
-  new WebSocketImpl(context_, app_refcount_->Clone(), socket.Pass());
+  new WebSocketImpl(context_, app_refcount_->Clone(), std::move(socket));
 }
 
 }  // namespace mojo
diff --git a/mojo/services/network/web_socket_impl.cc b/mojo/services/network/web_socket_impl.cc
index a9eab49..1d3182b 100644
--- a/mojo/services/network/web_socket_impl.cc
+++ b/mojo/services/network/web_socket_impl.cc
@@ -4,6 +4,8 @@
 
 #include "mojo/services/network/web_socket_impl.h"
 
+#include <utility>
+
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/message_pump/handle_watcher.h"
@@ -63,8 +65,7 @@ typedef net::WebSocketEventInterface::ChannelState ChannelState;
 struct WebSocketEventHandler : public net::WebSocketEventInterface {
  public:
   WebSocketEventHandler(WebSocketClientPtr client)
-      : client_(client.Pass()) {
-  }
+      : client_(std::move(client)) {}
   ~WebSocketEventHandler() override {}
 
  private:
@@ -106,10 +107,10 @@ ChannelState WebSocketEventHandler::OnAddChannelResponse(
     const std::string& selected_protocol,
     const std::string& extensions) {
   DataPipe data_pipe;
-  receive_stream_ = data_pipe.producer_handle.Pass();
+  receive_stream_ = std::move(data_pipe.producer_handle);
   write_queue_.reset(new WebSocketWriteQueue(receive_stream_.get()));
-  client_->DidConnect(
-      selected_protocol, extensions, data_pipe.consumer_handle.Pass());
+  client_->DidConnect(selected_protocol, extensions,
+                      std::move(data_pipe.consumer_handle));
   return WebSocketEventInterface::CHANNEL_ALIVE;
 }
 
@@ -177,13 +178,12 @@ void WebSocketEventHandler::DidWriteToReceiveStream(
 
 }  // namespace mojo
 
-WebSocketImpl::WebSocketImpl(
-    NetworkContext* context,
-    scoped_ptr<mojo::AppRefCount> app_refcount,
-    InterfaceRequest<WebSocket> request)
-    : context_(context), app_refcount_(app_refcount.Pass()),
-      binding_(this, request.Pass()) {
-}
+WebSocketImpl::WebSocketImpl(NetworkContext* context,
+                             scoped_ptr<mojo::AppRefCount> app_refcount,
+                             InterfaceRequest<WebSocket> request)
+    : context_(context),
+      app_refcount_(std::move(app_refcount)),
+      binding_(this, std::move(request)) {}
 
 WebSocketImpl::~WebSocketImpl() {
 }
@@ -194,11 +194,11 @@ void WebSocketImpl::Connect(const String& url,
                             ScopedDataPipeConsumerHandle send_stream,
                             WebSocketClientPtr client) {
   DCHECK(!channel_);
-  send_stream_ = send_stream.Pass();
+  send_stream_ = std::move(send_stream);
   read_queue_.reset(new WebSocketReadQueue(send_stream_.get()));
   scoped_ptr<net::WebSocketEventInterface> event_interface(
-      new WebSocketEventHandler(client.Pass()));
-  channel_.reset(new net::WebSocketChannel(event_interface.Pass(),
+      new WebSocketEventHandler(std::move(client)));
+  channel_.reset(new net::WebSocketChannel(std::move(event_interface),
                                            context_->url_request_context()));
   channel_->SendAddChannelRequest(GURL(url.get()),
                                   protocols.To<std::vector<std::string>>(),
diff --git a/mojo/services/test_service/test_request_tracker_application.cc b/mojo/services/test_service/test_request_tracker_application.cc
index 6facdc5..5168cfa 100644
--- a/mojo/services/test_service/test_request_tracker_application.cc
+++ b/mojo/services/test_service/test_request_tracker_application.cc
@@ -5,6 +5,7 @@
 #include "mojo/services/test_service/test_request_tracker_application.h"
 
 #include <assert.h>
+#include <utility>
 
 #include "mojo/application/public/cpp/application_connection.h"
 #include "mojo/application/public/cpp/application_runner.h"
@@ -38,19 +39,19 @@ bool TestRequestTrackerApplication::ConfigureIncomingConnection(
 void TestRequestTrackerApplication::Create(
     ApplicationConnection* connection,
     InterfaceRequest<TestTimeService> request) {
-  new TestTimeServiceImpl(app_impl_, request.Pass());
+  new TestTimeServiceImpl(app_impl_, std::move(request));
 }
 
 void TestRequestTrackerApplication::Create(
     ApplicationConnection* connection,
     InterfaceRequest<TestRequestTracker> request) {
-  new TestRequestTrackerImpl(request.Pass(), &context_);
+  new TestRequestTrackerImpl(std::move(request), &context_);
 }
 
 void TestRequestTrackerApplication::Create(
     ApplicationConnection* connection,
     InterfaceRequest<TestTrackedRequestService> request) {
-  new TestTrackedRequestServiceImpl(request.Pass(), &context_);
+  new TestTrackedRequestServiceImpl(std::move(request), &context_);
 }
 
 }  // namespace test
diff --git a/mojo/services/test_service/test_request_tracker_impl.cc b/mojo/services/test_service/test_request_tracker_impl.cc
index 09fa4d5..8e2dab4 100644
--- a/mojo/services/test_service/test_request_tracker_impl.cc
+++ b/mojo/services/test_service/test_request_tracker_impl.cc
@@ -4,6 +4,8 @@
 
 #include "mojo/services/test_service/test_request_tracker_impl.h"
 
+#include <utility>
+
 namespace mojo {
 namespace test {
 
@@ -16,8 +18,9 @@ TrackingContext::~TrackingContext() {
 TestRequestTrackerImpl::TestRequestTrackerImpl(
     InterfaceRequest<TestRequestTracker> request,
     TrackingContext* context)
-    : context_(context), binding_(this, request.Pass()), weak_factory_(this) {
-}
+    : context_(context),
+      binding_(this, std::move(request)),
+      weak_factory_(this) {}
 
 TestRequestTrackerImpl::~TestRequestTrackerImpl() {
 }
@@ -42,8 +45,7 @@ void TestRequestTrackerImpl::SetNameAndReturnId(
 TestTrackedRequestServiceImpl::TestTrackedRequestServiceImpl(
     InterfaceRequest<TestTrackedRequestService> request,
     TrackingContext* context)
-    : context_(context), binding_(this, request.Pass()) {
-}
+    : context_(context), binding_(this, std::move(request)) {}
 
 TestTrackedRequestServiceImpl::~TestTrackedRequestServiceImpl() {
 }
@@ -66,9 +68,9 @@ void TestTrackedRequestServiceImpl::GetReport(
       mean_health_numerator += it2->health;
     }
     report->mean_health = mean_health_numerator / num_samples;
-    reports.push_back(report.Pass());
+    reports.push_back(std::move(report));
   }
-  callback.Run(reports.Pass());
+  callback.Run(std::move(reports));
 }
 
 }  // namespace test
diff --git a/mojo/services/test_service/test_service_application.cc b/mojo/services/test_service/test_service_application.cc
index 7fd16fa..1f1cfe6 100644
--- a/mojo/services/test_service/test_service_application.cc
+++ b/mojo/services/test_service/test_service_application.cc
@@ -5,6 +5,7 @@
 #include "mojo/services/test_service/test_service_application.h"
 
 #include <assert.h>
+#include <utility>
 
 #include "mojo/application/public/cpp/application_connection.h"
 #include "mojo/application/public/cpp/application_runner.h"
@@ -35,13 +36,13 @@ bool TestServiceApplication::ConfigureIncomingConnection(
 
 void TestServiceApplication::Create(ApplicationConnection* connection,
                                     InterfaceRequest<TestService> request) {
-  new TestServiceImpl(app_impl_, this, request.Pass());
+  new TestServiceImpl(app_impl_, this, std::move(request));
   AddRef();
 }
 
 void TestServiceApplication::Create(ApplicationConnection* connection,
                                     InterfaceRequest<TestTimeService> request) {
-  new TestTimeServiceImpl(app_impl_, request.Pass());
+  new TestTimeServiceImpl(app_impl_, std::move(request));
 }
 
 void TestServiceApplication::AddRef() {
diff --git a/mojo/services/test_service/test_service_impl.cc b/mojo/services/test_service/test_service_impl.cc
index 1f467e5..b6c0c61f 100644
--- a/mojo/services/test_service/test_service_impl.cc
+++ b/mojo/services/test_service/test_service_impl.cc
@@ -4,6 +4,8 @@
 
 #include "mojo/services/test_service/test_service_impl.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/i18n/time_formatting.h"
 #include "base/strings/utf_string_conversions.h"
@@ -20,7 +22,7 @@ TestServiceImpl::TestServiceImpl(ApplicationImpl* app_impl,
                                  InterfaceRequest<TestService> request)
     : application_(application),
       app_impl_(app_impl),
-      binding_(this, request.Pass()) {
+      binding_(this, std::move(request)) {
   binding_.set_connection_error_handler(
       [this]() { application_->ReleaseRef(); });
 }
@@ -55,7 +57,7 @@ void TestServiceImpl::StartTrackingRequests(
     const mojo::Callback<void()>& callback) {
   TestRequestTrackerPtr tracker;
   app_impl_->ConnectToService("mojo:test_request_tracker_app", &tracker);
-  tracking_.reset(new TrackedService(tracker.Pass(), Name_, callback));
+  tracking_.reset(new TrackedService(std::move(tracker), Name_, callback));
 }
 
 }  // namespace test
diff --git a/mojo/services/test_service/test_time_service_impl.cc b/mojo/services/test_service/test_time_service_impl.cc
index ae26a8e..4e17fd3 100644
--- a/mojo/services/test_service/test_time_service_impl.cc
+++ b/mojo/services/test_service/test_time_service_impl.cc
@@ -2,10 +2,13 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "mojo/services/test_service/test_time_service_impl.h"
+
+#include <utility>
+
 #include "base/time/time.h"
 #include "mojo/application/public/cpp/application_impl.h"
 #include "mojo/services/test_service/test_request_tracker.mojom.h"
-#include "mojo/services/test_service/test_time_service_impl.h"
 #include "mojo/services/test_service/tracked_service.h"
 
 namespace mojo {
@@ -14,8 +17,7 @@ namespace test {
 TestTimeServiceImpl::TestTimeServiceImpl(
     ApplicationImpl* app_impl,
     InterfaceRequest<TestTimeService> request)
-    : app_impl_(app_impl), binding_(this, request.Pass()) {
-}
+    : app_impl_(app_impl), binding_(this, std::move(request)) {}
 
 TestTimeServiceImpl::~TestTimeServiceImpl() {
 }
@@ -24,7 +26,7 @@ void TestTimeServiceImpl::StartTrackingRequests(
     const mojo::Callback<void()>& callback) {
   TestRequestTrackerPtr tracker;
   app_impl_->ConnectToService("mojo:test_request_tracker_app", &tracker);
-  tracking_.reset(new TrackedService(tracker.Pass(), Name_, callback));
+  tracking_.reset(new TrackedService(std::move(tracker), Name_, callback));
 }
 
 void TestTimeServiceImpl::GetPartyTime(
diff --git a/mojo/services/test_service/test_time_service_impl.h b/mojo/services/test_service/test_time_service_impl.h
index 242f66c..7b98272 100644
--- a/mojo/services/test_service/test_time_service_impl.h
+++ b/mojo/services/test_service/test_time_service_impl.h
@@ -14,6 +14,7 @@
 namespace mojo {
 
 class ApplicationConnection;
+class ApplicationImpl;
 
 namespace test {
 
diff --git a/mojo/services/test_service/tracked_service.cc b/mojo/services/test_service/tracked_service.cc
index a2fedfc..544183e 100644
--- a/mojo/services/test_service/tracked_service.cc
+++ b/mojo/services/test_service/tracked_service.cc
@@ -4,6 +4,8 @@
 
 #include "mojo/services/test_service/tracked_service.h"
 
+#include <utility>
+
 #include "base/bind.h"
 
 namespace mojo {
@@ -15,7 +17,7 @@ TrackedService::TrackedService(TestRequestTrackerPtr tracker,
     : id_(0u),
       requests_since_upload_(0u),
       service_name_(service_name),
-      tracker_(tracker.Pass()),
+      tracker_(std::move(tracker)),
       tracking_connected_callback_(callback) {
   tracker_->SetNameAndReturnId(
       service_name, base::Bind(&TrackedService::SetId, base::Unretained(this)));
@@ -35,7 +37,7 @@ void TrackedService::SendStats() {
   ServiceStatsPtr stats(ServiceStats::New());
   stats->num_new_requests = requests_since_upload_;
   stats->health = 0.7;
-  tracker_->RecordStats(id_, stats.Pass());
+  tracker_->RecordStats(id_, std::move(stats));
   requests_since_upload_ = 0u;
 }
 
diff --git a/mojo/services/tracing/public/cpp/trace_provider_impl.cc b/mojo/services/tracing/public/cpp/trace_provider_impl.cc
index 785d20f..e9190f5 100644
--- a/mojo/services/tracing/public/cpp/trace_provider_impl.cc
+++ b/mojo/services/tracing/public/cpp/trace_provider_impl.cc
@@ -4,6 +4,8 @@
 
 #include "mojo/services/tracing/public/cpp/trace_provider_impl.h"
 
+#include <utility>
+
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
@@ -22,7 +24,7 @@ TraceProviderImpl::~TraceProviderImpl() {}
 
 void TraceProviderImpl::Bind(InterfaceRequest<tracing::TraceProvider> request) {
   if (!binding_.is_bound()) {
-    binding_.Bind(request.Pass());
+    binding_.Bind(std::move(request));
   } else {
     LOG(ERROR) << "Cannot accept two connections to TraceProvider.";
   }
@@ -31,7 +33,7 @@ void TraceProviderImpl::Bind(InterfaceRequest<tracing::TraceProvider> request) {
 void TraceProviderImpl::StartTracing(const String& categories,
                                      tracing::TraceRecorderPtr recorder) {
   DCHECK(!recorder_);
-  recorder_ = recorder.Pass();
+  recorder_ = std::move(recorder);
   tracing_forced_ = false;
   if (!base::trace_event::TraceLog::GetInstance()->IsEnabled()) {
     std::string categories_str = categories.To<std::string>();
diff --git a/mojo/services/tracing/public/cpp/tracing_impl.cc b/mojo/services/tracing/public/cpp/tracing_impl.cc
index eed10f2..4b0872d 100644
--- a/mojo/services/tracing/public/cpp/tracing_impl.cc
+++ b/mojo/services/tracing/public/cpp/tracing_impl.cc
@@ -4,6 +4,8 @@
 
 #include "mojo/services/tracing/public/cpp/tracing_impl.h"
 
+#include <utility>
+
 #include "base/lazy_instance.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/platform_thread.h"
@@ -66,7 +68,7 @@ void TracingImpl::Initialize(ApplicationImpl* app) {
 
 void TracingImpl::Create(ApplicationConnection* connection,
                          InterfaceRequest<tracing::TraceProvider> request) {
-  provider_impl_.Bind(request.Pass());
+  provider_impl_.Bind(std::move(request));
 }
 
 }  // namespace mojo
diff --git a/mojo/services/tracing/trace_data_sink.cc b/mojo/services/tracing/trace_data_sink.cc
index 1174bfc..e608a74 100644
--- a/mojo/services/tracing/trace_data_sink.cc
+++ b/mojo/services/tracing/trace_data_sink.cc
@@ -4,6 +4,8 @@
 
 #include "mojo/services/tracing/trace_data_sink.h"
 
+#include <utility>
+
 #include "base/logging.h"
 #include "mojo/common/data_pipe_utils.h"
 
@@ -12,8 +14,7 @@ using mojo::common::BlockingCopyFromString;
 namespace tracing {
 
 TraceDataSink::TraceDataSink(mojo::ScopedDataPipeProducerHandle pipe)
-    : pipe_(pipe.Pass()), empty_(true) {
-}
+    : pipe_(std::move(pipe)), empty_(true) {}
 
 TraceDataSink::~TraceDataSink() {
   if (pipe_.is_valid())
diff --git a/mojo/services/tracing/trace_recorder_impl.cc b/mojo/services/tracing/trace_recorder_impl.cc
index 493abb5..92dd95c 100644
--- a/mojo/services/tracing/trace_recorder_impl.cc
+++ b/mojo/services/tracing/trace_recorder_impl.cc
@@ -4,13 +4,14 @@
 
 #include "mojo/services/tracing/trace_recorder_impl.h"
 
+#include <utility>
+
 namespace tracing {
 
 TraceRecorderImpl::TraceRecorderImpl(
     mojo::InterfaceRequest<TraceRecorder> request,
     TraceDataSink* sink)
-    : sink_(sink), binding_(this, request.Pass()) {
-}
+    : sink_(sink), binding_(this, std::move(request)) {}
 
 TraceRecorderImpl::~TraceRecorderImpl() {
 }
diff --git a/mojo/services/tracing/tracing_app.cc b/mojo/services/tracing/tracing_app.cc
index e73f0ab..3bc3557 100644
--- a/mojo/services/tracing/tracing_app.cc
+++ b/mojo/services/tracing/tracing_app.cc
@@ -4,6 +4,8 @@
 
 #include "mojo/services/tracing/tracing_app.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ -33,32 +35,33 @@ bool TracingApp::ConfigureIncomingConnection(
     TraceRecorderPtr recorder_ptr;
     recorder_impls_.push_back(
         new TraceRecorderImpl(GetProxy(&recorder_ptr), sink_.get()));
-    provider_ptr->StartTracing(tracing_categories_, recorder_ptr.Pass());
+    provider_ptr->StartTracing(tracing_categories_, std::move(recorder_ptr));
   }
-  provider_ptrs_.AddInterfacePtr(provider_ptr.Pass());
+  provider_ptrs_.AddInterfacePtr(std::move(provider_ptr));
   return true;
 }
 
 void TracingApp::Create(mojo::ApplicationConnection* connection,
                         mojo::InterfaceRequest<TraceCollector> request) {
-  collector_binding_.Bind(request.Pass());
+  collector_binding_.Bind(std::move(request));
 }
 
 void TracingApp::Create(
     mojo::ApplicationConnection* connection,
     mojo::InterfaceRequest<StartupPerformanceDataCollector> request) {
-  startup_performance_data_collector_bindings_.AddBinding(this, request.Pass());
+  startup_performance_data_collector_bindings_.AddBinding(this,
+                                                          std::move(request));
 }
 
 void TracingApp::Start(mojo::ScopedDataPipeProducerHandle stream,
                        const mojo::String& categories) {
   tracing_categories_ = categories;
-  sink_.reset(new TraceDataSink(stream.Pass()));
+  sink_.reset(new TraceDataSink(std::move(stream)));
   provider_ptrs_.ForAllPtrs([categories, this](TraceProvider* controller) {
     TraceRecorderPtr ptr;
     recorder_impls_.push_back(
         new TraceRecorderImpl(GetProxy(&ptr), sink_.get()));
-    controller->StartTracing(categories, ptr.Pass());
+    controller->StartTracing(categories, std::move(ptr));
   });
   tracing_active_ = true;
 }