Change AlternativeServiceInfo to a class

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 <algorithm>
 #include <memory>
 #include <utility>
 
@@ skipping 201 matching lines @@
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   if (server.host().empty())
     return false;
 
   if (GetSupportsSpdy(server))
     return true;
   const AlternativeServiceInfoVector alternative_service_info_vector =
       GetAlternativeServiceInfos(server);
   for (const AlternativeServiceInfo& alternative_service_info :
        alternative_service_info_vector) {
-    if (alternative_service_info.alternative_service.protocol == kProtoQUIC) {
+    if (alternative_service_info.alternative_service().protocol == kProtoQUIC) {
       return true;
     }
   }
   return false;
 }
 
 bool HttpServerPropertiesImpl::GetSupportsSpdy(
     const url::SchemeHostPort& server) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   if (server.host().empty())
@@ skipping 64 matching lines @@
     const url::SchemeHostPort& origin) {
   // Copy valid alternative service infos into
   // |valid_alternative_service_infos|.
   AlternativeServiceInfoVector valid_alternative_service_infos;
   const base::Time now = base::Time::Now();
   AlternativeServiceMap::iterator map_it = alternative_service_map_.Get(origin);
   if (map_it != alternative_service_map_.end()) {
     HostPortPair host_port_pair(origin.host(), origin.port());
     for (AlternativeServiceInfoVector::iterator it = map_it->second.begin();
          it != map_it->second.end();) {
-      if (it->expiration < now) {
+      if (it->expiration() < now) {
         it = map_it->second.erase(it);
         continue;
       }
-      AlternativeService alternative_service(it->alternative_service);
+      AlternativeService alternative_service(it->alternative_service());
       if (alternative_service.host.empty()) {
         alternative_service.host = origin.host();
       }
       // If the alternative service is equivalent to the origin (same host, same
       // port, and both TCP), skip it.
       if (host_port_pair.Equals(alternative_service.host_port_pair()) &&
           alternative_service.protocol == kProtoHTTP2) {
         ++it;
         continue;
       }
       valid_alternative_service_infos.push_back(
-          AlternativeServiceInfo(alternative_service, it->expiration));
+          AlternativeServiceInfo(alternative_service, it->expiration()));
       ++it;
     }
     if (map_it->second.empty()) {
       alternative_service_map_.Erase(map_it);
     }
     return valid_alternative_service_infos;
   }
 
   CanonicalHostMap::const_iterator canonical = GetCanonicalHost(origin);
   if (canonical == canonical_host_to_origin_map_.end()) {
     return AlternativeServiceInfoVector();
   }
   map_it = alternative_service_map_.Get(canonical->second);
   if (map_it == alternative_service_map_.end()) {
     return AlternativeServiceInfoVector();
   }
   for (AlternativeServiceInfoVector::iterator it = map_it->second.begin();
        it != map_it->second.end();) {
-    if (it->expiration < now) {
+    if (it->expiration() < now) {
       it = map_it->second.erase(it);
       continue;
     }
-    AlternativeService alternative_service(it->alternative_service);
+    AlternativeService alternative_service(it->alternative_service());
     if (alternative_service.host.empty()) {
       alternative_service.host = canonical->second.host();
       if (IsAlternativeServiceBroken(alternative_service)) {
         ++it;
         continue;
       }
       alternative_service.host = origin.host();
     } else if (IsAlternativeServiceBroken(alternative_service)) {
       ++it;
       continue;
     }
     valid_alternative_service_infos.push_back(
-        AlternativeServiceInfo(alternative_service, it->expiration));
+        AlternativeServiceInfo(alternative_service, it->expiration()));
     ++it;
   }
   if (map_it->second.empty()) {
     alternative_service_map_.Erase(map_it);
   }
   return valid_alternative_service_infos;
 }
 
 bool HttpServerPropertiesImpl::SetAlternativeService(
     const url::SchemeHostPort& origin,
@@ skipping 22 matching lines @@
   bool changed = true;
   if (it != alternative_service_map_.end()) {
     DCHECK(!it->second.empty());
     if (it->second.size() == alternative_service_info_vector.size()) {
       const base::Time now = base::Time::Now();
       changed = false;
       auto new_it = alternative_service_info_vector.begin();
       for (const auto& old : it->second) {
         // Persist to disk immediately if new entry has different scheme, host,
         // or port.
-        if (old.alternative_service != new_it->alternative_service) {
+        if (old.alternative_service() != new_it->alternative_service()) {
           changed = true;
           break;
         }
         // Also persist to disk if new expiration it more that twice as far or
         // less than half as far in the future.
-        base::Time old_time = old.expiration;
-        base::Time new_time = new_it->expiration;
+        base::Time old_time = old.expiration();
+        base::Time new_time = new_it->expiration();
         if (new_time - now > 2 * (old_time - now) ||
             2 * (new_time - now) < (old_time - now)) {
           changed = true;
           break;
         }
         ++new_it;
       }
     }
   }
 
@@ skipping 64 matching lines @@
   std::unique_ptr<base::ListValue> dict_list(new base::ListValue);
   for (const auto& alternative_service_map_item : alternative_service_map_) {
     std::unique_ptr<base::ListValue> alternative_service_list(
         new base::ListValue);
     const url::SchemeHostPort& server = alternative_service_map_item.first;
     for (const AlternativeServiceInfo& alternative_service_info :
          alternative_service_map_item.second) {
       std::string alternative_service_string(
           alternative_service_info.ToString());
       AlternativeService alternative_service(
-          alternative_service_info.alternative_service);
+          alternative_service_info.alternative_service());
       if (alternative_service.host.empty()) {
         alternative_service.host = server.host();
       }
       if (IsAlternativeServiceBroken(alternative_service)) {
         alternative_service_string.append(" (broken)");
       }
       alternative_service_list->AppendString(alternative_service_string);
     }
     if (alternative_service_list->empty())
       continue;
@@ skipping 115 matching lines @@
   }
 
   const url::SchemeHostPort canonical_server = canonical->second;
   it = alternative_service_map_.Get(canonical_server);
   if (it == alternative_service_map_.end()) {
     return alternative_service_map_.end();
   }
 
   for (const AlternativeServiceInfo& alternative_service_info : it->second) {
     AlternativeService alternative_service(
-        alternative_service_info.alternative_service);
+        alternative_service_info.alternative_service());
     if (alternative_service.host.empty()) {
       alternative_service.host = canonical_server.host();
     }
     if (!IsAlternativeServiceBroken(alternative_service)) {
       return it;
     }
   }
 
   RemoveCanonicalHost(canonical_server);
   return alternative_service_map_.end();
