Make NQE a derived class of NetworkQualityProvider

chrome/browser/net/nqe/ui_network_quality_estimator_service.cc

 // Copyright 2016 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 "chrome/browser/net/nqe/ui_network_quality_estimator_service.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/threading/thread_checker.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/io_thread.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
 #include "components/prefs/pref_registry.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "components/variations/variations_associated_data.h"
 #include "content/public/browser/browser_thread.h"
+#include "net/nqe/effective_connection_type_observer.h"
 #include "net/nqe/network_qualities_prefs_manager.h"
 #include "net/nqe/network_quality.h"
+#include "net/nqe/rtt_throughput_estimates_observer.h"
 
 namespace {
 
 // PrefDelegateImpl writes the provided dictionary value to the network quality
 // estimator prefs on the disk.
 class PrefDelegateImpl
     : public net::NetworkQualitiesPrefsManager::PrefDelegate {
  public:
   // |pref_service| is used to read and write prefs from/to the disk.
   explicit PrefDelegateImpl(PrefService* pref_service)
@@ skipping 39 matching lines @@
       io_thread->globals()->network_quality_estimator.get());
 }
 
 }  // namespace
 
 // A class that sets itself as an observer of the EffectiveconnectionType for
 // the browser IO thread. It reports any change in EffectiveConnectionType back
 // to the UI service.
 // It is created on the UI thread, but used and deleted on the IO thread.
 class UINetworkQualityEstimatorService::IONetworkQualityObserver
-    : public net::NetworkQualityEstimator::EffectiveConnectionTypeObserver,
-      public net::NetworkQualityEstimator::RTTAndThroughputEstimatesObserver {
+    : public net::EffectiveConnectionTypeObserver,
+      public net::RTTAndThroughputEstimatesObserver {
  public:
   explicit IONetworkQualityObserver(
       base::WeakPtr<UINetworkQualityEstimatorService> service)
       : service_(service), network_quality_estimator_(nullptr) {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   }
 
   ~IONetworkQualityObserver() override {
     DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
     if (network_quality_estimator_) {
@@ skipping 118 matching lines @@
   transport_rtt_ = transport_rtt;
   downstream_throughput_kbps_ = downstream_throughput_kbps;
 
   for (auto& observer : rtt_throughput_observer_list_) {
     observer.OnRTTOrThroughputEstimatesComputed(http_rtt, transport_rtt,
                                                 downstream_throughput_kbps);
   }
 }
 
 void UINetworkQualityEstimatorService::AddEffectiveConnectionTypeObserver(
-    net::NetworkQualityEstimator::EffectiveConnectionTypeObserver* observer) {
+    net::EffectiveConnectionTypeObserver* observer) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   effective_connection_type_observer_list_.AddObserver(observer);
 
   // Notify the |observer| on the next message pump since |observer| may not
   // be completely set up for receiving the callbacks.
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
       base::BindOnce(&UINetworkQualityEstimatorService::
                          NotifyEffectiveConnectionTypeObserverIfPresent,
                      weak_factory_.GetWeakPtr(), observer));
 }
 
 void UINetworkQualityEstimatorService::RemoveEffectiveConnectionTypeObserver(
-    net::NetworkQualityEstimator::EffectiveConnectionTypeObserver* observer) {
+    net::EffectiveConnectionTypeObserver* observer) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   effective_connection_type_observer_list_.RemoveObserver(observer);
 }
 
 base::Optional<base::TimeDelta> UINetworkQualityEstimatorService::GetHttpRTT()
     const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   if (http_rtt_ == net::nqe::internal::InvalidRTT())
     return base::Optional<base::TimeDelta>();
@@ skipping 12 matching lines @@
 base::Optional<int32_t>
 UINetworkQualityEstimatorService::GetDownstreamThroughputKbps() const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   if (downstream_throughput_kbps_ == net::nqe::internal::kInvalidThroughput)
     return base::Optional<int32_t>();
   return downstream_throughput_kbps_;
 }
 
 void UINetworkQualityEstimatorService::AddRTTAndThroughputEstimatesObserver(
-    net::NetworkQualityEstimator::RTTAndThroughputEstimatesObserver* observer) {
+    net::RTTAndThroughputEstimatesObserver* observer) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   rtt_throughput_observer_list_.AddObserver(observer);
 
   // Notify the |observer| on the next message pump since |observer| may not
   // be completely set up for receiving the callbacks.
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
       base::BindOnce(&UINetworkQualityEstimatorService::
                          NotifyRTTAndThroughputObserverIfPresent,
                      weak_factory_.GetWeakPtr(), observer));
 }
 
 // Removes |observer| from the list of RTT and throughput estimate observers.
 // Must be called on the IO thread.
 void UINetworkQualityEstimatorService::RemoveRTTAndThroughputEstimatesObserver(
-    net::NetworkQualityEstimator::RTTAndThroughputEstimatesObserver* observer) {
+    net::RTTAndThroughputEstimatesObserver* observer) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   rtt_throughput_observer_list_.RemoveObserver(observer);
 }
 
 void UINetworkQualityEstimatorService::SetEffectiveConnectionTypeForTesting(
     net::EffectiveConnectionType type) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   EffectiveConnectionTypeChanged(type);
 }
 
 net::EffectiveConnectionType
 UINetworkQualityEstimatorService::GetEffectiveConnectionType() const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   return type_;
 }
 
 void UINetworkQualityEstimatorService::ClearPrefs() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (!prefs_manager_)
     return;
   prefs_manager_->ClearPrefs();
 }
 
 void UINetworkQualityEstimatorService::
     NotifyEffectiveConnectionTypeObserverIfPresent(
-        net::NetworkQualityEstimator::EffectiveConnectionTypeObserver* observer)
-        const {
+        net::EffectiveConnectionTypeObserver* observer) const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   if (!effective_connection_type_observer_list_.HasObserver(observer))
     return;
   if (type_ == net::EFFECTIVE_CONNECTION_TYPE_UNKNOWN)
     return;
   observer->OnEffectiveConnectionTypeChanged(type_);
 }
 
 void UINetworkQualityEstimatorService::NotifyRTTAndThroughputObserverIfPresent(
-    net::NetworkQualityEstimator::RTTAndThroughputEstimatesObserver* observer)
-    const {
+    net::RTTAndThroughputEstimatesObserver* observer) const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   if (!rtt_throughput_observer_list_.HasObserver(observer))
     return;
   observer->OnRTTOrThroughputEstimatesComputed(http_rtt_, transport_rtt_,
                                                downstream_throughput_kbps_);
 }
 
 // static
 void UINetworkQualityEstimatorService::RegisterProfilePrefs(
     PrefRegistrySimple* registry) {
   registry->RegisterDictionaryPref(prefs::kNetworkQualities,
                                    PrefRegistry::LOSSY_PREF);
 }
 
 std::map<net::nqe::internal::NetworkID,
          net::nqe::internal::CachedNetworkQuality>
 UINetworkQualityEstimatorService::ForceReadPrefsForTesting() const {
   if (!prefs_manager_) {
     return std::map<net::nqe::internal::NetworkID,
                     net::nqe::internal::CachedNetworkQuality>();
   }
   return prefs_manager_->ForceReadPrefsForTesting();
 }