QUIC - Always pesist 200 MRU alternate protocols to preferences file.

net/http/http_server_properties_manager.cc

 // Copyright 2014 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_manager.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
-#include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 
 namespace net {
 
 namespace {
@@ skipping 16 matching lines @@
 
 // "version" 0 indicates, http_server_properties doesn't have "version"
 // property.
 const int kMissingVersion = 0;
 
 // The version number of persisted http_server_properties.
 const int kVersionNumber = 3;
 
 typedef std::vector<std::string> StringVector;
 
-// Load either 200 or 1000 servers based on a coin flip.
-const int k200AlternateProtocolHostsToLoad = 200;
-const int k1000AlternateProtocolHostsToLoad = 1000;
-// Persist 1000 MRU AlternateProtocolHostPortPairs.
-const int kMaxAlternateProtocolHostsToPersist = 1000;
+// Persist 200 MRU AlternateProtocolHostPortPairs.
+const int kMaxAlternateProtocolHostsToPersist = 200;
 
 // Persist 200 MRU SpdySettingsHostPortPairs.
 const int kMaxSpdySettingsHostsToPersist = 200;
 
 // Persist 300 MRU SupportsSpdyServerHostPortPairs.
 const int kMaxSupportsSpdyServerHostsToPersist = 300;
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 144 matching lines @@
   http_server_properties_impl_->ClearAlternateProtocol(server);
   ScheduleUpdatePrefsOnNetworkThread();
 }
 
 const net::AlternateProtocolMap&
 HttpServerPropertiesManager::alternate_protocol_map() const {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->alternate_protocol_map();
 }
 
-void HttpServerPropertiesManager::SetAlternateProtocolExperiment(
-    AlternateProtocolExperiment experiment) {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
-  http_server_properties_impl_->SetAlternateProtocolExperiment(experiment);
-}
-
 void HttpServerPropertiesManager::SetAlternateProtocolProbabilityThreshold(
     double threshold) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   http_server_properties_impl_->SetAlternateProtocolProbabilityThreshold(
       threshold);
 }
 
-AlternateProtocolExperiment
-HttpServerPropertiesManager::GetAlternateProtocolExperiment() const {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
-  return http_server_properties_impl_->GetAlternateProtocolExperiment();
-}
-
 const SettingsMap& HttpServerPropertiesManager::GetSpdySettings(
     const HostPortPair& host_port_pair) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->GetSpdySettings(host_port_pair);
 }
 
 bool HttpServerPropertiesManager::SetSpdySetting(
     const HostPortPair& host_port_pair,
     SpdySettingsIds id,
     SpdySettingsFlags flags,
@@ skipping 111 matching lines @@
   }
 
   // String is host/port pair of spdy server.
   scoped_ptr<StringVector> spdy_servers(new StringVector);
   scoped_ptr<net::SpdySettingsMap> spdy_settings_map(
       new net::SpdySettingsMap(kMaxSpdySettingsHostsToPersist));
   scoped_ptr<net::AlternateProtocolMap> alternate_protocol_map(
       new net::AlternateProtocolMap(kMaxAlternateProtocolHostsToPersist));
   scoped_ptr<net::SupportsQuicMap> supports_quic_map(
       new net::SupportsQuicMap());
-  // TODO(rtenneti): Delete the following code after the experiment.
-  int alternate_protocols_to_load = k200AlternateProtocolHostsToLoad;
-  net::AlternateProtocolExperiment alternate_protocol_experiment =
-      net::ALTERNATE_PROTOCOL_NOT_PART_OF_EXPERIMENT;
-  if (version == kVersionNumber) {
-    if (base::RandInt(0, 99) == 0) {
-      alternate_protocol_experiment =
-          net::ALTERNATE_PROTOCOL_TRUNCATED_200_SERVERS;
-    } else {
-      alternate_protocols_to_load = k1000AlternateProtocolHostsToLoad;
-      alternate_protocol_experiment =
-          net::ALTERNATE_PROTOCOL_TRUNCATED_1000_SERVERS;
-    }
-    DVLOG(1) << "# of servers that support alternate_protocol: "
-             << alternate_protocols_to_load;
-  }
 
