Move HttpStreamFactoryImpl::JobController UMA to a schedule upload

net/base/network_change_notifier.cc

 // Copyright (c) 2012 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/base/network_change_notifier.h"
 
 #include <limits>
 #include <unordered_set>
 
 #include "base/macros.h"
@@ skipping 724 matching lines @@
 void NetworkChangeNotifier::ShutdownHistogramWatcher() {
   if (!g_network_change_notifier)
     return;
   g_network_change_notifier->histogram_watcher_.reset();
 }
 
 // static
 void NetworkChangeNotifier::FinalizingMetricsLogRecord() {
   if (!g_network_change_notifier)
     return;
-  g_network_change_notifier->OnFinalizingMetricsLogRecord();
+  g_network_change_notifier->NotifyObserversOfMetricsOnFinalize();
 }
 
 // static
 void NetworkChangeNotifier::LogOperatorCodeHistogram(ConnectionType type) {
 #if defined(OS_ANDROID)
   // On a connection type change to cellular, log the network operator MCC/MNC.
   // Log zero in other cases.
   unsigned mcc_mnc = 0;
   if (NetworkChangeNotifier::IsConnectionCellular(type)) {
     // Log zero if not perfectly converted.
@@ skipping 153 matching lines @@
   }
 }
 
 void NetworkChangeNotifier::RemoveNetworkObserver(NetworkObserver* observer) {
   DCHECK(AreNetworkHandlesSupported());
   if (g_network_change_notifier) {
     g_network_change_notifier->network_observer_list_->RemoveObserver(observer);
   }
 }
 
+void NetworkChangeNotifier::AddMetricsObserver(MetricsObserver* observer) {
+  if (g_network_change_notifier) {
+    g_network_change_notifier->metrics_observer_list_->AddObserver(observer);
+  }
+}
+
 // static
 void NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests() {
   if (g_network_change_notifier)
     g_network_change_notifier->NotifyObserversOfIPAddressChangeImpl();
 }
 
 // static
 void NetworkChangeNotifier::NotifyObserversOfConnectionTypeChangeForTests(
     ConnectionType type) {
   if (g_network_change_notifier)
@@ skipping 49 matching lines @@
           new base::ObserverListThreadSafe<DNSObserver>(
               base::ObserverListBase<DNSObserver>::NOTIFY_EXISTING_ONLY)),
       network_change_observer_list_(new base::ObserverListThreadSafe<
                                     NetworkChangeObserver>(
           base::ObserverListBase<NetworkChangeObserver>::NOTIFY_EXISTING_ONLY)),
       max_bandwidth_observer_list_(new base::ObserverListThreadSafe<
                                    MaxBandwidthObserver>(
           base::ObserverListBase<MaxBandwidthObserver>::NOTIFY_EXISTING_ONLY)),
       network_observer_list_(new base::ObserverListThreadSafe<NetworkObserver>(
           base::ObserverListBase<NetworkObserver>::NOTIFY_EXISTING_ONLY)),
+      metrics_observer_list_(new base::ObserverListThreadSafe<MetricsObserver>(
+          base::ObserverListBase<MetricsObserver>::NOTIFY_EXISTING_ONLY)),
       network_state_(new NetworkState()),
       network_change_calculator_(new NetworkChangeCalculator(params)) {
   DCHECK(!g_network_change_notifier);
   g_network_change_notifier = this;
   network_change_calculator_->Init();
 }
 
 #if defined(OS_LINUX)
 const internal::AddressTrackerLinux*
 NetworkChangeNotifier::GetAddressTrackerInternal() const {
@@ skipping 32 matching lines @@
 NetworkChangeNotifier::GetCurrentNetworkConnectionType(
     NetworkHandle network) const {
   return CONNECTION_UNKNOWN;
 }
 
 NetworkChangeNotifier::NetworkHandle
 NetworkChangeNotifier::GetCurrentDefaultNetwork() const {
   return kInvalidNetworkHandle;
 }
 
+void NetworkChangeNotifier::OnFinalizingMetricsLogRecord() {
+  if (g_network_change_notifier &&
+      !NetworkChangeNotifier::test_notifications_only_) {
+    g_network_change_notifier->NotifyObserversOfMetricsOnFinalize();
+  }
+}
+
 // static
 void NetworkChangeNotifier::NotifyObserversOfIPAddressChange() {
   if (g_network_change_notifier &&
       !NetworkChangeNotifier::test_notifications_only_) {
     g_network_change_notifier->NotifyObserversOfIPAddressChangeImpl();
   }
 }
 
 // static
 void NetworkChangeNotifier::NotifyObserversOfConnectionTypeChange() {
@@ skipping 100 matching lines @@
 }
 
 void NetworkChangeNotifier::NotifyObserversOfMaxBandwidthChangeImpl(
     double max_bandwidth_mbps,
     ConnectionType type) {
   max_bandwidth_observer_list_->Notify(
       FROM_HERE, &MaxBandwidthObserver::OnMaxBandwidthChanged,
       max_bandwidth_mbps, type);
 }
 
+void NetworkChangeNotifier::NotifyObserversOfMetricsOnFinalize() {
+  metrics_observer_list_->Notify(FROM_HERE,
+                                 &MetricsObserver::OnMetricsFinalize);
+}
+
 void NetworkChangeNotifier::NotifyObserversOfSpecificNetworkChangeImpl(
     NetworkChangeType type,
     NetworkHandle network) {
   switch (type) {
     case CONNECTED:
       network_observer_list_->Notify(
           FROM_HERE, &NetworkObserver::OnNetworkConnected, network);
       break;
     case DISCONNECTED:
       network_observer_list_->Notify(
@@ skipping 18 matching lines @@
 
 NetworkChangeNotifier::DisableForTest::~DisableForTest() {
   DCHECK(!g_network_change_notifier);
   g_network_change_notifier = network_change_notifier_;
 }
 
 void NetworkChangeNotifier::DNSObserver::OnInitialDNSConfigRead() {
 }
 
 }  // namespace net