SPDY - integration of spdy/3 code.

net/spdy/spdy_network_transaction_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/http/http_network_transaction.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 23 matching lines @@
   SPDYNOSSL,
   SPDYSSL,
 };
 class SpdyNetworkTransactionSpdy3Test
     : public ::testing::TestWithParam<SpdyNetworkTransactionSpdy3TestTypes> {
  protected:
 
   virtual void SetUp() {
     // By default, all tests turn off compression.
     EnableCompression(false);
+    SpdySession::set_default_protocol(SSLClientSocket::kProtoSPDY3);
     google_get_request_initialized_ = false;
     google_post_request_initialized_ = false;
     google_chunked_post_request_initialized_ = false;
   }
 
   virtual void TearDown() {
     // Empty the current queue.
     MessageLoop::current()->RunAllPending();
   }
 
@@ skipping 64 matching lines @@
         session_ = SpdySessionDependencies::SpdyCreateSession(
             session_deps_.get());
       HttpStreamFactory::set_use_alternate_protocols(false);
       HttpStreamFactory::set_force_spdy_over_ssl(false);
       HttpStreamFactory::set_force_spdy_always(false);
 
       std::vector<std::string> next_protos;
       next_protos.push_back("http/1.1");
       next_protos.push_back("spdy/2");
       next_protos.push_back("spdy/2.1");
+      next_protos.push_back("spdy/3");
 
       switch (test_type_) {
         case SPDYNPN:
           session_->http_server_properties()->SetAlternateProtocol(
               HostPortPair("www.google.com", 80), 443,
-              NPN_SPDY_21);
+              NPN_SPDY_3);
           HttpStreamFactory::set_use_alternate_protocols(true);
           HttpStreamFactory::SetNextProtos(next_protos);
           break;
         case SPDYNOSSL:
           HttpStreamFactory::set_force_spdy_over_ssl(false);
           HttpStreamFactory::set_force_spdy_always(true);
           break;
         case SPDYSSL:
           HttpStreamFactory::set_force_spdy_over_ssl(true);
           HttpStreamFactory::set_force_spdy_always(true);
@@ skipping 85 matching lines @@
       RunDefaultTest();
       VerifyDataConsumed();
     }
 
     void AddData(StaticSocketDataProvider* data) {
       DCHECK(!deterministic_);
       data_vector_.push_back(data);
       linked_ptr<SSLSocketDataProvider> ssl_(
           new SSLSocketDataProvider(ASYNC, OK));
       if (test_type_ == SPDYNPN) {
-        ssl_->SetNextProto(SSLClientSocket::kProtoSPDY21);
+        ssl_->SetNextProto(SSLClientSocket::kProtoSPDY3);
       }
       ssl_vector_.push_back(ssl_);
       if (test_type_ == SPDYNPN || test_type_ == SPDYSSL)
         session_deps_->socket_factory->AddSSLSocketDataProvider(ssl_.get());
       session_deps_->socket_factory->AddSocketDataProvider(data);
       if (test_type_ == SPDYNPN) {
         MockConnect never_finishing_connect(SYNCHRONOUS, ERR_IO_PENDING);
         linked_ptr<StaticSocketDataProvider>
             hanging_non_alternate_protocol_socket(
                 new StaticSocketDataProvider(NULL, 0, NULL, 0));
         hanging_non_alternate_protocol_socket->set_connect_data(
             never_finishing_connect);
         session_deps_->socket_factory->AddSocketDataProvider(
             hanging_non_alternate_protocol_socket.get());
         alternate_vector_.push_back(hanging_non_alternate_protocol_socket);
       }
     }
 
     void AddDeterministicData(DeterministicSocketData* data) {
       DCHECK(deterministic_);
       data_vector_.push_back(data);
       linked_ptr<SSLSocketDataProvider> ssl_(
           new SSLSocketDataProvider(ASYNC, OK));
       if (test_type_ == SPDYNPN) {
-        ssl_->SetNextProto(SSLClientSocket::kProtoSPDY21);
+        ssl_->SetNextProto(SSLClientSocket::kProtoSPDY3);
       }
       ssl_vector_.push_back(ssl_);
       if (test_type_ == SPDYNPN || test_type_ == SPDYSSL) {
         session_deps_->deterministic_socket_factory->
             AddSSLSocketDataProvider(ssl_.get());
       }
       session_deps_->deterministic_socket_factory->AddSocketDataProvider(data);
       if (test_type_ == SPDYNPN) {
         MockConnect never_finishing_connect(SYNCHRONOUS, ERR_IO_PENDING);
         scoped_refptr<DeterministicSocketData>
@@ skipping 657 matching lines @@
   scoped_ptr<spdy::SpdyFrame> resp2(ConstructSpdyGetSynReply(NULL, 0, 3));
   scoped_ptr<spdy::SpdyFrame> body2(ConstructSpdyBodyFrame(3, false));
   scoped_ptr<spdy::SpdyFrame> fbody2(ConstructSpdyBodyFrame(3, true));
 
   scoped_ptr<spdy::SpdyFrame> req3(ConstructSpdyGet(NULL, 0, false, 5, LOWEST));
   scoped_ptr<spdy::SpdyFrame> resp3(ConstructSpdyGetSynReply(NULL, 0, 5));
   scoped_ptr<spdy::SpdyFrame> body3(ConstructSpdyBodyFrame(5, false));
   scoped_ptr<spdy::SpdyFrame> fbody3(ConstructSpdyBodyFrame(5, true));
 
   spdy::SpdySettings 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 = 1;
 
   settings.push_back(spdy::SpdySetting(id, max_concurrent_streams));
   scoped_ptr<spdy::SpdyFrame> settings_frame(ConstructSpdySettings(settings));
 
   MockWrite writes[] = {
     CreateMockWrite(*req),
     CreateMockWrite(*req2),
     CreateMockWrite(*req3),
   };
@@ skipping 117 matching lines @@
   scoped_ptr<spdy::SpdyFrame> resp4(ConstructSpdyGetSynReply(NULL, 0, 5));
   scoped_ptr<spdy::SpdyFrame> fbody4(ConstructSpdyBodyFrame(5, true));
 
   scoped_ptr<spdy::SpdyFrame> req3(ConstructSpdyGet(NULL, 0, false, 7, LOWEST));
   scoped_ptr<spdy::SpdyFrame> resp3(ConstructSpdyGetSynReply(NULL, 0, 7));
   scoped_ptr<spdy::SpdyFrame> body3(ConstructSpdyBodyFrame(7, false));
   scoped_ptr<spdy::SpdyFrame> fbody3(ConstructSpdyBodyFrame(7, true));
 
 
   spdy::SpdySettings 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 = 1;
 
   settings.push_back(spdy::SpdySetting(id, max_concurrent_streams));
   scoped_ptr<spdy::SpdyFrame> settings_frame(ConstructSpdySettings(settings));
 
   MockWrite writes[] = { CreateMockWrite(*req),
     CreateMockWrite(*req2),
     CreateMockWrite(*req4),
     CreateMockWrite(*req3),
   };
@@ skipping 123 matching lines @@
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, false));
   scoped_ptr<spdy::SpdyFrame> fbody(ConstructSpdyBodyFrame(1, true));
 
   scoped_ptr<spdy::SpdyFrame> req2(ConstructSpdyGet(NULL, 0, false, 3, LOWEST));
   scoped_ptr<spdy::SpdyFrame> resp2(ConstructSpdyGetSynReply(NULL, 0, 3));
   scoped_ptr<spdy::SpdyFrame> body2(ConstructSpdyBodyFrame(3, false));
   scoped_ptr<spdy::SpdyFrame> fbody2(ConstructSpdyBodyFrame(3, true));
 
   spdy::SpdySettings 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 = 1;
 
   settings.push_back(spdy::SpdySetting(id, max_concurrent_streams));
   scoped_ptr<spdy::SpdyFrame> settings_frame(ConstructSpdySettings(settings));
 
   MockWrite writes[] = { CreateMockWrite(*req),
     CreateMockWrite(*req2),
   };
   MockRead reads[] = {
     CreateMockRead(*settings_frame, 1),
@@ skipping 114 matching lines @@
   // Construct the request.
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, false));
   scoped_ptr<spdy::SpdyFrame> fin_body(ConstructSpdyBodyFrame(1, true));
 
   scoped_ptr<spdy::SpdyFrame> req2(ConstructSpdyGet(NULL, 0, false, 3, LOWEST));
   scoped_ptr<spdy::SpdyFrame> resp2(ConstructSpdyGetSynReply(NULL, 0, 3));
 
   spdy::SpdySettings 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 = 1;
 
   settings.push_back(spdy::SpdySetting(id, max_concurrent_streams));
   scoped_ptr<spdy::SpdyFrame> settings_frame(ConstructSpdySettings(settings));
 
   MockWrite writes[] = { CreateMockWrite(*req),
     CreateMockWrite(*req2),
   };
   MockRead reads[] = {
     CreateMockRead(*settings_frame, 1),
@@ skipping 3063 matching lines @@
     ConstructSpdyPacket(kSynReplyInfo,
                         kExtraHeaders,
                         arraysize(kExtraHeaders) / 2,
                         NULL,
                         0));
 
   unsigned int kSampleId1 = 0x1;
   unsigned int kSampleValue1 = 0x0a0a0a0a;
   unsigned int kSampleId2 = 0x2;
   unsigned int kSampleValue2 = 0x0b0b0b0b;
