SPDY Settings - preferences read from the disk maintain MRU order

net/http/http_server_properties_impl_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_server_properties_impl.h"
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/ip_address_number.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 class ListValue;
 }
 
 namespace net {
 
-const int kMaxSupportsSpdyServerHosts = 500;
-
 class HttpServerPropertiesImplPeer {
  public:
   static void AddBrokenAlternativeServiceWithExpirationTime(
       HttpServerPropertiesImpl& impl,
       AlternativeService alternative_service,
       base::TimeTicks when) {
     impl.broken_alternative_services_.insert(
         std::make_pair(alternative_service, when));
     ++impl.recently_broken_alternative_services_[alternative_service];
   }
 
   static void ExpireBrokenAlternateProtocolMappings(
       HttpServerPropertiesImpl& impl) {
     impl.ExpireBrokenAlternateProtocolMappings();
   }
 };
 
 void PrintTo(const AlternativeService& alternative_service, std::ostream* os) {
   *os << alternative_service.ToString();
 }
 
 namespace {
 
+const int kMaxSupportsSpdyServerHosts = 500;
+const SpdySettingsIds kSpdySettingsId = SETTINGS_UPLOAD_BANDWIDTH;
+const SpdySettingsFlags kSpdySettingsFlags = SETTINGS_FLAG_PERSISTED;
+
+struct SpdySettingsDataToVerify {
+  HostPortPair spdy_server;
+  uint32 value;
+};
+
 class HttpServerPropertiesImplTest : public testing::Test {
  protected:
   bool HasAlternativeService(const HostPortPair& origin) {
     const AlternativeServiceVector alternative_service_vector =
         impl_.GetAlternativeServices(origin);
     return !alternative_service_vector.empty();
   }
 
   bool SetAlternativeService(const HostPortPair& origin,
                              const AlternativeService& alternative_service,
                              double alternative_probability) {
     const base::Time expiration =
         base::Time::Now() + base::TimeDelta::FromDays(1);
     return impl_.SetAlternativeService(origin, alternative_service,
                                        alternative_probability, expiration);
   }
 
+  void InitializeSpdySettingsUploadBandwidth(SpdySettingsMap* spdy_settings_map,
+                                             const HostPortPair& spdy_server,
+                                             uint32 value) {
+    SettingsMap settings_map;
+    settings_map[kSpdySettingsId] =
+        SettingsFlagsAndValue(kSpdySettingsFlags, value);
+    spdy_settings_map->Put(spdy_server, settings_map);
+  }
+
+  void VerifySpdySettingsUploadBandwidth(
+      const SpdySettingsDataToVerify* data_to_verify) {
+    const SpdySettingsMap& spdy_settings_map = impl_.spdy_settings_map();
+    int count = 0;
+    for (SpdySettingsMap::const_iterator map_it = spdy_settings_map.begin();
+         map_it != spdy_settings_map.end(); ++map_it, ++count) {
+      const SpdySettingsDataToVerify& data = data_to_verify[count];
+      EXPECT_TRUE(data.spdy_server.Equals(map_it->first));
+      const SettingsMap& settings_map_memory = map_it->second;
+
+      EXPECT_EQ(1U, settings_map_memory.size());
+      SettingsMap::const_iterator it =
+          settings_map_memory.find(kSpdySettingsId);
+      EXPECT_TRUE(it != settings_map_memory.end());
+      SettingsFlagsAndValue flags_and_value_memory = it->second;
+      EXPECT_EQ(kSpdySettingsFlags, flags_and_value_memory.first);
+      EXPECT_EQ(data.value, flags_and_value_memory.second);
+    }
+  }
+
   HttpServerPropertiesImpl impl_;
 };
 
 typedef HttpServerPropertiesImplTest SpdyServerPropertiesTest;
 
 TEST_F(SpdyServerPropertiesTest, Initialize) {
   HostPortPair spdy_server_google("www.google.com", 443);
   std::string spdy_server_g = spdy_server_google.ToString();
 
   HostPortPair spdy_server_docs("docs.google.com", 443);
@@ skipping 854 matching lines @@
   EXPECT_TRUE(
       impl_.WasAlternativeServiceRecentlyBroken(bar_alternative_service));
   EXPECT_FALSE(
       impl_.WasAlternativeServiceRecentlyBroken(baz_alternative_service));
 }
 
 typedef HttpServerPropertiesImplTest SpdySettingsServerPropertiesTest;
 
 TEST_F(SpdySettingsServerPropertiesTest, Initialize) {
   HostPortPair spdy_server_google("www.google.com", 443);
+  HostPortPair spdy_server_photos("photos.google.com", 443);
+  HostPortPair spdy_server_docs("docs.google.com", 443);
+  HostPortPair spdy_server_mail("mail.google.com", 443);
 
   // Check by initializing empty spdy settings.
   SpdySettingsMap spdy_settings_map(SpdySettingsMap::NO_AUTO_EVICT);
   impl_.InitializeSpdySettingsServers(&spdy_settings_map);
   EXPECT_TRUE(impl_.GetSpdySettings(spdy_server_google).empty());
 
-  // Check by initializing with www.google.com:443 spdy server settings.
-  SettingsMap settings_map;
-  const SpdySettingsIds id = SETTINGS_UPLOAD_BANDWIDTH;
-  const SpdySettingsFlags flags = SETTINGS_FLAG_PERSISTED;
-  const uint32 value = 31337;
-  SettingsFlagsAndValue flags_and_value(flags, value);
-  settings_map[id] = flags_and_value;
-  spdy_settings_map.Put(spdy_server_google, settings_map);
-  impl_.InitializeSpdySettingsServers(&spdy_settings_map);
+  // Check by initializing spdy server settings for www.google.com:443 and
+  // photos.google.com:443.
+  const SpdySettingsDataToVerify data_to_verify1[] = {
+      {spdy_server_google, 10000}, {spdy_server_photos, 20000},
+  };
+  // Insert them in reverse order to make spdy_server_google as MRU.
+  SpdySettingsMap spdy_settings_map1(SpdySettingsMap::NO_AUTO_EVICT);
+  InitializeSpdySettingsUploadBandwidth(&spdy_settings_map1,
+                                        data_to_verify1[1].spdy_server,
+                                        data_to_verify1[1].value);
+  InitializeSpdySettingsUploadBandwidth(&spdy_settings_map1,
+                                        data_to_verify1[0].spdy_server,
+                                        data_to_verify1[0].value);
+  impl_.InitializeSpdySettingsServers(&spdy_settings_map1);
+  VerifySpdySettingsUploadBandwidth(data_to_verify1);
 
-  const SettingsMap& settings_map2 = impl_.GetSpdySettings(spdy_server_google);
-  ASSERT_EQ(1U, settings_map2.size());
-  SettingsMap::const_iterator it = settings_map2.find(id);
-  EXPECT_TRUE(it != settings_map2.end());
-  SettingsFlagsAndValue flags_and_value2 = it->second;
-  EXPECT_EQ(flags, flags_and_value2.first);
-  EXPECT_EQ(value, flags_and_value2.second);
+  // Check by initializing mail.google.com:443 and docs.google.com:443 as spdy
+  // servers.
+  const SpdySettingsDataToVerify data_to_verify2[] = {
+      {spdy_server_google, 10000},
+      {spdy_server_photos, 20000},
+      {spdy_server_mail, 30000},
+      {spdy_server_docs, 40000},
+  };
+  SpdySettingsMap spdy_settings_map2(SpdySettingsMap::NO_AUTO_EVICT);
+  InitializeSpdySettingsUploadBandwidth(&spdy_settings_map2,
+                                        data_to_verify2[3].spdy_server,
+                                        data_to_verify2[3].value);
+  InitializeSpdySettingsUploadBandwidth(&spdy_settings_map2,
+                                        data_to_verify2[2].spdy_server,
+                                        data_to_verify2[2].value);
+  impl_.InitializeSpdySettingsServers(&spdy_settings_map2);
+  VerifySpdySettingsUploadBandwidth(data_to_verify2);
+
+  // Verify new data that is being initialized overwrites what is already in the
+  // memory and also verify the recency list order by updating 3rd and 1st
+  // element's data.
+  const SpdySettingsDataToVerify data_to_verify3[] = {
+      {spdy_server_google, 10000},
+      {spdy_server_photos, 60000},  // Change the value of photos.
+      {spdy_server_mail, 30000},
+      {spdy_server_docs, 50000},  // Change the value of docs.
+  };
+  SpdySettingsMap spdy_settings_map3(SpdySettingsMap::NO_AUTO_EVICT);
+  InitializeSpdySettingsUploadBandwidth(&spdy_settings_map3,
+                                        data_to_verify3[3].spdy_server,
+                                        data_to_verify3[3].value);
+  InitializeSpdySettingsUploadBandwidth(&spdy_settings_map3,
+                                        data_to_verify3[1].spdy_server,
+                                        data_to_verify3[1].value);
+  impl_.InitializeSpdySettingsServers(&spdy_settings_map3);
+  VerifySpdySettingsUploadBandwidth(data_to_verify3);
 }
 
 TEST_F(SpdySettingsServerPropertiesTest, SetSpdySetting) {
   HostPortPair spdy_server_empty(std::string(), 443);
   const SettingsMap& settings_map0 = impl_.GetSpdySettings(spdy_server_empty);
   EXPECT_EQ(0U, settings_map0.size());  // Returns kEmptySettingsMap.
 
   // Add www.google.com:443 as persisting.
   HostPortPair spdy_server_google("www.google.com", 443);
   const SpdySettingsIds id1 = SETTINGS_UPLOAD_BANDWIDTH;
@@ skipping 260 matching lines @@
   EXPECT_EQ(quic_server_info1, *(impl_.GetQuicServerInfo(quic_server_id)));
 
   impl_.Clear();
   EXPECT_EQ(0u, impl_.quic_server_info_map().size());
   EXPECT_EQ(nullptr, impl_.GetQuicServerInfo(quic_server_id));
 }
 
 }  // namespace
 
 }  // namespace net