Make GetAlternateProtocol return AlternativeService.

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/single_thread_task_runner.h"
@@ skipping 162 matching lines @@
   http_server_properties_impl_->SetHTTP11Required(server);
   ScheduleUpdatePrefsOnNetworkThread();
 }
 
 void HttpServerPropertiesManager::MaybeForceHTTP11(const HostPortPair& server,
                                                    SSLConfig* ssl_config) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   http_server_properties_impl_->MaybeForceHTTP11(server, ssl_config);
 }
 
-AlternateProtocolInfo HttpServerPropertiesManager::GetAlternateProtocol(
-    const HostPortPair& server) {
+AlternativeService HttpServerPropertiesManager::GetAlternativeService(
+    const HostPortPair& origin) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
-  return http_server_properties_impl_->GetAlternateProtocol(server);
+  return http_server_properties_impl_->GetAlternativeService(origin);
 }
 
 void HttpServerPropertiesManager::SetAlternateProtocol(
-    const HostPortPair& server,
+    const HostPortPair& origin,
     uint16 alternate_port,
     AlternateProtocol alternate_protocol,
     double alternate_probability) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   http_server_properties_impl_->SetAlternateProtocol(
-      server, alternate_port, alternate_protocol, alternate_probability);
+      origin, alternate_port, alternate_protocol, alternate_probability);
   ScheduleUpdatePrefsOnNetworkThread();
 }
 
 void HttpServerPropertiesManager::SetBrokenAlternateProtocol(
-    const HostPortPair& server) {
+    const HostPortPair& origin) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
-  http_server_properties_impl_->SetBrokenAlternateProtocol(server);
+  http_server_properties_impl_->SetBrokenAlternateProtocol(origin);
   ScheduleUpdatePrefsOnNetworkThread();
 }
 
 void HttpServerPropertiesManager::MarkAlternativeServiceRecentlyBroken(
     const AlternativeService& alternative_service) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   http_server_properties_impl_->MarkAlternativeServiceRecentlyBroken(
       alternative_service);
   ScheduleUpdatePrefsOnNetworkThread();
 }
 
 bool HttpServerPropertiesManager::IsAlternativeServiceBroken(
     const AlternativeService& alternative_service) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->IsAlternativeServiceBroken(
       alternative_service);
 }
 
 bool HttpServerPropertiesManager::WasAlternateProtocolRecentlyBroken(
-    const HostPortPair& server) {
+    const HostPortPair& origin) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->WasAlternateProtocolRecentlyBroken(
-      server);
+      origin);
 }
 
 void HttpServerPropertiesManager::ConfirmAlternateProtocol(
-    const HostPortPair& server) {
+    const HostPortPair& origin) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
-  http_server_properties_impl_->ConfirmAlternateProtocol(server);
+  http_server_properties_impl_->ConfirmAlternateProtocol(origin);
   ScheduleUpdatePrefsOnNetworkThread();
 }
 
 void HttpServerPropertiesManager::ClearAlternateProtocol(
-    const HostPortPair& server) {
+    const HostPortPair& origin) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
-  http_server_properties_impl_->ClearAlternateProtocol(server);
+  http_server_properties_impl_->ClearAlternateProtocol(origin);
   ScheduleUpdatePrefsOnNetworkThread();
 }
 
 const AlternateProtocolMap&
 HttpServerPropertiesManager::alternate_protocol_map() const {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->alternate_protocol_map();
 }
 
 void HttpServerPropertiesManager::SetAlternateProtocolProbabilityThreshold(
@@ skipping 639 matching lines @@
                                             server_network_stats_dict);
 }
 
 void HttpServerPropertiesManager::OnHttpServerPropertiesChanged() {
   DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
   if (!setting_prefs_)
     ScheduleUpdateCacheOnPrefThread();
 }
 
 }  // namespace net