Change AlternativeServiceInfo to a class

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 <utility>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
@@ skipping 569 matching lines @@
     DVLOG(1) << "Malformed alternative service protocol string for server: "
              << server_str;
     return false;
   }
   NextProto protocol = NextProtoFromString(protocol_str);
   if (!IsAlternateProtocolValid(protocol)) {
     DVLOG(1) << "Invalid alternative service protocol string for server: "
              << server_str;
     return false;
   }
-  alternative_service_info->alternative_service.protocol = protocol;
+  alternative_service_info->set_protocol(protocol);
 
   // Host is optional, defaults to "".
-  alternative_service_info->alternative_service.host.clear();
+  std::string host = "";
   if (alternative_service_dict.HasKey(kHostKey) &&
-      !alternative_service_dict.GetStringWithoutPathExpansion(
-          kHostKey, &(alternative_service_info->alternative_service.host))) {
+      !alternative_service_dict.GetStringWithoutPathExpansion(kHostKey,
+                                                              &host)) {
     DVLOG(1) << "Malformed alternative service host string for server: "
              << server_str;
     return false;
   }
+  alternative_service_info->set_host(host);
 
   // Port is mandatory.
   int port = 0;
   if (!alternative_service_dict.GetInteger(kPortKey, &port) ||
       !IsPortValid(port)) {
     DVLOG(1) << "Malformed alternative service port for server: " << server_str;
     return false;
   }
-  alternative_service_info->alternative_service.port =
-      static_cast<uint32_t>(port);
+  alternative_service_info->set_port(static_cast<uint32_t>(port));
 
   // Expiration is optional, defaults to one day.
   base::Time expiration;
   if (!alternative_service_dict.HasKey(kExpirationKey)) {
-    alternative_service_info->expiration =
-        base::Time::Now() + base::TimeDelta::FromDays(1);
+    alternative_service_info->set_expiration(base::Time::Now() +
+                                             base::TimeDelta::FromDays(1));
     return true;
   }
 
   std::string expiration_string;
   if (alternative_service_dict.GetStringWithoutPathExpansion(
           kExpirationKey, &expiration_string)) {
     int64_t expiration_int64 = 0;
     if (!base::StringToInt64(expiration_string, &expiration_int64)) {
       DVLOG(1) << "Malformed alternative service expiration for server: "
                << server_str;
       return false;
     }
-    alternative_service_info->expiration =
-        base::Time::FromInternalValue(expiration_int64);
+    alternative_service_info->set_expiration(
+        base::Time::FromInternalValue(expiration_int64));
     return true;
   }
 
   DVLOG(1) << "Malformed alternative service expiration for server: "
            << server_str;
   return false;
 }
 
 bool HttpServerPropertiesManager::AddToAlternativeServiceMap(
     const url::SchemeHostPort& server,
@@ skipping 15 matching lines @@
     const base::DictionaryValue* alternative_service_dict;
     if (!alternative_service_list_item.GetAsDictionary(
             &alternative_service_dict))
       return false;
     AlternativeServiceInfo alternative_service_info;
     if (!ParseAlternativeServiceDict(*alternative_service_dict,
                                      server.Serialize(),
                                      &alternative_service_info)) {
       return false;
     }
-    if (base::Time::Now() < alternative_service_info.expiration) {
+    if (base::Time::Now() < alternative_service_info.expiration()) {
       alternative_service_info_vector.push_back(alternative_service_info);
     }
   }
 
   if (alternative_service_info_vector.empty()) {
     return false;
   }
 
   alternative_service_map->Put(server, alternative_service_info_vector);
   return true;
@@ skipping 174 matching lines @@
   int count = 0;
   typedef std::map<std::string, bool> CanonicalHostPersistedMap;
   CanonicalHostPersistedMap persisted_map;
   // Maintain MRU order.
   for (AlternativeServiceMap::const_reverse_iterator it = map.rbegin();
        it != map.rend() && count < kMaxAlternateProtocolHostsToPersist; ++it) {
     const url::SchemeHostPort& server = it->first;
     AlternativeServiceInfoVector notbroken_alternative_service_info_vector;
     for (const AlternativeServiceInfo& alternative_service_info : it->second) {
       // Do not persist expired entries.
-      if (alternative_service_info.expiration < base::Time::Now()) {
+      if (alternative_service_info.expiration() < base::Time::Now()) {
         continue;
       }
       AlternativeService alternative_service(
-          alternative_service_info.alternative_service);
+          alternative_service_info.alternative_service());
       if (!IsAlternateProtocolValid(alternative_service.protocol)) {
         continue;
       }
       if (alternative_service.host.empty()) {
         alternative_service.host = server.host();
       }
       if (IsAlternativeServiceBroken(alternative_service)) {
         continue;
       }
       notbroken_alternative_service_info_vector.push_back(
@@ skipping 189 matching lines @@
     base::DictionaryValue* server_pref_dict) {
   if (!alternative_service_info_vector ||
       alternative_service_info_vector->empty()) {
     return;
   }
   std::unique_ptr<base::ListValue> alternative_service_list(
       new base::ListValue);
   for (const AlternativeServiceInfo& alternative_service_info :
        *alternative_service_info_vector) {
     const AlternativeService alternative_service =
-        alternative_service_info.alternative_service;
+        alternative_service_info.alternative_service();
     DCHECK(IsAlternateProtocolValid(alternative_service.protocol));
     std::unique_ptr<base::DictionaryValue> alternative_service_dict(
         new base::DictionaryValue);
     alternative_service_dict->SetInteger(kPortKey, alternative_service.port);
     if (!alternative_service.host.empty()) {
       alternative_service_dict->SetString(kHostKey, alternative_service.host);
     }
     alternative_service_dict->SetString(
         kProtocolKey, NextProtoToString(alternative_service.protocol));
     // JSON cannot store int64_t, so expiration is converted to a string.
     alternative_service_dict->SetString(
         kExpirationKey,
         base::Int64ToString(
-            alternative_service_info.expiration.ToInternalValue()));
+            alternative_service_info.expiration().ToInternalValue()));
     alternative_service_list->Append(std::move(alternative_service_dict));
   }
   if (alternative_service_list->GetSize() == 0)
     return;
   server_pref_dict->SetWithoutPathExpansion(
       kAlternativeServiceKey, std::move(alternative_service_list));
 }
 
 void HttpServerPropertiesManager::SaveSupportsQuicToPrefs(
     const IPAddress* last_quic_address,
@@ skipping 49 matching lines @@
   if (!setting_prefs_)
     ScheduleUpdateCacheOnPrefThread();
 }
 
 void HttpServerPropertiesManager::SetInitialized() {
   DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   is_initialized_ = true;
 }
 
 }  // namespace net