Update monet.

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 "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/common/data_pipe_utils.h"
+#include "mojo/data_pipe_utils/data_pipe_utils.h"
 #include "mojo/services/network/interfaces/http_connection.mojom.h"
 #include "mojo/services/network/interfaces/http_message.mojom.h"
 #include "mojo/services/network/interfaces/http_server.mojom.h"
 #include "mojo/services/network/interfaces/net_address.mojom.h"
 #include "mojo/services/network/interfaces/network_service.mojom.h"
 #include "mojo/services/network/interfaces/web_socket.mojom.h"
 #include "mojo/services/network/net_address_type_converters.h"
 #include "mojo/services/network/web_socket_read_queue.h"
 #include "mojo/services/network/web_socket_write_queue.h"
 #include "net/base/io_buffer.h"
@@ skipping 241 matching lines @@
   scoped_refptr<net::DrainableIOBuffer> write_buffer_;
   scoped_ptr<net::TCPClientSocket> socket_;
   int connect_result_;
 
   DISALLOW_COPY_AND_ASSIGN(TestHttpClient);
 };
 
 class WebSocketClientImpl : public WebSocketClient {
  public:
   explicit WebSocketClientImpl()
-      : binding_(this, &client_ptr_),
+      : binding_(this, &client_handle_),
         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();
 
     DataPipe data_pipe;
     send_stream_ = data_pipe.producer_handle.Pass();
     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());
+                         data_pipe.consumer_handle.Pass(),
+                         client_handle_.Pass());
   }
 
   // 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();
     write_send_stream_.reset(new WebSocketWriteQueue(send_stream_.get()));
 
     callback.Run(web_socket_request.Pass(), data_pipe.consumer_handle.Pass(),
-                 client_ptr_.Pass());
+                 client_handle_.Pass());
   }
 
   void WaitForConnectCompletion() {
     DCHECK(!run_loop_);
 
     if (receive_stream_.is_valid())
       return;
 
     base::RunLoop run_loop;
     run_loop_ = &run_loop;
@@ skipping 64 matching lines @@
   void OnFinishedReadingReceiveStream(uint32_t num_bytes, const char* data) {
     EXPECT_TRUE(data);
 
     received_messages_.push_back(std::string(data, num_bytes));
     if (run_loop_ && received_messages_.size() >= wait_for_message_count_) {
       wait_for_message_count_ = 0;
       run_loop_->Quit();
     }
   }
 
-  WebSocketClientPtr client_ptr_;
+  InterfaceHandle<WebSocketClient> client_handle_;
   Binding<WebSocketClient> binding_;
   WebSocketPtr web_socket_;
 
   ScopedDataPipeProducerHandle send_stream_;
   scoped_ptr<WebSocketWriteQueue> write_send_stream_;
 
   ScopedDataPipeConsumerHandle receive_stream_;
   scoped_ptr<WebSocketReadQueue> read_receive_stream_;
 
   std::vector<std::string> received_messages_;
   size_t wait_for_message_count_;
 
   // Pointing to a stack-allocated RunLoop instance.
   base::RunLoop* run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(WebSocketClientImpl);
 };
 
 class HttpConnectionDelegateImpl : public HttpConnectionDelegate {
  public:
   struct PendingRequest {
     HttpRequestPtr request;
     OnReceivedRequestCallback callback;
   };
 
-  HttpConnectionDelegateImpl(HttpConnectionPtr connection,
+  HttpConnectionDelegateImpl(InterfaceHandle<HttpConnection> connection,
                              InterfaceRequest<HttpConnectionDelegate> request)
-      : connection_(connection.Pass()),
+      : connection_(HttpConnectionPtr::Create(connection.Pass())),
         binding_(this, request.Pass()),
         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();
@@ skipping 62 matching lines @@
   scoped_ptr<WebSocketClientImpl> web_socket_;
 
   // Pointing to a stack-allocated RunLoop instance.
   base::RunLoop* run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpConnectionDelegateImpl);
 };
 
 class HttpServerDelegateImpl : public HttpServerDelegate {
  public:
-  explicit HttpServerDelegateImpl(HttpServerDelegatePtr* delegate_ptr)
-      : binding_(this, delegate_ptr),
+  explicit HttpServerDelegateImpl(
+      InterfaceHandle<HttpServerDelegate>* delegate_handle)
+      : binding_(this, delegate_handle),
         wait_for_connection_count_(0),
         run_loop_(nullptr) {}
   ~HttpServerDelegateImpl() override {}
 
   // HttpServerDelegate implementation.
-  void OnConnected(HttpConnectionPtr connection,
+  void OnConnected(InterfaceHandle<HttpConnection> connection,
                    InterfaceRequest<HttpConnectionDelegate> delegate) override {
     connections_.push_back(make_linked_ptr(
         new HttpConnectionDelegateImpl(connection.Pass(), delegate.Pass())));
     if (run_loop_ && connections_.size() >= wait_for_connection_count_) {
       wait_for_connection_count_ = 0;
       run_loop_->Quit();
     }
   }
 
   void WaitForConnection(size_t count) {
@@ skipping 32 matching lines @@
   bool ShouldCreateDefaultRunLoop() override { return false; }
 
   void SetUp() override {
     ApplicationTestBase::SetUp();
 
     ApplicationConnection* connection =
         application_impl()->ConnectToApplication("mojo:network_service");
     connection->ConnectToService(&network_service_);
   }
 
-  void CreateHttpServer(HttpServerDelegatePtr delegate,
+  void CreateHttpServer(InterfaceHandle<HttpServerDelegate> delegate,
                         NetAddressPtr* out_bound_to) {
     network_service_->CreateHttpServer(
         GetLocalHostWithAnyPort(), delegate.Pass(),
         [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();
         });
     network_service_.WaitForIncomingResponse();
   }
 
   NetworkServicePtr network_service_;
 
  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);
+  InterfaceHandle<HttpServerDelegate> server_delegate_handle;
+  HttpServerDelegateImpl server_delegate_impl(&server_delegate_handle);
+  CreateHttpServer(server_delegate_handle.Pass(), &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());
 
   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);
+  InterfaceHandle<HttpServerDelegate> server_delegate_handle;
+  HttpServerDelegateImpl server_delegate_impl(&server_delegate_handle);
+  CreateHttpServer(server_delegate_handle.Pass(), &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",
@@ skipping 15 matching lines @@
   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);
+  InterfaceHandle<HttpServerDelegate> server_delegate_handle;
+  HttpServerDelegateImpl server_delegate_impl(&server_delegate_handle);
+  CreateHttpServer(server_delegate_handle.Pass(), &bound_to);
 
   WebSocketPtr web_socket_ptr;
   network_service_->CreateWebSocket(GetProxy(&web_socket_ptr));
   WebSocketClientImpl socket_0;
   socket_0.Connect(
       web_socket_ptr.Pass(),
       base::StringPrintf("ws://127.0.0.1:%d/hello", bound_to->ipv4->port));
 
   server_delegate_impl.WaitForConnection(1);
   HttpConnectionDelegateImpl& connection =
@@ skipping 14 matching lines @@
 
   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