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

net/spdy/spdy_session_spdy2_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_session.h"
 
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_log_unittest.h"
 #include "net/spdy/spdy_io_buffer.h"
 #include "net/spdy/spdy_session_pool.h"
 #include "net/spdy/spdy_stream.h"
-#include "net/spdy/spdy_test_util.h"
+#include "net/spdy/spdy_test_util_spdy2.h"
 #include "testing/platform_test.h"
 
+using namespace net::test_spdy2;
+
 namespace net {
 
 // TODO(cbentzel): Expose compression setter/getter in public SpdySession
 //                 interface rather than going through all these contortions.
-class SpdySessionTest : public PlatformTest {
+class SpdySessionSpdy2Test : public PlatformTest {
  public:
   static void TurnOffCompression() {
     spdy::SpdyFramer::set_enable_compression_default(false);
   }
  protected:
   virtual void TearDown() {
     // Wanted to be 100% sure PING is disabled.
     SpdySession::set_enable_ping_based_connection_checking(false);
   }
 };
@@ skipping 32 matching lines @@
     callback.Run(OK);
   }
 
   virtual void set_chunk_callback(net::ChunkCallback *) {}
 
  private:
   CompletionCallback callback_;
 };
 
 // Test the SpdyIOBuffer class.
-TEST_F(SpdySessionTest, SpdyIOBuffer) {
+TEST_F(SpdySessionSpdy2Test, SpdyIOBuffer) {
   std::priority_queue<SpdyIOBuffer> queue_;
   const size_t kQueueSize = 100;
 
   // Insert 100 items; pri 100 to 1.
   for (size_t index = 0; index < kQueueSize; ++index) {
     SpdyIOBuffer buffer(new IOBuffer(), 0, kQueueSize - index, NULL);
     queue_.push(buffer);
   }
 
   // Insert several priority 0 items last.
@@ skipping 15 matching lines @@
   }
 
   int priority = 1;
   while (queue_.size()) {
     SpdyIOBuffer buffer = queue_.top();
     EXPECT_EQ(priority++, buffer.priority());
     queue_.pop();
   }
 }
 
