Fork SPDY/2 and SPDY/3 versions of our SPDY tests, in preparation for landing

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"
 #include "base/bind_helpers.h"
 #include "net/base/completion_callback.h"
 #include "net/proxy/proxy_server.h"
 #include "net/spdy/spdy_http_utils.h"
 #include "net/spdy/spdy_protocol.h"
 #include "net/spdy/spdy_session.h"
-#include "net/spdy/spdy_test_util.h"
-#include "net/spdy/spdy_websocket_test_util.h"
+#include "net/spdy/spdy_test_util_spdy3.h"
+#include "net/spdy/spdy_websocket_test_util_spdy3.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using namespace net::test_spdy3;
+
 namespace {
 
 struct SpdyWebSocketStreamEvent {
   enum EventType {
     EVENT_CREATED,
     EVENT_SENT_HEADERS,
     EVENT_RECEIVED_HEADER,
     EVENT_SENT_DATA,
     EVENT_RECEIVED_DATA,
     EVENT_CLOSE,
@@ skipping 10 matching lines @@
   EventType event_type;
   spdy::SpdyHeaderBlock headers;
   int result;
   std::string data;
 };
 
 }  // namespace
 
 namespace net {
 
+namespace {
+
 class SpdyWebSocketStreamEventRecorder : public SpdyWebSocketStream::Delegate {
  public:
   explicit SpdyWebSocketStreamEventRecorder(const CompletionCallback& callback)
       : callback_(callback) {}
   virtual ~SpdyWebSocketStreamEventRecorder() {}
 
   typedef base::Callback<void(SpdyWebSocketStreamEvent*)> StreamEventCallback;
 
   void SetOnCreated(const StreamEventCallback& callback) {
     on_created_ = callback;
@@ skipping 89 matching lines @@
   StreamEventCallback on_sent_headers_;
   StreamEventCallback on_received_header_;
   StreamEventCallback on_sent_data_;
   StreamEventCallback on_received_data_;
   StreamEventCallback on_close_;
   CompletionCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyWebSocketStreamEventRecorder);
 };
 
-class SpdyWebSocketStreamTest : public testing::Test {
+}  // namespace
+
+class SpdyWebSocketStreamSpdy3Test : public testing::Test {
  public:
   OrderedSocketData* data() { return data_.get(); }
 
   void DoSendHelloFrame(SpdyWebSocketStreamEvent* event) {
     websocket_stream_->SendData(kMessageFrame, kMessageFrameLength);
   }
 
   void DoSendClosingFrame(SpdyWebSocketStreamEvent* event) {
     websocket_stream_->SendData(kClosingFrame, kClosingFrameLength);
   }
 
   void DoClose(SpdyWebSocketStreamEvent* event) {
     websocket_stream_->Close();
   }
 
   void DoSync(SpdyWebSocketStreamEvent* event) {
     sync_callback_.SetResult(OK);
   }
 
  protected:
-  SpdyWebSocketStreamTest() {}
-  virtual ~SpdyWebSocketStreamTest() {}
+  SpdyWebSocketStreamSpdy3Test() {}
+  virtual ~SpdyWebSocketStreamSpdy3Test() {}
 
   virtual void SetUp() {
     EnableCompression(false);
     SpdySession::SetSSLMode(false);
 
     host_port_pair_.set_host("example.com");
     host_port_pair_.set_port(80);
     host_port_proxy_pair_.first = host_port_pair_;
     host_port_proxy_pair_.second = ProxyServer::Direct();
 
@@ skipping 111 matching lines @@
   HostPortProxyPair host_port_proxy_pair_;
   TestCompletionCallback completion_callback_;
   TestCompletionCallback sync_callback_;
 
   static const char kMessageFrame[];
   static const char kClosingFrame[];
   static const size_t kMessageFrameLength;
   static const size_t kClosingFrameLength;
 };
 
-const char SpdyWebSocketStreamTest::kMessageFrame[] = "\0hello\xff";
-const char SpdyWebSocketStreamTest::kClosingFrame[] = "\xff\0";
-const size_t SpdyWebSocketStreamTest::kMessageFrameLength =
-    arraysize(SpdyWebSocketStreamTest::kMessageFrame) - 1;
-const size_t SpdyWebSocketStreamTest::kClosingFrameLength =
-    arraysize(SpdyWebSocketStreamTest::kClosingFrame) - 1;
+const char SpdyWebSocketStreamSpdy3Test::kMessageFrame[] = "\0hello\xff";
+const char SpdyWebSocketStreamSpdy3Test::kClosingFrame[] = "\xff\0";
+const size_t SpdyWebSocketStreamSpdy3Test::kMessageFrameLength =
+    arraysize(SpdyWebSocketStreamSpdy3Test::kMessageFrame) - 1;
+const size_t SpdyWebSocketStreamSpdy3Test::kClosingFrameLength =
+    arraysize(SpdyWebSocketStreamSpdy3Test::kClosingFrame) - 1;
 
-TEST_F(SpdyWebSocketStreamTest, Basic) {
+TEST_F(SpdyWebSocketStreamSpdy3Test, Basic) {
   Prepare(1);
   MockWrite writes[] = {
     CreateMockWrite(*request_frame_.get(), 1),
     CreateMockWrite(*message_frame_.get(), 3),
     CreateMockWrite(*closing_frame_.get(), 5)
   };
 
   MockRead reads[] = {
     CreateMockRead(*response_frame_.get(), 2),
     CreateMockRead(*message_frame_.get(), 4),
     // Skip sequence 6 to notify closing has been sent.
     CreateMockRead(*closing_frame_.get(), 7),
     MockRead(SYNCHRONOUS, 0, 8)  // EOF cause OnCloseSpdyStream event.
   };
 
   EXPECT_EQ(OK, InitSession(reads, arraysize(reads),
                             writes, arraysize(writes), false));
 
   SpdyWebSocketStreamEventRecorder delegate(completion_callback_.callback());
   delegate.SetOnReceivedHeader(
-      base::Bind(&SpdyWebSocketStreamTest::DoSendHelloFrame,
+      base::Bind(&SpdyWebSocketStreamSpdy3Test::DoSendHelloFrame,
                  base::Unretained(this)));
   delegate.SetOnReceivedData(
-      base::Bind(&SpdyWebSocketStreamTest::DoSendClosingFrame,
+      base::Bind(&SpdyWebSocketStreamSpdy3Test::DoSendClosingFrame,
                  base::Unretained(this)));
 
   websocket_stream_.reset(new SpdyWebSocketStream(session_, &delegate));
 
   BoundNetLog net_log;
   GURL url("ws://example.com/echo");
   ASSERT_EQ(OK, websocket_stream_->InitializeStream(url, HIGHEST, net_log));
 
   ASSERT_TRUE(websocket_stream_->stream_);
   EXPECT_EQ(stream_id_, websocket_stream_->stream_->stream_id());
@@ skipping 30 matching lines @@
             events[6].event_type);
   EXPECT_EQ(OK, events[6].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());
 }
 
-TEST_F(SpdyWebSocketStreamTest, DestructionBeforeClose) {
+TEST_F(SpdyWebSocketStreamSpdy3Test, DestructionBeforeClose) {
   Prepare(1);
   MockWrite writes[] = {
     CreateMockWrite(*request_frame_.get(), 1),
     CreateMockWrite(*message_frame_.get(), 3)
   };
 
   MockRead reads[] = {
     CreateMockRead(*response_frame_.get(), 2),
     CreateMockRead(*message_frame_.get(), 4),
     MockRead(ASYNC, ERR_IO_PENDING, 5)
   };
 
   EXPECT_EQ(OK, InitSession(reads, arraysize(reads),
                             writes, arraysize(writes), false));
 
   SpdyWebSocketStreamEventRecorder delegate(completion_callback_.callback());
   delegate.SetOnReceivedHeader(
-      base::Bind(&SpdyWebSocketStreamTest::DoSendHelloFrame,
+      base::Bind(&SpdyWebSocketStreamSpdy3Test::DoSendHelloFrame,
                  base::Unretained(this)));
   delegate.SetOnReceivedData(
-      base::Bind(&SpdyWebSocketStreamTest::DoSync, base::Unretained(this)));
+      base::Bind(&SpdyWebSocketStreamSpdy3Test::DoSync,
+                 base::Unretained(this)));
 
   websocket_stream_.reset(new SpdyWebSocketStream(session_, &delegate));
 
   BoundNetLog net_log;
   GURL url("ws://example.com/echo");
   ASSERT_EQ(OK, websocket_stream_->InitializeStream(url, HIGHEST, net_log));
 
   SendRequest();
 
   sync_callback_.WaitForResult();
@@ skipping 19 matching lines @@
   EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
             events[3].event_type);
   EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[3].result);
 
   EXPECT_TRUE(http_session_->spdy_session_pool()->HasSession(
       host_port_proxy_pair_));
   EXPECT_TRUE(data()->at_read_eof());
   EXPECT_TRUE(data()->at_write_eof());
 }
 
-TEST_F(SpdyWebSocketStreamTest, DestructionAfterExplicitClose) {
+TEST_F(SpdyWebSocketStreamSpdy3Test, DestructionAfterExplicitClose) {
   Prepare(1);
   MockWrite writes[] = {
     CreateMockWrite(*request_frame_.get(), 1),
     CreateMockWrite(*message_frame_.get(), 3),
     CreateMockWrite(*closing_frame_.get(), 5)
   };
 
   MockRead reads[] = {
     CreateMockRead(*response_frame_.get(), 2),
     CreateMockRead(*message_frame_.get(), 4),
     MockRead(ASYNC, ERR_IO_PENDING, 6)
   };
 
   EXPECT_EQ(OK, InitSession(reads, arraysize(reads),
                             writes, arraysize(writes), false));
 
   SpdyWebSocketStreamEventRecorder delegate(completion_callback_.callback());
   delegate.SetOnReceivedHeader(
-      base::Bind(&SpdyWebSocketStreamTest::DoSendHelloFrame,
+      base::Bind(&SpdyWebSocketStreamSpdy3Test::DoSendHelloFrame,
                  base::Unretained(this)));
   delegate.SetOnReceivedData(
-      base::Bind(&SpdyWebSocketStreamTest::DoClose, base::Unretained(this)));
+      base::Bind(&SpdyWebSocketStreamSpdy3Test::DoClose,
+                 base::Unretained(this)));
 
   websocket_stream_.reset(new SpdyWebSocketStream(session_, &delegate));
 
   BoundNetLog net_log;
   GURL url("ws://example.com/echo");
   ASSERT_EQ(OK, websocket_stream_->InitializeStream(url, HIGHEST, net_log));
 
   SendRequest();
 
   completion_callback_.WaitForResult();
@@ skipping 17 matching lines @@
   EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[2].result);
   EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
             events[3].event_type);
   EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[3].result);
   EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_CLOSE, events[4].event_type);
 
   EXPECT_TRUE(http_session_->spdy_session_pool()->HasSession(
       host_port_proxy_pair_));
 }
 
-TEST_F(SpdyWebSocketStreamTest, IOPending) {
+TEST_F(SpdyWebSocketStreamSpdy3Test, IOPending) {
   Prepare(3);
   scoped_ptr<spdy::SpdyFrame> settings_frame(
       ConstructSpdySettings(spdy_settings_to_send_));
   MockWrite writes[] = {
     // Setting throttling make SpdySession send settings frame automatically.
     CreateMockWrite(*settings_frame.get(), 1),
     CreateMockWrite(*request_frame_.get(), 3),
     CreateMockWrite(*message_frame_.get(), 6),
     CreateMockWrite(*closing_frame_.get(), 9)
   };
@@ skipping 18 matching lines @@
   scoped_ptr<SpdyWebSocketStream> block_stream(
       new SpdyWebSocketStream(session_, &block_delegate));
   BoundNetLog block_net_log;
   GURL block_url("ws://example.com/block");
   ASSERT_EQ(OK,
             block_stream->InitializeStream(block_url, HIGHEST, block_net_log));
 
   // Create a WebSocketStream under test.
   SpdyWebSocketStreamEventRecorder delegate(completion_callback_.callback());
   delegate.SetOnCreated(
-      base::Bind(&SpdyWebSocketStreamTest::DoSync, base::Unretained(this)));
+      base::Bind(&SpdyWebSocketStreamSpdy3Test::DoSync,
+                 base::Unretained(this)));
   delegate.SetOnReceivedHeader(
-      base::Bind(&SpdyWebSocketStreamTest::DoSendHelloFrame,
+      base::Bind(&SpdyWebSocketStreamSpdy3Test::DoSendHelloFrame,
                  base::Unretained(this)));
   delegate.SetOnReceivedData(
-      base::Bind(&SpdyWebSocketStreamTest::DoSendClosingFrame,
+      base::Bind(&SpdyWebSocketStreamSpdy3Test::DoSendClosingFrame,
                  base::Unretained(this)));
 
   websocket_stream_.reset(new SpdyWebSocketStream(session_, &delegate));
   BoundNetLog net_log;
   GURL url("ws://example.com/echo");
   ASSERT_EQ(ERR_IO_PENDING, websocket_stream_->InitializeStream(
       url, HIGHEST, net_log));
 
   // Delete the fist stream to allow create the second stream.
   block_stream.reset();
@@ skipping 38 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