Add a probability to Alternate-Protocol support.

chrome/browser/net/http_server_properties_manager.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 "chrome/browser/net/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"
@@ skipping 148 matching lines @@
   http_server_properties_impl_->SetSupportsSpdy(server, support_spdy);
   ScheduleUpdatePrefsOnIO();
 }
 
 bool HttpServerPropertiesManager::HasAlternateProtocol(
     const net::HostPortPair& server) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return http_server_properties_impl_->HasAlternateProtocol(server);
 }
 
-net::PortAlternateProtocolPair
+net::AlternateProtocolInfo
 HttpServerPropertiesManager::GetAlternateProtocol(
     const net::HostPortPair& server) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return http_server_properties_impl_->GetAlternateProtocol(server);
 }
 
 void HttpServerPropertiesManager::SetAlternateProtocol(
     const net::HostPortPair& server,
     uint16 alternate_port,
-    net::AlternateProtocol alternate_protocol) {
+    net::AlternateProtocol alternate_protocol,
+    double alternate_probability) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   http_server_properties_impl_->SetAlternateProtocol(
-      server, alternate_port, alternate_protocol);
+      server, alternate_port, alternate_protocol, alternate_probability);
   ScheduleUpdatePrefsOnIO();
 }
 
 void HttpServerPropertiesManager::SetBrokenAlternateProtocol(
     const net::HostPortPair& server) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   http_server_properties_impl_->SetBrokenAlternateProtocol(server);
   ScheduleUpdatePrefsOnIO();
 }
 
@@ skipping 19 matching lines @@
 }
 
 const net::AlternateProtocolMap&
 HttpServerPropertiesManager::alternate_protocol_map() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return http_server_properties_impl_->alternate_protocol_map();
 }
 
 void HttpServerPropertiesManager::SetAlternateProtocolExperiment(
     net::AlternateProtocolExperiment experiment) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));

[ramant (doing other things), 2014/06/27 22:38:13]

Thanks for adding the DCHECKs.

[Ryan Hamilton, 2014/06/30 19:02:34]

My pleasure!

   http_server_properties_impl_->SetAlternateProtocolExperiment(experiment);
 }
 
+void HttpServerPropertiesManager::SetAlternateProtocolProbabilityThreshold(
+    double threshold) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  http_server_properties_impl_->SetAlternateProtocolProbabilityThreshold(
+      threshold);
+}
+
 net::AlternateProtocolExperiment
 HttpServerPropertiesManager::GetAlternateProtocolExperiment() const {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return http_server_properties_impl_->GetAlternateProtocolExperiment();
 }
 
 const net::SettingsMap&
 HttpServerPropertiesManager::GetSpdySettings(
     const net::HostPortPair& host_port_pair) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return http_server_properties_impl_->GetSpdySettings(host_port_pair);
 }
 
@@ skipping 195 matching lines @@
         continue;
       }
       net::AlternateProtocol protocol =
           net::AlternateProtocolFromString(protocol_str);
       if (!net::IsAlternateProtocolValid(protocol)) {
         DVLOG(1) << "Malformed Alternate-Protocol server: " << server_str;
         detected_corrupted_prefs = true;
         continue;
       }
 
-      net::PortAlternateProtocolPair port_alternate_protocol;
-      port_alternate_protocol.port = port;
-      port_alternate_protocol.protocol = protocol;
+      double probability = 1;
+      if (port_alternate_protocol_dict->HasKey("probability") &&
+          !port_alternate_protocol_dict->GetDoubleWithoutPathExpansion(
+              "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);
   }
 
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&HttpServerPropertiesManager::
                  UpdateCacheFromPrefsOnIO,
@@ skipping 110 matching lines @@
       FROM_HERE,
       base::Bind(&HttpServerPropertiesManager::UpdatePrefsOnUI,
                  ui_weak_ptr_,
                  base::Owned(spdy_server_list),
                  base::Owned(spdy_settings_map),
                  base::Owned(alternate_protocol_map),
                  completion));
 }
 
 // A local or temporary data structure to hold |supports_spdy|, SpdySettings,