-  int count = 0;
   for (base::DictionaryValue::Iterator it(*servers_dict); !it.IsAtEnd();
        it.Advance()) {
     // Get server's host/pair.
     const std::string& server_str = it.key();
     net::HostPortPair server = net::HostPortPair::FromString(server_str);
     if (server.host().empty()) {
       DVLOG(1) << "Malformed http_server_properties for server: " << server_str;
       detected_corrupted_prefs = true;
       continue;
     }
@@ skipping 44 matching lines @@
 
     // Get alternate_protocol server.
     DCHECK(alternate_protocol_map->Peek(server) ==
            alternate_protocol_map->end());
     const base::DictionaryValue* port_alternate_protocol_dict = NULL;
     if (!server_pref_dict->GetDictionaryWithoutPathExpansion(
             "alternate_protocol", &port_alternate_protocol_dict)) {
       continue;
     }
 
-    if (count >= alternate_protocols_to_load)

[jar (doing other things), 2014/10/23 23:11:51]

I think this is OK.  Just to confirm.... we will "reload" a potentially larger
list, but we'll only save a smaller (200 element, max) list.  Is that correct?

Should we consider avoiding loading more than some(?) max count?  ... or even
avoid re-loading more than we know we'll next save?

[ramant (doing other things), 2014/10/23 23:27:19]

Made this code similar to other MRU items we are persisting. An admin could edit
preferences file and add more entries (but when we persist the data to
preferences whenever an entry is added or deleted from the cache, it will only
save 200 entries).
Added back the delete code from previous patch (thought checking the count could
be unnecessary after browser is restarts couple of times).

-      continue;
     do {
       int port = 0;
       if (!port_alternate_protocol_dict->GetIntegerWithoutPathExpansion(
               "port", &port) ||
           (port > (1 << 16))) {
         DVLOG(1) << "Malformed Alternate-Protocol server: " << server_str;
         detected_corrupted_prefs = true;
         continue;
       }
       std::string protocol_str;
@@ skipping 17 matching lines @@
               "probability", &probability)) {
         DVLOG(1) << "Malformed Alternate-Protocol server: " << server_str;
         detected_corrupted_prefs = true;
         continue;
       }
 
       net::AlternateProtocolInfo port_alternate_protocol(port,
                                                          protocol,
                                                          probability);
       alternate_protocol_map->Put(server, port_alternate_protocol);
-      ++count;
     } while (false);
 
     // Get SupportsQuic.
     DCHECK(supports_quic_map->find(server) == supports_quic_map->end());
     const base::DictionaryValue* supports_quic_dict = NULL;
     if (!server_pref_dict->GetDictionaryWithoutPathExpansion(
             "supports_quic", &supports_quic_dict)) {
       continue;
     }
     do {
@@ skipping 17 matching lines @@
   }
 
   network_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           &HttpServerPropertiesManager::UpdateCacheFromPrefsOnNetworkThread,
           base::Unretained(this),
           base::Owned(spdy_servers.release()),
           base::Owned(spdy_settings_map.release()),
           base::Owned(alternate_protocol_map.release()),
-          alternate_protocol_experiment,
           base::Owned(supports_quic_map.release()),
           detected_corrupted_prefs));
 }
 
 void HttpServerPropertiesManager::UpdateCacheFromPrefsOnNetworkThread(
     StringVector* spdy_servers,
     net::SpdySettingsMap* spdy_settings_map,
     net::AlternateProtocolMap* alternate_protocol_map,
-    net::AlternateProtocolExperiment alternate_protocol_experiment,
     net::SupportsQuicMap* supports_quic_map,
     bool detected_corrupted_prefs) {
   // Preferences have the master data because admins might have pushed new
   // preferences. Update the cached data with new data from preferences.
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
 
   UMA_HISTOGRAM_COUNTS("Net.CountOfSpdyServers", spdy_servers->size());
   http_server_properties_impl_->InitializeSpdyServers(spdy_servers, true);
 
   // Update the cached data and use the new spdy_settings from preferences.
   UMA_HISTOGRAM_COUNTS("Net.CountOfSpdySettings", spdy_settings_map->size());
   http_server_properties_impl_->InitializeSpdySettingsServers(
       spdy_settings_map);
 
   // Update the cached data and use the new Alternate-Protocol server list from
   // preferences.
   UMA_HISTOGRAM_COUNTS("Net.CountOfAlternateProtocolServers",
                        alternate_protocol_map->size());
   http_server_properties_impl_->InitializeAlternateProtocolServers(
       alternate_protocol_map);
-  http_server_properties_impl_->SetAlternateProtocolExperiment(
-      alternate_protocol_experiment);
 
   http_server_properties_impl_->InitializeSupportsQuic(supports_quic_map);
 
   // Update the prefs with what we have read (delete all corrupted prefs).
   if (detected_corrupted_prefs)
     ScheduleUpdatePrefsOnNetworkThread();
 }
 
 //
 // Update Preferences with data from the cached data.
@@ skipping 258 matching lines @@
     completion.Run();
 }
 
 void HttpServerPropertiesManager::OnHttpServerPropertiesChanged() {
   DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
   if (!setting_prefs_)
     ScheduleUpdateCacheOnPrefThread();
 }
 
 }  // namespace net