Persist broken and recently-broken alt-svcs to prefs in HttpServerPropertiesManager

net/http/broken_alternative_services.h

 // 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.
 
 #ifndef NET_HTTP_BROKEN_ALTERNATIVE_SERVICES_H_
 #define NET_HTTP_BROKEN_ALTERNATIVE_SERVICES_H_
 
 #include <list>
 #include <unordered_map>
 
 #include "base/memory/weak_ptr.h"
+#include "base/time/default_tick_clock.h"
 #include "base/timer/timer.h"
 #include "net/http/http_server_properties.h"
 
-namespace base {
-class TickClock;
-}
-
 namespace net {
 
 // This class tracks HTTP alternative services that have been marked as broken.
 // The brokenness of an alt-svc will expire after some time according to an
 // exponential back-off formula: each time an alt-svc is marked broken, the
 // expiration delay will be some constant multiple of its previous expiration
 // delay. This prevents broken alt-svcs from being retried too often by the
 // network stack.
 class NET_EXPORT_PRIVATE BrokenAlternativeServices {
  public:
   // Delegate to be used by owner so it can be notified when the brokenness of
   // an AlternativeService expires.
   class NET_EXPORT Delegate {
    public:
     // Called when a broken alternative service's expiration time is reached.
     virtual void OnExpireBrokenAlternativeService(
         const AlternativeService& expired_alternative_service) = 0;
     virtual ~Delegate() {}
   };
 
   // |delegate| will be notified when a broken alternative service expires. It
   // must not be null.
   // |clock| is used for setting expiration times and scheduling the
   // expiration of broken alternative services. It must not be null.
   // |delegate| and |clock| are both unowned and must outlive this.
-  BrokenAlternativeServices(Delegate* delegate, base::TickClock* clock);
+  BrokenAlternativeServices(Delegate* delegate);
 
   BrokenAlternativeServices(const BrokenAlternativeServices&) = delete;
   void operator=(const BrokenAlternativeServices&) = delete;
 
   ~BrokenAlternativeServices();
 
+  void Clear();

[Ryan Hamilton, 2017/06/12 18:57:32]

nit: Comment (though it's probably fairly obvious)

Since this is so self-contained, consider breaking this out into a simple
stand-alone CL.

[wangyix1, 2017/06/14 00:01:25]

Done.

+
   // Marks |alternative_service| as broken until after some expiration delay
   // (determined by how many times it's been marked broken before). Being broken
   // will cause IsAlternativeServiceBroken(alternative_service) to return true
   // until the expiration time is reached, or until
   // ConfirmAlternativeService(alternative_service) is called.
   void MarkAlternativeServiceBroken(
       const AlternativeService& alternative_service);
 
   // Marks |alternative_service| as recently broken. Being recently broken will
   // cause WasAlternativeServiceRecentlyBroken(alternative_service) to return
@@ skipping 16 matching lines @@
       const AlternativeService& alternative_service);
 
   // Marks |alternative_service| as not broken and not recently broken.
   void ConfirmAlternativeService(const AlternativeService& alternative_service);
 
   // Adds broken and recently broken alternative services.
   // |broken_alternative_service_list| must be sorted from earliest to latest
   // expiration time.
   // All AlternativeServices in |broken_alternative_service_list| must exist in
   // |recently_broken_alternative_services|.
-  // Returns whether or not any alternative services were actually added.
-  bool AddBrokenAndRecentlyBrokenAlternativeServices(
+  //
+  // If a broken/recently-broken alt svc that's being added is already stored,
+  // the stored expiration/broken-count for that alt svc will be overwritten
+  // with the new value.
+  // However, |recently_broken_alternative_services_| will still have the
+  // already-stored alt svcs at the front of the recency list, followed by the
+  // newly added ones.
+  void AddBrokenAndRecentlyBrokenAlternativeServices(
       std::unique_ptr<BrokenAlternativeServiceList>
           broken_alternative_service_list,
       std::unique_ptr<RecentlyBrokenAlternativeServices>
           recently_broken_alternative_services);
 
   const BrokenAlternativeServiceList& broken_alternative_service_list() const;
 
   const RecentlyBrokenAlternativeServices&
   recently_broken_alternative_services() const;
 
+  // |clock| is unowned.

[Ryan Hamilton, 2017/06/12 18:57:32]

I think you mean to say that |clock| must outlive this?

[wangyix1, 2017/06/14 00:01:25]

Function has been removed

+  void SetTickClockForTesting(base::TickClock* clock);
+
  private:
   // TODO (wangyix): modify HttpServerPropertiesImpl unit tests so this
   // friendness is no longer required.
   friend class HttpServerPropertiesImplPeer;
 
   struct AlternativeServiceHash {
     size_t operator()(const net::AlternativeService& entry) const {
       return entry.protocol ^ std::hash<std::string>()(entry.host) ^ entry.port;
     }
   };
 
   typedef std::unordered_map<AlternativeService,
                              BrokenAlternativeServiceList::iterator,
                              AlternativeServiceHash>
       BrokenAlternativeServiceMap;
 
   // Inserts |alternative_service| and its |expiration| time into
   // |broken_alternative_service_list_| and |broken_alternative_service_map_|.
   // |it| is the position in |broken_alternative_service_list_| where it was
   // inserted.
   bool AddToBrokenAlternativeServiceListAndMap(
       const AlternativeService& alternative_service,
       base::TimeTicks expiration,
       BrokenAlternativeServiceList::iterator* it);
 
   void ExpireBrokenAlternateProtocolMappings();
-  void ScheduleBrokenAlternateProtocolMappingsExpiration();
+  void ScheduleBrokenAlternateProtocolMappingsExpiration(base::TimeTicks when);
 
   Delegate* delegate_;      // Unowned
-  base::TickClock* clock_;  // Unowned
+  base::TickClock* clock_;  // Unowned if not pointing to |default_clock_|.

[Ryan Hamilton, 2017/06/12 18:57:32]

I'd just say "Unowned". Because you'll never say "delete clock_" right?

[wangyix1, 2017/06/14 00:01:25]

Done.

+
+  base::DefaultTickClock default_clock_;
 
   // List of <broken alt svc, expiration time> pairs sorted by expiration time.
   BrokenAlternativeServiceList broken_alternative_service_list_;
   // A map from broken alt-svcs to their iterator pointing to that alt-svc's
   // position in |broken_alternative_service_list_|.
   BrokenAlternativeServiceMap broken_alternative_service_map_;
 
   // Maps broken alternative services to how many times they've been marked
   // broken.
   RecentlyBrokenAlternativeServices recently_broken_alternative_services_;
 
   // Used for scheduling the task that expires the brokenness of alternative
   // services.
   base::OneShotTimer expiration_timer_;
 
   base::WeakPtrFactory<BrokenAlternativeServices> weak_ptr_factory_;
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_BROKEN_ALTERNATIVE_SERVICES_H_