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

mojo/services/network/http_connection_impl.cc

 // Copyright 2015 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 "mojo/services/network/http_connection_impl.h"
 
 #include <limits>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "mojo/message_pump/handle_watcher.h"
 #include "mojo/public/cpp/bindings/type_converter.h"
 #include "mojo/public/cpp/system/data_pipe.h"
@@ skipping 17 matching lines @@
  public:
   using CompletionCallback =
       base::Callback<void(SimpleDataPipeReader*, scoped_ptr<std::string>)>;
 
   SimpleDataPipeReader() {}
   ~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();
   }
 
  private:
   void ReadMore() {
     const void* buf;
     uint32_t buf_size;
     MojoResult rv = BeginReadDataRaw(consumer_.get(), &buf, &buf_size,
                                      MOJO_READ_DATA_FLAG_NONE);
     if (rv == MOJO_RESULT_OK) {
       buffer_->append(static_cast<const char*>(buf), buf_size);
       EndReadDataRaw(consumer_.get(), buf_size);
       WaitToReadMore();
     } else if (rv == MOJO_RESULT_SHOULD_WAIT) {
       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);
     }
   }
 
   void WaitToReadMore() {
     watcher_.Start(consumer_.get(), MOJO_HANDLE_SIGNAL_READABLE,
                    MOJO_DEADLINE_INDEFINITE,
                    base::Bind(&SimpleDataPipeReader::OnHandleReady,
@@ skipping 11 matching lines @@
 };
 
 class HttpConnectionImpl::WebSocketImpl : public WebSocket {
  public:
   // |connection| must outlive this object.
   WebSocketImpl(HttpConnectionImpl* connection,
                 InterfaceRequest<WebSocket> request,
                 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());
     DCHECK(client_);
     DCHECK(send_stream_.is_valid());
 
     binding_.set_connection_error_handler([this]() { Close(); });
     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 {}
 
   void Close() {
     DCHECK(!IsClosing());
 
     binding_.Close();
     client_.reset();
 
@@ skipping 100 matching lines @@
   static HttpRequestPtr Convert(const net::HttpServerRequestInfo& obj) {
     HttpRequestPtr request(HttpRequest::New());
     request->method = obj.method;
     request->url = obj.path;
     request->headers.resize(obj.headers.size());
     size_t index = 0;
     for (const auto& item : obj.headers) {
       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());
       MojoCreateDataPipeOptions options;
       options.struct_size = sizeof(MojoCreateDataPipeOptions);
       options.flags = MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE;
       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;
   }
 };
 
 HttpConnectionImpl::HttpConnectionImpl(int connection_id,
                                        HttpServerImpl* server,
                                        HttpConnectionDelegatePtr delegate,
                                        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(); });
   delegate_.set_connection_error_handler([this]() { Close(); });
 }
 
 HttpConnectionImpl::~HttpConnectionImpl() {
   STLDeleteElements(&response_body_readers_);
 }
 
 void HttpConnectionImpl::OnReceivedHttpRequest(
     const net::HttpServerRequestInfo& info) {
   if (IsClosing())
     return;
 
   delegate_->OnReceivedRequest(
       HttpRequest::From(info), [this](HttpResponsePtr response) {
         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);
         }
       });
 }
 
 void HttpConnectionImpl::OnReceivedWebSocketRequest(
     const net::HttpServerRequestInfo& info) {
   if (IsClosing())
     return;
 
   delegate_->OnReceivedWebSocketRequest(
       HttpRequest::From(info),
       [this, info](InterfaceRequest<WebSocket> web_socket,
                    ScopedDataPipeConsumerHandle send_stream,
                    WebSocketClientPtr web_socket_client) {
         if (!web_socket.is_pending() || !send_stream.is_valid() ||
             !web_socket_client) {
           Close();
           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);
       });
 }
 
 void HttpConnectionImpl::OnReceivedWebSocketMessage(const std::string& data) {
   if (IsClosing())
     return;
 
   web_socket_->OnReceivedWebSocketMessage(data);
 }
@@ skipping 92 matching lines @@
     // The close operation is initiated by this object.
     NotifyOwnerCloseIfAllDone();
   } else {
     // The close operation is initiated by |web_socket_|; start closing this
     // object.
     Close();
   }
 }
 
 }  // namespace mojo