[net/http] Add HttpStreamParser.Websocket101Response test

net/http/http_stream_parser_unittest.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/http/http_stream_parser.h"
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_data_stream.h"
 #include "net/base/upload_file_element_reader.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_request_info.h"
+#include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/socket_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace net {
 
 const size_t kOutputSize = 1024;  // Just large enough for this test.
 // The number of bytes that can fit in a buffer of kOutputSize.
@@ skipping 383 matching lines @@
           EXPECT_TRUE(response_info.headers.get());
         } else {
           EXPECT_EQ(ERR_RESPONSE_HEADERS_TRUNCATED, rv);
           EXPECT_FALSE(response_info.headers.get());
         }
       }
     }
   }
 }
 
+// Confirm that on 101 response, the headers are parsed but the data that
+// follows remains in the buffer.
+TEST(HttpStreamParser, Websocket101Response) {
+  MockRead reads[] = {
+    MockRead(SYNCHRONOUS, 1,
+             "HTTP/1.1 101 Switching Protocols\r\n"
+             "Upgrade: websocket\r\n"
+             "Connection: Upgrade\r\n"
+             "\r\n"
+             "a fake websocket frame"),
+  };
+
+  MockWrite writes[] = {
+    MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n\r\n"),
+  };
+
+  DeterministicSocketData data(reads, arraysize(reads),
+                               writes, arraysize(writes));
+  data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
+  data.SetStop(2);
+
+  scoped_ptr<DeterministicMockTCPClientSocket> transport(
+      new DeterministicMockTCPClientSocket(NULL, &data));
+  data.set_delegate(transport->AsWeakPtr());
+
+  TestCompletionCallback callback;
+  int rv = transport->Connect(callback.callback());
+  rv = callback.GetResult(rv);
+  ASSERT_EQ(OK, rv);
+
+  scoped_ptr<ClientSocketHandle> socket_handle(new ClientSocketHandle);
+  socket_handle->SetSocket(transport.PassAs<StreamSocket>());
+
+  HttpRequestInfo request_info;
+  request_info.method = "GET";
+  request_info.url = GURL("http://localhost");
+  request_info.load_flags = LOAD_NORMAL;
+
+  scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
+  HttpStreamParser parser(
+      socket_handle.get(), &request_info, read_buffer.get(), BoundNetLog());
+
+  HttpRequestHeaders request_headers;
+  HttpResponseInfo response_info;
+  rv = parser.SendRequest("GET / HTTP/1.1\r\n", request_headers,
+                          &response_info, callback.callback());
+  ASSERT_EQ(OK, rv);
+
+  rv = parser.ReadResponseHeaders(callback.callback());
+  EXPECT_EQ(OK, rv);
+  ASSERT_TRUE(response_info.headers.get());
+  EXPECT_EQ(101, response_info.headers->response_code());
+  EXPECT_TRUE(response_info.headers->HasHeaderValue("Connection", "Upgrade"));
+  EXPECT_TRUE(response_info.headers->HasHeaderValue("Upgrade", "websocket"));
+  EXPECT_EQ(read_buffer->capacity(), read_buffer->offset());
+  EXPECT_EQ("a fake websocket frame",
+            base::StringPiece(read_buffer->StartOfBuffer(),
+                              read_buffer->capacity()));
+}
+
+
 }  // namespace net