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

mojo/services/network/http_server_apptest.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 <utility>
+
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "mojo/application/public/cpp/application_connection.h"
 #include "mojo/application/public/cpp/application_impl.h"
@@ skipping 26 matching lines @@
   NetAddressPtr addr(NetAddress::New());
   addr->family = NET_ADDRESS_FAMILY_IPV4;
   addr->ipv4 = NetAddressIPv4::New();
   addr->ipv4->port = 0;
   addr->ipv4->addr.resize(4);
   addr->ipv4->addr[0] = 127;
   addr->ipv4->addr[1] = 0;
   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>>;
 
 struct TestRequest {
   std::string method;
   std::string url;
   TestHeaders headers;
   scoped_ptr<std::string> body;
 };
@@ skipping 17 matching lines @@
 
 HttpResponsePtr MakeResponseStruct(const TestResponse& data) {
   HttpResponsePtr response(HttpResponse::New());
   response->status_code = data.status_code;
   response->headers.resize(data.headers.size());
   size_t index = 0;
   for (const auto& item : data.headers) {
     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) {
     uint32_t num_bytes = static_cast<uint32_t>(data.body->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);
-    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,
                   const Array<HttpHeaderPtr>& headers) {
   // The server impl fiddles with Content-Length and Content-Type. So we don't
   // do a strict check here.
   std::map<std::string, std::string> header_map;
   for (size_t i = 0; i < headers.size(); ++i) {
     std::string lower_name =
         base::ToLowerASCII(headers[i]->name.To<std::string>());
     header_map[lower_name] = headers[i]->value;
   }
 
   for (const auto& item : expected) {
     std::string lower_name = base::ToLowerASCII(item.first);
     EXPECT_NE(header_map.end(), header_map.find(lower_name));
     EXPECT_EQ(item.second, header_map[lower_name]);
   }
 }
 
 void CheckRequest(const TestRequest& expected, HttpRequestPtr request) {
   EXPECT_EQ(expected.method, request->method);
   EXPECT_EQ(expected.url, request->url);
   CheckHeaders(expected.headers, request->headers);
   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());
   }
 }
 
 void CheckResponse(const TestResponse& expected, const std::string& response) {
   int header_end =
       net::HttpUtil::LocateEndOfHeaders(response.c_str(), response.size());
   std::string assembled_headers =
@@ skipping 127 matching lines @@
 class WebSocketClientImpl : public WebSocketClient {
  public:
   explicit WebSocketClientImpl()
       : binding_(this, &client_ptr_),
         wait_for_message_count_(0),
         run_loop_(nullptr) {}
   ~WebSocketClientImpl() override {}
 
   // 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.
   void AcceptConnectRequest(
       const HttpConnectionDelegate::OnReceivedWebSocketRequestCallback&
           callback) {
     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() {
     DCHECK(!run_loop_);
 
     if (receive_stream_.is_valid())
       return;
 
     base::RunLoop run_loop;
     run_loop_ = &run_loop;
@@ skipping 23 matching lines @@
     run_loop_ = nullptr;
   }
 
   std::vector<std::string>& received_messages() { return received_messages_; }
 
  private:
   // WebSocketClient implementation.
   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);
     if (run_loop_)
       run_loop_->Quit();
   }
 
   void DidReceiveData(bool fin,
                       WebSocket::MessageType type,
                       uint32_t num_bytes) override {
@@ skipping 48 matching lines @@
 
 class HttpConnectionDelegateImpl : public HttpConnectionDelegate {
  public:
   struct PendingRequest {
     HttpRequestPtr request;
     OnReceivedRequestCallback callback;
   };
 
   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 {}
 
   // HttpConnectionDelegate implementation:
   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_) {
       wait_for_request_count_ = 0;
       run_loop_->Quit();
     }
   }
 
   void OnReceivedWebSocketRequest(
       HttpRequestPtr request,
       const OnReceivedWebSocketRequestCallback& callback) override {
     web_socket_.reset(new WebSocketClientImpl());
 
     web_socket_->AcceptConnectRequest(callback);
 
     if (run_loop_)
       run_loop_->Quit();
   }
 
   void SendResponse(HttpResponsePtr response) {
     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) {
     DCHECK(!run_loop_);
 
     if (pending_requests_.size() >= count)
       return;
 
     wait_for_request_count_ = count;
     base::RunLoop run_loop;
@@ skipping 37 matching lines @@
  public:
   explicit HttpServerDelegateImpl(HttpServerDelegatePtr* delegate_ptr)
       : binding_(this, delegate_ptr),
         wait_for_connection_count_(0),
         run_loop_(nullptr) {}
   ~HttpServerDelegateImpl() override {}
 
   // 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();
     }
   }
 
   void WaitForConnection(size_t count) {
     DCHECK(!run_loop_);
 
     if (connections_.size() >= count)
@@ skipping 33 matching lines @@
 
     scoped_ptr<ApplicationConnection> connection =
         application_impl()->ConnectToApplication("mojo:network_service");
     connection->ConnectToService(&network_service_);
     connection->ConnectToService(&web_socket_factory_);
   }
 
   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();
   }
 
   NetworkServicePtr network_service_;
   WebSocketFactoryPtr web_socket_factory_;
 
  private:
   base::MessageLoop message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpServerAppTest);
 };
 
 }  // namespace
 
 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>());
 
   server_delegate_impl.WaitForConnection(1);
   HttpConnectionDelegateImpl& connection =
       *server_delegate_impl.connections()[0];
 
   TestRequest request_data = {"HEAD", "/test", {{"Hello", "World"}}, nullptr};
   client.Send(MakeRequestMessage(request_data));
 
   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));
   // This causes the underlying TCP connection to be closed. The client can
   // determine the end of the response based on that.
   server_delegate_impl.connections().clear();
 
   std::string response_message;
   client.ReadResponse(&response_message);
 
   CheckResponse(response_data, response_message);
 }
 
 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>());
 
   server_delegate_impl.WaitForConnection(1);
   HttpConnectionDelegateImpl& connection =
       *server_delegate_impl.connections()[0];
 
   TestRequest request_data = {
       "Post",
       "/test",
       {{"Hello", "World"},
        {"Content-Length", "23"},
        {"Content-Type", "text/plain"}},
       make_scoped_ptr(new std::string("This is a test request!"))};
   client.Send(MakeRequestMessage(request_data));
 
   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", "26"}},
       make_scoped_ptr(new std::string("This is a test response..."))};
   connection.SendResponse(MakeResponseStruct(response_data));
 
   std::string response_message;
   client.ReadResponse(&response_message);
 
   CheckResponse(response_data, response_message);
 }
 
 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);
   HttpConnectionDelegateImpl& connection =
       *server_delegate_impl.connections()[0];
 
   connection.WaitForWebSocketRequest();
   WebSocketClientImpl& socket_1 = *connection.web_socket();
 
   socket_1.WaitForConnectCompletion();
   socket_0.WaitForConnectCompletion();
 
   socket_0.Send("Hello");
   socket_0.Send("world!");
 
   socket_1.WaitForMessage(2);
   EXPECT_EQ("Hello", socket_1.received_messages()[0]);
   EXPECT_EQ("world!", socket_1.received_messages()[1]);
 
   socket_1.Send("How do");
   socket_1.Send("you do?");
 
   socket_0.WaitForMessage(2);
   EXPECT_EQ("How do", socket_0.received_messages()[0]);
   EXPECT_EQ("you do?", socket_0.received_messages()[1]);
 }
 
 }  // namespace mojo