-TEST_F(SpdySessionTest, GoAway) {
+TEST_F(SpdySessionSpdy2Test, GoAway) {
   SpdySessionDependencies session_deps;
   session_deps.host_resolver->set_synchronous_mode(true);
 
   MockConnect connect_data(SYNCHRONOUS, OK);
   scoped_ptr<spdy::SpdyFrame> goaway(ConstructSpdyGoAway());
   MockRead reads[] = {
     CreateMockRead(*goaway),
     MockRead(SYNCHRONOUS, 0, 0)  // EOF
   };
   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
@@ skipping 38 matching lines @@
       spdy_session_pool->Get(pair, BoundNetLog());
 
   // Delete the first session.
   session = NULL;
 
   // Delete the second session.
   spdy_session_pool->Remove(session2);
   session2 = NULL;
 }
 
-TEST_F(SpdySessionTest, Ping) {
+TEST_F(SpdySessionSpdy2Test, Ping) {
   SpdySessionDependencies session_deps;
   session_deps.host_resolver->set_synchronous_mode(true);
 
   MockConnect connect_data(SYNCHRONOUS, OK);
   scoped_ptr<spdy::SpdyFrame> read_ping(ConstructSpdyPing());
   MockRead reads[] = {
     CreateMockRead(*read_ping),
     CreateMockRead(*read_ping),
     MockRead(SYNCHRONOUS, 0, 0)  // EOF
   };
@@ skipping 70 matching lines @@
   EXPECT_FALSE(session->trailing_ping_pending());
   EXPECT_FALSE(session->check_ping_status_pending());
   EXPECT_GE(session->received_data_time(), before_ping_time);
 
   EXPECT_FALSE(spdy_session_pool->HasSession(pair));
 
   // Delete the first session.
   session = NULL;
 }
 
-TEST_F(SpdySessionTest, FailedPing) {
+TEST_F(SpdySessionSpdy2Test, FailedPing) {
   SpdySessionDependencies session_deps;
   session_deps.host_resolver->set_synchronous_mode(true);
 
   MockConnect connect_data(SYNCHRONOUS, OK);
   scoped_ptr<spdy::SpdyFrame> read_ping(ConstructSpdyPing());
   MockRead reads[] = {
     CreateMockRead(*read_ping),
     MockRead(SYNCHRONOUS, 0, 0)  // EOF
   };
   scoped_ptr<spdy::SpdyFrame> write_ping(ConstructSpdyPing());
@@ skipping 109 matching lines @@
   }
 
   scoped_refptr<SpdySession> session_;
   scoped_refptr<SpdyStream> first_stream_;
   scoped_refptr<SpdyStream> stream_;
   CompletionCallback callback_;
 };
 
 // TODO(kristianm): Could also test with more sessions where some are idle,
 // and more than one session to a HostPortPair.
-TEST_F(SpdySessionTest, CloseIdleSessions) {
+TEST_F(SpdySessionSpdy2Test, CloseIdleSessions) {
   SpdySessionDependencies session_deps;
   scoped_refptr<HttpNetworkSession> http_session(
   SpdySessionDependencies::SpdyCreateSession(&session_deps));
   SpdySessionPool* spdy_session_pool(http_session->spdy_session_pool());
 
   // Set up session 1
   const std::string kTestHost1("http://www.a.com");
   HostPortPair test_host_port_pair1(kTestHost1, 80);
   HostPortProxyPair pair1(test_host_port_pair1, ProxyServer::Direct());
   scoped_refptr<SpdySession> session1 =
@@ skipping 84 matching lines @@
   spdy_session_pool->CloseIdleSessions();
   EXPECT_FALSE(session2->is_active());
   EXPECT_TRUE(session2->IsClosed());
 }
 
 // Start with max concurrent streams set to 1.  Request two streams.  Receive a
 // settings frame setting max concurrent streams to 2.  Have the callback
 // release the stream, which releases its reference (the last) to the session.
 // Make sure nothing blows up.
 // http://crbug.com/57331
-TEST_F(SpdySessionTest, OnSettings) {
+TEST_F(SpdySessionSpdy2Test, OnSettings) {
   SpdySessionDependencies session_deps;
   session_deps.host_resolver->set_synchronous_mode(true);
 
   spdy::SpdySettings new_settings;
   spdy::SettingsFlagsAndId id(0);
   id.set_id(spdy::SETTINGS_MAX_CONCURRENT_STREAMS);
   const size_t max_concurrent_streams = 2;
   new_settings.push_back(spdy::SpdySetting(id, max_concurrent_streams));
 
   // Set up the socket so we read a SETTINGS frame that raises max concurrent
@@ skipping 71 matching lines @@
   session = NULL;
   spdy_stream1 = NULL;
 
   EXPECT_EQ(OK, stream_releaser.WaitForResult());
 }
 
 // Start with max concurrent streams set to 1.  Request two streams.  When the
 // first completes, have the callback close itself, which should trigger the
 // second stream creation.  Then cancel that one immediately.  Don't crash.
 // http://crbug.com/63532
-TEST_F(SpdySessionTest, CancelPendingCreateStream) {
+TEST_F(SpdySessionSpdy2Test, CancelPendingCreateStream) {
   SpdySessionDependencies session_deps;
   session_deps.host_resolver->set_synchronous_mode(true);
 
   MockRead reads[] = {
     MockRead(SYNCHRONOUS, ERR_IO_PENDING)  // Stall forever.
   };
 
   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
   MockConnect connect_data(SYNCHRONOUS, OK);
 
@@ skipping 65 matching lines @@
   spdy_stream1->Cancel();
   spdy_stream1 = NULL;
 
   session->CancelPendingCreateStreams(&spdy_stream2);
   callback.reset();
 
   // Should not crash when running the pending callback.
   MessageLoop::current()->RunAllPending();
 }
 
-TEST_F(SpdySessionTest, SendSettingsOnNewSession) {
+TEST_F(SpdySessionSpdy2Test, SendSettingsOnNewSession) {
   SpdySessionDependencies session_deps;
   session_deps.host_resolver->set_synchronous_mode(true);
 
   MockRead reads[] = {
     MockRead(SYNCHRONOUS, ERR_IO_PENDING)  // Stall forever.
   };
 
   // Create the bogus setting that we want to verify is sent out.
   // Note that it will be marked as SETTINGS_FLAG_PERSISTED when sent out.  But
   // to set it into the SpdySettingsStorage, we need to mark as
@@ skipping 47 matching lines @@
   scoped_ptr<ClientSocketHandle> connection(new ClientSocketHandle);
   EXPECT_EQ(OK, connection->Init(test_host_port_pair.ToString(),
                                  transport_params, MEDIUM, CompletionCallback(),
                                  http_session->GetTransportSocketPool(),
                                  BoundNetLog()));
   EXPECT_EQ(OK, session->InitializeWithSocket(connection.release(), false, OK));
   MessageLoop::current()->RunAllPending();
   EXPECT_TRUE(data.at_write_eof());
 }
 
+namespace {
 // This test has two variants, one for each style of closing the connection.
 // If |clean_via_close_current_sessions| is false, the sessions are closed
 // manually, calling SpdySessionPool::Remove() directly.  If it is true,
 // sessions are closed with SpdySessionPool::CloseCurrentSessions().
 void IPPoolingTest(bool clean_via_close_current_sessions) {
   const int kTestPort = 80;
   struct TestHosts {
     std::string name;
     std::string iplist;
     HostPortProxyPair pair;
@@ skipping 98 matching lines @@
   } else {
     spdy_session_pool->CloseCurrentSessions();
   }
 
   // Verify that the map is all cleaned up.
   EXPECT_FALSE(spdy_session_pool->HasSession(test_hosts[0].pair));
   EXPECT_FALSE(spdy_session_pool->HasSession(test_hosts[1].pair));
   EXPECT_FALSE(spdy_session_pool->HasSession(test_hosts[2].pair));
 }
 
-TEST_F(SpdySessionTest, IPPooling) {
+}  // namespace
+
+TEST_F(SpdySessionSpdy2Test, IPPooling) {
   IPPoolingTest(false);
 }
 
-TEST_F(SpdySessionTest, IPPoolingCloseCurrentSessions) {
+TEST_F(SpdySessionSpdy2Test, IPPoolingCloseCurrentSessions) {
   IPPoolingTest(true);
 }
 
-TEST_F(SpdySessionTest, ClearSettingsStorage) {
+TEST_F(SpdySessionSpdy2Test, ClearSettingsStorage) {
   SpdySettingsStorage settings_storage;
   const std::string kTestHost("www.foo.com");
   const int kTestPort = 80;
   HostPortPair test_host_port_pair(kTestHost, kTestPort);
   spdy::SpdySettings test_settings;
   spdy::SettingsFlagsAndId id(0);
   id.set_id(spdy::SETTINGS_MAX_CONCURRENT_STREAMS);
   id.set_flags(spdy::SETTINGS_FLAG_PLEASE_PERSIST);
   const size_t max_concurrent_streams = 2;
   test_settings.push_back(spdy::SpdySetting(id, max_concurrent_streams));
 
   settings_storage.Set(test_host_port_pair, test_settings);
   EXPECT_NE(0u, settings_storage.Get(test_host_port_pair).size());
   settings_storage.Clear();
   EXPECT_EQ(0u, settings_storage.Get(test_host_port_pair).size());
 }
 
-TEST_F(SpdySessionTest, ClearSettingsStorageOnIPAddressChanged) {
+TEST_F(SpdySessionSpdy2Test, ClearSettingsStorageOnIPAddressChanged) {
   const std::string kTestHost("www.foo.com");
   const int kTestPort = 80;
   HostPortPair test_host_port_pair(kTestHost, kTestPort);
 
   SpdySessionDependencies session_deps;
   scoped_refptr<HttpNetworkSession> http_session(
       SpdySessionDependencies::SpdyCreateSession(&session_deps));
   SpdySessionPool* spdy_session_pool(http_session->spdy_session_pool());
 
   HttpServerProperties* test_http_server_properties =
       spdy_session_pool->http_server_properties();
   spdy::SettingsFlagsAndId id(0);
   id.set_id(spdy::SETTINGS_MAX_CONCURRENT_STREAMS);
   id.set_flags(spdy::SETTINGS_FLAG_PLEASE_PERSIST);
   const size_t max_concurrent_streams = 2;
   spdy::SpdySettings test_settings;
   test_settings.push_back(spdy::SpdySetting(id, max_concurrent_streams));
 
   test_http_server_properties->SetSpdySettings(test_host_port_pair,
                                                test_settings);
   EXPECT_NE(0u, test_http_server_properties->GetSpdySettings(
       test_host_port_pair).size());
   spdy_session_pool->OnIPAddressChanged();
   EXPECT_EQ(0u, test_http_server_properties->GetSpdySettings(
       test_host_port_pair).size());
 }
 
-TEST_F(SpdySessionTest, NeedsCredentials) {
+TEST_F(SpdySessionSpdy2Test, NeedsCredentials) {
   SpdySessionDependencies session_deps;
 
   MockConnect connect_data(SYNCHRONOUS, OK);
   MockRead reads[] = {
     MockRead(SYNCHRONOUS, ERR_IO_PENDING)  // Stall forever.
   };
   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
   data.set_connect_data(connect_data);
   session_deps.socket_factory->AddSocketDataProvider(&data);
 
@@ skipping 47 matching lines @@
   HostPortPair test_host_port_pair2(kTestHost2, kTestPort);
   EXPECT_TRUE(session->NeedsCredentials(test_host_port_pair2));
 
   // Flush the SpdySession::OnReadComplete() task.
   MessageLoop::current()->RunAllPending();
 
   spdy_session_pool->Remove(session);
   EXPECT_FALSE(spdy_session_pool->HasSession(pair));
 }
 
-TEST_F(SpdySessionTest, SendCredentials) {
+TEST_F(SpdySessionSpdy2Test, SendCredentials) {
   SpdySessionDependencies session_deps;
 
   MockConnect connect_data(SYNCHRONOUS, OK);
   MockRead reads[] = {
     MockRead(SYNCHRONOUS, ERR_IO_PENDING)  // Stall forever.
   };
   spdy::SpdySettings settings;
   scoped_ptr<spdy::SpdyFrame> settings_frame(
       ConstructSpdySettings(settings));
   MockWrite writes[] = {
@@ skipping 54 matching lines @@
   HostPortPair test_host_port_pair2(kTestHost2, kTestPort);
   EXPECT_TRUE(session->NeedsCredentials(test_host_port_pair2));
 
   // Flush the SpdySession::OnReadComplete() task.
   MessageLoop::current()->RunAllPending();
 
   spdy_session_pool->Remove(session);
   EXPECT_FALSE(spdy_session_pool->HasSession(pair));
 }
 
-TEST_F(SpdySessionTest, CloseSessionOnError) {
+TEST_F(SpdySessionSpdy2Test, CloseSessionOnError) {
   SpdySessionDependencies session_deps;
   session_deps.host_resolver->set_synchronous_mode(true);
 
   MockConnect connect_data(SYNCHRONOUS, OK);
   scoped_ptr<spdy::SpdyFrame> goaway(ConstructSpdyGoAway());
   MockRead reads[] = {
     CreateMockRead(*goaway),
     MockRead(SYNCHRONOUS, 0, 0)  // EOF
   };
 
@@ skipping 49 matching lines @@
       net::NetLog::PHASE_NONE);
 
   CapturingNetLog::Entry entry = entries[pos];
   NetLogSpdySessionCloseParameter* request_params =
       static_cast<NetLogSpdySessionCloseParameter*>(
           entry.extra_parameters.get());
   EXPECT_EQ(ERR_CONNECTION_CLOSED, request_params->status());
 }
 
 }  // namespace net