SPDY - persist SPDY settings.

net/spdy/spdy_network_transaction_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/http/http_network_transaction.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 917 matching lines @@
   scoped_ptr<SpdyFrame> resp2(ConstructSpdyGetSynReply(NULL, 0, 3));
   scoped_ptr<SpdyFrame> body2(ConstructSpdyBodyFrame(3, false));
   scoped_ptr<SpdyFrame> fbody2(ConstructSpdyBodyFrame(3, true));
 
   scoped_ptr<SpdyFrame> req3(ConstructSpdyGet(NULL, 0, false, 5, LOWEST));
   scoped_ptr<SpdyFrame> resp3(ConstructSpdyGetSynReply(NULL, 0, 5));
   scoped_ptr<SpdyFrame> body3(ConstructSpdyBodyFrame(5, false));
   scoped_ptr<SpdyFrame> fbody3(ConstructSpdyBodyFrame(5, true));
 
   SpdySettings settings;
-  SettingsFlagsAndId id(0, SETTINGS_MAX_CONCURRENT_STREAMS);
+  SettingsFlagsAndId id(SETTINGS_FLAG_NONE, SETTINGS_MAX_CONCURRENT_STREAMS);
   const size_t max_concurrent_streams = 1;
 
   settings.push_back(SpdySetting(id, max_concurrent_streams));
   scoped_ptr<SpdyFrame> settings_frame(ConstructSpdySettings(settings));
 
   MockWrite writes[] = {
     CreateMockWrite(*req),
     CreateMockWrite(*req2),
     CreateMockWrite(*req3),
   };
@@ skipping 115 matching lines @@
   scoped_ptr<SpdyFrame> req4(
       ConstructSpdyGet(NULL, 0, false, 5, HIGHEST));
   scoped_ptr<SpdyFrame> resp4(ConstructSpdyGetSynReply(NULL, 0, 5));
   scoped_ptr<SpdyFrame> fbody4(ConstructSpdyBodyFrame(5, true));
 
   scoped_ptr<SpdyFrame> req3(ConstructSpdyGet(NULL, 0, false, 7, LOWEST));
   scoped_ptr<SpdyFrame> resp3(ConstructSpdyGetSynReply(NULL, 0, 7));
   scoped_ptr<SpdyFrame> body3(ConstructSpdyBodyFrame(7, false));
   scoped_ptr<SpdyFrame> fbody3(ConstructSpdyBodyFrame(7, true));
 
-
   SpdySettings settings;
-  SettingsFlagsAndId id(0, SETTINGS_MAX_CONCURRENT_STREAMS);
+  SettingsFlagsAndId id(SETTINGS_FLAG_NONE, SETTINGS_MAX_CONCURRENT_STREAMS);
   const size_t max_concurrent_streams = 1;
 
   settings.push_back(SpdySetting(id, max_concurrent_streams));
   scoped_ptr<SpdyFrame> settings_frame(ConstructSpdySettings(settings));
 
   MockWrite writes[] = { CreateMockWrite(*req),
     CreateMockWrite(*req2),
     CreateMockWrite(*req4),
     CreateMockWrite(*req3),
   };
@@ skipping 46 matching lines @@
   TestCompletionCallback callback4;
 
   HttpRequestInfo httpreq1 = CreateGetRequest();
   HttpRequestInfo httpreq2 = CreateGetRequest();
   HttpRequestInfo httpreq3 = CreateGetRequest();
   HttpRequestInfo httpreq4 = CreateGetRequest();
   httpreq4.priority = HIGHEST;
 
   out.rv = trans1->Start(&httpreq1, callback1.callback(), log);
   ASSERT_EQ(ERR_IO_PENDING, out.rv);
-  // run transaction 1 through quickly to force a read of our SETTINGS
-  // frame
+  // Run transaction 1 through quickly to force a read of our SETTINGS frame.
   out.rv = callback1.WaitForResult();
   ASSERT_EQ(OK, out.rv);
 
   out.rv = trans2->Start(&httpreq2, callback2.callback(), log);
   ASSERT_EQ(ERR_IO_PENDING, out.rv);
   out.rv = trans3->Start(&httpreq3, callback3.callback(), log);
   ASSERT_EQ(ERR_IO_PENDING, out.rv);
   out.rv = trans4->Start(&httpreq4, callback4.callback(), log);
   ASSERT_EQ(ERR_IO_PENDING, out.rv);
 
