WebSocket over SPDY: update test data and expectation

net/spdy/spdy_test_util_spdy2.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_test_util_spdy2.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 436 matching lines @@
                                    extra_header_count,
                                    /*compressed*/ false,
                                    stream_id,
                                    LOWEST,
                                    SYN_STREAM,
                                    CONTROL_FLAG_NONE,
                                    kConnectHeaders,
                                    arraysize(kConnectHeaders));
 }
 
-// Constructs a standard SPDY SYN_STREAM frame for a WebSocket over SPDY
-// opening handshake.
-SpdyFrame* ConstructSpdyWebSocket(int stream_id,
-                                  const char* path,
-                                  const char* host,
-                                  const char* origin) {
-  const char* const kWebSocketHeaders[] = {
-    "path",
-    path,
-    "host",
-    host,
-    "version",
-    "WebSocket/13",
-    "scheme",
-    "ws",
-    "origin",
-    origin
-  };
-  return ConstructSpdyControlFrame(/*extra_headers*/ NULL,
-                                   /*extra_header_count*/ 0,
-                                   /*compressed*/ false,
-                                   stream_id,
-                                   LOWEST,
-                                   SYN_STREAM,
-                                   CONTROL_FLAG_NONE,
-                                   kWebSocketHeaders,
-                                   arraysize(kWebSocketHeaders));
-}
-
 // Constructs a standard SPDY push SYN packet.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // Returns a SpdyFrame.
 SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
                                    int extra_header_count,
                                    int stream_id,
                                    int associated_stream_id) {
   const char* const kStandardGetHeaders[] = {
     "hello",
@@ skipping 180 matching lines @@
                                    extra_header_count,
                                    false,
                                    stream_id,
                                    LOWEST,
                                    SYN_REPLY,
                                    CONTROL_FLAG_NONE,
                                    kStandardGetHeaders,
                                    arraysize(kStandardGetHeaders));
 }
 
-// Constructs a standard SPDY SYN_REPLY packet to match the WebSocket over SPDY
-// opening handshake.
-// Returns a SpdyFrame.
-SpdyFrame* ConstructSpdyWebSocketSynReply(int stream_id) {
-  static const char* const kStandardWebSocketHeaders[] = {
-    "status",
-    "101"
-  };
-  return ConstructSpdyControlFrame(NULL,
-                                   0,
-                                   false,
-                                   stream_id,
-                                   LOWEST,
-                                   SYN_REPLY,
-                                   CONTROL_FLAG_NONE,
-                                   kStandardWebSocketHeaders,
-                                   arraysize(kStandardWebSocketHeaders));
-}
-
 // Constructs a standard SPDY POST SYN packet.
 // |content_length| is the size of post data.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // Returns a SpdyFrame.
 SpdyFrame* ConstructSpdyPost(int64 content_length,
                                    const char* const extra_headers[],
                                    int extra_header_count) {
   std::string length_str = base::Int64ToString(content_length);
   const char* post_headers[] = {
@@ skipping 86 matching lines @@
 }
 
 // Constructs a single SPDY data frame with the given content.
 SpdyFrame* ConstructSpdyBodyFrame(int stream_id, const char* data,
                                         uint32 len, bool fin) {
   BufferedSpdyFramer framer(2);
   return framer.CreateDataFrame(
       stream_id, data, len, fin ? DATA_FLAG_FIN : DATA_FLAG_NONE);
 }
 
-// Constructs a SPDY HEADERS frame for a WebSocket frame over SPDY.
-SpdyFrame* ConstructSpdyWebSocketHeadersFrame(int stream_id,
-                                              const char* length,
-                                              bool fin) {
-  static const char* const kHeaders[] = {
-    "opcode",
-    "1",  // text frame
-    "length",
-    length,
-    "fin",
-    fin ? "1" : "0"
-  };
-  return ConstructSpdyControlFrame(/*extra_headers*/ NULL,
-                                   /*extra_header_count*/ 0,
-                                   /*compression*/ false,
-                                   stream_id,
-                                   LOWEST,
-                                   HEADERS,
-                                   CONTROL_FLAG_NONE,
-                                   kHeaders,
-                                   arraysize(kHeaders));
-}
-
 // Wraps |frame| in the payload of a data frame in stream |stream_id|.
 SpdyFrame* ConstructWrappedSpdyFrame(
     const scoped_ptr<SpdyFrame>& frame,
     int stream_id) {
   return ConstructSpdyBodyFrame(stream_id, frame->data(),
                                 frame->length() + SpdyFrame::kHeaderSize,
                                 false);
 }
 
 // Construct an expected SPDY reply string.
@@ skipping 248 matching lines @@
 }
 
 SpdyTestStateHelper::~SpdyTestStateHelper() {
   SpdySession::ResetStaticSettingsToInit();
   // TODO(rch): save/restore this value
   BufferedSpdyFramer::set_enable_compression_default(true);
 }
 
 }  // namespace test_spdy2
 }  // namespace net