-// and PortAlternateProtocolPair preferences for a server. This is used only in
+// and AlternateProtocolInfo preferences for a server. This is used only in
 // UpdatePrefsOnUI.
 struct ServerPref {
   ServerPref()
       : supports_spdy(false),
         settings_map(NULL),
         alternate_protocol(NULL) {
   }
   ServerPref(bool supports_spdy,
              const net::SettingsMap* settings_map,
-             const net::PortAlternateProtocolPair* alternate_protocol)
+             const net::AlternateProtocolInfo* alternate_protocol)
       : supports_spdy(supports_spdy),
         settings_map(settings_map),
         alternate_protocol(alternate_protocol) {
   }
   bool supports_spdy;
   const net::SettingsMap* settings_map;
-  const net::PortAlternateProtocolPair* alternate_protocol;
+  const net::AlternateProtocolInfo* alternate_protocol;
 };
 
 void HttpServerPropertiesManager::UpdatePrefsOnUI(
     base::ListValue* spdy_server_list,
     net::SpdySettingsMap* spdy_settings_map,
     net::AlternateProtocolMap* alternate_protocol_map,
     const base::Closure& completion) {
 
   typedef std::map<net::HostPortPair, ServerPref> ServerPrefMap;
   ServerPrefMap server_pref_map;
@@ skipping 29 matching lines @@
     } else {
       it->second.settings_map = &map_it->second;
     }
   }
 
   // Add AlternateProtocol servers to server_pref_map.
   for (net::AlternateProtocolMap::const_iterator map_it =
            alternate_protocol_map->begin();
        map_it != alternate_protocol_map->end(); ++map_it) {
     const net::HostPortPair& server = map_it->first;
-    const net::PortAlternateProtocolPair& port_alternate_protocol =
+    const net::AlternateProtocolInfo& port_alternate_protocol =
         map_it->second;
     if (!net::IsAlternateProtocolValid(port_alternate_protocol.protocol)) {
       continue;
     }
 
     ServerPrefMap::iterator it = server_pref_map.find(server);
     if (it == server_pref_map.end()) {
       ServerPref server_pref(false, NULL, &map_it->second);
       server_pref_map[server] = server_pref;
     } else {
@@ skipping 27 matching lines @@
         std::string key = base::StringPrintf("%u", id);
         spdy_settings_dict->SetInteger(key, value);
       }
       server_pref_dict->SetWithoutPathExpansion("settings", spdy_settings_dict);
     }
 
     // Save alternate_protocol.
     if (server_pref.alternate_protocol) {
       base::DictionaryValue* port_alternate_protocol_dict =
           new base::DictionaryValue;
-      const net::PortAlternateProtocolPair* port_alternate_protocol =
+      const net::AlternateProtocolInfo* port_alternate_protocol =
           server_pref.alternate_protocol;
       port_alternate_protocol_dict->SetInteger(
           "port", port_alternate_protocol->port);
       const char* protocol_str =
           net::AlternateProtocolToString(port_alternate_protocol->protocol);
       port_alternate_protocol_dict->SetString("protocol_str", protocol_str);
+      port_alternate_protocol_dict->SetDouble(
+          "probability", port_alternate_protocol->probability);
       server_pref_dict->SetWithoutPathExpansion(
           "alternate_protocol", port_alternate_protocol_dict);
     }
 
     servers_dict->SetWithoutPathExpansion(server.ToString(), server_pref_dict);
   }
 
   http_server_properties_dict.SetWithoutPathExpansion("servers", servers_dict);
   SetVersion(&http_server_properties_dict, kVersionNumber);
   setting_prefs_ = true;
   pref_service_->Set(prefs::kHttpServerProperties,
                      http_server_properties_dict);
   setting_prefs_ = false;
 
   // Note that |completion| will be fired after we have written everything to
   // the Preferences, but likely before these changes are serialized to disk.
   // This is not a problem though, as JSONPrefStore guarantees that this will
   // happen, pretty soon, and even in the case we shut down immediately.
   if (!completion.is_null())
     completion.Run();
 }
 
 void HttpServerPropertiesManager::OnHttpServerPropertiesChanged() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!setting_prefs_)
     ScheduleUpdateCacheOnUI();
 }
 
 }  // namespace chrome_browser_net