-  unsigned int kSampleId3 = 0xababab;
+  unsigned int kSampleId3 = 0x3;
   unsigned int kSampleValue3 = 0x0c0c0c0c;
   scoped_ptr<spdy::SpdyFrame> settings_frame;
   {
     // Construct the SETTINGS frame.
     spdy::SpdySettings settings;
-    spdy::SettingsFlagsAndId setting(0);
     // First add a persisted setting
-    setting.set_flags(spdy::SETTINGS_FLAG_PLEASE_PERSIST);
-    setting.set_id(kSampleId1);
-    settings.push_back(std::make_pair(setting, kSampleValue1));
+    spdy::SettingsFlagsAndId setting1(spdy::SETTINGS_FLAG_PLEASE_PERSIST,
+                                      kSampleId1);
+    settings.push_back(std::make_pair(setting1, kSampleValue1));
     // Next add a non-persisted setting
-    setting.set_flags(0);
-    setting.set_id(kSampleId2);
-    settings.push_back(std::make_pair(setting, kSampleValue2));
+    spdy::SettingsFlagsAndId setting2(0, kSampleId2);
+    settings.push_back(std::make_pair(setting2, kSampleValue2));
     // Next add another persisted setting
-    setting.set_flags(spdy::SETTINGS_FLAG_PLEASE_PERSIST);
-    setting.set_id(kSampleId3);
-    settings.push_back(std::make_pair(setting, kSampleValue3));
+    spdy::SettingsFlagsAndId setting3(spdy::SETTINGS_FLAG_PLEASE_PERSIST,
+                                      kSampleId3);
+    settings.push_back(std::make_pair(setting3, kSampleValue3));
     settings_frame.reset(ConstructSpdySettings(settings));
   }
 
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*reply),
     CreateMockRead(*body),
     CreateMockRead(*settings_frame),
     MockRead(ASYNC, 0, 0)  // EOF
   };
