Revert "Reland: Network Service: Migrate NetworkMetricsProvider to NetworkConnectionTracker"

This reverts commit 0df82fcd.

Reason for revert: The Builder linux64 trunk keeps failing due to ChromeBrowserMainBrowserTest.VariationsServiceStartsRequestOnNetworkChange browser test.
https://bugs.chromium.org/p/chromium/issues/detail?id=902784

Bug: 902784, 883121

Original change's description:
> Reland: Network Service: Migrate NetworkMetricsProvider to NetworkConnectionTracker
> 
> The "Initial upload" patch of this CL is the same as:
> https://chromium-review.googlesource.com/c/chromium/src/+/1274585
> 
> The above original CL was reverted at:
> https://chromium-review.googlesource.com/c/chromium/src/+/1319614
> 
> The major changes since the "Initial upload" patch set 1:
> Removed some unnecessary include files and removed the "//services/network/public/cpp"
> dep from "components/metrics/BUILD.gn". These include files and dep caused the
> build error Cronet for Android.
> 
> TBR=olivierrobin@chromium.org, michaelbai@chromium.org, jam@chromium.org, fdoray@chromium.org, asvitkine@chromium.org
> 
> Bug: 883121
> Change-Id: Ifcaf40ea1b72ddc3a6a72be16e4d52190740e5a4
> Reviewed-on: https://chromium-review.googlesource.com/c/1320710
> Reviewed-by: Jun Cai <juncai@chromium.org>
> Commit-Queue: Jun Cai <juncai@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#605899}

TBR=michaelbai@chromium.org,jam@chromium.org,fdoray@chromium.org,asvitkine@chromium.org,olivierrobin@chromium.org,juncai@chromium.org

