Move HttpStreamFactoryImpl::JobController UMA to a schedule upload

net/base/network_change_notifier.h

 // 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.
 
 #ifndef NET_BASE_NETWORK_CHANGE_NOTIFIER_H_
 #define NET_BASE_NETWORK_CHANGE_NOTIFIER_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 229 matching lines @@
     virtual void OnNetworkMadeDefault(NetworkHandle network) = 0;
 
    protected:
     NetworkObserver() {}
     virtual ~NetworkObserver() {}
 
    private:
     DISALLOW_COPY_AND_ASSIGN(NetworkObserver);
   };
 
+  // An interface that when implemented and added via AddMetricsObserver(),
+  // provides notifications when metrics are cut. The callback is called
+  // asynchronously on observer's thread.
+  class NET_EXPORT MetricsObserver {
+   public:
+    virtual void OnMetricsFinalize() = 0;
+
+   protected:
+    MetricsObserver() {}
+    virtual ~MetricsObserver() {}
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(MetricsObserver);
+  };
+
   // An invalid NetworkHandle.
   static const NetworkHandle kInvalidNetworkHandle;
 
   virtual ~NetworkChangeNotifier();
 
   // Replaces the default class factory instance of NetworkChangeNotifier class.
   // The method will take over the ownership of |factory| object.
   static void SetFactory(NetworkChangeNotifierFactory* factory);
 
   // Creates the process-wide, platform-specific NetworkChangeNotifier.  The
@@ skipping 112 matching lines @@
   // Registers |observer| to receive notifications of network changes.  The
   // thread on which this is called is the thread on which |observer| will be
   // called back with notifications.  This is safe to call if Create() has not
   // been called (as long as it doesn't race the Create() call on another
   // thread), in which case it will simply do nothing.
   static void AddIPAddressObserver(IPAddressObserver* observer);
   static void AddConnectionTypeObserver(ConnectionTypeObserver* observer);
   static void AddDNSObserver(DNSObserver* observer);
   static void AddNetworkChangeObserver(NetworkChangeObserver* observer);
   static void AddMaxBandwidthObserver(MaxBandwidthObserver* observer);
+  static void AddMetricsObserver(MetricsObserver* observer);
   static void AddNetworkObserver(NetworkObserver* observer);
 
   // Unregisters |observer| from receiving notifications.  This must be called
   // on the same thread on which AddObserver() was called.  Like AddObserver(),
   // this is safe to call if Create() has not been called (as long as it doesn't
   // race the Create() call on another thread), in which case it will simply do
   // nothing.  Technically, it's also safe to call after the notifier object has
   // been destroyed, if the call doesn't race the notifier's destruction, but
   // there's no reason to use the API in this risky way, so don't do it.
   static void RemoveIPAddressObserver(IPAddressObserver* observer);
@@ skipping 118 matching lines @@
       double* max_bandwidth_mbps,
       ConnectionType* connection_type) const;
   virtual bool AreNetworkHandlesCurrentlySupported() const;
   virtual void GetCurrentConnectedNetworks(NetworkList* network_list) const;
   virtual ConnectionType GetCurrentNetworkConnectionType(
       NetworkHandle network) const;
   virtual NetworkHandle GetCurrentDefaultNetwork() const;
 
   // Hook that allows derived implementations to log histograms at the time a
   // new histogram record is being finalized.
-  virtual void OnFinalizingMetricsLogRecord() {}
+  virtual void OnFinalizingMetricsLogRecord();
 
   // Broadcasts a notification to all registered observers.  Note that this
   // happens asynchronously, even for observers on the current thread, even in
   // tests.
   static void NotifyObserversOfIPAddressChange();
   static void NotifyObserversOfConnectionTypeChange();
   static void NotifyObserversOfDNSChange();
   static void NotifyObserversOfInitialDNSConfigRead();
   static void NotifyObserversOfNetworkChange(ConnectionType type);
   static void NotifyObserversOfMaxBandwidthChange(double max_bandwidth_mbps,
@@ skipping 16 matching lines @@
   class NetworkState;
   class NetworkChangeCalculator;
 
   void NotifyObserversOfIPAddressChangeImpl();
   void NotifyObserversOfConnectionTypeChangeImpl(ConnectionType type);
   void NotifyObserversOfDNSChangeImpl();
   void NotifyObserversOfInitialDNSConfigReadImpl();
   void NotifyObserversOfNetworkChangeImpl(ConnectionType type);
   void NotifyObserversOfMaxBandwidthChangeImpl(double max_bandwidth_mbps,
                                                ConnectionType type);
+  void NotifyObserversOfMetricsOnFinalize();
+
   void NotifyObserversOfSpecificNetworkChangeImpl(NetworkChangeType type,
                                                   NetworkHandle network);
 
   const scoped_refptr<base::ObserverListThreadSafe<IPAddressObserver>>
       ip_address_observer_list_;
   const scoped_refptr<base::ObserverListThreadSafe<ConnectionTypeObserver>>
       connection_type_observer_list_;
   const scoped_refptr<base::ObserverListThreadSafe<DNSObserver>>
       resolver_state_observer_list_;
   const scoped_refptr<base::ObserverListThreadSafe<NetworkChangeObserver>>
       network_change_observer_list_;
   const scoped_refptr<base::ObserverListThreadSafe<MaxBandwidthObserver>>
       max_bandwidth_observer_list_;
   const scoped_refptr<base::ObserverListThreadSafe<NetworkObserver>>
       network_observer_list_;
+  const scoped_refptr<base::ObserverListThreadSafe<MetricsObserver>>
+      metrics_observer_list_;
 
   // The current network state. Hosts DnsConfig, exposed via GetDnsConfig.
   std::unique_ptr<NetworkState> network_state_;
 
   // A little-piggy-back observer that simply logs UMA histogram data.
   std::unique_ptr<HistogramWatcher> histogram_watcher_;
 
   // Computes NetworkChange signal from IPAddress and ConnectionType signals.
   std::unique_ptr<NetworkChangeCalculator> network_change_calculator_;
 
   // Set true to disable non-test notifications (to prevent flakes in tests).
   static bool test_notifications_only_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkChangeNotifier);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_NETWORK_CHANGE_NOTIFIER_H_