@@ skipping 55 matching lines @@
   scoped_ptr<SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body(ConstructSpdyBodyFrame(1, false));
   scoped_ptr<SpdyFrame> fbody(ConstructSpdyBodyFrame(1, true));
 
   scoped_ptr<SpdyFrame> req2(ConstructSpdyGet(NULL, 0, false, 3, LOWEST));
   scoped_ptr<SpdyFrame> resp2(ConstructSpdyGetSynReply(NULL, 0, 3));
   scoped_ptr<SpdyFrame> body2(ConstructSpdyBodyFrame(3, false));
   scoped_ptr<SpdyFrame> fbody2(ConstructSpdyBodyFrame(3, true));
 
   SpdySettings settings;
-  SettingsFlagsAndId id(0, SETTINGS_MAX_CONCURRENT_STREAMS);
+  SettingsFlagsAndId id(SETTINGS_FLAG_NONE, SETTINGS_MAX_CONCURRENT_STREAMS);
   const size_t max_concurrent_streams = 1;
 
   settings.push_back(SpdySetting(id, max_concurrent_streams));
   scoped_ptr<SpdyFrame> settings_frame(ConstructSpdySettings(settings));
 
   MockWrite writes[] = { CreateMockWrite(*req),
     CreateMockWrite(*req2),
   };
   MockRead reads[] = {
     CreateMockRead(*settings_frame, 1),
@@ skipping 32 matching lines @@
   TestCompletionCallback callback1;
   TestCompletionCallback callback2;
   TestCompletionCallback callback3;
 
   HttpRequestInfo httpreq1 = CreateGetRequest();
   HttpRequestInfo httpreq2 = CreateGetRequest();
   HttpRequestInfo httpreq3 = CreateGetRequest();
 
   out.rv = trans1->Start(&httpreq1, callback1.callback(), log);
   ASSERT_EQ(out.rv, ERR_IO_PENDING);
-  // run transaction 1 through quickly to force a read of our SETTINGS
-  // frame
+  // Run transaction 1 through quickly to force a read of our SETTINGS frame.
   out.rv = callback1.WaitForResult();
   ASSERT_EQ(OK, out.rv);
 
   out.rv = trans2->Start(&httpreq2, callback2.callback(), log);
   ASSERT_EQ(out.rv, ERR_IO_PENDING);
   out.rv = trans3->Start(&httpreq3, callback3.callback(), log);
   delete trans3.release();
   ASSERT_EQ(out.rv, ERR_IO_PENDING);
   out.rv = callback2.WaitForResult();
   ASSERT_EQ(OK, out.rv);
@@ skipping 60 matching lines @@
   // Construct the request.
   scoped_ptr<SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   scoped_ptr<SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body(ConstructSpdyBodyFrame(1, false));
   scoped_ptr<SpdyFrame> fin_body(ConstructSpdyBodyFrame(1, true));
 
   scoped_ptr<SpdyFrame> req2(ConstructSpdyGet(NULL, 0, false, 3, LOWEST));
   scoped_ptr<SpdyFrame> resp2(ConstructSpdyGetSynReply(NULL, 0, 3));
 
   SpdySettings settings;
-  SettingsFlagsAndId id(0, SETTINGS_MAX_CONCURRENT_STREAMS);
+  SettingsFlagsAndId id(SETTINGS_FLAG_NONE, SETTINGS_MAX_CONCURRENT_STREAMS);
   const size_t max_concurrent_streams = 1;
 
   settings.push_back(SpdySetting(id, max_concurrent_streams));
   scoped_ptr<SpdyFrame> settings_frame(ConstructSpdySettings(settings));
 
   MockWrite writes[] = { CreateMockWrite(*req),
     CreateMockWrite(*req2),
   };
   MockRead reads[] = {
     CreateMockRead(*settings_frame, 1),
@@ skipping 27 matching lines @@
   TestCompletionCallback callback1;
   TestCompletionCallback callback2;
   KillerCallback callback3(trans3);
 
   HttpRequestInfo httpreq1 = CreateGetRequest();
   HttpRequestInfo httpreq2 = CreateGetRequest();
   HttpRequestInfo httpreq3 = CreateGetRequest();
 
   out.rv = trans1.Start(&httpreq1, callback1.callback(), log);
   ASSERT_EQ(out.rv, ERR_IO_PENDING);
-  // run transaction 1 through quickly to force a read of our SETTINGS
-  // frame
+  // Run transaction 1 through quickly to force a read of our SETTINGS frame.
   out.rv = callback1.WaitForResult();
   ASSERT_EQ(OK, out.rv);
 
   out.rv = trans2.Start(&httpreq2, callback2.callback(), log);
   ASSERT_EQ(out.rv, ERR_IO_PENDING);
   out.rv = trans3->Start(&httpreq3, callback3.callback(), log);
   ASSERT_EQ(out.rv, ERR_IO_PENDING);
   out.rv = callback3.WaitForResult();
   ASSERT_EQ(ERR_ABORTED, out.rv);
 
@@ skipping 20 matching lines @@
 
 // Test that a simple PUT request works.
 TEST_P(SpdyNetworkTransactionSpdy2Test, Put) {
   // Setup the request
   HttpRequestInfo request;
   request.method = "PUT";
   request.url = GURL("http://www.google.com/");
 
   const SpdyHeaderInfo kSynStartHeader = {
     SYN_STREAM,             // Kind = Syn
-    1,                            // Stream ID
-    0,                            // Associated stream ID
+    1,                      // Stream ID
+    0,                      // Associated stream ID
     net::ConvertRequestPriorityToSpdyPriority(LOWEST),  // Priority
     CONTROL_FLAG_FIN,       // Control Flags
-    false,                        // Compressed
+    false,                  // Compressed
     INVALID,                // Status
-    NULL,                         // Data
-    0,                            // Length
+    NULL,                   // Data
+    0,                      // Length
     DATA_FLAG_NONE          // Data Flags
   };
   const char* const kPutHeaders[] = {
     "method", "PUT",
     "url", "/",
     "host", "www.google.com",
     "scheme", "http",
     "version", "HTTP/1.1",
     "content-length", "0"
   };
   scoped_ptr<SpdyFrame> req(ConstructSpdyPacket(kSynStartHeader, NULL, 0,
     kPutHeaders, arraysize(kPutHeaders) / 2));
   MockWrite writes[] = {
     CreateMockWrite(*req)
   };
 
   scoped_ptr<SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   const SpdyHeaderInfo kSynReplyHeader = {
     SYN_REPLY,              // Kind = SynReply
-    1,                            // Stream ID
-    0,                            // Associated stream ID
+    1,                      // Stream ID
+    0,                      // Associated stream ID
     net::ConvertRequestPriorityToSpdyPriority(LOWEST),  // Priority
     CONTROL_FLAG_NONE,      // Control Flags
-    false,                        // Compressed
+    false,                  // Compressed
     INVALID,                // Status
-    NULL,                         // Data
-    0,                            // Length
+    NULL,                   // Data
+    0,                      // Length
     DATA_FLAG_NONE          // Data Flags
   };
   static const char* const kStandardGetHeaders[] = {
     "status", "200",
     "version", "HTTP/1.1"
     "content-length", "1234"
   };
   scoped_ptr<SpdyFrame> resp(ConstructSpdyPacket(kSynReplyHeader,
       NULL, 0, kStandardGetHeaders, arraysize(kStandardGetHeaders) / 2));
   MockRead reads[] = {
@@ skipping 16 matching lines @@
 
 // Test that a simple HEAD request works.
 TEST_P(SpdyNetworkTransactionSpdy2Test, Head) {
   // Setup the request
   HttpRequestInfo request;
   request.method = "HEAD";
   request.url = GURL("http://www.google.com/");
 
   const SpdyHeaderInfo kSynStartHeader = {
     SYN_STREAM,             // Kind = Syn
-    1,                            // Stream ID
-    0,                            // Associated stream ID
+    1,                      // Stream ID
+    0,                      // Associated stream ID
     net::ConvertRequestPriorityToSpdyPriority(LOWEST),  // Priority
     CONTROL_FLAG_FIN,       // Control Flags
-    false,                        // Compressed
+    false,                  // Compressed
     INVALID,                // Status
-    NULL,                         // Data
-    0,                            // Length
+    NULL,                   // Data
+    0,                      // Length
     DATA_FLAG_NONE          // Data Flags
   };
   const char* const kHeadHeaders[] = {
     "method", "HEAD",
     "url", "/",
     "host", "www.google.com",
     "scheme", "http",
     "version", "HTTP/1.1",
     "content-length", "0"
   };
   scoped_ptr<SpdyFrame> req(ConstructSpdyPacket(kSynStartHeader, NULL, 0,
     kHeadHeaders, arraysize(kHeadHeaders) / 2));
   MockWrite writes[] = {
     CreateMockWrite(*req)
   };
 
   scoped_ptr<SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   const SpdyHeaderInfo kSynReplyHeader = {
     SYN_REPLY,              // Kind = SynReply
-    1,                            // Stream ID
-    0,                            // Associated stream ID
+    1,                      // Stream ID
+    0,                      // Associated stream ID
     net::ConvertRequestPriorityToSpdyPriority(LOWEST),  // Priority
     CONTROL_FLAG_NONE,      // Control Flags
-    false,                        // Compressed
+    false,                  // Compressed
     INVALID,                // Status
-    NULL,                         // Data
-    0,                            // Length
+    NULL,                   // Data
+    0,                      // Length
     DATA_FLAG_NONE          // Data Flags
   };
   static const char* const kStandardGetHeaders[] = {
     "status", "200",
     "version", "HTTP/1.1"
     "content-length", "1234"
   };
   scoped_ptr<SpdyFrame> resp(ConstructSpdyPacket(kSynReplyHeader,
       NULL, 0, kStandardGetHeaders, arraysize(kStandardGetHeaders) / 2));
   MockRead reads[] = {
@@ skipping 1543 matching lines @@
     }
     EXPECT_EQ(std::string(test_cases[i].expected_headers), lines);
   }
 }
 
 // Verify that various SynReply headers parse vary fields correctly
 // through the HTTP layer, and the response matches the request.
 TEST_P(SpdyNetworkTransactionSpdy2Test, SynReplyHeadersVary) {
   static const SpdyHeaderInfo syn_reply_info = {
     SYN_REPLY,                              // Syn Reply
-    1,                                            // Stream ID
-    0,                                            // Associated Stream ID
-    net::ConvertRequestPriorityToSpdyPriority(LOWEST),
-                                                  // Priority
+    1,                                      // Stream ID
+    0,                                      // Associated Stream ID
+    net::ConvertRequestPriorityToSpdyPriority(LOWEST),  // Priority
     CONTROL_FLAG_NONE,                      // Control Flags
-    false,                                        // Compressed
+    false,                                  // Compressed
     INVALID,                                // Status
-    NULL,                                         // Data
-    0,                                            // Data Length
+    NULL,                                   // Data
+    0,                                      // Data Length
     DATA_FLAG_NONE                          // Data Flags
   };
   // Modify the following data to change/add test cases:
   struct SynReplyTests {
     const SpdyHeaderInfo* syn_reply;
     bool vary_matches;
     int num_headers[2];
     const char* extra_headers[2][16];
   } test_cases[] = {
     // Test the case of a multi-valued cookie.  When the value is delimited
@@ skipping 140 matching lines @@
                              256);
 
     EXPECT_EQ(std::string(reply_buffer), lines) << i;
   }
 }
 
 // Verify that we don't crash on invalid SynReply responses.
 TEST_P(SpdyNetworkTransactionSpdy2Test, InvalidSynReply) {
   const SpdyHeaderInfo kSynStartHeader = {
     SYN_REPLY,              // Kind = SynReply
-    1,                            // Stream ID
-    0,                            // Associated stream ID
-    net::ConvertRequestPriorityToSpdyPriority(LOWEST),
-                                  // Priority
+    1,                      // Stream ID
+    0,                      // Associated stream ID
+    net::ConvertRequestPriorityToSpdyPriority(LOWEST),  // Priority
     CONTROL_FLAG_NONE,      // Control Flags
-    false,                        // Compressed
+    false,                  // Compressed
     INVALID,                // Status
-    NULL,                         // Data
-    0,                            // Length
+    NULL,                   // Data
+    0,                      // Length
     DATA_FLAG_NONE          // Data Flags
   };
 
   struct InvalidSynReplyTests {
     int num_headers;
     const char* headers[10];
   } test_cases[] = {
     // SYN_REPLY missing status header
     { 4,
       { "cookie", "val1",
@@ skipping 692 matching lines @@
 
   // Verify that we consumed all test data.
   helper.VerifyDataConsumed();
 }
 
 // Test that if the server requests persistence of settings, that we save
 // the settings in the SpdySettingsStorage.
 TEST_P(SpdyNetworkTransactionSpdy2Test, SettingsSaved) {
   static const SpdyHeaderInfo kSynReplyInfo = {
     SYN_REPLY,                              // Syn Reply
-    1,                                            // Stream ID
-    0,                                            // Associated Stream ID
-    net::ConvertRequestPriorityToSpdyPriority(LOWEST),
-                                                  // Priority
+    1,                                      // Stream ID
+    0,                                      // Associated Stream ID
+    net::ConvertRequestPriorityToSpdyPriority(LOWEST),  // Priority
     CONTROL_FLAG_NONE,                      // Control Flags
-    false,                                        // Compressed
+    false,                                  // Compressed
     INVALID,                                // Status
-    NULL,                                         // Data
-    0,                                            // Data Length
+    NULL,                                   // Data
+    0,                                      // Data Length
     DATA_FLAG_NONE                          // Data Flags
   };
   static const char* const kExtraHeaders[] = {
     "status",   "200",
     "version",  "HTTP/1.1"
   };
 
   BoundNetLog net_log;
   NormalSpdyTransactionHelper helper(CreateGetRequest(), net_log, GetParam());
   helper.RunPreTestSetup();
 
   // Verify that no settings exist initially.
   HostPortPair host_port_pair("www.google.com", helper.port());
   SpdySessionPool* spdy_session_pool = helper.session()->spdy_session_pool();
   EXPECT_TRUE(spdy_session_pool->http_server_properties()->GetSpdySettings(
       host_port_pair).empty());
 
   // Construct the request.
   scoped_ptr<SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   // Construct the reply.
   scoped_ptr<SpdyFrame> reply(
     ConstructSpdyPacket(kSynReplyInfo,
                         kExtraHeaders,
                         arraysize(kExtraHeaders) / 2,
                         NULL,
                         0));
 
-  unsigned int kSampleId1 = 0x1;
+  const SpdySettingsIds kSampleId1 = SETTINGS_UPLOAD_BANDWIDTH;
   unsigned int kSampleValue1 = 0x0a0a0a0a;
-  unsigned int kSampleId2 = 0x2;
+  const SpdySettingsIds kSampleId2 = SETTINGS_DOWNLOAD_BANDWIDTH;
   unsigned int kSampleValue2 = 0x0b0b0b0b;
-  unsigned int kSampleId3 = 0x3;
+  const SpdySettingsIds kSampleId3 = SETTINGS_ROUND_TRIP_TIME;
   unsigned int kSampleValue3 = 0x0c0c0c0c;
   scoped_ptr<SpdyFrame> settings_frame;
   {
     // Construct the SETTINGS frame.
     SpdySettings settings;
-    // First add a persisted setting
-    SettingsFlagsAndId setting1(SETTINGS_FLAG_PLEASE_PERSIST,
-                                      kSampleId1);
+    // First add a persisted setting.
+    SettingsFlagsAndId setting1(SETTINGS_FLAG_PLEASE_PERSIST, kSampleId1);
     settings.push_back(std::make_pair(setting1, kSampleValue1));
-    // Next add a non-persisted setting
-    SettingsFlagsAndId setting2(0, kSampleId2);
+    // Next add a non-persisted setting.
+    SettingsFlagsAndId setting2(SETTINGS_FLAG_NONE, kSampleId2);
     settings.push_back(std::make_pair(setting2, kSampleValue2));
-    // Next add another persisted setting
-    SettingsFlagsAndId setting3(SETTINGS_FLAG_PLEASE_PERSIST,
-                                      kSampleId3);
+    // Next add another persisted setting.
+    SettingsFlagsAndId setting3(SETTINGS_FLAG_PLEASE_PERSIST, kSampleId3);
     settings.push_back(std::make_pair(setting3, kSampleValue3));
     settings_frame.reset(ConstructSpdySettings(settings));
   }
 
   scoped_ptr<SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*reply),
     CreateMockRead(*body),
     CreateMockRead(*settings_frame),
     MockRead(ASYNC, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
   helper.AddData(data.get());
   helper.RunDefaultTest();
   helper.VerifyDataConsumed();
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 
-  // TODO(rtenneti): Persist spdy settings.
-#ifdef PERSIST_SPDY_SETTINGS
   {
     // Verify we had two persisted settings.
-    SpdySettings saved_settings =
+    const SettingsMap& settings_map =
         spdy_session_pool->http_server_properties()->GetSpdySettings(
             host_port_pair);
-    ASSERT_EQ(2u, saved_settings.size());
+    ASSERT_EQ(2u, settings_map.size());
 
     // Verify the first persisted setting.
-    SpdySetting setting = saved_settings.front();
-    saved_settings.pop_front();
-    EXPECT_EQ(SETTINGS_FLAG_PERSISTED, setting.first.flags());
-    EXPECT_EQ(kSampleId1, setting.first.id());
-    EXPECT_EQ(kSampleValue1, setting.second);
+    SettingsMap::const_iterator it1 = settings_map.find(kSampleId1);
+    EXPECT_TRUE(it1 != settings_map.end());
+    SettingsFlagsAndValue flags_and_value1 = it1->second;
+    EXPECT_EQ(SETTINGS_FLAG_PERSISTED, flags_and_value1.first);
+    EXPECT_EQ(kSampleValue1, flags_and_value1.second);
 
     // Verify the second persisted setting.
-    setting = saved_settings.front();
-    saved_settings.pop_front();
-    EXPECT_EQ(SETTINGS_FLAG_PERSISTED, setting.first.flags());
-    EXPECT_EQ(kSampleId3, setting.first.id());
-    EXPECT_EQ(kSampleValue3, setting.second);
+    SettingsMap::const_iterator it3 = settings_map.find(kSampleId3);
+    EXPECT_TRUE(it3 != settings_map.end());
+    SettingsFlagsAndValue flags_and_value3 = it3->second;
+    EXPECT_EQ(SETTINGS_FLAG_PERSISTED, flags_and_value3.first);
+    EXPECT_EQ(kSampleValue3, flags_and_value3.second);
   }
-#endif
 }
 
 // Test that when there are settings saved that they are sent back to the
 // server upon session establishment.
 TEST_P(SpdyNetworkTransactionSpdy2Test, SettingsPlayback) {
   static const SpdyHeaderInfo kSynReplyInfo = {
     SYN_REPLY,                              // Syn Reply
-    1,                                            // Stream ID
-    0,                                            // Associated Stream ID
-    net::ConvertRequestPriorityToSpdyPriority(LOWEST),
-                                                  // Priority
+    1,                                      // Stream ID
+    0,                                      // Associated Stream ID
+    net::ConvertRequestPriorityToSpdyPriority(LOWEST),  // Priority
     CONTROL_FLAG_NONE,                      // Control Flags
-    false,                                        // Compressed
+    false,                                  // Compressed
     INVALID,                                // Status
-    NULL,                                         // Data
-    0,                                            // Data Length
+    NULL,                                   // Data
+    0,                                      // Data Length
     DATA_FLAG_NONE                          // Data Flags
   };
   static const char* kExtraHeaders[] = {
     "status",   "200",
     "version",  "HTTP/1.1"
   };
 
   BoundNetLog net_log;
   NormalSpdyTransactionHelper helper(CreateGetRequest(), net_log, GetParam());
   helper.RunPreTestSetup();
 
   // Verify that no settings exist initially.
   HostPortPair host_port_pair("www.google.com", helper.port());
   SpdySessionPool* spdy_session_pool = helper.session()->spdy_session_pool();
   EXPECT_TRUE(spdy_session_pool->http_server_properties()->GetSpdySettings(
       host_port_pair).empty());
 
-  unsigned int kSampleId1 = 0x1;
+  const SpdySettingsIds kSampleId1 = SETTINGS_UPLOAD_BANDWIDTH;
   unsigned int kSampleValue1 = 0x0a0a0a0a;
-  unsigned int kSampleId2 = 0xababab;
+  const SpdySettingsIds kSampleId2 = SETTINGS_ROUND_TRIP_TIME;
   unsigned int kSampleValue2 = 0x0c0c0c0c;
-  // Manually insert settings into the SpdySettingsStorage here.
-  {
-    SpdySettings settings;
-    // First add a persisted setting
-    SettingsFlagsAndId setting1(SETTINGS_FLAG_PLEASE_PERSIST,
-                                      kSampleId1);
-    settings.push_back(std::make_pair(setting1, kSampleValue1));
-    // Next add another persisted setting
-    SettingsFlagsAndId setting2(SETTINGS_FLAG_PLEASE_PERSIST,
-                                      kSampleId2);
-    settings.push_back(std::make_pair(setting2, kSampleValue2));
 
-    spdy_session_pool->http_server_properties()->SetSpdySettings(
-        host_port_pair, settings);
-  }
+  // First add a persisted setting.
+  spdy_session_pool->http_server_properties()->SetSpdySetting(
+      host_port_pair,
+      kSampleId1,
+      SETTINGS_FLAG_PLEASE_PERSIST,
+      kSampleValue1);
+
+  // Next add another persisted setting.
+  spdy_session_pool->http_server_properties()->SetSpdySetting(
+      host_port_pair,
+      kSampleId2,
+      SETTINGS_FLAG_PLEASE_PERSIST,
+      kSampleValue2);
 
   EXPECT_EQ(2u, spdy_session_pool->http_server_properties()->GetSpdySettings(
       host_port_pair).size());
 
   // Construct the SETTINGS frame.
-  const SpdySettings& settings =
+  const SettingsMap& settings_map =
       spdy_session_pool->http_server_properties()->GetSpdySettings(
           host_port_pair);
+
+  SpdySettings settings;
+  for (SettingsMap::const_iterator i = settings_map.begin(),
+           end = settings_map.end(); i != end; ++i) {
+    const SpdySettingsIds id = i->first;
+    const SpdySettingsFlags flags = i->second.first;
+    const uint32 val = i->second.second;
+    SettingsFlagsAndId flags_and_id(flags, id);
+    settings.push_back(SpdySetting(flags_and_id, val));
+  }
+
   scoped_ptr<SpdyFrame> settings_frame(ConstructSpdySettings(settings));
 
   // Construct the request.
   scoped_ptr<SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
 
   MockWrite writes[] = {
     CreateMockWrite(*settings_frame),
     CreateMockWrite(*req),
   };
 
@@ skipping 18 matching lines @@
   helper.AddData(data.get());
   helper.RunDefaultTest();
   helper.VerifyDataConsumed();
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 
   {
     // Verify we had two persisted settings.
-    SpdySettings saved_settings =
+    const SettingsMap& settings_map =
         spdy_session_pool->http_server_properties()->GetSpdySettings(
             host_port_pair);
-    ASSERT_EQ(2u, saved_settings.size());
+    ASSERT_EQ(2u, settings_map.size());
 
     // Verify the first persisted setting.
-    SpdySetting setting = saved_settings.front();
-    saved_settings.pop_front();
-    EXPECT_EQ(SETTINGS_FLAG_PERSISTED, setting.first.flags());
-    EXPECT_EQ(kSampleId1, setting.first.id());
-    EXPECT_EQ(kSampleValue1, setting.second);
+    SettingsMap::const_iterator it1 = settings_map.find(kSampleId1);
+    EXPECT_TRUE(it1 != settings_map.end());
+    SettingsFlagsAndValue flags_and_value1 = it1->second;
+    EXPECT_EQ(SETTINGS_FLAG_PERSISTED, flags_and_value1.first);
+    EXPECT_EQ(kSampleValue1, flags_and_value1.second);
 
     // Verify the second persisted setting.
-    setting = saved_settings.front();
-    saved_settings.pop_front();
-    EXPECT_EQ(SETTINGS_FLAG_PERSISTED, setting.first.flags());
-    EXPECT_EQ(kSampleId2, setting.first.id());
-    EXPECT_EQ(kSampleValue2, setting.second);
+    SettingsMap::const_iterator it2 = settings_map.find(kSampleId2);
+    EXPECT_TRUE(it2 != settings_map.end());
+    SettingsFlagsAndValue flags_and_value2 = it2->second;
+    EXPECT_EQ(SETTINGS_FLAG_PERSISTED, flags_and_value2.first);
+    EXPECT_EQ(kSampleValue2, flags_and_value2.second);
   }
 }
 
 TEST_P(SpdyNetworkTransactionSpdy2Test, GoAwayWithActiveStream) {
   scoped_ptr<SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   scoped_ptr<SpdyFrame> go_away(ConstructSpdyGoAway());
   MockRead reads[] = {
     CreateMockRead(*go_away),
@@ skipping 1259 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