@@ skipping 63 matching lines @@
   EXPECT_TRUE(spdy_session_pool->http_server_properties()->GetSpdySettings(
       host_port_pair).empty());
 
   unsigned int kSampleId1 = 0x1;
   unsigned int kSampleValue1 = 0x0a0a0a0a;
   unsigned int kSampleId2 = 0xababab;
   unsigned int kSampleValue2 = 0x0c0c0c0c;
   // Manually insert settings into the SpdySettingsStorage here.
   {
     spdy::SpdySettings settings;
-    spdy::SettingsFlagsAndId setting(0);
     // First add a persisted setting
-    setting.set_flags(spdy::SETTINGS_FLAG_PLEASE_PERSIST);
-    setting.set_id(kSampleId1);
-    settings.push_back(std::make_pair(setting, kSampleValue1));
+    spdy::SettingsFlagsAndId setting1(spdy::SETTINGS_FLAG_PLEASE_PERSIST,
+                                      kSampleId1);
+    settings.push_back(std::make_pair(setting1, kSampleValue1));
     // Next add another persisted setting
-    setting.set_flags(spdy::SETTINGS_FLAG_PLEASE_PERSIST);
-    setting.set_id(kSampleId2);
-    settings.push_back(std::make_pair(setting, kSampleValue2));
+    spdy::SettingsFlagsAndId setting2(spdy::SETTINGS_FLAG_PLEASE_PERSIST,
+                                      kSampleId2);
+    settings.push_back(std::make_pair(setting2, kSampleValue2));
 
     spdy_session_pool->http_server_properties()->SetSpdySettings(
         host_port_pair, settings);
   }
 
   EXPECT_EQ(2u, spdy_session_pool->http_server_properties()->GetSpdySettings(
       host_port_pair).size());
 
   // Construct the SETTINGS frame.
   const spdy::SpdySettings& settings =
@@ skipping 1327 matching lines @@
                                     << " Write index: "
                                     << data->write_index();
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
   EXPECT_TRUE(response.headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 }
 
 }  // namespace net