SPDY - integration of spdy/3 code.

net/spdy/spdy_session_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_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_spdy3.h"
 #include "testing/platform_test.h"
 
 using namespace net::test_spdy3;
 
 namespace net {
 
 // TODO(cbentzel): Expose compression setter/getter in public SpdySession
 //                 interface rather than going through all these contortions.
 class SpdySessionSpdy3Test : public PlatformTest {
  public:
   static void TurnOffCompression() {
     spdy::SpdyFramer::set_enable_compression_default(false);
   }
  protected:
+  virtual void SetUp() {
+    SpdySession::set_default_protocol(SSLClientSocket::kProtoSPDY3);
+  }
+
   virtual void TearDown() {
     // Wanted to be 100% sure PING is disabled.
     SpdySession::set_enable_ping_based_connection_checking(false);
   }
 };
 
 class TestSpdyStreamDelegate : public net::SpdyStream::Delegate {
  public:
   explicit TestSpdyStreamDelegate(const CompletionCallback& callback)
       : callback_(callback) {}
@@ skipping 453 matching lines @@
 // 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(SpdySessionSpdy3Test, 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);
+  spdy::SettingsFlagsAndId id(0, 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
   // streams to 2.
   MockConnect connect_data(SYNCHRONOUS, OK);
   scoped_ptr<spdy::SpdyFrame> settings_frame(
       ConstructSpdySettings(new_settings));
   MockRead reads[] = {
     CreateMockRead(*settings_frame),
@@ skipping 11 matching lines @@
       SpdySessionDependencies::SpdyCreateSession(&session_deps));
 
   const std::string kTestHost("www.foo.com");
   const int kTestPort = 80;
   HostPortPair test_host_port_pair(kTestHost, kTestPort);
   HostPortProxyPair pair(test_host_port_pair, ProxyServer::Direct());
 
   // Initialize the SpdySettingsStorage with 1 max concurrent streams.
   SpdySessionPool* spdy_session_pool(http_session->spdy_session_pool());
   spdy::SpdySettings old_settings;
-  id.set_flags(spdy::SETTINGS_FLAG_PLEASE_PERSIST);
-  old_settings.push_back(spdy::SpdySetting(id, 1));
+  spdy::SettingsFlagsAndId id1(spdy::SETTINGS_FLAG_PLEASE_PERSIST, id.id());
+  old_settings.push_back(spdy::SpdySetting(id1, 1));
   spdy_session_pool->http_server_properties()->SetSpdySettings(
       test_host_port_pair, old_settings);
 
   // Create a session.
   EXPECT_FALSE(spdy_session_pool->HasSession(pair));
   scoped_refptr<SpdySession> session =
       spdy_session_pool->Get(pair, BoundNetLog());
   ASSERT_TRUE(spdy_session_pool->HasSession(pair));
 
   scoped_refptr<TransportSocketParams> transport_params(
@@ skipping 60 matching lines @@
       SpdySessionDependencies::SpdyCreateSession(&session_deps));
 
   const std::string kTestHost("www.foo.com");
   const int kTestPort = 80;
   HostPortPair test_host_port_pair(kTestHost, kTestPort);
   HostPortProxyPair pair(test_host_port_pair, ProxyServer::Direct());
 
   // Initialize the SpdySettingsStorage with 1 max concurrent streams.
   SpdySessionPool* spdy_session_pool(http_session->spdy_session_pool());
   spdy::SpdySettings settings;
-  spdy::SettingsFlagsAndId id(0);
-  id.set_id(spdy::SETTINGS_MAX_CONCURRENT_STREAMS);
-  id.set_flags(spdy::SETTINGS_FLAG_PLEASE_PERSIST);
+  spdy::SettingsFlagsAndId id(spdy::SETTINGS_FLAG_PLEASE_PERSIST,
+                              spdy::SETTINGS_MAX_CONCURRENT_STREAMS);
   settings.push_back(spdy::SpdySetting(id, 1));
   spdy_session_pool->http_server_properties()->SetSpdySettings(
       test_host_port_pair, settings);
 
   // Create a session.
   EXPECT_FALSE(spdy_session_pool->HasSession(pair));
   scoped_refptr<SpdySession> session =
       spdy_session_pool->Get(pair, BoundNetLog());
   ASSERT_TRUE(spdy_session_pool->HasSession(pair));
 
@@ skipping 50 matching lines @@
     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
   // SETTINGS_FLAG_PLEASE_PERSIST.
   spdy::SpdySettings settings;
   const uint32 kBogusSettingId = 0xABAB;
   const uint32 kBogusSettingValue = 0xCDCD;
-  spdy::SettingsFlagsAndId id(0);
-  id.set_id(kBogusSettingId);
-  id.set_flags(spdy::SETTINGS_FLAG_PERSISTED);
+  spdy::SettingsFlagsAndId id(spdy::SETTINGS_FLAG_PERSISTED, kBogusSettingId);
   settings.push_back(spdy::SpdySetting(id, kBogusSettingValue));
   MockConnect connect_data(SYNCHRONOUS, OK);
   scoped_ptr<spdy::SpdyFrame> settings_frame(
       ConstructSpdySettings(settings));
   MockWrite writes[] = {
     CreateMockWrite(*settings_frame),
   };
 
   StaticSocketDataProvider data(
       reads, arraysize(reads), writes, arraysize(writes));
   data.set_connect_data(connect_data);
   session_deps.socket_factory->AddSocketDataProvider(&data);
 
   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   session_deps.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   scoped_refptr<HttpNetworkSession> http_session(
       SpdySessionDependencies::SpdyCreateSession(&session_deps));
 
   const std::string kTestHost("www.foo.com");
   const int kTestPort = 80;
   HostPortPair test_host_port_pair(kTestHost, kTestPort);
   HostPortProxyPair pair(test_host_port_pair, ProxyServer::Direct());
 
-  id.set_flags(spdy::SETTINGS_FLAG_PLEASE_PERSIST);
+  spdy::SettingsFlagsAndId id1(spdy::SETTINGS_FLAG_PLEASE_PERSIST, id.id());
   settings.clear();
-  settings.push_back(spdy::SpdySetting(id, kBogusSettingValue));
+  settings.push_back(spdy::SpdySetting(id1, kBogusSettingValue));
   SpdySessionPool* spdy_session_pool(http_session->spdy_session_pool());
   spdy_session_pool->http_server_properties()->SetSpdySettings(
       test_host_port_pair, settings);
   EXPECT_FALSE(spdy_session_pool->HasSession(pair));
   scoped_refptr<SpdySession> session =
       spdy_session_pool->Get(pair, BoundNetLog());
   EXPECT_TRUE(spdy_session_pool->HasSession(pair));
 
   scoped_refptr<TransportSocketParams> transport_params(
       new TransportSocketParams(test_host_port_pair,
@@ skipping 138 matching lines @@
 TEST_F(SpdySessionSpdy3Test, IPPoolingCloseCurrentSessions) {
   IPPoolingTest(true);
 }
 
 TEST_F(SpdySessionSpdy3Test, 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);
+  spdy::SettingsFlagsAndId id(spdy::SETTINGS_FLAG_PLEASE_PERSIST,
+                              spdy::SETTINGS_MAX_CONCURRENT_STREAMS);
   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(SpdySessionSpdy3Test, 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);
+  spdy::SettingsFlagsAndId id(spdy::SETTINGS_FLAG_PLEASE_PERSIST,
+                              spdy::SETTINGS_MAX_CONCURRENT_STREAMS);
   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(
@@ skipping 206 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