Change-Id: I37832c49552e6d163439d719d5820e1811ccadcb
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: 883121
Reviewed-on: https://chromium-review.googlesource.com/c/1324104Reviewed-by: Jun Cai <juncai@chromium.org>
Commit-Queue: Jun Cai <juncai@chromium.org>
Cr-Commit-Position: refs/heads/master@{#606136}

android_webview/browser/aw_metrics_service_client.cc

@@ -32,7 +32,6 @@
 #include "components/metrics/metrics_pref_names.h"
 #include "components/metrics/metrics_service.h"
 #include "components/metrics/metrics_state_manager.h"
-#include "components/metrics/net/network_metrics_provider.h"
 #include "components/metrics/ui/screen_info_metrics_provider.h"
 #include "components/metrics/url_constants.h"
 #include "components/metrics/version_utils.h"
@@ -40,7 +39,6 @@
 #include "components/version_info/android/channel_getter.h"
 #include "components/version_info/version_info.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/network_service_instance.h"
 
 namespace android_webview {
 
@@ -169,8 +167,7 @@ void AwMetricsServiceClient::InitializeWithClientId() {
 
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(
-          new metrics::NetworkMetricsProvider(
-              content::CreateNetworkConnectionTrackerAsyncGetter())));
+          new metrics::NetworkMetricsProvider));
 
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(

chrome/browser/metrics/chrome_metrics_service_client.cc

@@ -90,7 +90,6 @@
 #include "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/histogram_fetcher.h"
-#include "content/public/browser/network_service_instance.h"
 #include "content/public/browser/notification_service.h"
 #include "ppapi/buildflags/buildflags.h"
 #include "printing/buildflags/buildflags.h"
@@ -607,7 +606,6 @@ void ChromeMetricsServiceClient::RegisterMetricsServiceProviders() {
 
   metrics_service_->RegisterMetricsProvider(
       std::make_unique<metrics::NetworkMetricsProvider>(
-          content::CreateNetworkConnectionTrackerAsyncGetter(),
           std::make_unique<metrics::NetworkQualityEstimatorProviderImpl>()));
 
   // Currently, we configure OmniboxMetricsProvider to not log events to UMA
@@ -729,7 +727,6 @@ void ChromeMetricsServiceClient::RegisterMetricsServiceProviders() {
 void ChromeMetricsServiceClient::RegisterUKMProviders() {
   ukm_service_->RegisterMetricsProvider(
       std::make_unique<metrics::NetworkMetricsProvider>(
-          content::CreateNetworkConnectionTrackerAsyncGetter(),
           std::make_unique<metrics::NetworkQualityEstimatorProviderImpl>()));
 
 #if defined(OS_CHROMEOS)

chromecast/browser/metrics/cast_metrics_service_client.cc

@@ -35,7 +35,6 @@
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/histogram_fetcher.h"
-#include "content/public/browser/network_service_instance.h"
 #include "content/public/common/content_switches.h"
 #include "services/network/public/cpp/shared_url_loader_factory.h"
 
@@ -356,8 +355,7 @@ void CastMetricsServiceClient::Initialize() {
             new ::metrics::ScreenInfoMetricsProvider));
   }
   metrics_service_->RegisterMetricsProvider(
-      std::make_unique<::metrics::NetworkMetricsProvider>(
-          content::CreateNetworkConnectionTrackerAsyncGetter()));
+      std::make_unique<::metrics::NetworkMetricsProvider>());
   shell::CastBrowserProcess::GetInstance()->browser_client()->
       RegisterMetricsProviders(metrics_service_.get());
 

components/metrics/BUILD.gn

@@ -430,10 +430,6 @@ source_set("unit_tests") {
   if (is_ios) {
     sources -= [ "child_call_stack_profile_collector_unittest.cc" ]
   }
-
-  if (!is_ios) {
-    deps += [ "//content/test:test_support" ]
-  }
 }
 
 # Convenience testing target

components/metrics/metrics_service.h

@@ -33,6 +33,7 @@
 #include "components/metrics/metrics_log_store.h"
 #include "components/metrics/metrics_provider.h"
 #include "components/metrics/metrics_reporting_service.h"
+#include "components/metrics/net/network_metrics_provider.h"
 #include "components/variations/synthetic_trial_registry.h"
 
 class PrefService;

components/metrics/net/DEPS

@@ -4,7 +4,6 @@ include_rules = [
   "+components/data_use_measurement/core",
   "+components/encrypted_messages",
   "+components/variations",
-  "+content/public/test/test_browser_thread_bundle.h",
   "+net",
   "+services/network/public/cpp",
   "+services/network/test",

components/metrics/net/network_metrics_provider.cc

@@ -55,14 +55,10 @@ ConvertEffectiveConnectionType(
 }
 
 NetworkMetricsProvider::NetworkMetricsProvider(
-    network::NetworkConnectionTrackerAsyncGetter
-        network_connection_tracker_async_getter,
     std::unique_ptr<NetworkQualityEstimatorProvider>
         network_quality_estimator_provider)
-    : network_connection_tracker_(nullptr),
-      connection_type_is_ambiguous_(false),
-      connection_type_(network::mojom::ConnectionType::CONNECTION_UNKNOWN),
-      network_connection_tracker_initialized_(false),
+    : connection_type_is_ambiguous_(false),
+      network_change_notifier_initialized_(false),
       wifi_phy_layer_protocol_is_ambiguous_(false),
       wifi_phy_layer_protocol_(net::WIFI_PHY_LAYER_PROTOCOL_UNKNOWN),
       total_aborts_(0),
@@ -73,9 +69,11 @@ NetworkMetricsProvider::NetworkMetricsProvider(
       min_effective_connection_type_(net::EFFECTIVE_CONNECTION_TYPE_UNKNOWN),
       max_effective_connection_type_(net::EFFECTIVE_CONNECTION_TYPE_UNKNOWN),
       weak_ptr_factory_(this) {
-  network_connection_tracker_async_getter.Run(
-      base::BindOnce(&NetworkMetricsProvider::SetNetworkConnectionTracker,
-                     weak_ptr_factory_.GetWeakPtr()));
+  net::NetworkChangeNotifier::AddNetworkChangeObserver(this);
+  connection_type_ = net::NetworkChangeNotifier::GetConnectionType();
+  if (connection_type_ != net::NetworkChangeNotifier::CONNECTION_UNKNOWN)
+    network_change_notifier_initialized_ = true;
+
   ProbeWifiPHYLayerProtocol();
 
   if (network_quality_estimator_provider_) {
@@ -90,21 +88,7 @@ NetworkMetricsProvider::NetworkMetricsProvider(
 
 NetworkMetricsProvider::~NetworkMetricsProvider() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  if (network_connection_tracker_)
-    network_connection_tracker_->RemoveNetworkConnectionObserver(this);
-}
-
-void NetworkMetricsProvider::SetNetworkConnectionTracker(
-    network::NetworkConnectionTracker* network_connection_tracker) {
-  DCHECK(network_connection_tracker);
-  network_connection_tracker_ = network_connection_tracker;
-  network_connection_tracker_->AddNetworkConnectionObserver(this);
-  network_connection_tracker_->GetConnectionType(
-      &connection_type_,
-      base::BindOnce(&NetworkMetricsProvider::OnConnectionChanged,
-                     weak_ptr_factory_.GetWeakPtr()));
-  if (connection_type_ != network::mojom::ConnectionType::CONNECTION_UNKNOWN)
-    network_connection_tracker_initialized_ = true;
+  net::NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
 }
 
 void NetworkMetricsProvider::ProvideCurrentSessionData(
@@ -120,7 +104,7 @@ void NetworkMetricsProvider::ProvideSystemProfileMetrics(
     SystemProfileProto* system_profile) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!connection_type_is_ambiguous_ ||
-         network_connection_tracker_initialized_);
+         network_change_notifier_initialized_);
   SystemProfileProto::Network* network = system_profile->mutable_network();
   network->set_connection_type_is_ambiguous(connection_type_is_ambiguous_);
   network->set_connection_type(GetConnectionType());
@@ -133,21 +117,13 @@ void NetworkMetricsProvider::ProvideSystemProfileMetrics(
   network->set_max_effective_connection_type(
       ConvertEffectiveConnectionType(max_effective_connection_type_));
 
-  // Note: We get the initial connection type when it becomes available and it
-  // is handled at SetNetworkConnectionTracker() when GetConnectionType() is
-  // called.
-  //
   // Update the connection type. Note that this is necessary to set the network
   // type to "none" if there is no network connection for an entire UMA logging
   // window, since OnConnectionTypeChanged() ignores transitions to the "none"
-  // state, and that is ok since it just deals with the current known state.
-  if (network_connection_tracker_) {
-    network_connection_tracker_->GetConnectionType(&connection_type_,
-                                                   base::DoNothing());
-  }
-
-  if (connection_type_ != network::mojom::ConnectionType::CONNECTION_UNKNOWN)
-    network_connection_tracker_initialized_ = true;
+  // state.
+  connection_type_ = net::NetworkChangeNotifier::GetConnectionType();
+  if (connection_type_ != net::NetworkChangeNotifier::CONNECTION_UNKNOWN)
+    network_change_notifier_initialized_ = true;
   // Reset the "ambiguous" flags, since a new metrics log session has started.
   connection_type_is_ambiguous_ = false;
   wifi_phy_layer_protocol_is_ambiguous_ = false;
@@ -170,8 +146,8 @@ void NetworkMetricsProvider::ProvideSystemProfileMetrics(
     WriteWifiAccessPointProto(info, network);
 }
 
-void NetworkMetricsProvider::OnConnectionChanged(
-    network::mojom::ConnectionType type) {
+void NetworkMetricsProvider::OnNetworkChanged(
+    net::NetworkChangeNotifier::ConnectionType type) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   // To avoid reporting an ambiguous connection type for users on flaky
   // connections, ignore transitions to the "none" state. Note that the
@@ -179,27 +155,26 @@ void NetworkMetricsProvider::OnConnectionChanged(
   // new UMA logging window begins, so users who genuinely transition to offline
   // mode for an extended duration will still be at least partially represented
   // in the metrics logs.
-  if (type == network::mojom::ConnectionType::CONNECTION_NONE) {
-    network_connection_tracker_initialized_ = true;
+  if (type == net::NetworkChangeNotifier::CONNECTION_NONE) {
+    network_change_notifier_initialized_ = true;
     return;
   }
 
-  DCHECK(network_connection_tracker_initialized_ ||
-         connection_type_ ==
-             network::mojom::ConnectionType::CONNECTION_UNKNOWN);
+  DCHECK(network_change_notifier_initialized_ ||
+         connection_type_ == net::NetworkChangeNotifier::CONNECTION_UNKNOWN);
 
   if (type != connection_type_ &&
-      connection_type_ != network::mojom::ConnectionType::CONNECTION_NONE &&
-      network_connection_tracker_initialized_) {
-    // If |network_connection_tracker_initialized_| is false, it implies that
-    // this is the first connection change callback received from network
-    // connection tracker, and the previous connection type was
-    // CONNECTION_UNKNOWN. In that case, connection type should not be marked as
-    // ambiguous since there was no actual change in the connection type.
+      connection_type_ != net::NetworkChangeNotifier::CONNECTION_NONE &&
+      network_change_notifier_initialized_) {
+    // If |network_change_notifier_initialized_| is false, it implies that this
+    // is the first connection change callback received from network change
+    // notifier, and the previous connection type was CONNECTION_UNKNOWN. In
+    // that case, connection type should not be marked as ambiguous since there
+    // was no actual change in the connection type.
     connection_type_is_ambiguous_ = true;
   }
 
-  network_connection_tracker_initialized_ = true;
+  network_change_notifier_initialized_ = true;
   connection_type_ = type;
 
   ProbeWifiPHYLayerProtocol();
@@ -209,21 +184,21 @@ SystemProfileProto::Network::ConnectionType
 NetworkMetricsProvider::GetConnectionType() const {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   switch (connection_type_) {
-    case network::mojom::ConnectionType::CONNECTION_NONE:
+    case net::NetworkChangeNotifier::CONNECTION_NONE:
       return SystemProfileProto::Network::CONNECTION_NONE;
-    case network::mojom::ConnectionType::CONNECTION_UNKNOWN:
+    case net::NetworkChangeNotifier::CONNECTION_UNKNOWN:
       return SystemProfileProto::Network::CONNECTION_UNKNOWN;
-    case network::mojom::ConnectionType::CONNECTION_ETHERNET:
+    case net::NetworkChangeNotifier::CONNECTION_ETHERNET:
       return SystemProfileProto::Network::CONNECTION_ETHERNET;
-    case network::mojom::ConnectionType::CONNECTION_WIFI:
+    case net::NetworkChangeNotifier::CONNECTION_WIFI:
       return SystemProfileProto::Network::CONNECTION_WIFI;
-    case network::mojom::ConnectionType::CONNECTION_2G:
+    case net::NetworkChangeNotifier::CONNECTION_2G:
       return SystemProfileProto::Network::CONNECTION_2G;
-    case network::mojom::ConnectionType::CONNECTION_3G:
+    case net::NetworkChangeNotifier::CONNECTION_3G:
       return SystemProfileProto::Network::CONNECTION_3G;
-    case network::mojom::ConnectionType::CONNECTION_4G:
+    case net::NetworkChangeNotifier::CONNECTION_4G:
       return SystemProfileProto::Network::CONNECTION_4G;
-    case network::mojom::ConnectionType::CONNECTION_BLUETOOTH:
+    case net::NetworkChangeNotifier::CONNECTION_BLUETOOTH:
       return SystemProfileProto::Network::CONNECTION_BLUETOOTH;
   }
   NOTREACHED();

components/metrics/net/network_metrics_provider.h

@@ -16,9 +16,9 @@
 #include "base/single_thread_task_runner.h"
 #include "components/metrics/metrics_provider.h"
 #include "components/metrics/net/wifi_access_point_info_provider.h"
+#include "net/base/network_change_notifier.h"
 #include "net/base/network_interfaces.h"
 #include "net/nqe/effective_connection_type.h"
-#include "services/network/public/cpp/network_connection_tracker.h"
 #include "third_party/metrics_proto/system_profile.pb.h"
 
 namespace metrics {
@@ -27,11 +27,11 @@ SystemProfileProto::Network::EffectiveConnectionType
 ConvertEffectiveConnectionType(
     net::EffectiveConnectionType effective_connection_type);
 
-// Registers as observer with network::NetworkConnectionTracker and keeps track
-// of the network environment.
+// Registers as observer with net::NetworkChangeNotifier and
+// network::NetworkQualityTracker to keep track of the network environment.
 class NetworkMetricsProvider
     : public MetricsProvider,
-      public network::NetworkConnectionTracker::NetworkConnectionObserver {
+      public net::NetworkChangeNotifier::NetworkChangeObserver {
  public:
   // Class that provides |this| with the network quality estimator.
   class NetworkQualityEstimatorProvider {
@@ -54,10 +54,9 @@ class NetworkMetricsProvider
   // Creates a NetworkMetricsProvider, where
   // |network_quality_estimator_provider| should be set if it is useful to
   // attach the quality of the network to the metrics report.
-  NetworkMetricsProvider(network::NetworkConnectionTrackerAsyncGetter
-                             network_connection_tracker_async_getter,
-                         std::unique_ptr<NetworkQualityEstimatorProvider>
-                             network_quality_estimator_provider = nullptr);
+  explicit NetworkMetricsProvider(
+      std::unique_ptr<NetworkQualityEstimatorProvider>
+          network_quality_estimator_provider = nullptr);
   ~NetworkMetricsProvider() override;
 
  private:
@@ -74,8 +73,9 @@ class NetworkMetricsProvider
       ChromeUserMetricsExtension* uma_proto) override;
   void ProvideSystemProfileMetrics(SystemProfileProto* system_profile) override;
 
-  // NetworkConnectionObserver:
-  void OnConnectionChanged(network::mojom::ConnectionType type) override;
+  // NetworkChangeObserver:
+  void OnNetworkChanged(
+      net::NetworkChangeNotifier::ConnectionType type) override;
 
   SystemProfileProto::Network::ConnectionType GetConnectionType() const;
   SystemProfileProto::Network::WifiPHYLayerProtocol GetWifiPHYLayerProtocol()
@@ -98,24 +98,12 @@ class NetworkMetricsProvider
 
   void OnEffectiveConnectionTypeChanged(net::EffectiveConnectionType type);
 
-  // Used as a callback to be given to NetworkConnectionTracker async getter to
-  // set the |network_connection_tracker_|.
-  void SetNetworkConnectionTracker(
-      network::NetworkConnectionTracker* network_connection_tracker);
-
-  // Watches for network connection changes.
-  // This |network_connection_tracker_| raw pointer is not owned by this class.
-  // It is obtained from the global |g_network_connection_tracker| pointer in
-  // //content/public/browser/network_service_instance.cc and points to the same
-  // object.
-  network::NetworkConnectionTracker* network_connection_tracker_;
-
   // True if |connection_type_| changed during the lifetime of the log.
   bool connection_type_is_ambiguous_;
-  // The connection type according to network::NetworkConnectionTracker.
-  network::mojom::ConnectionType connection_type_;
-  // True if the network connection tracker has been initialized.
-  bool network_connection_tracker_initialized_;
+  // The connection type according to net::NetworkChangeNotifier.
+  net::NetworkChangeNotifier::ConnectionType connection_type_;
+  // True if the network change notifier has been initialized.
+  bool network_change_notifier_initialized_;
 
   // True if |wifi_phy_layer_protocol_| changed during the lifetime of the log.
   bool wifi_phy_layer_protocol_is_ambiguous_;

components/metrics/net/network_metrics_provider_unittest.cc

@@ -10,9 +10,9 @@
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
+#include "base/test/scoped_task_environment.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "build/build_config.h"
-#include "services/network/test/test_network_connection_tracker.h"
+#include "net/base/network_change_notifier.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/metrics_proto/system_profile.pb.h"
 
@@ -21,26 +21,14 @@
 #include "chromeos/network/network_handler.h"
 #endif  // OS_CHROMEOS
 
-#if defined(OS_IOS)
-#include "base/test/scoped_task_environment.h"
-#else  // !defined(OS_IOS)
-#include "content/public/test/test_browser_thread_bundle.h"
-#endif  // defined(OS_IOS)
-
 namespace metrics {
 
 class NetworkMetricsProviderTest : public testing::Test {
  public:
  protected:
   NetworkMetricsProviderTest()
-#if defined(OS_IOS)
       : scoped_task_environment_(
-            base::test::ScopedTaskEnvironment::MainThreadType::IO)
-#else   // !defined(OS_IOS)
-      : test_browser_thread_bundle_(
-            content::TestBrowserThreadBundle::IO_MAINLOOP)
-#endif  // defined(OS_IOS)
-  {
+            base::test::ScopedTaskEnvironment::MainThreadType::IO) {
 #if defined(OS_CHROMEOS)
     chromeos::DBusThreadManager::Initialize();
     chromeos::NetworkHandler::Initialize();
@@ -48,17 +36,13 @@ class NetworkMetricsProviderTest : public testing::Test {
   }
 
  private:
-#if defined(OS_IOS)
   base::test::ScopedTaskEnvironment scoped_task_environment_;
-#else   // !defined(OS_IOS)
-  content::TestBrowserThreadBundle test_browser_thread_bundle_;
-#endif  // defined(OS_IOS)
 };
 
 // Verifies that the effective connection type is correctly set.
 TEST_F(NetworkMetricsProviderTest, EffectiveConnectionType) {
-  NetworkMetricsProvider network_metrics_provider(
-      network::TestNetworkConnectionTracker::CreateAsyncGetter());
+  SystemProfileProto system_profile;
+  NetworkMetricsProvider network_metrics_provider;
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(net::EFFECTIVE_CONNECTION_TYPE_UNKNOWN,
@@ -67,7 +51,6 @@ TEST_F(NetworkMetricsProviderTest, EffectiveConnectionType) {
             network_metrics_provider.min_effective_connection_type_);
   EXPECT_EQ(net::EFFECTIVE_CONNECTION_TYPE_UNKNOWN,
             network_metrics_provider.max_effective_connection_type_);
-  SystemProfileProto system_profile;
   network_metrics_provider.ProvideSystemProfileMetrics(&system_profile);
   EXPECT_EQ(SystemProfileProto::Network::EFFECTIVE_CONNECTION_TYPE_UNKNOWN,
             system_profile.network().min_effective_connection_type());
@@ -116,8 +99,8 @@ TEST_F(NetworkMetricsProviderTest, EffectiveConnectionType) {
 // Verifies that the effective connection type is not set to UNKNOWN when there
 // is a change in the connection type.
 TEST_F(NetworkMetricsProviderTest, ECTAmbiguousOnConnectionTypeChange) {
-  NetworkMetricsProvider network_metrics_provider(
-      network::TestNetworkConnectionTracker::CreateAsyncGetter());
+  SystemProfileProto system_profile;
+  NetworkMetricsProvider network_metrics_provider;
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(net::EFFECTIVE_CONNECTION_TYPE_UNKNOWN,
@@ -138,7 +121,6 @@ TEST_F(NetworkMetricsProviderTest, ECTAmbiguousOnConnectionTypeChange) {
 
   // There is no change in the connection type. Effective connection types
   // should be reported as 2G.
-  SystemProfileProto system_profile;
   network_metrics_provider.ProvideSystemProfileMetrics(&system_profile);
   EXPECT_EQ(SystemProfileProto::Network::EFFECTIVE_CONNECTION_TYPE_2G,
             system_profile.network().min_effective_connection_type());
@@ -147,8 +129,8 @@ TEST_F(NetworkMetricsProviderTest, ECTAmbiguousOnConnectionTypeChange) {
 
   // Even with change in the connection type, effective connection types
   // should be reported as 2G.
-  network_metrics_provider.OnConnectionChanged(
-      network::mojom::ConnectionType::CONNECTION_2G);
+  network_metrics_provider.OnNetworkChanged(
+      net::NetworkChangeNotifier::CONNECTION_2G);
   network_metrics_provider.ProvideSystemProfileMetrics(&system_profile);
   EXPECT_EQ(SystemProfileProto::Network::EFFECTIVE_CONNECTION_TYPE_2G,
             system_profile.network().min_effective_connection_type());
@@ -162,14 +144,13 @@ TEST_F(NetworkMetricsProviderTest, ECTNotAmbiguousOnUnknownOrOffline) {
   for (net::EffectiveConnectionType force_ect :
        {net::EFFECTIVE_CONNECTION_TYPE_UNKNOWN,
         net::EFFECTIVE_CONNECTION_TYPE_OFFLINE}) {
-    NetworkMetricsProvider network_metrics_provider(
-        network::TestNetworkConnectionTracker::CreateAsyncGetter());
+    NetworkMetricsProvider network_metrics_provider;
     base::RunLoop().RunUntilIdle();
 
+    SystemProfileProto system_profile;
     network_metrics_provider.OnEffectiveConnectionTypeChanged(
         net::EFFECTIVE_CONNECTION_TYPE_2G);
 
-    SystemProfileProto system_profile;
     network_metrics_provider.ProvideSystemProfileMetrics(&system_profile);
 
     network_metrics_provider.OnEffectiveConnectionTypeChanged(force_ect);
@@ -192,49 +173,46 @@ TEST_F(NetworkMetricsProviderTest, ECTNotAmbiguousOnUnknownOrOffline) {
 
 // Verifies that the connection type is ambiguous boolean is correctly set.
 TEST_F(NetworkMetricsProviderTest, ConnectionTypeIsAmbiguous) {
-  NetworkMetricsProvider network_metrics_provider(
-      network::TestNetworkConnectionTracker::CreateAsyncGetter());
+  SystemProfileProto system_profile;
+  NetworkMetricsProvider network_metrics_provider;
 
-  EXPECT_EQ(network::mojom::ConnectionType::CONNECTION_UNKNOWN,
+  EXPECT_EQ(net::NetworkChangeNotifier::CONNECTION_UNKNOWN,
             network_metrics_provider.connection_type_);
   EXPECT_FALSE(network_metrics_provider.connection_type_is_ambiguous_);
-  EXPECT_FALSE(
-      network_metrics_provider.network_connection_tracker_initialized_);
+  EXPECT_FALSE(network_metrics_provider.network_change_notifier_initialized_);
 
   // When a connection type change callback is received, network change notifier
   // should be marked as initialized.
-  network_metrics_provider.OnConnectionChanged(
-      network::mojom::ConnectionType::CONNECTION_2G);
-  EXPECT_EQ(network::mojom::ConnectionType::CONNECTION_2G,
+  network_metrics_provider.OnNetworkChanged(
+      net::NetworkChangeNotifier::CONNECTION_2G);
+  EXPECT_EQ(net::NetworkChangeNotifier::CONNECTION_2G,
             network_metrics_provider.connection_type_);
   // Connection type should not be marked as ambiguous when a delayed connection
   // type change callback is received due to delayed initialization of the
   // network change notifier.
   EXPECT_FALSE(network_metrics_provider.connection_type_is_ambiguous_);
-  EXPECT_TRUE(network_metrics_provider.network_connection_tracker_initialized_);
+  EXPECT_TRUE(network_metrics_provider.network_change_notifier_initialized_);
 
   // On collection of the system profile, |connection_type_is_ambiguous_| should
-  // stay false, and |network_connection_tracker_initialized_| should remain
-  // true.
-  SystemProfileProto system_profile;
+  // stay false, and |network_change_notifier_initialized_| should remain true.
   network_metrics_provider.ProvideSystemProfileMetrics(&system_profile);
   EXPECT_FALSE(network_metrics_provider.connection_type_is_ambiguous_);
-  EXPECT_TRUE(network_metrics_provider.network_connection_tracker_initialized_);
+  EXPECT_TRUE(network_metrics_provider.network_change_notifier_initialized_);
   EXPECT_FALSE(system_profile.network().connection_type_is_ambiguous());
   EXPECT_EQ(SystemProfileProto::Network::CONNECTION_2G,
             system_profile.network().connection_type());
 
-  network_metrics_provider.OnConnectionChanged(
-      network::mojom::ConnectionType::CONNECTION_3G);
+  network_metrics_provider.OnNetworkChanged(
+      net::NetworkChangeNotifier::CONNECTION_3G);
   EXPECT_TRUE(network_metrics_provider.connection_type_is_ambiguous_);
-  EXPECT_TRUE(network_metrics_provider.network_connection_tracker_initialized_);
+  EXPECT_TRUE(network_metrics_provider.network_change_notifier_initialized_);
 
   // On collection of the system profile, |connection_type_is_ambiguous_| should
-  // be reset to false, and |network_connection_tracker_initialized_| should
-  // remain true.
+  // be reset to false, and |network_change_notifier_initialized_| should remain
+  // true.
   network_metrics_provider.ProvideSystemProfileMetrics(&system_profile);
   EXPECT_FALSE(network_metrics_provider.connection_type_is_ambiguous_);
-  EXPECT_TRUE(network_metrics_provider.network_connection_tracker_initialized_);
+  EXPECT_TRUE(network_metrics_provider.network_change_notifier_initialized_);
   EXPECT_TRUE(system_profile.network().connection_type_is_ambiguous());
   EXPECT_EQ(SystemProfileProto::Network::CONNECTION_3G,
             system_profile.network().connection_type());

content/browser/network_service_instance.cc

@@ -25,6 +25,7 @@
 #include "net/log/net_log_util.h"
 #include "services/network/network_service.h"
 #include "services/network/public/cpp/features.h"
+#include "services/network/public/cpp/network_connection_tracker.h"
 #include "services/network/public/cpp/network_switches.h"
 #include "services/network/public/mojom/net_log.mojom.h"
 #include "services/network/public/mojom/network_change_manager.mojom.h"
@@ -204,32 +205,11 @@ network::NetworkConnectionTracker* GetNetworkConnectionTracker() {
 
 void GetNetworkConnectionTrackerFromUIThread(
     base::OnceCallback<void(network::NetworkConnectionTracker*)> callback) {
-  // TODO(fdoray): Investigate why this is needed. The IO thread is supposed to
-  // be initialized by the time the UI thread starts running tasks.
-  //
-  // GetNetworkConnectionTracker() will call CreateNetworkServiceOnIO(). Here it
-  // makes sure the IO thread is running when CreateNetworkServiceOnIO() is
-  // called.
-  if (!content::BrowserThread::IsThreadInitialized(
-          content::BrowserThread::IO)) {
-    // IO thread is not yet initialized. Try again in the next message pump.
-    bool task_posted = base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::BindOnce(&GetNetworkConnectionTrackerFromUIThread,
-                                  std::move(callback)));
-    DCHECK(task_posted);
-    return;
-  }
-
   base::PostTaskWithTraitsAndReplyWithResult(
       FROM_HERE, {BrowserThread::UI, base::TaskPriority::BEST_EFFORT},
       base::BindOnce(&GetNetworkConnectionTracker), std::move(callback));
 }
 
-network::NetworkConnectionTrackerAsyncGetter
-CreateNetworkConnectionTrackerAsyncGetter() {
-  return base::BindRepeating(&content::GetNetworkConnectionTrackerFromUIThread);
-}
-
 void SetNetworkConnectionTrackerForTesting(
     network::NetworkConnectionTracker* network_connection_tracker) {
   if (g_network_connection_tracker != network_connection_tracker) {

content/public/browser/network_service_instance.h

@@ -10,9 +10,9 @@
 #include "base/callback.h"
 #include "base/callback_list.h"
 #include "content/common/content_export.h"
-#include "services/network/public/cpp/network_connection_tracker.h"
 
 namespace network {
+class NetworkConnectionTracker;
 class NetworkService;
 namespace mojom {
 class NetworkService;
@@ -72,10 +72,6 @@ CONTENT_EXPORT network::NetworkConnectionTracker* GetNetworkConnectionTracker();
 CONTENT_EXPORT void GetNetworkConnectionTrackerFromUIThread(
     base::OnceCallback<void(network::NetworkConnectionTracker*)> callback);
 
-// Helper method to create a NetworkConnectionTrackerAsyncGetter.
-CONTENT_EXPORT network::NetworkConnectionTrackerAsyncGetter
-CreateNetworkConnectionTrackerAsyncGetter();
-
 // Sets the NetworkConnectionTracker instance to use. For testing only.
 // Must be called on the UI thread. Must be called before the first call to
 // GetNetworkConnectionTracker.

ios/chrome/browser/metrics/ios_chrome_metrics_service_client.mm

@@ -67,16 +67,6 @@
 #error "This file requires ARC support."
 #endif
 
-namespace {
-
-void GetNetworkConnectionTrackerAsync(
-    base::OnceCallback<void(network::NetworkConnectionTracker*)> callback) {
-  std::move(callback).Run(
-      GetApplicationContext()->GetNetworkConnectionTracker());
-}
-
-}  // namespace
-
 IOSChromeMetricsServiceClient::IOSChromeMetricsServiceClient(
     metrics::MetricsStateManager* state_manager)
     : metrics_state_manager_(state_manager),
@@ -206,8 +196,7 @@ void IOSChromeMetricsServiceClient::Initialize() {
 
   // Register metrics providers.
   metrics_service_->RegisterMetricsProvider(
-      std::make_unique<metrics::NetworkMetricsProvider>(
-          base::BindRepeating(&GetNetworkConnectionTrackerAsync)));
+      std::make_unique<metrics::NetworkMetricsProvider>());
 
   // Currently, we configure OmniboxMetricsProvider to not log events to UMA
   // if there is a single incognito session visible. In the future, it may

services/network/public/cpp/network_connection_tracker.h

@@ -26,10 +26,6 @@ namespace network {
 class NetworkConnectionTracker;
 using NetworkConnectionTrackerGetter =
     base::RepeatingCallback<NetworkConnectionTracker*()>;
-// Defines the type of a callback that can be used to asynchronously get a
-// NetworkConnectionTracker instance.
-using NetworkConnectionTrackerAsyncGetter = base::RepeatingCallback<void(
-    base::OnceCallback<void(NetworkConnectionTracker*)>)>;
 
 // This class subscribes to network change events from
 // network::mojom::NetworkChangeManager and propogates these notifications to

services/network/test/test_network_connection_tracker.cc

@@ -4,10 +4,7 @@
 
 #include "services/network/test/test_network_connection_tracker.h"
 
-#include <utility>
-
 #include "base/bind.h"
-#include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/sequenced_task_runner_handle.h"
@@ -18,19 +15,6 @@ static TestNetworkConnectionTracker* g_test_network_connection_tracker_instance;
 
 namespace {
 
-using NetworkConnectionTrackerCallback =
-    base::OnceCallback<void(NetworkConnectionTracker*)>;
-
-void GetInstanceAsync(NetworkConnectionTrackerCallback callback) {
-  base::SequencedTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE,
-      base::BindOnce(
-          [](NetworkConnectionTrackerCallback callback) {
-            std::move(callback).Run(g_test_network_connection_tracker_instance);
-          },
-          std::move(callback)));
-}
-
 NetworkConnectionTracker* GetNonTestInstance() {
   return TestNetworkConnectionTracker::GetInstance();
 }
@@ -54,12 +38,6 @@ NetworkConnectionTrackerGetter TestNetworkConnectionTracker::CreateGetter() {
   return base::BindRepeating(&GetNonTestInstance);
 }
 
-// static
-NetworkConnectionTrackerAsyncGetter
-TestNetworkConnectionTracker::CreateAsyncGetter() {
-  return base::BindRepeating(&GetInstanceAsync);
-}
-
 TestNetworkConnectionTracker::TestNetworkConnectionTracker() {
   if (g_test_network_connection_tracker_instance) {
     LOG(WARNING) << "Creating more than one TestNetworkConnectionTracker";

services/network/test/test_network_connection_tracker.h

@@ -29,10 +29,6 @@ class TestNetworkConnectionTracker : public NetworkConnectionTracker {
   // TestNetworkConnectionTracker instance when called.
   static NetworkConnectionTrackerGetter CreateGetter();
 
-  // Creates a NetworkConnectionTrackerGetter that will asynchronously return
-  // the active TestNetworkConnectionTracker instance.
-  static NetworkConnectionTrackerAsyncGetter CreateAsyncGetter();
-
   ~TestNetworkConnectionTracker() override;
 
   bool GetConnectionType(network::mojom::ConnectionType* type,