NQE servicification of UKM page load metrics

Use network quality tracker instead of network quality estimator (NQE)
in UKM page load metrics.

Network quality tracker can provide network service when network
service is enabled as well as when network service is disabled.

Cq-Include-Trybots: luci.chromium.try:linux_mojo
Change-Id: Icffe39d2ae493934456ff911290bc50d53efab49
Bug: 819244
Reviewed-on: https://chromium-review.googlesource.com/1177199
Commit-Queue: Tarun Bansal <tbansal@chromium.org>
Reviewed-by: Helen Li <xunjieli@chromium.org>
Reviewed-by: Charlie Harrison <csharrison@chromium.org>
Cr-Commit-Position: refs/heads/master@{#583873}

chrome/browser/page_load_metrics/observers/ukm_page_load_metrics_observer.cc

@@ -7,44 +7,30 @@
 #include <memory>
 
 #include "chrome/browser/browser_process.h"
-#include "chrome/browser/net/nqe/ui_network_quality_estimator_service.h"
-#include "chrome/browser/net/nqe/ui_network_quality_estimator_service_factory.h"
 #include "chrome/browser/page_load_metrics/page_load_metrics_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "components/metrics/net/network_metrics_provider.h"
-#include "content/public/browser/web_contents.h"
 #include "services/metrics/public/cpp/metrics_utils.h"
 #include "services/metrics/public/cpp/ukm_builders.h"
 #include "services/metrics/public/cpp/ukm_recorder.h"
+#include "services/network/public/cpp/network_quality_tracker.h"
 #include "third_party/metrics_proto/system_profile.pb.h"
 
-namespace {
-
-UINetworkQualityEstimatorService* GetNQEService(
-    content::WebContents* web_contents) {
-  Profile* profile =
-      Profile::FromBrowserContext(web_contents->GetBrowserContext());
-  if (!profile)
-    return nullptr;
-  return UINetworkQualityEstimatorServiceFactory::GetForProfile(profile);
-}
-
-}  // namespace
-
 // static
 std::unique_ptr<page_load_metrics::PageLoadMetricsObserver>
-UkmPageLoadMetricsObserver::CreateIfNeeded(content::WebContents* web_contents) {
+UkmPageLoadMetricsObserver::CreateIfNeeded() {
   if (!ukm::UkmRecorder::Get()) {
     return nullptr;
   }
   return std::make_unique<UkmPageLoadMetricsObserver>(
-      GetNQEService(web_contents));
+      g_browser_process->network_quality_tracker());
 }
 
 UkmPageLoadMetricsObserver::UkmPageLoadMetricsObserver(
-    net::NetworkQualityEstimator::NetworkQualityProvider*
-        network_quality_provider)
-    : network_quality_provider_(network_quality_provider) {}
+    network::NetworkQualityTracker* network_quality_tracker)
+    : network_quality_tracker_(network_quality_tracker) {
+  DCHECK(network_quality_tracker_);
+}
 
 UkmPageLoadMetricsObserver::~UkmPageLoadMetricsObserver() = default;
 
@@ -62,14 +48,12 @@ UkmPageLoadMetricsObserver::ObservePolicy UkmPageLoadMetricsObserver::OnStart(
   // record UKM metrics for that data once we've confirmed that we're observing
   // a web page load.
 
-  if (network_quality_provider_) {
   effective_connection_type_ =
-        network_quality_provider_->GetEffectiveConnectionType();
-    http_rtt_estimate_ = network_quality_provider_->GetHttpRTT();
-    transport_rtt_estimate_ = network_quality_provider_->GetTransportRTT();
+      network_quality_tracker_->GetEffectiveConnectionType();
+  http_rtt_estimate_ = network_quality_tracker_->GetHttpRTT();
+  transport_rtt_estimate_ = network_quality_tracker_->GetTransportRTT();
   downstream_kbps_estimate_ =
-        network_quality_provider_->GetDownstreamThroughputKbps();
-  }
+      network_quality_tracker_->GetDownstreamThroughputKbps();
   page_transition_ = navigation_handle->GetPageTransition();
   return CONTINUE_OBSERVING;
 }

chrome/browser/page_load_metrics/observers/ukm_page_load_metrics_observer.h

@@ -10,11 +10,10 @@
 #include "base/time/time.h"
 #include "chrome/browser/page_load_metrics/page_load_metrics_observer.h"
 #include "components/ukm/ukm_source.h"
-#include "net/nqe/network_quality_estimator.h"
 #include "ui/base/page_transition_types.h"
 
-namespace content {
-class WebContents;
+namespace network {
+class NetworkQualityTracker;
 }
 
 // If URL-Keyed-Metrics (UKM) is enabled in the system, this is used to
@@ -24,11 +23,10 @@ class UkmPageLoadMetricsObserver
  public:
   // Returns a UkmPageLoadMetricsObserver, or nullptr if it is not needed.
   static std::unique_ptr<page_load_metrics::PageLoadMetricsObserver>
-  CreateIfNeeded(content::WebContents* web_contents);
+  CreateIfNeeded();
 
   explicit UkmPageLoadMetricsObserver(
-      net::NetworkQualityEstimator::NetworkQualityProvider*
-          network_quality_provider);
+      network::NetworkQualityTracker* network_quality_tracker);
   ~UkmPageLoadMetricsObserver() override;
 
   // page_load_metrics::PageLoadMetricsObserver implementation:
