[chromedriver] Write websocket client and sync websocket client.

chrome/test/chromedriver/net/web_socket.cc

Index: chrome/test/chromedriver/net/web_socket.cc
diff --git a/chrome/test/chromedriver/net/web_socket.cc b/chrome/test/chromedriver/net/web_socket.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e309aaa1c4345aa835005f57987143d0be3e5159
--- /dev/null
+++ b/chrome/test/chromedriver/net/web_socket.cc
@@ -0,0 +1,143 @@
+// Copyright (c) 2012 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 "chrome/test/chromedriver/net/web_socket.h"
+
+#include "base/memory/scoped_vector.h"
+#include "base/string_split.h"
+#include "base/stringprintf.h"
+#include "net/base/io_buffer.h"
+#include "net/url_request/url_request_context_getter.h"
+#include "net/websockets/websocket_frame.h"
+#include "net/websockets/websocket_frame_parser.h"
+#include "net/websockets/websocket_job.h"
+
+WebSocket::WebSocket(
+    net::URLRequestContextGetter* context_getter,
+    const GURL& url,
+    WebSocketListener* listener)
+    : context_getter_(context_getter),
+      url_(url),
+      listener_(listener),
+      connected_(false) {
+  net::WebSocketJob::EnsureInit();
+  web_socket_ = new net::WebSocketJob(this);
+}
+
+WebSocket::~WebSocket() {
+  CHECK(thread_checker_.CalledOnValidThread());
+  web_socket_->Close();

[Takashi Toyoshima, 2012/11/27 07:57:37]

This Close() may not perform closing handshake correctly.
If you need to close the connection gracefully, you should expose Close method
as WebSocket::Close(). Caller should call WebSocket::Close() and wait OnClose()
delegate call before deleting WebSocket object.

[kkania, 2012/11/27 19:58:23]

Ok. Right now we don't have any need to close the connection gracefully, since
this will only be called when terminating ChromeDriver/Chrome. I may add this in
the future. Let me know if there's a reason I should add it now.

[Takashi Toyoshima, 2012/11/28 09:11:30]

Without closing handshake, we have no confidence that all sent packages are
received by a server. If your application level protocol has a kind of ACK
mechanism, or it's not problem that a server misses to receive some data, it's
not mandatory. You can omit this now.

+  web_socket_->DetachDelegate();
+}
+
+void WebSocket::Connect(const base::Callback<void(bool)>& callback) {
+  CHECK(thread_checker_.CalledOnValidThread());
+  CHECK_EQ(net::WebSocketJob::INITIALIZED, web_socket_->state());
+
+  connect_callback_ = callback;
+
+  scoped_refptr<net::SocketStream> socket = new net::SocketStream(
+      url_, web_socket_);
+  socket->set_context(context_getter_->GetURLRequestContext());
+
+  web_socket_->InitSocketStream(socket);
+  web_socket_->Connect();
+}
+
+bool WebSocket::Write(const std::string& message) {
+  CHECK(thread_checker_.CalledOnValidThread());
+
+  net::WebSocketFrameHeader header;
+  header.final = true;
+  header.reserved1 = false;
+  header.reserved2 = false;
+  header.reserved3 = false;
+  header.opcode = net::WebSocketFrameHeader::kOpCodeText;
+  header.masked = true;
+  header.payload_length = message.length();
+  int header_size = net::GetWebSocketFrameHeaderSize(header);
+  net::WebSocketMaskingKey masking_key = net::GenerateWebSocketMaskingKey();
+  std::string header_str;
+  header_str.resize(header_size);
+  CHECK_EQ(header_size, net::WriteWebSocketFrameHeader(
+      header, &masking_key, &header_str[0], header_str.length()));
+
+  std::string masked_message = message;
+  net::MaskWebSocketFramePayload(
+      masking_key, 0, &masked_message[0], masked_message.length());
+  std::string data = header_str + masked_message;
+  return web_socket_->SendData(data.c_str(), data.length());
+}
+
+void WebSocket::OnConnected(net::SocketStream* socket,
+                            int max_pending_send_allowed) {
+  std::string handshake = base::StringPrintf(
+      "GET %s HTTP/1.1\r\n"
+      "Host: %s\r\n"
+      "Upgrade: WebSocket\r\n"

[Takashi Toyoshima, 2012/11/27 07:57:37]

The value is case-insensitive, but I recommend to use 'websocket' here.

[kkania, 2012/11/27 19:58:23]

Done.

+      "Connection: Upgrade\r\n"
+      "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"

[Takashi Toyoshima, 2012/11/27 07:57:37]

This value must not be a constant string.
It's a base64-encoded 16-bytes randomized values.

std::string sec_key;
static const size_t nonce_size = 16;
char key[nonce_size];
base::RandBytes(key, nonce_size);
base::StringPieve key_piece(key, nonce_size);
base::Base64Encode(key_piece, sec_key);

[kkania, 2012/11/27 19:58:23]

Done.

+      "Sec-WebSocket-Version: 13\r\n"

[Takashi Toyoshima, 2012/11/27 07:57:37]

If ChromeDriver works over the internet, I suggest to add following two headers
like other browser implementations do.

- Pragma: no-cache
- Cache-Control: no-cache

These headers are useful to connect over some kinds of poor proxies.

[kkania, 2012/11/27 19:58:23]

Done.

+      "\r\n",
+      url_.path().c_str(),
+      url_.host().c_str());
+  if (!web_socket_->SendData(handshake.c_str(), handshake.length()))
+    OnConnectFinished(false);
+}
+
+void WebSocket::OnSentData(net::SocketStream* socket,
+                           int amount_sent) {}
+
+void WebSocket::OnReceivedData(net::SocketStream* socket,
+                               const char* data, int len) {
+  net::WebSocketJob::State state = web_socket_->state();
+  if (!connect_callback_.is_null()) {
+    std::vector<std::string> parts;
+    base::SplitStringUsingSubstr(std::string(data, len), "\r\n", &parts);
+    if (parts.empty() ||
+        parts[0] != "HTTP/1.1 101 WebSocket Protocol Handshake") {
+      OnConnectFinished(false);
+      return;
+    }

[Takashi Toyoshima, 2012/11/27 07:57:37]

You should not expect 'WebSocket Protocol Handshake' here. Just check status
code here.
And should check Upgrade, Connection, Sec-WebSocket-Accept headers.

Maybe you can use net/http/http_response_headers to parse response.

[kkania, 2012/11/27 19:58:23]

Done.

+    OnConnectFinished(state == net::WebSocketJob::OPEN);
+  } else if (connected_) {
+    incoming_msg_buf_ += std::string(data, len);
+    ScopedVector<net::WebSocketFrameChunk> frame_chunks;
+    net::WebSocketFrameParser parser;
+    CHECK(parser.Decode(incoming_msg_buf_.c_str(),
+                        incoming_msg_buf_.length(),
+                        &frame_chunks));
+    int processed_data = 0;
+    std::string message;
+    int header = 0;
+    for (size_t i = 0; i < frame_chunks.size(); ++i) {
+      scoped_refptr<net::IOBufferWithSize> buffer = frame_chunks[i]->data;
+      if (buffer)
+        message += std::string(buffer->data(), buffer->size());
+      if (frame_chunks[i]->final_chunk) {
+        processed_data += frame_chunks[header]->header->payload_length +
+            net::GetWebSocketFrameHeaderSize(*frame_chunks[header]->header);
+        listener_->OnMessageReceived(message);
+        message.clear();
+        header = i + 1;
+      }
+    }
+    if (processed_data)
+      incoming_msg_buf_.erase(0, processed_data);
+  }
+}
+
+void WebSocket::OnClose(net::SocketStream* socket) {
+  if (!connect_callback_.is_null())
+    OnConnectFinished(false);
+  else
+    listener_->OnClose();
+}
+
+void WebSocket::OnConnectFinished(bool success) {
+  connected_ = success;
+  base::Callback<void(bool)> temp = connect_callback_;
+  connect_callback_.Reset();
+  temp.Run(success);
+}