Replace StreamListenSocket with StreamSocket in HttpServer.

net/server/web_socket.cc

 // 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 "net/server/web_socket.h"
 
 #include <limits>
 
 #include "base/base64.h"
 #include "base/rand_util.h"
 #include "base/logging.h"
 #include "base/md5.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_byteorder.h"
-#include "net/server/http_connection.h"
+#include "net/server/http_server.h"
 #include "net/server/http_server_request_info.h"
 #include "net/server/http_server_response_info.h"
 
 namespace net {
 
 namespace {
 
 static uint32 WebSocketKeyFingerprint(const std::string& str) {
   std::string result;
   const char* p_char = str.c_str();
   int length = str.length();
   int spaces = 0;
   for (int i = 0; i < length; ++i) {
     if (p_char[i] >= '0' && p_char[i] <= '9')
       result.append(&p_char[i], 1);
     else if (p_char[i] == ' ')
       spaces++;
   }
   if (spaces == 0)
     return 0;
   int64 number = 0;
   if (!base::StringToInt64(result, &number))
     return 0;
   return base::HostToNet32(static_cast<uint32>(number / spaces));
 }
 
 class WebSocketHixie76 : public net::WebSocket {
  public:
-  static net::WebSocket* Create(HttpConnection* connection,
+  static net::WebSocket* Create(HttpServer* server,
+                                HttpConnection* connection,
                                 const HttpServerRequestInfo& request,
                                 size_t* pos) {
-    if (connection->recv_data().length() < *pos + kWebSocketHandshakeBodyLen)
+    if (connection->read_buf()->GetUnconsumedSize()
+        < static_cast<int>(*pos + kWebSocketHandshakeBodyLen))
       return NULL;
-    return new WebSocketHixie76(connection, request, pos);
+    return new WebSocketHixie76(server, connection, request, pos);
   }
 
   virtual void Accept(const HttpServerRequestInfo& request) OVERRIDE {
     std::string key1 = request.GetHeaderValue("sec-websocket-key1");
     std::string key2 = request.GetHeaderValue("sec-websocket-key2");
 
     uint32 fp1 = WebSocketKeyFingerprint(key1);
     uint32 fp2 = WebSocketKeyFingerprint(key2);
 
     char data[16];
     memcpy(data, &fp1, 4);
     memcpy(data + 4, &fp2, 4);
     memcpy(data + 8, &key3_[0], 8);
 
     base::MD5Digest digest;
     base::MD5Sum(data, 16, &digest);
 
     std::string origin = request.GetHeaderValue("origin");
     std::string host = request.GetHeaderValue("host");
     std::string location = "ws://" + host + request.path;
-    connection_->Send(base::StringPrintf(
-        "HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
-        "Upgrade: WebSocket\r\n"
-        "Connection: Upgrade\r\n"
-        "Sec-WebSocket-Origin: %s\r\n"
-        "Sec-WebSocket-Location: %s\r\n"
-        "\r\n",
-        origin.c_str(),
-        location.c_str()));
-    connection_->Send(reinterpret_cast<char*>(digest.a), 16);
+    server_->SendRaw(
+        connection_->id(),
+        base::StringPrintf("HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
+                           "Upgrade: WebSocket\r\n"
+                           "Connection: Upgrade\r\n"
+                           "Sec-WebSocket-Origin: %s\r\n"
+                           "Sec-WebSocket-Location: %s\r\n"
+                           "\r\n",
+                           origin.c_str(),
+                           location.c_str()));
+    server_->SendRaw(connection_->id(),
+                     std::string(reinterpret_cast<char*>(digest.a), 16));
   }
 
   virtual ParseResult Read(std::string* message) OVERRIDE {
     DCHECK(message);
-    const std::string& data = connection_->recv_data();
-    if (data[0])
+    HttpConnection::ReadIOBuffer* read_buf = connection_->read_buf();
+    if (read_buf->data()[0])
       return FRAME_ERROR;
 
+    base::StringPiece data(read_buf->data(), read_buf->GetUnconsumedSize());
     size_t pos = data.find('\377', 1);
-    if (pos == std::string::npos)
+    if (pos == base::StringPiece::npos)
       return FRAME_INCOMPLETE;
 
-    std::string buffer(data.begin() + 1, data.begin() + pos);
-    message->swap(buffer);
-    connection_->Shift(pos + 1);
+    message->assign(read_buf->data() + 1, pos - 1);
+    read_buf->DidConsume(pos + 1);
 
     return FRAME_OK;
   }
 
   virtual void Send(const std::string& message) OVERRIDE {
     char message_start = 0;
     char message_end = -1;
-    connection_->Send(&message_start, 1);
-    connection_->Send(message);
-    connection_->Send(&message_end, 1);
+    server_->SendRaw(connection_->id(), std::string(1, message_start));
+    server_->SendRaw(connection_->id(), message);
+    server_->SendRaw(connection_->id(), std::string(1, message_end));
   }
 
  private:
   static const int kWebSocketHandshakeBodyLen;
 
-  WebSocketHixie76(HttpConnection* connection,
+  WebSocketHixie76(HttpServer* server,
+                   HttpConnection* connection,
                    const HttpServerRequestInfo& request,
-                   size_t* pos) : WebSocket(connection) {
+                   size_t* pos)
+      : WebSocket(server, connection) {
     std::string key1 = request.GetHeaderValue("sec-websocket-key1");
     std::string key2 = request.GetHeaderValue("sec-websocket-key2");
 
     if (key1.empty()) {
-      connection->Send(HttpServerResponseInfo::CreateFor500(
-          "Invalid request format. Sec-WebSocket-Key1 is empty or isn't "
-          "specified."));
+      server->SendResponse(
+          connection->id(),
+          HttpServerResponseInfo::CreateFor500(
+              "Invalid request format. Sec-WebSocket-Key1 is empty or isn't "
+              "specified."));
       return;
     }
 
     if (key2.empty()) {
-      connection->Send(HttpServerResponseInfo::CreateFor500(
-          "Invalid request format. Sec-WebSocket-Key2 is empty or isn't "
-          "specified."));
+      server->SendResponse(
+          connection->id(),
+          HttpServerResponseInfo::CreateFor500(
+              "Invalid request format. Sec-WebSocket-Key2 is empty or isn't "
+              "specified."));
       return;
     }
 
-    key3_ = connection->recv_data().substr(
-        *pos,
-        *pos + kWebSocketHandshakeBodyLen);
+    key3_.assign(connection->read_buf()->data() + *pos,
+                 kWebSocketHandshakeBodyLen);
     *pos += kWebSocketHandshakeBodyLen;
   }
 
   std::string key3_;
 
   DISALLOW_COPY_AND_ASSIGN(WebSocketHixie76);
 };
 
 const int WebSocketHixie76::kWebSocketHandshakeBodyLen = 8;
 
@@ skipping 17 matching lines @@
 const unsigned char kMaskBit = 0x80;
 const unsigned char kPayloadLengthMask = 0x7F;
 
 const size_t kMaxSingleBytePayloadLength = 125;
 const size_t kTwoBytePayloadLengthField = 126;
 const size_t kEightBytePayloadLengthField = 127;
 const size_t kMaskingKeyWidthInBytes = 4;
 
 class WebSocketHybi17 : public WebSocket {
  public:
-  static WebSocket* Create(HttpConnection* connection,
+  static WebSocket* Create(HttpServer* server,
+                           HttpConnection* connection,
                            const HttpServerRequestInfo& request,
                            size_t* pos) {
     std::string version = request.GetHeaderValue("sec-websocket-version");
     if (version != "8" && version != "13")
       return NULL;
 
     std::string key = request.GetHeaderValue("sec-websocket-key");
     if (key.empty()) {
-      connection->Send(HttpServerResponseInfo::CreateFor500(
-          "Invalid request format. Sec-WebSocket-Key is empty or isn't "
-          "specified."));
+      server->SendResponse(
+          connection->id(),
+          HttpServerResponseInfo::CreateFor500(
+              "Invalid request format. Sec-WebSocket-Key is empty or isn't "
+              "specified."));
       return NULL;
     }
-    return new WebSocketHybi17(connection, request, pos);
+    return new WebSocketHybi17(server, connection, request, pos);
   }
 
   virtual void Accept(const HttpServerRequestInfo& request) OVERRIDE {
     static const char* const kWebSocketGuid =
         "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
     std::string key = request.GetHeaderValue("sec-websocket-key");
     std::string data = base::StringPrintf("%s%s", key.c_str(), kWebSocketGuid);
     std::string encoded_hash;
     base::Base64Encode(base::SHA1HashString(data), &encoded_hash);
 
-    std::string response = base::StringPrintf(
-        "HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
-        "Upgrade: WebSocket\r\n"
-        "Connection: Upgrade\r\n"
-        "Sec-WebSocket-Accept: %s\r\n"
-        "\r\n",
-        encoded_hash.c_str());
-    connection_->Send(response);
+    server_->SendRaw(
+        connection_->id(),
+        base::StringPrintf("HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
+                           "Upgrade: WebSocket\r\n"
+                           "Connection: Upgrade\r\n"
+                           "Sec-WebSocket-Accept: %s\r\n"
+                           "\r\n",
+                           encoded_hash.c_str()));
   }
 
   virtual ParseResult Read(std::string* message) OVERRIDE {
-    const std::string& frame = connection_->recv_data();
+    HttpConnection::ReadIOBuffer* read_buf = connection_->read_buf();
+    base::StringPiece frame(read_buf->data(), read_buf->GetUnconsumedSize());
     int bytes_consumed = 0;
-
     ParseResult result =
         WebSocket::DecodeFrameHybi17(frame, true, &bytes_consumed, message);
     if (result == FRAME_OK)
-      connection_->Shift(bytes_consumed);
+      read_buf->DidConsume(bytes_consumed);
     if (result == FRAME_CLOSE)
       closed_ = true;
     return result;
   }
 
   virtual void Send(const std::string& message) OVERRIDE {
     if (closed_)
       return;
-    std::string data = WebSocket::EncodeFrameHybi17(message, 0);
-    connection_->Send(data);
+    server_->SendRaw(connection_->id(),
+                     WebSocket::EncodeFrameHybi17(message, 0));
   }
 
  private:
-  WebSocketHybi17(HttpConnection* connection,
+  WebSocketHybi17(HttpServer* server,
+                  HttpConnection* connection,
                   const HttpServerRequestInfo& request,
                   size_t* pos)
-    : WebSocket(connection),
-      op_code_(0),
-      final_(false),
-      reserved1_(false),
-      reserved2_(false),
-      reserved3_(false),
-      masked_(false),
-      payload_(0),
-      payload_length_(0),
-      frame_end_(0),
-      closed_(false) {
+      : WebSocket(server, connection),
+        op_code_(0),
+        final_(false),
+        reserved1_(false),
+        reserved2_(false),
+        reserved3_(false),
+        masked_(false),
+        payload_(0),
+        payload_length_(0),
+        frame_end_(0),
+        closed_(false) {
   }
 
   OpCode op_code_;
   bool final_;
   bool reserved1_;
   bool reserved2_;
   bool reserved3_;
   bool masked_;
   const char* payload_;
   size_t payload_length_;
   const char* frame_end_;
   bool closed_;
 
   DISALLOW_COPY_AND_ASSIGN(WebSocketHybi17);
 };
 
 }  // anonymous namespace
 
-WebSocket* WebSocket::CreateWebSocket(HttpConnection* connection,
+WebSocket* WebSocket::CreateWebSocket(HttpServer* server,
+                                      HttpConnection* connection,
                                       const HttpServerRequestInfo& request,
                                       size_t* pos) {
-  WebSocket* socket = WebSocketHybi17::Create(connection, request, pos);
+  WebSocket* socket = WebSocketHybi17::Create(server, connection, request, pos);
   if (socket)
     return socket;
 
-  return WebSocketHixie76::Create(connection, request, pos);
+  return WebSocketHixie76::Create(server, connection, request, pos);
 }
 
 // static
-WebSocket::ParseResult WebSocket::DecodeFrameHybi17(const std::string& frame,
-                                                    bool client_frame,
-                                                    int* bytes_consumed,
-                                                    std::string* output) {
+WebSocket::ParseResult WebSocket::DecodeFrameHybi17(
+    const base::StringPiece& frame,
+    bool client_frame,
+    int* bytes_consumed,
+    std::string* output) {
   size_t data_length = frame.length();
   if (data_length < 2)
     return FRAME_INCOMPLETE;
 
   const char* buffer_begin = const_cast<char*>(frame.data());
   const char* p = buffer_begin;
   const char* buffer_end = p + data_length;
 
   unsigned char first_byte = *p++;
   unsigned char second_byte = *p++;
@@ skipping 57 matching lines @@
   if (static_cast<size_t>(buffer_end - p) < total_length)
     return FRAME_INCOMPLETE;
 
   if (masked) {
     output->resize(payload_length);
     const char* masking_key = p;
     char* payload = const_cast<char*>(p + kMaskingKeyWidthInBytes);
     for (size_t i = 0; i < payload_length; ++i)  // Unmask the payload.
       (*output)[i] = payload[i] ^ masking_key[i % kMaskingKeyWidthInBytes];
   } else {
-    std::string buffer(p, p + payload_length);
-    output->swap(buffer);
+    output->assign(p, p + payload_length);
   }
 
   size_t pos = p + actual_masking_key_length + payload_length - buffer_begin;
   *bytes_consumed = pos;
   return closed ? FRAME_CLOSE : FRAME_OK;
 }
 
 // static
 std::string WebSocket::EncodeFrameHybi17(const std::string& message,
                                          int masking_key) {
@@ skipping 29 matching lines @@
     const char* mask_bytes = reinterpret_cast<char*>(&masking_key);
     frame.insert(frame.end(), mask_bytes, mask_bytes + 4);
     for (size_t i = 0; i < data_length; ++i)  // Mask the payload.
       frame.push_back(data[i] ^ mask_bytes[i % kMaskingKeyWidthInBytes]);
   } else {
     frame.insert(frame.end(), data, data + data_length);
   }
   return std::string(&frame[0], frame.size());
 }
 
-WebSocket::WebSocket(HttpConnection* connection) : connection_(connection) {
+WebSocket::WebSocket(HttpServer* server, HttpConnection* connection)
+    : server_(server),
+      connection_(connection) {
 }
 
 }  // namespace net