Mojo service implementation for HTTP server - part 3

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/application/public/cpp/application_connection.h"
 #include "mojo/application/public/cpp/application_impl.h"
 #include "mojo/application/public/cpp/application_test_base.h"
 #include "mojo/common/data_pipe_utils.h"
 #include "mojo/services/network/net_address_type_converters.h"
+#include "mojo/services/network/public/cpp/web_socket_read_queue.h"
+#include "mojo/services/network/public/cpp/web_socket_write_queue.h"
+#include "mojo/services/network/public/interfaces/http_connection.mojom.h"
+#include "mojo/services/network/public/interfaces/http_message.mojom.h"
 #include "mojo/services/network/public/interfaces/http_server.mojom.h"
+#include "mojo/services/network/public/interfaces/net_address.mojom.h"
 #include "mojo/services/network/public/interfaces/network_service.mojom.h"
+#include "mojo/services/network/public/interfaces/web_socket.mojom.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/socket/tcp_client_socket.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace {
@@ skipping 226 matching lines @@
   }
 
   scoped_refptr<net::IOBufferWithSize> read_buffer_;
   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_),
+        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());
+  }
+
+  // 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());
+  }
+
+  void WaitForConnectCompletion() {
+    DCHECK(!run_loop_);
+
+    if (receive_stream_.is_valid())
+      return;
+
+    base::RunLoop run_loop;
+    run_loop_ = &run_loop;
+    run_loop.Run();
+    run_loop_ = nullptr;
+  }
+
+  void Send(const std::string& message) {
+    DCHECK(!message.empty());
+
+    uint32_t size = static_cast<uint32_t>(message.size());
+    write_send_stream_->Write(
+        &message[0], size,
+        base::Bind(&WebSocketClientImpl::OnFinishedWritingSendStream,
+                   base::Unretained(this), size));
+  }
+
+  void WaitForMessage(size_t count) {
+    DCHECK(!run_loop_);
+
+    if (received_messages_.size() >= count)
+      return;
+    wait_for_message_count_ = count;
+    base::RunLoop run_loop;
+    run_loop_ = &run_loop;
+    run_loop.Run();
+    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();
+    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 {
+    DCHECK(num_bytes > 0);
+
+    read_receive_stream_->Read(
+        num_bytes,
+        base::Bind(&WebSocketClientImpl::OnFinishedReadingReceiveStream,
+                   base::Unretained(this), num_bytes));
+  }
+
+  void DidReceiveFlowControl(int64_t quota) override {}
+
+  void DidFail(const String& message) override {}
+
+  void DidClose(bool was_clean, uint16_t code, const String& reason) override {}
+
+  void OnFinishedWritingSendStream(uint32_t num_bytes, const char* buffer) {
+    EXPECT_TRUE(buffer);
+
+    web_socket_->Send(true, WebSocket::MESSAGE_TYPE_TEXT, num_bytes);
+  }
+
+  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_;
+  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,
                              InterfaceRequest<HttpConnectionDelegate> request)
       : connection_(connection.Pass()),
         binding_(this, request.Pass()),
-        run_loop_(nullptr),
-        wait_for_request_count_(0) {}
+        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->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 {
-    NOTREACHED();
+    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());
   }
 
   void WaitForRequest(size_t count) {
     DCHECK(!run_loop_);
 
+    if (pending_requests_.size() >= count)
+      return;
+
     wait_for_request_count_ = count;
     base::RunLoop run_loop;
     run_loop_ = &run_loop;
     run_loop.Run();
     run_loop_ = nullptr;
   }
 
+  void WaitForWebSocketRequest() {
+    DCHECK(!run_loop_);
+
+    if (web_socket_)
+      return;
+
+    base::RunLoop run_loop;
+    run_loop_ = &run_loop;
+    run_loop.Run();
+    run_loop_ = nullptr;
+  }
+
   std::vector<linked_ptr<PendingRequest>>& pending_requests() {
     return pending_requests_;
   }
 
+  WebSocketClientImpl* web_socket() { return web_socket_.get(); }
+
  private:
   HttpConnectionPtr connection_;
   Binding<HttpConnectionDelegate> binding_;
   std::vector<linked_ptr<PendingRequest>> pending_requests_;
+  size_t wait_for_request_count_;
+  scoped_ptr<WebSocketClientImpl> web_socket_;
+
   // Pointing to a stack-allocated RunLoop instance.
   base::RunLoop* run_loop_;
-  size_t wait_for_request_count_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpConnectionDelegateImpl);
 };
 
 class HttpServerDelegateImpl : public HttpServerDelegate {
  public:
   explicit HttpServerDelegateImpl(HttpServerDelegatePtr* delegate_ptr)
       : binding_(this, delegate_ptr),
-        run_loop_(nullptr),
-        wait_for_connection_count_(0) {}
+        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())));
     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)
+      return;
+
     wait_for_connection_count_ = count;
     base::RunLoop run_loop;
     run_loop_ = &run_loop;
     run_loop.Run();
     run_loop_ = nullptr;
   }
 
   std::vector<linked_ptr<HttpConnectionDelegateImpl>>& connections() {
     return connections_;
   }
 
  private:
   Binding<HttpServerDelegate> binding_;
   std::vector<linked_ptr<HttpConnectionDelegateImpl>> connections_;
+  size_t wait_for_connection_count_;
   // Pointing to a stack-allocated RunLoop instance.
   base::RunLoop* run_loop_;
-  size_t wait_for_connection_count_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpServerDelegateImpl);
 };
 
 class HttpServerAppTest : public test::ApplicationTestBase {
  public:
   HttpServerAppTest() : message_loop_(base::MessageLoop::TYPE_IO) {}
   ~HttpServerAppTest() override {}
 
  protected:
@@ skipping 92 matching lines @@
       {{"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);
+
+  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 =
+      *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