WebSocket over SPDY: update test data and expectation

net/spdy/spdy_websocket_stream_spdy3_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/spdy/spdy_websocket_stream.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 45 matching lines @@
   virtual ~SpdyWebSocketStreamEventRecorder() {}
 
   typedef base::Callback<void(SpdyWebSocketStreamEvent*)> StreamEventCallback;
 
   void SetOnCreated(const StreamEventCallback& callback) {
     on_created_ = callback;
   }
   void SetOnSentHeaders(const StreamEventCallback& callback) {
     on_sent_headers_ = callback;
   }
-  void SetOnReceivedHeader(
-      const StreamEventCallback& callback) {
+  void SetOnReceivedHeader(const StreamEventCallback& callback) {
     on_received_header_ = callback;
   }
   void SetOnSentData(const StreamEventCallback& callback) {
     on_sent_data_ = callback;
   }
-  void SetOnReceivedData(
-      const StreamEventCallback& callback) {
+  void SetOnReceivedData(const StreamEventCallback& callback) {
     on_received_data_ = callback;
   }
   void SetOnClose(const StreamEventCallback& callback) {
     on_close_ = callback;
   }
 
   virtual void OnCreatedSpdyStream(int result) {
     events_.push_back(
         SpdyWebSocketStreamEvent(SpdyWebSocketStreamEvent::EVENT_CREATED,
                                  SpdyHeaderBlock(),
@@ skipping 118 matching lines @@
             SETTINGS_FLAG_PERSISTED, spdy_settings_value_to_set_);
   }
 
   virtual void TearDown() {
     MessageLoop::current()->RunAllPending();
   }
 
   void Prepare(SpdyStreamId stream_id) {
     stream_id_ = stream_id;
 
-    const char* const request_headers[] = {
-      "url", "ws://example.com/echo",
-      "origin", "http://example.com/wsdemo",
-    };
+    request_frame_.reset(ConstructSpdyWebSocketSynStream(
+        stream_id_,
+        "/echo",
+        "example.com",
+        "http://example.com/wsdemo"));
 
-    int request_header_count = arraysize(request_headers) / 2;
-
-    const char* const response_headers[] = {
-      "sec-websocket-location", "ws://example.com/echo",
-      "sec-websocket-origin", "http://example.com/wsdemo",
-    };
-
-    int response_header_count = arraysize(response_headers) / 2;
-
-    request_frame_.reset(ConstructSpdyWebSocketHandshakeRequestFrame(
-        request_headers,
-        request_header_count,
-        stream_id_,
-        HIGHEST));
-    response_frame_.reset(ConstructSpdyWebSocketHandshakeResponseFrame(
-        response_headers,
-        response_header_count,
-        stream_id_,
-        HIGHEST));
+    response_frame_.reset(ConstructSpdyWebSocketSynReply(stream_id_));
 
     message_frame_.reset(ConstructSpdyWebSocketDataFrame(
         kMessageFrame,
         kMessageFrameLength,
         stream_id_,
         false));
 
     closing_frame_.reset(ConstructSpdyWebSocketDataFrame(
         kClosingFrame,
         kClosingFrameLength,
         stream_id_,
         false));
   }
+
   int InitSession(MockRead* reads, size_t reads_count,
                   MockWrite* writes, size_t writes_count,
                   bool throttling) {
     data_.reset(new OrderedSocketData(reads, reads_count,
                                       writes, writes_count));
     session_deps_.socket_factory->AddSocketDataProvider(data_.get());
     http_session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
     SpdySessionPool* spdy_session_pool(http_session_->spdy_session_pool());
 
     if (throttling) {
@@ skipping 15 matching lines @@
     scoped_ptr<ClientSocketHandle> connection(new ClientSocketHandle);
     EXPECT_EQ(ERR_IO_PENDING,
               connection->Init(host_port_pair_.ToString(), transport_params_,
                                MEDIUM, callback.callback(),
                                http_session_->GetTransportSocketPool(
                                    HttpNetworkSession::NORMAL_SOCKET_POOL),
                                BoundNetLog()));
     EXPECT_EQ(OK, callback.WaitForResult());
     return session_->InitializeWithSocket(connection.release(), false, OK);
   }
+
   void SendRequest() {
     scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock);
-    (*headers)["url"] = "ws://example.com/echo";
-    (*headers)["origin"] = "http://example.com/wsdemo";
+    (*headers)[":path"] = "/echo";
+    (*headers)[":host"] = "example.com";
+    (*headers)[":version"] = "WebSocket/13";
+    (*headers)[":scheme"] = "ws";
+    (*headers)[":origin"] = "http://example.com/wsdemo";
 
     websocket_stream_->SendRequest(headers.Pass());
   }
 
   SpdySettingsIds spdy_settings_id_to_set_;
   SpdySettingsFlags spdy_settings_flags_to_set_;
   uint32 spdy_settings_value_to_set_;
   SettingsMap spdy_settings_to_send_;
   SpdySessionDependencies session_deps_;
   scoped_ptr<OrderedSocketData> data_;
@@ skipping 14 matching lines @@
 
   static const char kMessageFrame[];
   static const char kClosingFrame[];
   static const size_t kMessageFrameLength;
   static const size_t kClosingFrameLength;
 
  private:
   SpdyTestStateHelper spdy_state_;
 };
 
-const char SpdyWebSocketStreamSpdy3Test::kMessageFrame[] = "\0hello\xff";
-const char SpdyWebSocketStreamSpdy3Test::kClosingFrame[] = "\xff\0";
+// TODO(toyoshim): Replace old framing data to new one, then use HEADERS and
+// data frames.
+const char SpdyWebSocketStreamSpdy3Test::kMessageFrame[] = "\x81\x05hello";
+const char SpdyWebSocketStreamSpdy3Test::kClosingFrame[] = "\x88\0";
 const size_t SpdyWebSocketStreamSpdy3Test::kMessageFrameLength =
     arraysize(SpdyWebSocketStreamSpdy3Test::kMessageFrame) - 1;
 const size_t SpdyWebSocketStreamSpdy3Test::kClosingFrameLength =
     arraysize(SpdyWebSocketStreamSpdy3Test::kClosingFrame) - 1;
 
 TEST_F(SpdyWebSocketStreamSpdy3Test, Basic) {
   Prepare(1);
   MockWrite writes[] = {
     CreateMockWrite(*request_frame_.get(), 1),
     CreateMockWrite(*message_frame_.get(), 3),
@@ skipping 288 matching lines @@
   EXPECT_EQ(OK, events[7].result);
 
   // EOF close SPDY session.
   EXPECT_TRUE(!http_session_->spdy_session_pool()->HasSession(
       host_port_proxy_pair_));
   EXPECT_TRUE(data()->at_read_eof());
   EXPECT_TRUE(data()->at_write_eof());
 }
 
 }  // namespace net