Rename TaskRunner::RunsTasksOnCurrentThread() in //net

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>
@@ skipping 31 matching lines @@
 //
 // 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.
 //
 // It must be constructed with correct task runners passed in to set up
 // |pref_task_runner_| and |network_task_runner| as well as the prefs listeners.
 //
-// ShutdownOnPrefThread must be called from pref thread before destruction, to
+// ShutdownOnPrefSequence must be called from pref thread before destruction, to
 // release the prefs listeners on the pref thread.
 //
 // Class requires that update tasks from the Pref thread can post safely to the
 // network thread, so the destruction order must guarantee that if |this|
 // exists in pref thread, then a potential destruction on network thread will
 // come after any task posted to network thread from that method on pref thread.
 // This is used to go through network thread before the actual update starts,
 // and grab a WeakPtr.
 class NET_EXPORT HttpServerPropertiesManager : public HttpServerProperties {
  public:
@@ skipping 29 matching lines @@
   // 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.
   HttpServerPropertiesManager(
       PrefDelegate* pref_delegate,
       scoped_refptr<base::SingleThreadTaskRunner> pref_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> network_task_runner);
   ~HttpServerPropertiesManager() override;
 
   // Initialize on Network thread.
-  void InitializeOnNetworkThread();
+  void InitializeOnNetworkSequence();
 
   // Prepare for shutdown. Must be called on the Pref thread before destruction.
-  void ShutdownOnPrefThread();
+  void ShutdownOnPrefSequence();
 
   // Helper function for unit tests to set the version in the dictionary.
   static void SetVersion(base::DictionaryValue* http_server_properties_dict,
                          int version_number);
 
   // Deletes all data. Works asynchronously, but if a |completion| callback is
   // provided, it will be fired on the pref thread when everything is done.
   void Clear(const base::Closure& completion);
 
   // ----------------------------------
@@ skipping 44 matching lines @@
   const QuicServerInfoMap& quic_server_info_map() const override;
   size_t max_server_configs_stored_in_properties() const override;
   void SetMaxServerConfigsStoredInProperties(
       size_t max_server_configs_stored_in_properties) override;
   bool IsInitialized() const override;
 
   static base::TimeDelta GetUpdateCacheDelayForTesting();
   static base::TimeDelta GetUpdatePrefsDelayForTesting();
 
  protected:
-  // The location where ScheduleUpdatePrefsOnNetworkThread was called.
+  // The location where ScheduleUpdatePrefsOnNetworkSequence was called.
   // Must be kept up to date with HttpServerPropertiesUpdatePrefsLocation in
   // histograms.xml.
   enum Location {
     SUPPORTS_SPDY = 0,
     HTTP_11_REQUIRED = 1,
     SET_ALTERNATIVE_SERVICES = 2,
     MARK_ALTERNATIVE_SERVICE_BROKEN = 3,
     MARK_ALTERNATIVE_SERVICE_RECENTLY_BROKEN = 4,
     CONFIRM_ALTERNATIVE_SERVICE = 5,
     CLEAR_ALTERNATIVE_SERVICE = 6,
@@ skipping 13 matching lines @@
 
   // These are used to delay updating of the cached data in
   // |http_server_properties_impl_| while the preferences are changing, and
   // execute only one update per simultaneous prefs changes.
   void ScheduleUpdateCacheOnPrefThread();
 
   // Update cached prefs in |http_server_properties_impl_| with data from
   // preferences. It gets the data on pref thread and calls
   // UpdateSpdyServersFromPrefsOnNetworkThread() to perform the update on
   // network thread.
-  virtual void UpdateCacheFromPrefsOnPrefThread();
+  virtual void UpdateCacheFromPrefsOnPrefSequence();
 
   // Starts the update of cached prefs in |http_server_properties_impl_| on the
   // network thread. Protected for testing.
-  void UpdateCacheFromPrefsOnNetworkThread(
+  void UpdateCacheFromPrefsOnNetworkSequence(
       std::vector<std::string>* spdy_servers,
       AlternativeServiceMap* alternative_service_map,
       IPAddress* last_quic_address,
       ServerNetworkStatsMap* server_network_stats_map,
       QuicServerInfoMap* quic_server_info_map,
       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 ScheduleUpdatePrefsOnNetworkThread(Location location);
+  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 UpdatePrefsFromCacheOnNetworkThread();
+  void UpdatePrefsFromCacheOnNetworkSequence();
 
   // Same as above, but fires an optional |completion| callback on pref thread
   // when finished. Virtual for testing.
-  virtual void UpdatePrefsFromCacheOnNetworkThread(
+  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(base::ListValue* spdy_server_list,
                                AlternativeServiceMap* alternative_service_map,
                                IPAddress* last_quic_address,
                                ServerNetworkStatsMap* server_network_stats_map,
                                QuicServerInfoMap* quic_server_info_map,
                                const base::Closure& completion);
@@ skipping 55 matching lines @@
   // Used to post cache update tasks.
   std::unique_ptr<base::OneShotTimer> pref_cache_update_timer_;
 
   std::unique_ptr<PrefDelegate> pref_delegate_;
   bool setting_prefs_;
 
   // --------------
   // Network thread
   // --------------
 
-  // Whether InitializeOnNetworkThread() has completed.
+  // Whether InitializeOnNetworkSequence() has completed.
   bool is_initialized_;
 
   const scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
 
   // Used to post |prefs::kHttpServerProperties| pref update tasks.
   std::unique_ptr<base::OneShotTimer> network_prefs_update_timer_;
 
   std::unique_ptr<HttpServerPropertiesImpl> http_server_properties_impl_;
 
   // Used to get |weak_ptr_| to self on the pref thread.
   std::unique_ptr<base::WeakPtrFactory<HttpServerPropertiesManager>>
       pref_weak_ptr_factory_;
 
   // Used to get |weak_ptr_| to self on the network thread.
   std::unique_ptr<base::WeakPtrFactory<HttpServerPropertiesManager>>
       network_weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpServerPropertiesManager);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_SERVER_PROPERTIES_MANAGER_H_