BASELINE: Update Chromium to 63.0.3239.58

Change-Id: Ia93b322a00ba4dd4004f3bcf1254063ba90e1605
Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>

1 files changed, 157 insertions, 271 deletions

diff --git a/chromium/net/http/http_server_properties_manager.cc b/chromium/net/http/http_server_properties_manager.cc
index db96b915dfb..30361742ee8 100644
--- a/chromium/net/http/http_server_properties_manager.cc
+++ b/chromium/net/http/http_server_properties_manager.cc
@@ -7,12 +7,9 @@
 #include <utility>
 
 #include "base/bind.h"
-#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
-#include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
-#include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "net/base/ip_address.h"
 #include "net/base/port_util.h"
@@ -89,11 +86,20 @@ void AddAlternativeServiceFieldsToDictionaryValue(
 }
 
 std::unique_ptr<base::Value> NetLogCallback(
-    const base::Value& http_server_properties_dict,
+    const base::Value* http_server_properties_dict,
     NetLogCaptureMode capture_mode) {
-  return std::make_unique<base::Value>(http_server_properties_dict.Clone());
+  return http_server_properties_dict->CreateDeepCopy();
 }
 
+// A local or temporary data structure to hold preferences for a server.
+// This is used only in UpdatePrefs.
+struct ServerPref {
+  bool supports_spdy = false;
+  const AlternativeServiceInfoVector* alternative_service_info_vector = nullptr;
+  const SupportsQuic* supports_quic = nullptr;
+  const ServerNetworkStats* server_network_stats = nullptr;
+};
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -102,77 +108,30 @@ std::unique_ptr<base::Value> NetLogCallback(
 HttpServerPropertiesManager::PrefDelegate::~PrefDelegate() {}
 
 HttpServerPropertiesManager::HttpServerPropertiesManager(
-    PrefDelegate* pref_delegate,
-    scoped_refptr<base::SingleThreadTaskRunner> pref_task_runner,
-    scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
-    NetLog* net_log)
-    : HttpServerPropertiesManager(pref_delegate,
-                                  std::move(pref_task_runner),
-                                  std::move(network_task_runner),
-                                  net_log,
-                                  nullptr) {}
-
-HttpServerPropertiesManager::HttpServerPropertiesManager(
-    PrefDelegate* pref_delegate,
-    scoped_refptr<base::SingleThreadTaskRunner> pref_task_runner,
-    scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
+    std::unique_ptr<PrefDelegate> pref_delegate,
     NetLog* net_log,
     base::TickClock* clock)
-    : pref_task_runner_(std::move(pref_task_runner)),
-      pref_delegate_(pref_delegate),
-      setting_prefs_(false),
+    : pref_delegate_(std::move(pref_delegate)),
       clock_(clock ? clock : &default_clock_),
-      is_initialized_(false),
-      network_task_runner_(std::move(network_task_runner)),
       net_log_(
           NetLogWithSource::Make(net_log,
                                  NetLogSourceType::HTTP_SERVER_PROPERTIES)) {
-  DCHECK(pref_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(pref_delegate_);
   DCHECK(clock_);
-  pref_weak_ptr_factory_.reset(
-      new base::WeakPtrFactory<HttpServerPropertiesManager>(this));
-  pref_weak_ptr_ = pref_weak_ptr_factory_->GetWeakPtr();
-  pref_cache_update_timer_.reset(new base::OneShotTimer);
-  pref_cache_update_timer_->SetTaskRunner(pref_task_runner_);
+
   pref_delegate_->StartListeningForUpdates(
       base::Bind(&HttpServerPropertiesManager::OnHttpServerPropertiesChanged,
                  base::Unretained(this)));
-}
-
-HttpServerPropertiesManager::~HttpServerPropertiesManager() {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
-  network_weak_ptr_factory_.reset();
-}
-
-void HttpServerPropertiesManager::InitializeOnNetworkSequence() {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   net_log_.BeginEvent(NetLogEventType::HTTP_SERVER_PROPERTIES_INITIALIZATION);
 
-  network_weak_ptr_factory_.reset(
-      new base::WeakPtrFactory<HttpServerPropertiesManager>(this));
   http_server_properties_impl_.reset(new HttpServerPropertiesImpl(clock_));
-
-  network_prefs_update_timer_.reset(new base::OneShotTimer);
-  network_prefs_update_timer_->SetTaskRunner(network_task_runner_);
-  // UpdateCacheFromPrefsOnPrefSequence() will post a task to network thread to
-  // update server properties. SetInitialized() will be run after that task is
-  // run as |network_task_runner_| is single threaded.
-  pref_task_runner_->PostTaskAndReply(
-      FROM_HERE,
-      base::Bind(
-          &HttpServerPropertiesManager::UpdateCacheFromPrefsOnPrefSequence,
-          pref_weak_ptr_),
-      base::Bind(&HttpServerPropertiesManager::SetInitialized,
-                 network_weak_ptr_factory_->GetWeakPtr()));
 }
 
-void HttpServerPropertiesManager::ShutdownOnPrefSequence() {
-  DCHECK(pref_task_runner_->RunsTasksInCurrentSequence());
-  // Cancel any pending updates, and stop listening for pref change updates.
-  pref_cache_update_timer_->Stop();
-  pref_weak_ptr_factory_.reset();
-  pref_delegate_->StopListeningForUpdates();
+HttpServerPropertiesManager::~HttpServerPropertiesManager() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  // Flush settings on destruction.
+  UpdatePrefsFromCache();
 }
 
 // static
@@ -187,63 +146,59 @@ void HttpServerPropertiesManager::SetVersion(
 }
 
 void HttpServerPropertiesManager::Clear() {
-  Clear(base::Closure());
-}
-
-void HttpServerPropertiesManager::Clear(const base::Closure& completion) {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   http_server_properties_impl_->Clear();
-  UpdatePrefsFromCacheOnNetworkSequence(completion);
+  UpdatePrefsFromCache();
 }
 
 bool HttpServerPropertiesManager::SupportsRequestPriority(
     const url::SchemeHostPort& server) {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return http_server_properties_impl_->SupportsRequestPriority(server);
 }
 
 bool HttpServerPropertiesManager::GetSupportsSpdy(
     const url::SchemeHostPort& server) {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return http_server_properties_impl_->GetSupportsSpdy(server);
 }
 
 void HttpServerPropertiesManager::SetSupportsSpdy(
     const url::SchemeHostPort& server,
     bool support_spdy) {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   bool old_support_spdy = http_server_properties_impl_->GetSupportsSpdy(server);
   http_server_properties_impl_->SetSupportsSpdy(server, support_spdy);
   bool new_support_spdy = http_server_properties_impl_->GetSupportsSpdy(server);
   if (old_support_spdy != new_support_spdy)
-    ScheduleUpdatePrefsOnNetworkSequence(SUPPORTS_SPDY);
+    ScheduleUpdatePrefs(SUPPORTS_SPDY);
 }
 
 bool HttpServerPropertiesManager::RequiresHTTP11(const HostPortPair& server) {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return http_server_properties_impl_->RequiresHTTP11(server);
 }
 
 void HttpServerPropertiesManager::SetHTTP11Required(
     const HostPortPair& server) {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   http_server_properties_impl_->SetHTTP11Required(server);
-  ScheduleUpdatePrefsOnNetworkSequence(HTTP_11_REQUIRED);
+  ScheduleUpdatePrefs(HTTP_11_REQUIRED);
 }
 
 void HttpServerPropertiesManager::MaybeForceHTTP11(const HostPortPair& server,
                                                    SSLConfig* ssl_config) {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   http_server_properties_impl_->MaybeForceHTTP11(server, ssl_config);
 }
 
 AlternativeServiceInfoVector
 HttpServerPropertiesManager::GetAlternativeServiceInfos(
     const url::SchemeHostPort& origin) {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return http_server_properties_impl_->GetAlternativeServiceInfos(origin);
 }
 
@@ -251,11 +206,11 @@ bool HttpServerPropertiesManager::SetHttp2AlternativeService(
     const url::SchemeHostPort& origin,
     const AlternativeService& alternative_service,
     base::Time expiration) {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   const bool changed = http_server_properties_impl_->SetHttp2AlternativeService(
       origin, alternative_service, expiration);
   if (changed) {
-    ScheduleUpdatePrefsOnNetworkSequence(SET_ALTERNATIVE_SERVICES);
+    ScheduleUpdatePrefs(SET_ALTERNATIVE_SERVICES);
   }
   return changed;
 }
@@ -264,12 +219,12 @@ bool HttpServerPropertiesManager::SetQuicAlternativeService(
     const url::SchemeHostPort& origin,
     const AlternativeService& alternative_service,
     base::Time expiration,
-    const QuicVersionVector& advertised_versions) {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+    const QuicTransportVersionVector& advertised_versions) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   const bool changed = http_server_properties_impl_->SetQuicAlternativeService(
       origin, alternative_service, expiration, advertised_versions);
   if (changed) {
-    ScheduleUpdatePrefsOnNetworkSequence(SET_ALTERNATIVE_SERVICES);
+    ScheduleUpdatePrefs(SET_ALTERNATIVE_SERVICES);
   }
   return changed;
 }
@@ -277,49 +232,48 @@ bool HttpServerPropertiesManager::SetQuicAlternativeService(
 bool HttpServerPropertiesManager::SetAlternativeServices(
     const url::SchemeHostPort& origin,
     const AlternativeServiceInfoVector& alternative_service_info_vector) {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   const bool changed = http_server_properties_impl_->SetAlternativeServices(
       origin, alternative_service_info_vector);
   if (changed) {
-    ScheduleUpdatePrefsOnNetworkSequence(SET_ALTERNATIVE_SERVICES);
+    ScheduleUpdatePrefs(SET_ALTERNATIVE_SERVICES);
   }
   return changed;
 }
 
 void HttpServerPropertiesManager::MarkAlternativeServiceBroken(
     const AlternativeService& alternative_service) {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   http_server_properties_impl_->MarkAlternativeServiceBroken(
       alternative_service);
-  ScheduleUpdatePrefsOnNetworkSequence(MARK_ALTERNATIVE_SERVICE_BROKEN);
+  ScheduleUpdatePrefs(MARK_ALTERNATIVE_SERVICE_BROKEN);
 }
 
 void HttpServerPropertiesManager::MarkAlternativeServiceRecentlyBroken(
     const AlternativeService& alternative_service) {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   http_server_properties_impl_->MarkAlternativeServiceRecentlyBroken(
       alternative_service);
-  ScheduleUpdatePrefsOnNetworkSequence(
-      MARK_ALTERNATIVE_SERVICE_RECENTLY_BROKEN);
+  ScheduleUpdatePrefs(MARK_ALTERNATIVE_SERVICE_RECENTLY_BROKEN);
 }
 
 bool HttpServerPropertiesManager::IsAlternativeServiceBroken(
     const AlternativeService& alternative_service) const {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return http_server_properties_impl_->IsAlternativeServiceBroken(
       alternative_service);
 }
 
 bool HttpServerPropertiesManager::WasAlternativeServiceRecentlyBroken(
     const AlternativeService& alternative_service) {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return http_server_properties_impl_->WasAlternativeServiceRecentlyBroken(
       alternative_service);
 }
 
 void HttpServerPropertiesManager::ConfirmAlternativeService(
     const AlternativeService& alternative_service) {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   bool old_value = http_server_properties_impl_->IsAlternativeServiceBroken(
       alternative_service);
   http_server_properties_impl_->ConfirmAlternativeService(alternative_service);
@@ -328,43 +282,43 @@ void HttpServerPropertiesManager::ConfirmAlternativeService(
   // For persisting, we only care about the value returned by
   // IsAlternativeServiceBroken. If that value changes, then call persist.
   if (old_value != new_value)
-    ScheduleUpdatePrefsOnNetworkSequence(CONFIRM_ALTERNATIVE_SERVICE);
+    ScheduleUpdatePrefs(CONFIRM_ALTERNATIVE_SERVICE);
 }
 
 const AlternativeServiceMap&
 HttpServerPropertiesManager::alternative_service_map() const {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return http_server_properties_impl_->alternative_service_map();
 }
 
 std::unique_ptr<base::Value>
 HttpServerPropertiesManager::GetAlternativeServiceInfoAsValue() const {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return http_server_properties_impl_->GetAlternativeServiceInfoAsValue();
 }
 
 bool HttpServerPropertiesManager::GetSupportsQuic(
     IPAddress* last_address) const {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return http_server_properties_impl_->GetSupportsQuic(last_address);
 }
 
 void HttpServerPropertiesManager::SetSupportsQuic(bool used_quic,
                                                   const IPAddress& address) {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   IPAddress old_last_quic_addr;
   http_server_properties_impl_->GetSupportsQuic(&old_last_quic_addr);
   http_server_properties_impl_->SetSupportsQuic(used_quic, address);
   IPAddress new_last_quic_addr;
   http_server_properties_impl_->GetSupportsQuic(&new_last_quic_addr);
   if (old_last_quic_addr != new_last_quic_addr)
-    ScheduleUpdatePrefsOnNetworkSequence(SET_SUPPORTS_QUIC);
+    ScheduleUpdatePrefs(SET_SUPPORTS_QUIC);
 }
 
 void HttpServerPropertiesManager::SetServerNetworkStats(
     const url::SchemeHostPort& server,
     ServerNetworkStats stats) {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   ServerNetworkStats old_stats;
   const ServerNetworkStats* old_stats_ptr =
       http_server_properties_impl_->GetServerNetworkStats(server);
@@ -374,70 +328,70 @@ void HttpServerPropertiesManager::SetServerNetworkStats(
   ServerNetworkStats new_stats =
       *(http_server_properties_impl_->GetServerNetworkStats(server));
   if (old_stats != new_stats)
-    ScheduleUpdatePrefsOnNetworkSequence(SET_SERVER_NETWORK_STATS);
+    ScheduleUpdatePrefs(SET_SERVER_NETWORK_STATS);
 }
 
 void HttpServerPropertiesManager::ClearServerNetworkStats(
     const url::SchemeHostPort& server) {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   bool need_update =
       http_server_properties_impl_->GetServerNetworkStats(server) != nullptr;
   http_server_properties_impl_->ClearServerNetworkStats(server);
   if (need_update)
-    ScheduleUpdatePrefsOnNetworkSequence(CLEAR_SERVER_NETWORK_STATS);
+    ScheduleUpdatePrefs(CLEAR_SERVER_NETWORK_STATS);
 }
 
 const ServerNetworkStats* HttpServerPropertiesManager::GetServerNetworkStats(
     const url::SchemeHostPort& server) {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return http_server_properties_impl_->GetServerNetworkStats(server);
 }
 
 const ServerNetworkStatsMap&
 HttpServerPropertiesManager::server_network_stats_map() const {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return http_server_properties_impl_->server_network_stats_map();
 }
 
 bool HttpServerPropertiesManager::SetQuicServerInfo(
     const QuicServerId& server_id,
     const std::string& server_info) {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   bool changed =
       http_server_properties_impl_->SetQuicServerInfo(server_id, server_info);
   if (changed)
-    ScheduleUpdatePrefsOnNetworkSequence(SET_QUIC_SERVER_INFO);
+    ScheduleUpdatePrefs(SET_QUIC_SERVER_INFO);
   return changed;
 }
 
 const std::string* HttpServerPropertiesManager::GetQuicServerInfo(
     const QuicServerId& server_id) {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return http_server_properties_impl_->GetQuicServerInfo(server_id);
 }
 
 const QuicServerInfoMap& HttpServerPropertiesManager::quic_server_info_map()
     const {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return http_server_properties_impl_->quic_server_info_map();
 }
 
 size_t HttpServerPropertiesManager::max_server_configs_stored_in_properties()
     const {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return http_server_properties_impl_
       ->max_server_configs_stored_in_properties();
 }
 
 void HttpServerPropertiesManager::SetMaxServerConfigsStoredInProperties(
     size_t max_server_configs_stored_in_properties) {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return http_server_properties_impl_->SetMaxServerConfigsStoredInProperties(
       max_server_configs_stored_in_properties);
 }
 
 bool HttpServerPropertiesManager::IsInitialized() const {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   return is_initialized_;
 }
@@ -452,37 +406,46 @@ base::TimeDelta HttpServerPropertiesManager::GetUpdatePrefsDelayForTesting() {
   return kUpdatePrefsDelay;
 }
 
-//
-// Update the HttpServerPropertiesImpl's cache with data from preferences.
-//
-void HttpServerPropertiesManager::ScheduleUpdateCacheOnPrefThread() {
-  DCHECK(pref_task_runner_->RunsTasksInCurrentSequence());
+void HttpServerPropertiesManager::ScheduleUpdateCacheForTesting() {
+  ScheduleUpdateCache();
+}
+
+void HttpServerPropertiesManager::ScheduleUpdateCache() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   // Do not schedule a new update if there is already one scheduled.
-  if (pref_cache_update_timer_->IsRunning())
+  if (pref_cache_update_timer_.IsRunning())
     return;
 
-  pref_cache_update_timer_->Start(
+  if (!is_initialized_) {
+    UpdateCacheFromPrefs();
+    return;
+  }
+
+  pref_cache_update_timer_.Start(
       FROM_HERE, kUpdateCacheDelay, this,
-      &HttpServerPropertiesManager::UpdateCacheFromPrefsOnPrefSequence);
+      &HttpServerPropertiesManager::UpdateCacheFromPrefs);
 }
 
-void HttpServerPropertiesManager::UpdateCacheFromPrefsOnPrefSequence() {
-  // The preferences can only be read on the pref thread.
-  DCHECK(pref_task_runner_->RunsTasksInCurrentSequence());
+void HttpServerPropertiesManager::UpdateCacheFromPrefs() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
-  if (!pref_delegate_->HasServerProperties())
-    return;
+  if (!is_initialized_) {
+    net_log_.EndEvent(NetLogEventType::HTTP_SERVER_PROPERTIES_INITIALIZATION);
+    is_initialized_ = true;
+  }
 
-  bool detected_corrupted_prefs = false;
-  const base::DictionaryValue& http_server_properties_dict =
+  const base::DictionaryValue* http_server_properties_dict =
       pref_delegate_->GetServerProperties();
+  // If there are no preferences set, do nothing.
+  if (!http_server_properties_dict)
+    return;
 
-  net_log_.AddEvent(
-      NetLogEventType::HTTP_SERVER_PROPERTIES_UPDATE_CACHE,
-      base::Bind(&NetLogCallback, http_server_properties_dict.Clone()));
+  bool detected_corrupted_prefs = false;
+  net_log_.AddEvent(NetLogEventType::HTTP_SERVER_PROPERTIES_UPDATE_CACHE,
+                    base::Bind(&NetLogCallback, http_server_properties_dict));
   int version = kMissingVersion;
-  if (!http_server_properties_dict.GetIntegerWithoutPathExpansion(kVersionKey,
-                                                                  &version)) {
+  if (!http_server_properties_dict->GetIntegerWithoutPathExpansion(kVersionKey,
+                                                                   &version)) {
     DVLOG(1) << "Missing version. Clearing all properties.";
     return;
   }
@@ -503,7 +466,7 @@ void HttpServerPropertiesManager::UpdateCacheFromPrefsOnPrefSequence() {
     //         ...
     //      }, ...
     // },
-    if (!http_server_properties_dict.GetDictionaryWithoutPathExpansion(
+    if (!http_server_properties_dict->GetDictionaryWithoutPathExpansion(
             kServersKey, &servers_dict)) {
       DVLOG(1) << "Malformed http_server_properties for servers.";
       return;
@@ -533,7 +496,7 @@ void HttpServerPropertiesManager::UpdateCacheFromPrefsOnPrefSequence() {
     //          ...
     //      ], ...
     // },
-    if (!http_server_properties_dict.GetListWithoutPathExpansion(
+    if (!http_server_properties_dict->GetListWithoutPathExpansion(
             kServersKey, &servers_list)) {
       DVLOG(1) << "Malformed http_server_properties for servers list.";
       return;
@@ -541,7 +504,7 @@ void HttpServerPropertiesManager::UpdateCacheFromPrefsOnPrefSequence() {
   }
 
   std::unique_ptr<IPAddress> addr = std::make_unique<IPAddress>();
-  ReadSupportsQuic(http_server_properties_dict, addr.get());
+  ReadSupportsQuic(*http_server_properties_dict, addr.get());
 
   // String is "scheme://host:port" tuple of spdy server.
   std::unique_ptr<SpdyServersMap> spdy_servers_map(
@@ -579,7 +542,7 @@ void HttpServerPropertiesManager::UpdateCacheFromPrefsOnPrefSequence() {
     }
   }
 
-  if (!AddToQuicServerInfoMap(http_server_properties_dict,
+  if (!AddToQuicServerInfoMap(*http_server_properties_dict,
                               quic_server_info_map.get())) {
     detected_corrupted_prefs = true;
   }
@@ -590,7 +553,7 @@ void HttpServerPropertiesManager::UpdateCacheFromPrefsOnPrefSequence() {
   std::unique_ptr<RecentlyBrokenAlternativeServices>
       recently_broken_alternative_services;
   const base::ListValue* broken_alt_svc_list;
-  if (http_server_properties_dict.GetListWithoutPathExpansion(
+  if (http_server_properties_dict->GetListWithoutPathExpansion(
           kBrokenAlternativeServicesKey, &broken_alt_svc_list)) {
     broken_alternative_service_list =
         std::make_unique<BrokenAlternativeServiceList>();
@@ -617,17 +580,45 @@ void HttpServerPropertiesManager::UpdateCacheFromPrefsOnPrefSequence() {
     }
   }
 
-  network_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(
-          &HttpServerPropertiesManager::UpdateCacheFromPrefsOnNetworkSequence,
-          base::Unretained(this), base::Passed(&spdy_servers_map),
-          base::Passed(&alternative_service_map), base::Passed(&addr),
-          base::Passed(&server_network_stats_map),
-          base::Passed(&quic_server_info_map),
-          base::Passed(&broken_alternative_service_list),
-          base::Passed(&recently_broken_alternative_services),
-          detected_corrupted_prefs));
+  // Set the properties loaded from prefs on |http_server_properties_impl_|.
+
+  UMA_HISTOGRAM_COUNTS_1M("Net.CountOfSpdyServers", spdy_servers_map->size());
+  http_server_properties_impl_->SetSpdyServers(std::move(spdy_servers_map));
+
+  // Update the cached data and use the new alternative service list from
+  // preferences.
+  UMA_HISTOGRAM_COUNTS_1M("Net.CountOfAlternateProtocolServers",
+                          alternative_service_map->size());
+  http_server_properties_impl_->SetAlternativeServiceServers(
+      std::move(alternative_service_map));
+
+  http_server_properties_impl_->SetSupportsQuic(*addr);
+
+  http_server_properties_impl_->SetServerNetworkStats(
+      std::move(server_network_stats_map));
+
+  UMA_HISTOGRAM_COUNTS_1000("Net.CountOfQuicServerInfos",
+                            quic_server_info_map->size());
+
+  http_server_properties_impl_->SetQuicServerInfoMap(
+      std::move(quic_server_info_map));
+
+  if (recently_broken_alternative_services) {
+    DCHECK(broken_alternative_service_list);
+
+    UMA_HISTOGRAM_COUNTS_1000("Net.CountOfBrokenAlternativeServices",
+                              broken_alternative_service_list->size());
+    UMA_HISTOGRAM_COUNTS_1000("Net.CountOfRecentlyBrokenAlternativeServices",
+                              recently_broken_alternative_services->size());
+
+    http_server_properties_impl_->SetBrokenAndRecentlyBrokenAlternativeServices(
+        std::move(broken_alternative_service_list),
+        std::move(recently_broken_alternative_services));
+  }
+
+  // Update the prefs with what we have read (delete all corrupted prefs).
+  if (detected_corrupted_prefs)
+    ScheduleUpdatePrefs(DETECTED_CORRUPTED_PREFS);
 }
 
 bool HttpServerPropertiesManager::AddToBrokenAlternativeServices(
@@ -828,7 +819,7 @@ bool HttpServerPropertiesManager::ParseAlternativeServiceInfoDictOfServer(
                << "server: " << server_str;
       return false;
     }
-    QuicVersionVector advertised_versions;
+    QuicTransportVersionVector advertised_versions;
     for (const auto& value : *versions_list) {
       int version;
       if (!value.GetAsInteger(&version)) {
@@ -836,7 +827,7 @@ bool HttpServerPropertiesManager::ParseAlternativeServiceInfoDictOfServer(
                  << server_str;
         return false;
       }
-      advertised_versions.push_back(QuicVersion(version));
+      advertised_versions.push_back(QuicTransportVersion(version));
     }
     alternative_service_info->set_advertised_versions(advertised_versions);
   }
@@ -982,87 +973,26 @@ bool HttpServerPropertiesManager::AddToQuicServerInfoMap(
   return !detected_corrupted_prefs;
 }
 
-void HttpServerPropertiesManager::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) {
-  // Preferences have the master data because admins might have pushed new
-  // preferences. Update the cached data with new data from preferences.
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
-
-  UMA_HISTOGRAM_COUNTS_1M("Net.CountOfSpdyServers", spdy_servers_map->size());
-  http_server_properties_impl_->SetSpdyServers(std::move(spdy_servers_map));
-
-  // Update the cached data and use the new alternative service list from
-  // preferences.
-  UMA_HISTOGRAM_COUNTS_1M("Net.CountOfAlternateProtocolServers",
-                          alternative_service_map->size());
-  http_server_properties_impl_->SetAlternativeServiceServers(
-      std::move(alternative_service_map));
-
-  http_server_properties_impl_->SetSupportsQuic(*last_quic_address);
-
-  http_server_properties_impl_->SetServerNetworkStats(
-      std::move(server_network_stats_map));
-
-  UMA_HISTOGRAM_COUNTS_1000("Net.CountOfQuicServerInfos",
-                            quic_server_info_map->size());
-
-  http_server_properties_impl_->SetQuicServerInfoMap(
-      std::move(quic_server_info_map));
-
-  if (recently_broken_alternative_services) {
-    DCHECK(broken_alternative_service_list);
-
-    UMA_HISTOGRAM_COUNTS_1000("Net.CountOfBrokenAlternativeServices",
-                              broken_alternative_service_list->size());
-    UMA_HISTOGRAM_COUNTS_1000("Net.CountOfRecentlyBrokenAlternativeServices",
-                              recently_broken_alternative_services->size());
-
-    http_server_properties_impl_->SetBrokenAndRecentlyBrokenAlternativeServices(
-        std::move(broken_alternative_service_list),
-        std::move(recently_broken_alternative_services));
-  }
-
-  // Update the prefs with what we have read (delete all corrupted prefs).
-  if (detected_corrupted_prefs)
-    ScheduleUpdatePrefsOnNetworkSequence(DETECTED_CORRUPTED_PREFS);
-}
-
 //
 // Update Preferences with data from the cached data.
 //
-void HttpServerPropertiesManager::ScheduleUpdatePrefsOnNetworkSequence(
-    Location location) {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+void HttpServerPropertiesManager::ScheduleUpdatePrefs(Location location) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   // Do not schedule a new update if there is already one scheduled.
-  if (network_prefs_update_timer_->IsRunning())
+  if (network_prefs_update_timer_.IsRunning())
     return;
 
-  network_prefs_update_timer_->Start(
+  network_prefs_update_timer_.Start(
       FROM_HERE, kUpdatePrefsDelay, this,
-      &HttpServerPropertiesManager::UpdatePrefsFromCacheOnNetworkSequence);
+      &HttpServerPropertiesManager::UpdatePrefsFromCache);
 
   // TODO(rtenneti): Delete the following histogram after collecting some data.
   UMA_HISTOGRAM_ENUMERATION("Net.HttpServerProperties.UpdatePrefs", location,
                             HttpServerPropertiesManager::NUM_LOCATIONS);
 }
 
-// This is required so we can set this as the callback for a timer.
-void HttpServerPropertiesManager::UpdatePrefsFromCacheOnNetworkSequence() {
-  UpdatePrefsFromCacheOnNetworkSequence(base::Closure());
-}
-
-void HttpServerPropertiesManager::UpdatePrefsFromCacheOnNetworkSequence(
-    const base::Closure& completion) {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+void HttpServerPropertiesManager::UpdatePrefsFromCache() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // It is in MRU order.
   std::unique_ptr<std::vector<std::string>> spdy_servers =
@@ -1177,44 +1107,13 @@ void HttpServerPropertiesManager::UpdatePrefsFromCacheOnNetworkSequence(
 
   std::unique_ptr<IPAddress> last_quic_addr = std::make_unique<IPAddress>();
   http_server_properties_impl_->GetSupportsQuic(last_quic_addr.get());
-  // Update the preferences on the pref thread.
-  pref_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&HttpServerPropertiesManager::UpdatePrefsOnPrefThread,
-                 pref_weak_ptr_, base::Passed(&spdy_servers),
-                 base::Passed(&alternative_service_map),
-                 base::Passed(&last_quic_addr),
-                 base::Passed(&server_network_stats_map),
-                 base::Passed(&quic_server_info_map),
-                 base::Passed(&broken_alt_svc_list),
-                 base::Passed(&recently_broken_alt_svcs), completion));
-}
 
-// A local or temporary data structure to hold preferences for a server.
-// This is used only in UpdatePrefsOnPrefThread.
-struct ServerPref {
-  bool supports_spdy = false;
-  const AlternativeServiceInfoVector* alternative_service_info_vector = nullptr;
-  const SupportsQuic* supports_quic = nullptr;
-  const ServerNetworkStats* server_network_stats = nullptr;
-};
-
-// All maps and lists are in MRU order.
-void HttpServerPropertiesManager::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) {
+  // Now update the prefs.
+  // TODO(mmenke): Should this be inlined above?
   typedef base::MRUCache<url::SchemeHostPort, ServerPref> ServerPrefMap;
   ServerPrefMap server_pref_map(ServerPrefMap::NO_AUTO_EVICT);
 
-  DCHECK(pref_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // Add servers that support spdy to server_pref_map in the MRU order.
   DCHECK(spdy_servers);
@@ -1296,31 +1195,24 @@ void HttpServerPropertiesManager::UpdatePrefsOnPrefThread(
                                                       std::move(servers_list));
   SetVersion(&http_server_properties_dict, kVersionNumber);
 
-  DCHECK(last_quic_address);
-  SaveSupportsQuicToPrefs(*last_quic_address, &http_server_properties_dict);
+  DCHECK(last_quic_addr);
+  SaveSupportsQuicToPrefs(*last_quic_addr, &http_server_properties_dict);
 
   if (quic_server_info_map) {
     SaveQuicServerInfoMapToServerPrefs(*quic_server_info_map,
                                        &http_server_properties_dict);
   }
 
-  SaveBrokenAlternativeServicesToPrefs(
-      broken_alternative_service_list.get(),
-      recently_broken_alternative_services.get(), &http_server_properties_dict);
+  SaveBrokenAlternativeServicesToPrefs(broken_alt_svc_list.get(),
+                                       recently_broken_alt_svcs.get(),
+                                       &http_server_properties_dict);
 
   setting_prefs_ = true;
   pref_delegate_->SetServerProperties(http_server_properties_dict);
   setting_prefs_ = false;
 
-  net_log_.AddEvent(
-      NetLogEventType::HTTP_SERVER_PROPERTIES_UPDATE_PREFS,
-      base::Bind(&NetLogCallback, http_server_properties_dict.Clone()));
-  // Note that |completion| will be fired after we have written everything to
-  // the Preferences, but likely before these changes are serialized to disk.
-  // This is not a problem though, as JSONPrefStore guarantees that this will
-  // happen, pretty soon, and even in the case we shut down immediately.
-  if (!completion.is_null())
-    completion.Run();
+  net_log_.AddEvent(NetLogEventType::HTTP_SERVER_PROPERTIES_UPDATE_PREFS,
+                    base::Bind(&NetLogCallback, &http_server_properties_dict));
 }
 
 void HttpServerPropertiesManager::SaveAlternativeServiceToServerPrefs(
@@ -1468,15 +1360,9 @@ void HttpServerPropertiesManager::SaveBrokenAlternativeServicesToPrefs(
 }
 
 void HttpServerPropertiesManager::OnHttpServerPropertiesChanged() {
-  DCHECK(pref_task_runner_->RunsTasksInCurrentSequence());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!setting_prefs_)
-    ScheduleUpdateCacheOnPrefThread();
-}
-
-void HttpServerPropertiesManager::SetInitialized() {
-  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
-  is_initialized_ = true;
-  net_log_.EndEvent(NetLogEventType::HTTP_SERVER_PROPERTIES_INITIALIZATION);
+    ScheduleUpdateCache();
 }
 
 }  // namespace net