Add NetLog events for HttpServerPropertiesManager

net/http/http_server_properties_manager.cc

 // 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.
 
 #include "net/http/http_server_properties_manager.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
@@ skipping 47 matching lines @@
 const char kUsedQuicKey[] = "used_quic";
 const char kAddressKey[] = "address";
 const char kAlternativeServiceKey[] = "alternative_service";
 const char kProtocolKey[] = "protocol_str";
 const char kHostKey[] = "host";
 const char kPortKey[] = "port";
 const char kExpirationKey[] = "expiration";
 const char kNetworkStatsKey[] = "network_stats";
 const char kSrttKey[] = "srtt";
 
+std::unique_ptr<base::Value> NetLogCallback(
+    const base::DictionaryValue& http_server_properties_dict,
+    NetLogCaptureMode capture_mode) {
+  return base::WrapUnique<base::DictionaryValue>(
+      http_server_properties_dict.DeepCopy());
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 //  HttpServerPropertiesManager
 
 HttpServerPropertiesManager::PrefDelegate::~PrefDelegate() {}
 
 HttpServerPropertiesManager::HttpServerPropertiesManager(
     PrefDelegate* pref_delegate,
     scoped_refptr<base::SingleThreadTaskRunner> pref_task_runner,
-    scoped_refptr<base::SingleThreadTaskRunner> network_task_runner)
+    scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
+    NetLog* net_log)
     : pref_task_runner_(std::move(pref_task_runner)),
       pref_delegate_(pref_delegate),
       setting_prefs_(false),
       is_initialized_(false),
-      network_task_runner_(std::move(network_task_runner)) {
+      network_task_runner_(std::move(network_task_runner)),
+      net_log_(
+          NetLogWithSource::Make(net_log,
+                                 NetLogSourceType::HTTP_SERVER_PROPERTIES)) {
   DCHECK(pref_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(pref_delegate_);
   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());
 
   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.
@@ skipping 295 matching lines @@
   // The preferences can only be read on the pref thread.
   DCHECK(pref_task_runner_->RunsTasksInCurrentSequence());
 
   if (!pref_delegate_->HasServerProperties())
     return;
 
   bool detected_corrupted_prefs = false;
   const base::DictionaryValue& http_server_properties_dict =
       pref_delegate_->GetServerProperties();
 
+  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)) {
     DVLOG(1) << "Missing version. Clearing all properties.";
     return;
   }
 
   const base::DictionaryValue* servers_dict = nullptr;
   const base::ListValue* servers_list = nullptr;
   if (version < 4) {
@@ skipping 617 matching lines @@
 
   SaveSupportsQuicToPrefs(last_quic_address, &http_server_properties_dict);
 
   SaveQuicServerInfoMapToServerPrefs(quic_server_info_map,
                                      &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));

[Zhongyi Shi, 2017/06/20 20:00:53]

I am not sure whether it would be a good idea to log all the entries from
HttpServerProperties dict in NetLogs. Additionally, this is logged every time a
update is scheduled, regardless of diff size. 

[xunjieli, 2017/06/20 20:19:08]

Are you concerned about the performance cost? I am not sure if that's an issue.
The entire dictionary is serialized and persisted every 60s regardless. It's
more work if we want to figure out the exact property that has changed.

[Zhongyi Shi, 2017/06/20 21:38:48]

Acknowledged. Discussed offline, since the server properties is only logged when
update finishes, which is every 60s. Agreed that it's still reasonable.

   // 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();
 }
 
 void HttpServerPropertiesManager::SaveAlternativeServiceToServerPrefs(
     const AlternativeServiceInfoVector* alternative_service_info_vector,
@@ skipping 81 matching lines @@
 
 void HttpServerPropertiesManager::OnHttpServerPropertiesChanged() {
   DCHECK(pref_task_runner_->RunsTasksInCurrentSequence());
   if (!setting_prefs_)
     ScheduleUpdateCacheOnPrefThread();
 }
 
 void HttpServerPropertiesManager::SetInitialized() {
   DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   is_initialized_ = true;
+  net_log_.EndEvent(NetLogEventType::HTTP_SERVER_PROPERTIES_INITIALIZATION);
 }
 
 }  // namespace net