HttpServerProperties - Track UpdatePrefs callers. In offical builds, on

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 "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 48 matching lines @@
 const char kAddressKey[] = "address";
 const char kAlternateProtocolKey[] = "alternate_protocol";
 const char kAlternativeServiceKey[] = "alternative_service";
 const char kProtocolKey[] = "protocol_str";
 const char kHostKey[] = "host";
 const char kPortKey[] = "port";
 const char kProbabilityKey[] = "probability";
 const char kNetworkStatsKey[] = "network_stats";
 const char kSrttKey[] = "srtt";
 
+enum Location {
+  SUPPORTS_SPDY = 0,
+  HTTP_11_REQUIRED = 1,
+  SET_ALTERNATIVE_SERVICE = 2,
+  MARK_ALTERNATIVE_SERVICE_BROKEN = 3,
+  MARK_ALTERNATIVE_SERVICE_RECENTLY_BROKEN = 4,
+  CONFIRM_ALTERNATIVE_SERVICE = 5,
+  CLEAR_ALTERNATIVE_SERVICE = 6,
+  SET_SPDY_SETTING = 7,
+  CLEAR_SPDY_SETTINGS = 8,
+  CLEAR_ALL_SPDY_SETTINGS = 9,
+  SET_SUPPORTS_QUIC = 10,
+  SET_SERVER_NETWORK_STATS = 11,
+  DETECTED_CORRUPTED_PREFS = 12,
+  NUM_LOCATIONS = 13,
+};
+
+// TODO(rtenneti): Delete the following histogram after collecting some data.
+void RecordUpdatePrefs(Location location) {
+  UMA_HISTOGRAM_ENUMERATION("Net.HttpServerProperties.UpdatePrefs", location,
+                            NUM_LOCATIONS);
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 //  HttpServerPropertiesManager
 
 HttpServerPropertiesManager::HttpServerPropertiesManager(
     PrefService* pref_service,
     const char* pref_path,
     scoped_refptr<base::SequencedTaskRunner> network_task_runner)
     : pref_task_runner_(base::ThreadTaskRunnerHandle::Get()),
@@ skipping 75 matching lines @@
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->SupportsRequestPriority(server);
 }
 
 void HttpServerPropertiesManager::SetSupportsSpdy(const HostPortPair& server,
                                                   bool support_spdy) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
 
   http_server_properties_impl_->SetSupportsSpdy(server, support_spdy);
   ScheduleUpdatePrefsOnNetworkThread();
+  RecordUpdatePrefs(SUPPORTS_SPDY);
 }
 
 bool HttpServerPropertiesManager::RequiresHTTP11(const HostPortPair& server) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->RequiresHTTP11(server);
 }
 
 void HttpServerPropertiesManager::SetHTTP11Required(
     const HostPortPair& server) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
 
   http_server_properties_impl_->SetHTTP11Required(server);
   ScheduleUpdatePrefsOnNetworkThread();
+  RecordUpdatePrefs(HTTP_11_REQUIRED);
 }
 
 void HttpServerPropertiesManager::MaybeForceHTTP11(const HostPortPair& server,
                                                    SSLConfig* ssl_config) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   http_server_properties_impl_->MaybeForceHTTP11(server, ssl_config);
 }
 
 AlternativeService HttpServerPropertiesManager::GetAlternativeService(
     const HostPortPair& origin) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->GetAlternativeService(origin);
 }
 
 void HttpServerPropertiesManager::SetAlternativeService(
     const HostPortPair& origin,
     const AlternativeService& alternative_service,
     double alternative_probability) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   http_server_properties_impl_->SetAlternativeService(
       origin, alternative_service, alternative_probability);
   ScheduleUpdatePrefsOnNetworkThread();
+  RecordUpdatePrefs(SET_ALTERNATIVE_SERVICE);
 }
 
 void HttpServerPropertiesManager::MarkAlternativeServiceBroken(
     const AlternativeService& alternative_service) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   http_server_properties_impl_->MarkAlternativeServiceBroken(
       alternative_service);
   ScheduleUpdatePrefsOnNetworkThread();
+  RecordUpdatePrefs(MARK_ALTERNATIVE_SERVICE_BROKEN);
 }
 
 void HttpServerPropertiesManager::MarkAlternativeServiceRecentlyBroken(
     const AlternativeService& alternative_service) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   http_server_properties_impl_->MarkAlternativeServiceRecentlyBroken(
       alternative_service);
   ScheduleUpdatePrefsOnNetworkThread();
+  RecordUpdatePrefs(MARK_ALTERNATIVE_SERVICE_RECENTLY_BROKEN);
 }
 
 bool HttpServerPropertiesManager::IsAlternativeServiceBroken(
     const AlternativeService& alternative_service) const {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->IsAlternativeServiceBroken(
       alternative_service);
 }
 
 bool HttpServerPropertiesManager::WasAlternativeServiceRecentlyBroken(
     const AlternativeService& alternative_service) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->WasAlternativeServiceRecentlyBroken(
       alternative_service);
 }
 
 void HttpServerPropertiesManager::ConfirmAlternativeService(
     const AlternativeService& alternative_service) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   http_server_properties_impl_->ConfirmAlternativeService(alternative_service);
   ScheduleUpdatePrefsOnNetworkThread();
