Add getters and setters for BrokenAlternativeService's list of broken and recently-broken alt svcs

net/http/broken_alternative_services.cc

 // Copyright (c) 2017 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/broken_alternative_services.h"
 
 #include "base/memory/singleton.h"
 #include "base/time/tick_clock.h"
 #include "base/time/time.h"
 #include "net/http/http_server_properties_impl.h"
@@ skipping 96 matching lines @@
     broken_alternative_service_list_.erase(map_it->second);
     broken_alternative_service_map_.erase(map_it);
   }
 
   auto it = recently_broken_alternative_services_.Get(alternative_service);
   if (it != recently_broken_alternative_services_.end()) {
     recently_broken_alternative_services_.Erase(it);
   }
 }
 
+const BrokenAlternativeServiceList&
+BrokenAlternativeServices::broken_alternative_service_list() const {
+  return broken_alternative_service_list_;
+}
+
+const RecentlyBrokenAlternativeServices&
+BrokenAlternativeServices::recently_broken_alternative_services() const {
+  return recently_broken_alternative_services_;
+}
+
+void BrokenAlternativeServices::AddBrokenAndRecentlyBrokenAlternativeServices(
+    std::unique_ptr<BrokenAlternativeServiceList>
+        broken_alternative_service_list,
+    std::unique_ptr<RecentlyBrokenAlternativeServices>
+        recently_broken_alternative_services) {
+  // Make sure all alt svcs in |broken_alternative_service_list| has an entry
+  // in |recently_broken_alternative_services|
+  for (const auto& pair : *broken_alternative_service_list) {
+    DCHECK(recently_broken_alternative_services->Peek(pair.first) !=
+           recently_broken_alternative_services->end());
+  }

[Zhongyi Shi, 2017/06/02 18:19:44]

|recently_broken_alternative_services| is an MRUCache. Does the access to this
cache for DCHECK modify the data?

[wangyix1, 2017/06/05 19:16:25]

No, Peek() does not modify the recency list, unlike Get().

[Zhongyi Shi, 2017/06/06 22:17:49]

I miss-read the code, yeah, Peek() should be fine. 

[wangyix1, 2017/06/09 19:26:40]

Acknowledged.

+
+  recently_broken_alternative_services_.Swap(
+      *recently_broken_alternative_services);
+  // Add back all existing recently broken alt svcs to cache so they're at
+  // front of recency list.

[Zhongyi Shi, 2017/06/02 18:19:44]

I might lose some context but why those existing recently broken alt svc should
be in front of newly added recently broken alt svcs?

[wangyix1, 2017/06/05 19:16:24]

It's not clear from the name, but this method will be used for loading broken
and recently-broken alt svcs from disk and adding it to the cache. The ones
loaded from disk should be less recent than the ones already in the cache. I
wonder if this should be made more clear?

+  for (auto it = recently_broken_alternative_services->rbegin();
+       it != recently_broken_alternative_services->rend(); ++it) {
+    if (recently_broken_alternative_services_.Get(it->first) ==
+        recently_broken_alternative_services_.end()) {
+      recently_broken_alternative_services_.Put(it->first, it->second);
+    }
+  }
+
+  // Add broken alt svcs to |broken_alternative_service_map_|. Remove all
+  // that already exist in the map.
+  auto it = broken_alternative_service_list->begin();
+  while (it != broken_alternative_service_list->end()) {
+    const AlternativeService& alternative_service = it->first;
+    if (broken_alternative_service_map_.find(alternative_service) ==
+        broken_alternative_service_map_.end()) {
+      broken_alternative_service_map_.insert(
+          std::make_pair(alternative_service, it));
+      ++it;
+    } else {
+      broken_alternative_service_list->erase(it++);
+    }
+  }
+
+  // Merge |broken_alternative_service_list| with
+  // |broken_alternative_service_list_|. Both should already be sorted by
+  // expiration time.
+  bool schedule_expiration =
+      (!broken_alternative_service_list->empty() &&
+       (broken_alternative_service_list_.empty() ||
+        broken_alternative_service_list->front().second <
+            broken_alternative_service_list_.front().second));
+
+  broken_alternative_service_list_.merge(
+      *broken_alternative_service_list,
+      [](const std::pair<AlternativeService, base::TimeTicks>& lhs,
+         const std::pair<AlternativeService, base::TimeTicks>& rhs) -> bool {
+        return lhs.second < rhs.second;
+      });
+
+  if (schedule_expiration)
+    ScheduleBrokenAlternateProtocolMappingsExpiration();
+}
+
 bool BrokenAlternativeServices::AddToBrokenAlternativeServiceListAndMap(
     const AlternativeService& alternative_service,
     base::TimeTicks expiration,
     BrokenAlternativeServiceList::iterator* it) {
   DCHECK(it);
 
   auto map_it = broken_alternative_service_map_.find(alternative_service);
   if (map_it != broken_alternative_service_map_.end())
     return false;
 
   // Iterate from end of |broken_alternative_service_list_| to find where to
   // insert it to keep the list sorted by expiration time.
   auto list_it = broken_alternative_service_list_.end();
   while (list_it != broken_alternative_service_list_.begin()) {
     --list_it;
-    if (list_it->expiration <= expiration) {
+    if (list_it->second <= expiration) {
       ++list_it;
       break;
     }
   }
 
   // Insert |alternative_service| into the list and the map
   list_it = broken_alternative_service_list_.insert(
-      list_it, BrokenAltSvcExpireInfo(alternative_service, expiration));
+      list_it, std::make_pair(alternative_service, expiration));
   broken_alternative_service_map_.insert(
       std::make_pair(alternative_service, list_it));
 
   *it = list_it;
   return true;
 }
 
 void BrokenAlternativeServices::ExpireBrokenAlternateProtocolMappings() {
   base::TimeTicks now = clock_->NowTicks();
 
   while (!broken_alternative_service_list_.empty()) {
     auto it = broken_alternative_service_list_.begin();
-    if (now < it->expiration) {
+    if (now < it->second) {
       break;
     }
 
-    delegate_->OnExpireBrokenAlternativeService(it->alternative_service);
+    delegate_->OnExpireBrokenAlternativeService(it->first);
 
-    broken_alternative_service_map_.erase(it->alternative_service);
+    broken_alternative_service_map_.erase(it->first);
     broken_alternative_service_list_.erase(it);
   }
 
   if (!broken_alternative_service_list_.empty())
     ScheduleBrokenAlternateProtocolMappingsExpiration();
 }
 
 void BrokenAlternativeServices ::
     ScheduleBrokenAlternateProtocolMappingsExpiration() {
   DCHECK(!broken_alternative_service_list_.empty());
   base::TimeTicks now = clock_->NowTicks();
-  base::TimeTicks when = broken_alternative_service_list_.front().expiration;
+  base::TimeTicks when = broken_alternative_service_list_.front().second;
   base::TimeDelta delay = when > now ? when - now : base::TimeDelta();
   expiration_timer_.Stop();
   expiration_timer_.Start(
       FROM_HERE, delay,
       base::Bind(
           &BrokenAlternativeServices ::ExpireBrokenAlternateProtocolMappings,
           weak_ptr_factory_.GetWeakPtr()));
 }
 
 }  // namespace net