Introduce AlternativeService in BrokenAlternateProtol{List,Map}.

net/http/http_server_properties_impl.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 "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 286 matching lines @@
     std::string canonical_suffix = canonical_suffixes_[i];
     if (EndsWith(server.host(), canonical_suffixes_[i], false)) {
       HostPortPair canonical_host(canonical_suffix, server.port());
       canonical_host_to_origin_map_[canonical_host] = server;
       break;
     }
   }
 }
 
 void HttpServerPropertiesImpl::SetBrokenAlternateProtocol(
     const HostPortPair& server) {

[Ryan Hamilton, 2015/03/06 23:01:12]

To be clear, the way |server| is *currently* being used is that it's used as an
origin to look up the protocol in the map, but is being called with the
alternative. You'll fix this mismatch in a follow up CL?  

[Bence, 2015/03/08 18:09:04]

Yes, it is exactly the case.  It will take an AlternativeService within a few
CLs from now.

   AlternateProtocolMap::iterator it = alternate_protocol_map_.Get(server);
   const AlternateProtocolInfo alternate = GetAlternateProtocol(server);
   if (it == alternate_protocol_map_.end()) {
     if (alternate.protocol == UNINITIALIZED_ALTERNATE_PROTOCOL) {
       LOG(DFATAL) << "Trying to mark unknown alternate protocol broken.";
       return;
     }
     // This server's alternate protocol information is coming from a canonical
     // server. Add an entry in the map for this server explicitly so that
     // it can be marked as broken.
     it = alternate_protocol_map_.Put(server, alternate);
   }
   it->second.is_broken = true;
-  const BrokenAlternateProtocolEntry entry(server, alternate.port,
-                                           alternate.protocol);
-  int count = ++broken_alternate_protocol_map_[entry];
+  const AlternativeService altsvc(alternate.protocol, server.host(),

[Ryan Hamilton, 2015/03/06 23:01:12]

same comment here about abbreviations.

[Bence, 2015/03/08 18:09:04]

Same reply here about abbreviations.

+                                  alternate.port);
+  int count = ++broken_alternate_protocol_map_[altsvc];
   base::TimeDelta delay =
       base::TimeDelta::FromSeconds(kBrokenAlternateProtocolDelaySecs);
   base::TimeTicks when = base::TimeTicks::Now() + delay * (1 << (count - 1));
   broken_alternate_protocol_list_.push_back(
-      BrokenAlternateProtocolEntryWithTime(entry, when));
+      BrokenAlternateProtocolEntryWithTime(altsvc, when));
 
   // Do not leave this host as canonical so that we don't infer the other
   // hosts are also broken without testing them first.
   RemoveCanonicalHost(server);
 
   // If this is the only entry in the list, schedule an expiration task.
   // Otherwise it will be rescheduled automatically when the pending task runs.
   if (broken_alternate_protocol_list_.size() == 1) {
     ScheduleBrokenAlternateProtocolMappingsExpiration();
   }
 }
 
 bool HttpServerPropertiesImpl::WasAlternateProtocolRecentlyBroken(
     const HostPortPair& server) {
   const AlternateProtocolInfo alternate_protocol = GetAlternateProtocol(server);
   if (alternate_protocol.protocol == UNINITIALIZED_ALTERNATE_PROTOCOL)
     return false;
-  const BrokenAlternateProtocolEntry entry(server, alternate_protocol.port,
-                                           alternate_protocol.protocol);
-  return ContainsKey(broken_alternate_protocol_map_, entry);
+  const AlternativeService altsvc(alternate_protocol.protocol, server.host(),
+                                  alternate_protocol.port);
+  return ContainsKey(broken_alternate_protocol_map_, altsvc);
 }
 
 void HttpServerPropertiesImpl::ConfirmAlternateProtocol(
     const HostPortPair& server) {
   const AlternateProtocolInfo alternate_protocol = GetAlternateProtocol(server);
   if (alternate_protocol.protocol == UNINITIALIZED_ALTERNATE_PROTOCOL)
     return;
-  const BrokenAlternateProtocolEntry entry(server, alternate_protocol.port,
-                                           alternate_protocol.protocol);
-  broken_alternate_protocol_map_.erase(entry);
+  const AlternativeService altsvc(alternate_protocol.protocol, server.host(),
+                                  alternate_protocol.port);
+  broken_alternate_protocol_map_.erase(altsvc);
 }
 
 void HttpServerPropertiesImpl::ClearAlternateProtocol(
     const HostPortPair& server) {
   AlternateProtocolMap::iterator it = alternate_protocol_map_.Peek(server);
   if (it != alternate_protocol_map_.end())
     alternate_protocol_map_.Erase(it);
 
   RemoveCanonicalHost(server);
 }
@@ skipping 135 matching lines @@
 
 void HttpServerPropertiesImpl::ExpireBrokenAlternateProtocolMappings() {
   base::TimeTicks now = base::TimeTicks::Now();
   while (!broken_alternate_protocol_list_.empty()) {
     BrokenAlternateProtocolEntryWithTime entry_with_time =
         broken_alternate_protocol_list_.front();
     if (now < entry_with_time.when) {
       break;
     }
 
-    const BrokenAlternateProtocolEntry& entry =
-        entry_with_time.broken_alternate_protocol_entry;
-    ClearAlternateProtocol(entry.server);
+    const AlternativeService& altsvc = entry_with_time.altsvc;
+    ClearAlternateProtocol(HostPortPair(altsvc.host, altsvc.port));
     broken_alternate_protocol_list_.pop_front();
   }
   ScheduleBrokenAlternateProtocolMappingsExpiration();
 }
 
 void
 HttpServerPropertiesImpl::ScheduleBrokenAlternateProtocolMappingsExpiration() {
   if (broken_alternate_protocol_list_.empty()) {
     return;
   }
   base::TimeTicks now = base::TimeTicks::Now();
   base::TimeTicks when = broken_alternate_protocol_list_.front().when;
   base::TimeDelta delay = when > now ? when - now : base::TimeDelta();
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(
           &HttpServerPropertiesImpl::ExpireBrokenAlternateProtocolMappings,
           weak_ptr_factory_.GetWeakPtr()),
       delay);
 }
 
 }  // namespace net