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

net/http/http_server_properties_manager.h

 // 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.
 
 #ifndef NET_HTTP_HTTP_SERVER_PROPERTIES_MANAGER_H_
 #define NET_HTTP_HTTP_SERVER_PROPERTIES_MANAGER_H_
 
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
+#include "base/time/default_tick_clock.h"
 #include "base/timer/timer.h"
 #include "base/values.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/net_export.h"
 #include "net/http/http_server_properties.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/log/net_log_with_source.h"
 
 namespace base {
 class SingleThreadTaskRunner;
@@ skipping 58 matching lines @@
   //
   // Ownership of the PrefDelegate pointer is taken by this class. This is
   // passed as a raw pointer rather than a scoped_refptr currently because
   // the test uses gmock and it doesn't forward move semantics properly.
   //
   // There are two SingleThreadTaskRunners:
   // |pref_task_runner| should be bound with the pref thread and is used to post
   // cache update to the pref thread;
   // |network_task_runner| should be bound with the network thread and is used
   // to post pref update to the cache thread.
+  //
+  // |clock| is used for setting expiration times and scheduling the
+  // expiration of broken alternative services. It must not be null.
   HttpServerPropertiesManager(
       PrefDelegate* pref_delegate,
       scoped_refptr<base::SingleThreadTaskRunner> pref_task_runner,
+      scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
+      NetLog* net_log,
+      base::TickClock* clock);
+
+  // Default clock will be used.
+  HttpServerPropertiesManager(
+      PrefDelegate* pref_delegate,
+      scoped_refptr<base::SingleThreadTaskRunner> pref_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
       NetLog* net_log);
   ~HttpServerPropertiesManager() override;
 
   // Initialize on Network thread.
   void InitializeOnNetworkSequence();
 
   // Prepare for shutdown. Must be called on the Pref thread before destruction.
   void ShutdownOnPrefSequence();
 
@@ skipping 97 matching lines @@
   virtual void UpdateCacheFromPrefsOnPrefSequence();
 
   // Starts the update of cached prefs in |http_server_properties_impl_| on the
   // network thread. Protected for testing.
   void UpdateCacheFromPrefsOnNetworkSequence(
       std::unique_ptr<SpdyServersMap> spdy_servers_map,
       std::unique_ptr<AlternativeServiceMap> alternative_service_map,
       std::unique_ptr<IPAddress> last_quic_address,
       std::unique_ptr<ServerNetworkStatsMap> server_network_stats_map,
       std::unique_ptr<QuicServerInfoMap> quic_server_info_map,
+      std::unique_ptr<BrokenAlternativeServiceList>
+          broken_alternative_service_list,
+      std::unique_ptr<RecentlyBrokenAlternativeServices>
+          recently_broken_alternative_services,
       bool detected_corrupted_prefs);
 
   // These are used to delay updating the preferences when cached data in
   // |http_server_properties_impl_| is changing, and execute only one update per
   // simultaneous spdy_servers or spdy_settings or alternative_service changes.
   // |location| specifies where this method is called from. Virtual for testing.
   virtual void ScheduleUpdatePrefsOnNetworkSequence(Location location);
 
   // Update prefs::kHttpServerProperties in preferences with the cached data
   // from |http_server_properties_impl_|. This gets the data on network thread
   // and posts a task (UpdatePrefsOnPrefThread) to update preferences on pref
   // thread.
   void UpdatePrefsFromCacheOnNetworkSequence();
 
   // Same as above, but fires an optional |completion| callback on pref thread
   // when finished. Virtual for testing.
   virtual void UpdatePrefsFromCacheOnNetworkSequence(
       const base::Closure& completion);
 
   // Update prefs::kHttpServerProperties preferences on pref thread. Executes an
   // optional |completion| callback when finished. Protected for testing.
   void UpdatePrefsOnPrefThread(
       std::unique_ptr<std::vector<std::string>> spdy_servers,
       std::unique_ptr<AlternativeServiceMap> alternative_service_map,
       std::unique_ptr<IPAddress> last_quic_address,
       std::unique_ptr<ServerNetworkStatsMap> server_network_stats_map,
       std::unique_ptr<QuicServerInfoMap> quic_server_info_map,
+      std::unique_ptr<BrokenAlternativeServiceList>
+          broken_alternative_service_list,
+      std::unique_ptr<RecentlyBrokenAlternativeServices>
+          recently_broken_alternative_services,
       const base::Closure& completion);
 
  private:
   FRIEND_TEST_ALL_PREFIXES(HttpServerPropertiesManagerTest,
                            AddToAlternativeServiceMap);
   FRIEND_TEST_ALL_PREFIXES(HttpServerPropertiesManagerTest,
                            DoNotLoadAltSvcForInsecureOrigins);
   FRIEND_TEST_ALL_PREFIXES(HttpServerPropertiesManagerTest,
                            DoNotLoadExpiredAlternativeService);
   void OnHttpServerPropertiesChanged();
 
   bool AddServersData(const base::DictionaryValue& server_dict,
                       SpdyServersMap* spdy_servers_map,
                       AlternativeServiceMap* alternative_service_map,
                       ServerNetworkStatsMap* network_stats_map,
                       int version);
-  bool ParseAlternativeServiceDict(
-      const base::DictionaryValue& alternative_service_dict,
+  bool ParseAlternativeServiceDict(const base::DictionaryValue& dict,
+                                   bool host_required,
+                                   const std::string& parsing_under,
+                                   AlternativeService* alternative_service);
+  bool ParseAlternativeServiceInfoExpiration(
+      const base::DictionaryValue& dict,
       const std::string& server_str,
       AlternativeServiceInfo* alternative_service_info);
   bool AddToAlternativeServiceMap(
       const url::SchemeHostPort& server,
       const base::DictionaryValue& server_dict,
       AlternativeServiceMap* alternative_service_map);
   bool ReadSupportsQuic(const base::DictionaryValue& server_dict,
                         IPAddress* last_quic_address);
   bool AddToNetworkStatsMap(const url::SchemeHostPort& server,
                             const base::DictionaryValue& server_dict,
                             ServerNetworkStatsMap* network_stats_map);
   bool AddToQuicServerInfoMap(const base::DictionaryValue& server_dict,
                               QuicServerInfoMap* quic_server_info_map);
-
+  bool AddToBrokenAlternativeServices(
+      const base::DictionaryValue& broken_alt_svc_entry_dict,
+      BrokenAlternativeServiceList* broken_alternative_service_list,
+      RecentlyBrokenAlternativeServices* recently_broken_alternative_services);
   void SaveAlternativeServiceToServerPrefs(
       const AlternativeServiceInfoVector& alternative_service_info_vector,
       base::DictionaryValue* server_pref_dict);
   void SaveSupportsQuicToPrefs(
       const IPAddress& last_quic_address,
       base::DictionaryValue* http_server_properties_dict);
   void SaveNetworkStatsToServerPrefs(
       const ServerNetworkStats& server_network_stats,
       base::DictionaryValue* server_pref_dict);
   void SaveQuicServerInfoMapToServerPrefs(
       const QuicServerInfoMap& quic_server_info_map,
       base::DictionaryValue* http_server_properties_dict);
+  void SaveBrokenAlternativeServicesToPrefs(
+      const BrokenAlternativeServiceList* broken_alternative_service_list,
+      const RecentlyBrokenAlternativeServices*
+          recently_broken_alternative_services,
+      base::DictionaryValue* http_server_properties_dict);
+
   void SetInitialized();
 
+  base::DefaultTickClock default_clock_;

[Ryan Hamilton, 2017/07/06 16:48:22]

Do we really need a default clock in both the impl and the manager?

[wangyix1, 2017/07/06 18:04:29]

I put a default clock in impl since it's instantiated in many places other than
the manager and didn't want to explicitly add a DefaultTickClock instance in
every place it's used.

The manager needs a TickClock for converting broken alt-svc expiration times
from TimeTicks to Time. Instead of having its own TickClock* and DefaultClock, I
could add a function Impl::GetTickClock() and have the manager use that instead?

[Ryan Hamilton, 2017/07/06 18:36:19]

Ah, I see. Yuck :(
 
Oh, that's clever. Sure, that sounds like a good idea. 

+
   // -----------
   // Pref thread
   // -----------
 
   const scoped_refptr<base::SingleThreadTaskRunner> pref_task_runner_;
 
   base::WeakPtr<HttpServerPropertiesManager> pref_weak_ptr_;
 
   // Used to post cache update tasks.
   std::unique_ptr<base::OneShotTimer> pref_cache_update_timer_;
 
   std::unique_ptr<PrefDelegate> pref_delegate_;
   bool setting_prefs_;
 
+  base::TickClock* clock_;  // Unowned
+
   // --------------
   // Network thread
   // --------------
 
   // Whether InitializeOnNetworkSequence() has completed.
   bool is_initialized_;
 
   const scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
 
   // Used to post |prefs::kHttpServerProperties| pref update tasks.
@@ skipping 10 matching lines @@
       network_weak_ptr_factory_;
 
   const NetLogWithSource net_log_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpServerPropertiesManager);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_SERVER_PROPERTIES_MANAGER_H_