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"
@@ skipping 28 matching lines @@
   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,
                                 const HttpServerRequestInfo& request,
                                 size_t* pos) {
-    if (connection->recv_data().length() < *pos + kWebSocketHandshakeBodyLen)
+    if (connection->read_buf()->GetUnconsumedSize()
+        < *pos + kWebSocketHandshakeBodyLen)
       return NULL;
     return new WebSocketHixie76(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);
@@ skipping 16 matching lines @@
         "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);
   }
 
   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;
 
+    std::string data(read_buf->data(), read_buf->GetUnconsumedSize());
     size_t pos = data.find('\377', 1);
     if (pos == std::string::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);
@@ skipping 15 matching lines @@
       return;
     }
 
     if (key2.empty()) {
       connection->Send(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 53 matching lines @@
         "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);
   }
 
   virtual ParseResult Read(std::string* message) OVERRIDE {
-    const std::string& frame = connection_->recv_data();
+    HttpConnection::ReadIOBuffer* read_buf = connection_->read_buf();
+    const std::string 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);
@@ skipping 172 matching lines @@
   } else {
     frame.insert(frame.end(), data, data + data_length);
   }
   return std::string(&frame[0], frame.size());
 }
 
 WebSocket::WebSocket(HttpConnection* connection) : connection_(connection) {
 }
 
 }  // namespace net