+  RecordUpdatePrefs(CONFIRM_ALTERNATIVE_SERVICE);
 }
 
 void HttpServerPropertiesManager::ClearAlternativeService(
     const HostPortPair& origin) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   http_server_properties_impl_->ClearAlternativeService(origin);
   ScheduleUpdatePrefsOnNetworkThread();
+  RecordUpdatePrefs(CLEAR_ALTERNATIVE_SERVICE);
 }
 
 const AlternativeServiceMap&
 HttpServerPropertiesManager::alternative_service_map() const {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->alternative_service_map();
 }
 
 base::Value* HttpServerPropertiesManager::GetAlternativeServiceInfoAsValue()
     const {
@@ skipping 15 matching lines @@
 }
 
 bool HttpServerPropertiesManager::SetSpdySetting(
     const HostPortPair& host_port_pair,
     SpdySettingsIds id,
     SpdySettingsFlags flags,
     uint32 value) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   bool persist = http_server_properties_impl_->SetSpdySetting(
       host_port_pair, id, flags, value);
-  if (persist)
+  if (persist) {
     ScheduleUpdatePrefsOnNetworkThread();
+    RecordUpdatePrefs(SET_SPDY_SETTING);
+  }
   return persist;
 }
 
 void HttpServerPropertiesManager::ClearSpdySettings(
     const HostPortPair& host_port_pair) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   http_server_properties_impl_->ClearSpdySettings(host_port_pair);
   ScheduleUpdatePrefsOnNetworkThread();
+  RecordUpdatePrefs(CLEAR_SPDY_SETTINGS);
 }
 
 void HttpServerPropertiesManager::ClearAllSpdySettings() {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   http_server_properties_impl_->ClearAllSpdySettings();
   ScheduleUpdatePrefsOnNetworkThread();
+  RecordUpdatePrefs(CLEAR_ALL_SPDY_SETTINGS);
 }
 
 const SpdySettingsMap& HttpServerPropertiesManager::spdy_settings_map()
     const {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->spdy_settings_map();
 }
 
 bool HttpServerPropertiesManager::GetSupportsQuic(
     IPAddressNumber* last_address) const {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->GetSupportsQuic(last_address);
 }
 
 void HttpServerPropertiesManager::SetSupportsQuic(
     bool used_quic,
     const IPAddressNumber& address) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   http_server_properties_impl_->SetSupportsQuic(used_quic, address);
   ScheduleUpdatePrefsOnNetworkThread();
+  RecordUpdatePrefs(SET_SUPPORTS_QUIC);
 }
 
 void HttpServerPropertiesManager::SetServerNetworkStats(
     const HostPortPair& host_port_pair,
     ServerNetworkStats stats) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   http_server_properties_impl_->SetServerNetworkStats(host_port_pair, stats);
   ScheduleUpdatePrefsOnNetworkThread();
+  RecordUpdatePrefs(SET_SERVER_NETWORK_STATS);

[mmenke, 2015/05/12 14:35:03]

Suggest making this an argument to ScheduleUpdatePrefsOnNetworkThread instead -
makes sure you catch all calls, and new callers add a histogram entry.

[ramant (doing other things), 2015/05/12 17:32:22]

Doh!.

Thanks and Done.

 }
 
 const ServerNetworkStats* HttpServerPropertiesManager::GetServerNetworkStats(
     const HostPortPair& host_port_pair) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->GetServerNetworkStats(host_port_pair);
 }
 
 const ServerNetworkStatsMap&
 HttpServerPropertiesManager::server_network_stats_map() const {
@@ skipping 312 matching lines @@
                        alternative_service_map->size());
   http_server_properties_impl_->InitializeAlternativeServiceServers(
       alternative_service_map);
 
   http_server_properties_impl_->InitializeSupportsQuic(last_quic_address);
 
   http_server_properties_impl_->InitializeServerNetworkStats(
       server_network_stats_map);
 
   // Update the prefs with what we have read (delete all corrupted prefs).
-  if (detected_corrupted_prefs)
+  if (detected_corrupted_prefs) {
     ScheduleUpdatePrefsOnNetworkThread();
+    RecordUpdatePrefs(DETECTED_CORRUPTED_PREFS);
+  }
 }
 
 //
 // Update Preferences with data from the cached data.
 //
 void HttpServerPropertiesManager::ScheduleUpdatePrefsOnNetworkThread() {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   // Cancel pending updates, if any.
   network_prefs_update_timer_->Stop();
   StartPrefsUpdateTimerOnNetworkThread(
@@ skipping 280 matching lines @@
                                             server_network_stats_dict);
 }
 
 void HttpServerPropertiesManager::OnHttpServerPropertiesChanged() {
   DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
   if (!setting_prefs_)
     ScheduleUpdateCacheOnPrefThread();
 }
 
 }  // namespace net