network_health: add skeleton network health class

This class will be used to collect and aggregate network information for
feedback, device telemetry, and debugging.

Bug: chromium:1057739
Test: unit_tests --gtest_filter=NetworkHealthTest.*
Change-Id: I6d3181e96dbe8f51ed698f3b5838cc7f79bd355a
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2117159
Commit-Queue: Trent Begin <tbegin@chromium.org>
Reviewed-by: Steven Bennetts <stevenjb@chromium.org>
Cr-Commit-Position: refs/heads/master@{#755567}

chrome/browser/chromeos/BUILD.gn

@@ -172,6 +172,7 @@ source_set("chromeos") {
     "//chromeos/services/multidevice_setup/public/cpp:auth_token_validator",
     "//chromeos/services/multidevice_setup/public/cpp:oobe_completion_tracker",
     "//chromeos/services/multidevice_setup/public/cpp:prefs",
+    "//chromeos/services/network_config:in_process_instance",
     "//chromeos/services/secure_channel",
     "//chromeos/services/secure_channel/public/cpp/client",
     "//chromeos/settings",
@@ -1700,6 +1701,8 @@ source_set("chromeos") {
     "net/delay_network_call.h",
     "net/dhcp_wpad_url_client.cc",
     "net/dhcp_wpad_url_client.h",
+    "net/network_health.cc",
+    "net/network_health.h",
     "net/network_portal_detector_impl.cc",
     "net/network_portal_detector_impl.h",
     "net/network_portal_detector_test_impl.cc",
@@ -2973,6 +2976,7 @@ source_set("unit_tests") {
     "login/version_updater/version_updater_unittest.cc",
     "mobile/mobile_activator_unittest.cc",
     "net/client_cert_store_chromeos_unittest.cc",
+    "net/network_health_unittest.cc",
     "net/network_portal_detector_impl_unittest.cc",
     "net/network_pref_state_observer_unittest.cc",
     "net/network_throttling_observer_unittest.cc",

chrome/browser/chromeos/chrome_browser_main_chromeos.cc

@@ -85,6 +85,7 @@
 #include "chrome/browser/chromeos/login/startup_utils.h"
 #include "chrome/browser/chromeos/login/users/chrome_user_manager.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
+#include "chrome/browser/chromeos/net/network_health.h"
 #include "chrome/browser/chromeos/net/network_portal_detector_impl.h"
 #include "chrome/browser/chromeos/net/network_pref_state_observer.h"
 #include "chrome/browser/chromeos/net/network_throttling_observer.h"
@@ -864,6 +865,9 @@ void ChromeBrowserMainPartsChromeos::PostProfileInit() {
   // Initialize an observer to update NetworkHandler's pref based services.
   network_pref_state_observer_ = std::make_unique<NetworkPrefStateObserver>();
 
+  // Initialize the NetworkHealth aggregator.
+  network_health_ = std::make_unique<NetworkHealth>();
+
   // Initialize input methods.
   input_method::InputMethodManager* manager =
       input_method::InputMethodManager::Get();
@@ -1039,6 +1043,7 @@ void ChromeBrowserMainPartsChromeos::PostMainMessageLoopRun() {
   // We should remove observers attached to D-Bus clients before
   // DBusThreadManager is shut down.
   network_pref_state_observer_.reset();
+  network_health_.reset();
   power_metrics_reporter_.reset();
   renderer_freezer_.reset();
   wake_on_wifi_manager_.reset();

chrome/browser/chromeos/chrome_browser_main_chromeos.h

@@ -51,6 +51,7 @@ class LoginScreenExtensionsLifetimeManager;
 class LoginScreenExtensionsStorageCleaner;
 class LowDiskNotification;
 class NetworkChangeManagerClient;
+class NetworkHealth;
 class NetworkPrefStateObserver;
 class NetworkThrottlingObserver;
 class PowerMetricsReporter;
@@ -112,6 +113,7 @@ class ChromeBrowserMainPartsChromeos : public ChromeBrowserMainPartsLinux {
 
  private:
   std::unique_ptr<default_app_order::ExternalLoader> app_order_loader_;
+  std::unique_ptr<NetworkHealth> network_health_;
   std::unique_ptr<NetworkPrefStateObserver> network_pref_state_observer_;
   std::unique_ptr<IdleActionWarningObserver> idle_action_warning_observer_;
   std::unique_ptr<RendererFreezer> renderer_freezer_;

chrome/browser/chromeos/net/network_health.cc

+// Copyright 2020 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/chromeos/net/network_health.h"
+
+#include <vector>
+
+#include "chromeos/network/network_event_log.h"
+#include "chromeos/services/network_config/in_process_instance.h"
+#include "chromeos/services/network_config/public/mojom/cros_network_config.mojom.h"
+
+using chromeos::network_config::mojom::FilterType;
+using chromeos::network_config::mojom::NetworkFilter;
+using chromeos::network_config::mojom::NetworkStatePropertiesPtr;
+using chromeos::network_config::mojom::NetworkType;
+
+namespace chromeos {
+
+NetworkHealth::NetworkHealthState::NetworkHealthState() {}
+
+NetworkHealth::NetworkHealthState::~NetworkHealthState() {}
+
+NetworkHealth::NetworkHealthState::NetworkHealthState(
+    const NetworkHealth::NetworkHealthState&) = default;
+
+NetworkHealth::NetworkState::NetworkState() {}
+
+NetworkHealth::NetworkState::~NetworkState() {}
+
+NetworkHealth::NetworkHealth() {
+  chromeos::network_config::BindToInProcessInstance(
+      remote_cros_network_config_.BindNewPipeAndPassReceiver());
+  remote_cros_network_config_->AddObserver(
+      cros_network_config_observer_receiver_.BindNewPipeAndPassRemote());
+  RefreshNetworkHealthState();
+}
+
+NetworkHealth::~NetworkHealth() {}
+
+NetworkHealth::NetworkHealthState NetworkHealth::GetNetworkHealthState() {
+  NET_LOG(EVENT) << "Network Health State Requested";
+  return network_health_state_;
+}
+
+void NetworkHealth::RefreshNetworkHealthState() {
+  RequestActiveNetworks();
+}
+
+void NetworkHealth::OnActiveNetworksReceived(
+    std::vector<NetworkStatePropertiesPtr> network_props) {
+  std::vector<NetworkState> active_networks;
+  for (const auto& prop : network_props) {
+    DCHECK(prop);
+    NetworkState state;
+    state.name = prop->name;
+    state.type = prop->type;
+    state.connection_state = prop->connection_state;
+    active_networks.push_back(std::move(state));
+  }
+
+  network_health_state_.active_networks.swap(active_networks);
+}
+
+void NetworkHealth::OnActiveNetworksChanged(
+    std::vector<NetworkStatePropertiesPtr> network_props) {
+  OnActiveNetworksReceived(std::move(network_props));
+}
+
+void NetworkHealth::RequestActiveNetworks() {
+  remote_cros_network_config_->GetNetworkStateList(
+      NetworkFilter::New(FilterType::kActive, NetworkType::kAll,
+                         network_config::mojom::kNoLimit),
+      base::BindOnce(&NetworkHealth::OnActiveNetworksReceived,
+                     base::Unretained(this)));
+}
+
+}  // namespace chromeos

chrome/browser/chromeos/net/network_health.h

+// Copyright 2020 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 CHROME_BROWSER_CHROMEOS_NET_NETWORK_HEALTH_H_
+#define CHROME_BROWSER_CHROMEOS_NET_NETWORK_HEALTH_H_
+
+#include <string>
+#include <vector>
+
+#include "chromeos/services/network_config/public/mojom/cros_network_config.mojom.h"
+#include "mojo/public/cpp/bindings/remote.h"
+
+namespace chromeos {
+
+class NetworkHealth
+    : public chromeos::network_config::mojom::CrosNetworkConfigObserver {
+ public:
+  // Structure for a single network's status.
+  struct NetworkState {
+    NetworkState();
+    ~NetworkState();
+
+    std::string name;
+    chromeos::network_config::mojom::NetworkType type;
+    chromeos::network_config::mojom::ConnectionStateType connection_state;
+  };
+
+  // Structure containing the current snapshot of the state of Network Health.
+  struct NetworkHealthState {
+    NetworkHealthState();
+    NetworkHealthState(const NetworkHealthState&);
+    ~NetworkHealthState();
+
+    std::vector<NetworkState> active_networks;
+  };
+
+  NetworkHealth();
+
+  ~NetworkHealth() override;
+
+  // Returns the current NetworkHealthState.
+  NetworkHealthState GetNetworkHealthState();
+
+  // Handler for receiving new active networks.
+  void OnActiveNetworksReceived(
+      std::vector<chromeos::network_config::mojom::NetworkStatePropertiesPtr>);
+
+  // CrosNetworkConfigObserver implementation
+  void OnActiveNetworksChanged(
+      std::vector<chromeos::network_config::mojom::NetworkStatePropertiesPtr>)
+      override;
+
+  // CrosNetworkConfigObserver unimplemented callbacks
+  void OnNetworkStateListChanged() override {}
+  void OnNetworkStateChanged(
+      chromeos::network_config::mojom::NetworkStatePropertiesPtr) override {}
+  void OnDeviceStateListChanged() override {}
+  void OnVpnProvidersChanged() override {}
+  void OnNetworkCertificatesChanged() override {}
+
+ private:
+  // Asynchronous call that refreshes the current Network Health State.
+  void RefreshNetworkHealthState();
+  void RequestActiveNetworks();
+
+  mojo::Remote<chromeos::network_config::mojom::CrosNetworkConfig>
+      remote_cros_network_config_;
+  mojo::Receiver<chromeos::network_config::mojom::CrosNetworkConfigObserver>
+      cros_network_config_observer_receiver_{this};
+
+  NetworkHealthState network_health_state_;
+};
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_NET_NETWORK_HEALTH_H_

chrome/browser/chromeos/net/network_health_unittest.cc

+// Copyright 2020 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/chromeos/net/network_health.h"
+
+#include "chromeos/services/network_config/public/cpp/cros_network_config_test_helper.h"
+#include "chromeos/services/network_config/public/mojom/cros_network_config.mojom.h"
+#include "content/public/test/browser_task_environment.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/cros_system_api/dbus/shill/dbus-constants.h"
+
+namespace {
+
+// Constant values for fake device and service.
+constexpr char kServicePath[] = "/service/0";
+constexpr char kServiceName[] = "service_name";
+constexpr char kServiceGUID[] = "wifi_guid";
+constexpr char kDevicePath[] = "/device/wifi";
+constexpr char kDeviceName[] = "device_name";
+constexpr char kDefaultProfle[] = "/profile/default";
+
+}  // namespace
+
+namespace chromeos {
+
+class NetworkHealthTest : public ::testing::Test {
+ public:
+  NetworkHealthTest() {}
+
+ protected:
+  content::BrowserTaskEnvironment task_environment_;
+  network_config::CrosNetworkConfigTestHelper cros_network_config_test_helper_;
+  NetworkHealth network_health_;
+};
+
+TEST_F(NetworkHealthTest, GetNetworkHealthSucceeds) {
+  // Create an active network.
+  cros_network_config_test_helper_.network_state_helper().AddDevice(
+      kDevicePath, shill::kTypeWifi, kDeviceName);
+
+  cros_network_config_test_helper_.network_state_helper()
+      .service_test()
+      ->AddService(kServicePath, kServiceGUID, kServiceName, shill::kTypeWifi,
+                   shill::kStateOnline, true);
+
+  cros_network_config_test_helper_.network_state_helper()
+      .profile_test()
+      ->AddService(kDefaultProfle, kServicePath);
+
+  // Wait until the network and service have been created and configured.
+  task_environment_.RunUntilIdle();
+
+  auto network_health_state = network_health_.GetNetworkHealthState();
+
+  EXPECT_EQ(network_health_state.active_networks.size(), std::size_t(1));
+  EXPECT_EQ(network_health_state.active_networks[0].name, kServiceName);
+}
+
+}  // namespace chromeos