@@ -71,8 +69,8 @@ class UkmPageLoadMetricsObserver
       const page_load_metrics::PageLoadExtraInfo& info,
       base::TimeTicks app_background_time);
 
-  net::NetworkQualityEstimator::NetworkQualityProvider* const
-      network_quality_provider_;
+  // Guaranteed to be non-null during the lifetime of |this|.
+  network::NetworkQualityTracker* network_quality_tracker_;
 
   // The number of body (not header) prefilter bytes consumed by requests for
   // the page.

chrome/browser/page_load_metrics/observers/ukm_page_load_metrics_observer_unittest.cc

@@ -15,9 +15,9 @@
 #include "components/ukm/ukm_source.h"
 #include "content/public/test/navigation_simulator.h"
 #include "net/nqe/effective_connection_type.h"
-#include "net/nqe/network_quality_provider.h"
 #include "services/metrics/public/cpp/metrics_utils.h"
 #include "services/metrics/public/cpp/ukm_builders.h"
+#include "services/network/public/cpp/network_quality_tracker.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "third_party/metrics_proto/system_profile.pb.h"
 
@@ -32,13 +32,13 @@ using PageLoad = ukm::builders::PageLoad;
 const char kTestUrl1[] = "https://www.google.com/";
 const char kTestUrl2[] = "https://www.example.com/";
 
-class MockNetworkQualityProvider : public net::NetworkQualityProvider {
+class MockNetworkQualityProvider : public network::NetworkQualityTracker {
  public:
   MOCK_CONST_METHOD0(GetEffectiveConnectionType,
                      net::EffectiveConnectionType());
-  MOCK_CONST_METHOD0(GetHttpRTT, base::Optional<base::TimeDelta>());
-  MOCK_CONST_METHOD0(GetTransportRTT, base::Optional<base::TimeDelta>());
-  MOCK_CONST_METHOD0(GetDownstreamThroughputKbps, base::Optional<int32_t>());
+  MOCK_CONST_METHOD0(GetHttpRTT, base::TimeDelta());
+  MOCK_CONST_METHOD0(GetTransportRTT, base::TimeDelta());
+  MOCK_CONST_METHOD0(GetDownstreamThroughputKbps, int32_t());
 };
 
 }  // namespace
@@ -60,15 +60,15 @@ class UkmPageLoadMetricsObserverTest
 
     EXPECT_CALL(mock_network_quality_provider_, GetHttpRTT())
         .Times(AnyNumber())
-        .WillRepeatedly(Return(base::Optional<base::TimeDelta>()));
+        .WillRepeatedly(Return(base::TimeDelta()));
 
     EXPECT_CALL(mock_network_quality_provider_, GetTransportRTT())
         .Times(AnyNumber())
-        .WillRepeatedly(Return(base::Optional<base::TimeDelta>()));
+        .WillRepeatedly(Return(base::TimeDelta()));
 
     EXPECT_CALL(mock_network_quality_provider_, GetDownstreamThroughputKbps())
         .Times(AnyNumber())
-        .WillRepeatedly(Return(base::Optional<int32_t>()));
+        .WillRepeatedly(Return(int32_t()));
   }
 
   MockNetworkQualityProvider& mock_network_quality_provider() {

chrome/browser/page_load_metrics/page_load_metrics_initialize.cc

@@ -127,7 +127,7 @@ void PageLoadMetricsEmbedder::RegisterObservers(
       tracker->AddObserver(std::move(ads_observer));
 
     std::unique_ptr<page_load_metrics::PageLoadMetricsObserver> ukm_observer =
-        UkmPageLoadMetricsObserver::CreateIfNeeded(web_contents_);
+        UkmPageLoadMetricsObserver::CreateIfNeeded();
     if (ukm_observer)
       tracker->AddObserver(std::move(ukm_observer));
 

services/network/public/cpp/network_quality_tracker.h

@@ -76,21 +76,21 @@ class COMPONENT_EXPORT(NETWORK_CPP) NetworkQualityTracker
   ~NetworkQualityTracker() override;
 
   // Returns the current estimate of the effective connection type.
-  net::EffectiveConnectionType GetEffectiveConnectionType() const;
+  virtual net::EffectiveConnectionType GetEffectiveConnectionType() const;
 
   // Returns the current HTTP RTT estimate. The RTT at the HTTP layer measures
   // the time from when the request was sent (this happens after the connection
   // is established) to the time when the response headers were received.
-  base::TimeDelta GetHttpRTT() const;
+  virtual base::TimeDelta GetHttpRTT() const;
 
   // Returns the current transport-layer RTT estimate. The RTT at the transport
   // layer provides an aggregate estimate of the transport RTT as computed by
   // various underlying TCP and QUIC connections.
-  base::TimeDelta GetTransportRTT() const;
+  virtual base::TimeDelta GetTransportRTT() const;
 
   // Returns the current downstream throughput estimate (in kilobits per
   // second).
-  int32_t GetDownstreamThroughputKbps() const;
+  virtual int32_t GetDownstreamThroughputKbps() const;
 
   // Registers |observer| to receive notifications of network changes. The
   // thread on which this is called is the thread on which |observer| will be