@@ skipping 26 matching lines @@
 
 void HttpServerPropertiesImpl::OnExpireBrokenAlternativeService(
     const AlternativeService& expired_alternative_service) {
   // Remove every occurrence of |expired_alternative_service| from
   // |alternative_service_map_|.
   for (AlternativeServiceMap::iterator map_it =
            alternative_service_map_.begin();
        map_it != alternative_service_map_.end();) {
     for (AlternativeServiceInfoVector::iterator it = map_it->second.begin();
          it != map_it->second.end();) {
-      AlternativeService alternative_service(it->alternative_service);
+      AlternativeService alternative_service(it->alternative_service());
       // Empty hostname in map means hostname of key: substitute before
       // comparing to |expired_alternative_service|.
       if (alternative_service.host.empty()) {
         alternative_service.host = map_it->first.host();
       }
       if (alternative_service == expired_alternative_service) {
         it = map_it->second.erase(it);
         continue;
       }
       ++it;
     }
     // If an origin has an empty list of alternative services, then remove it
     // from both |canonical_host_to_origin_map_| and
     // |alternative_service_map_|.
     if (map_it->second.empty()) {
       RemoveCanonicalHost(map_it->first);
       map_it = alternative_service_map_.Erase(map_it);
       continue;
     }
     ++map_it;
   }
 }
 
 }  // namespace net