SPDY - replaced SpdySettings (list) with SettingsMap

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/host_cache.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_log_unittest.h"
 #include "net/spdy/spdy_io_buffer.h"
@@ skipping 482 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);
 
-  SpdySettings new_settings;
+  SettingsMap new_settings;
   const SpdySettingsIds kSpdySettingsIds1 = SETTINGS_MAX_CONCURRENT_STREAMS;
-  SettingsFlagsAndId id(SETTINGS_FLAG_NONE, kSpdySettingsIds1);
   const size_t max_concurrent_streams = 2;
-  new_settings.push_back(SpdySetting(id, max_concurrent_streams));
+  new_settings[kSpdySettingsIds1] =
+      SettingsFlagsAndValue(SETTINGS_FLAG_NONE, 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<SpdyFrame> settings_frame(ConstructSpdySettings(new_settings));
   MockRead reads[] = {
     CreateMockRead(*settings_frame),
     MockRead(SYNCHRONOUS, 0, 0)  // EOF
   };
 
   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
   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());
 
-  // Initialize the SpdySettingsStorage with 1 max concurrent streams.
+  // Initialize the SpdySetting with 1 max concurrent streams.
   SpdySessionPool* spdy_session_pool(http_session->spdy_session_pool());
   spdy_session_pool->http_server_properties()->SetSpdySetting(
       test_host_port_pair,
       kSpdySettingsIds1,
       SETTINGS_FLAG_PLEASE_PERSIST,
       1);
 
   // Create a session.
   EXPECT_FALSE(spdy_session_pool->HasSession(pair));
   scoped_refptr<SpdySession> session =
@@ skipping 62 matching lines @@
   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());
 
-  // Initialize the SpdySettingsStorage with 1 max concurrent streams.
+  // Initialize the SpdySetting with 1 max concurrent streams.
   SpdySessionPool* spdy_session_pool(http_session->spdy_session_pool());
   spdy_session_pool->http_server_properties()->SetSpdySetting(
       test_host_port_pair,
       SETTINGS_MAX_CONCURRENT_STREAMS,
       SETTINGS_FLAG_PLEASE_PERSIST,
       1);
 
   // Create a session.
   EXPECT_FALSE(spdy_session_pool->HasSession(pair));
   scoped_refptr<SpdySession> session =
@@ skipping 49 matching lines @@
 TEST_F(SpdySessionSpdy3Test, 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
+  // to persist it into the HttpServerProperties, we need to mark as
   // SETTINGS_FLAG_PLEASE_PERSIST.
-  SpdySettings settings;
+  SettingsMap settings;
   const SpdySettingsIds kSpdySettingsIds1 = SETTINGS_UPLOAD_BANDWIDTH;
   const uint32 kBogusSettingValue = 0xCDCD;
-  SettingsFlagsAndId id(SETTINGS_FLAG_PERSISTED, kSpdySettingsIds1);
-  settings.push_back(SpdySetting(id, kBogusSettingValue));
+  settings[kSpdySettingsIds1] =
+      SettingsFlagsAndValue(SETTINGS_FLAG_PERSISTED, kBogusSettingValue);
   MockConnect connect_data(SYNCHRONOUS, OK);
   scoped_ptr<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);
@@ skipping 176 matching lines @@
 }  // namespace
 
 TEST_F(SpdySessionSpdy3Test, IPPooling) {
   IPPoolingTest(false);
 }
 
 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);
-  SpdySettings test_settings;
-  SettingsFlagsAndId id(SETTINGS_FLAG_PLEASE_PERSIST,
-                        SETTINGS_MAX_CONCURRENT_STREAMS);
-  const size_t max_concurrent_streams = 2;
-  test_settings.push_back(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());
 
@@ skipping 76 matching lines @@
   spdy_session_pool->Remove(session);
 }
 
 TEST_F(SpdySessionSpdy3Test, SendCredentials) {
   SpdySessionDependencies session_deps;
 
   MockConnect connect_data(SYNCHRONOUS, OK);
   MockRead reads[] = {
     MockRead(SYNCHRONOUS, ERR_IO_PENDING)  // Stall forever.
   };
-  SpdySettings settings;
+  SettingsMap settings;
   scoped_ptr<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);
@@ skipping 115 matching lines @@
   CapturingNetLog::Entry entry = entries[pos];
   NetLogSpdySessionCloseParameter* request_params =
       static_cast<NetLogSpdySessionCloseParameter*>(
           entry.extra_parameters.get());
   EXPECT_EQ(ERR_CONNECTION_CLOSED, request_params->status());
 }
 
 TEST_F(SpdySessionSpdy3Test, UpdateStreamsSendWindowSize) {
   // Set SETTINGS_INITIAL_WINDOW_SIZE to a small number so that WINDOW_UPDATE
   // gets sent.
-  SpdySettings new_settings;
-  SettingsFlagsAndId id(0, SETTINGS_INITIAL_WINDOW_SIZE);
+  SettingsMap new_settings;
   int32 window_size = 1;
-  new_settings.push_back(SpdySetting(id, window_size));
+  new_settings[SETTINGS_INITIAL_WINDOW_SIZE] =
+      SettingsFlagsAndValue(SETTINGS_FLAG_NONE, window_size);
 
   // Set up the socket so we read a SETTINGS frame that sets
   // INITIAL_WINDOW_SIZE.
   MockConnect connect_data(SYNCHRONOUS, OK);
   scoped_ptr<SpdyFrame> settings_frame(ConstructSpdySettings(new_settings));
   MockRead reads[] = {
     CreateMockRead(*settings_frame),
     MockRead(SYNCHRONOUS, 0, 0)  // EOF
   };
 
@@ skipping 62 matching lines @@
                                   &spdy_stream2,
                                   BoundNetLog(),
                                   callback1.callback()));
 
   EXPECT_EQ(spdy_stream2->send_window_size(), window_size);
   spdy_stream2->Cancel();
   spdy_stream2 = NULL;
 }
 
 }  // namespace net