network_health: add minimal mojo interface

This change adds a basic mojo interface to query NetworkHealth for the
cached active networks and devices.

Bug: chromium:1057739
Change-Id: I5c7437a522535f8a3154e3ec74bc17d67f4b2dfa
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2161701
Commit-Queue: Trent Begin <tbegin@chromium.org>
Reviewed-by: Steven Bennetts <stevenjb@chromium.org>
Cr-Commit-Position: refs/heads/master@{#763424}

chrome/browser/chromeos/BUILD.gn

@@ -77,6 +77,7 @@ source_set("chromeos") {
     "//chrome/browser/apps/platform_apps",
     "//chrome/browser/apps/platform_apps/api",
     "//chrome/browser/chromeos/child_accounts/time_limits/web_time_limit_error_page",
+    "//chrome/browser/chromeos/net/mojom",
     "//chrome/browser/chromeos/power/ml/smart_dim",
     "//chrome/browser/devtools",
     "//chrome/browser/extensions",

chrome/browser/chromeos/chrome_browser_main_chromeos.cc

@@ -876,7 +876,7 @@ void ChromeBrowserMainPartsChromeos::PostProfileInit() {
   network_pref_state_observer_ = std::make_unique<NetworkPrefStateObserver>();
 
   // Initialize the NetworkHealth aggregator.
-  network_health_ = std::make_unique<NetworkHealth>();
+  network_health_ = std::make_unique<network_health::NetworkHealth>();
 
   // Initialize input methods.
   input_method::InputMethodManager* manager =

chrome/browser/chromeos/chrome_browser_main_chromeos.h

@@ -51,7 +51,6 @@ class LoginScreenExtensionsLifetimeManager;
 class LoginScreenExtensionsStorageCleaner;
 class LowDiskNotification;
 class NetworkChangeManagerClient;
-class NetworkHealth;
 class NetworkPrefStateObserver;
 class NetworkThrottlingObserver;
 class PowerMetricsReporter;
@@ -71,6 +70,10 @@ namespace internal {
 class DBusServices;
 }  // namespace internal
 
+namespace network_health {
+class NetworkHealth;
+}  // namespace network_health
+
 namespace power {
 class SmartChargingManager;
 namespace ml {
@@ -114,7 +117,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<network_health::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/mojom/BUILD.gn

+# 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.
+
+import("//mojo/public/tools/bindings/mojom.gni")
+
+mojom("mojom") {
+  sources = [ "network_health.mojom" ]
+
+  public_deps =
+      [ "//chromeos/services/network_config/public/mojom:network_types" ]
+}

chrome/browser/chromeos/net/mojom/OWNERS

+per-file *.mojom=set noparent
+per-file *.mojom=file://ipc/SECURITY_OWNERS

chrome/browser/chromeos/net/mojom/network_health.mojom

+// 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.
+
+module chromeos.network_health.mojom;
+
+import "chromeos/services/network_config/public/mojom/network_types.mojom";
+
+// Contains information for a single network.
+struct Network {
+  chromeos.network_config.mojom.ConnectionStateType connection_state;
+  string name;
+  chromeos.network_config.mojom.NetworkType type;
+};
+
+// Contains information for a single network device.
+struct Device {
+  chromeos.network_config.mojom.DeviceStateType connection_state;
+  // Optional string for the device’s mac_address. Will only be populated if
+  // applicable to the device.
+  string? mac_address;
+  chromeos.network_config.mojom.NetworkType type;
+};
+
+// Interface for retrieving aggregated information about the current network
+// state and health.
+interface NetworkHealthService {
+  // Returns a list of the network devices.
+  GetDeviceList() => (array<Device> devices);
+
+  // Returns a list of the active (connected or connecting) networks.
+  GetActiveNetworkList() => (array<Network> active_networks);
+};

chrome/browser/chromeos/net/network_health.cc

@@ -6,35 +6,20 @@
 
 #include <vector>
 
+#include "chrome/browser/chromeos/net/mojom/network_health.mojom.h"
 #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::DeviceStatePropertiesPtr;
-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 {
+namespace network_health {
 
 NetworkHealth::NetworkHealthState::NetworkHealthState() {}
 
 NetworkHealth::NetworkHealthState::~NetworkHealthState() {}
 
-NetworkHealth::NetworkHealthState::NetworkHealthState(
-    const NetworkHealth::NetworkHealthState&) = default;
-
-NetworkHealth::NetworkState::NetworkState() {}
-
-NetworkHealth::NetworkState::~NetworkState() {}
-
-NetworkHealth::DeviceState::DeviceState() {}
-
-NetworkHealth::DeviceState::~DeviceState() {}
-
 NetworkHealth::NetworkHealth() {
-  chromeos::network_config::BindToInProcessInstance(
+  network_config::BindToInProcessInstance(
       remote_cros_network_config_.BindNewPipeAndPassReceiver());
   remote_cros_network_config_->AddObserver(
       cros_network_config_observer_receiver_.BindNewPipeAndPassRemote());
@@ -43,7 +28,8 @@ NetworkHealth::NetworkHealth() {
 
 NetworkHealth::~NetworkHealth() {}
 
-NetworkHealth::NetworkHealthState NetworkHealth::GetNetworkHealthState() {
+const NetworkHealth::NetworkHealthState&
+NetworkHealth::GetNetworkHealthState() {
   NET_LOG(EVENT) << "Network Health State Requested";
   return network_health_state_;
 }
@@ -53,36 +39,39 @@ void NetworkHealth::RefreshNetworkHealthState() {
   RequestDeviceStateList();
 }
 
+void NetworkHealth::GetDeviceList(GetDeviceListCallback callback) {
+  std::move(callback).Run(mojo::Clone(network_health_state_.devices));
+}
+
+void NetworkHealth::GetActiveNetworkList(
+    GetActiveNetworkListCallback callback) {
+  std::move(callback).Run(mojo::Clone(network_health_state_.active_networks));
+}
+
 void NetworkHealth::OnActiveNetworksReceived(
-    std::vector<NetworkStatePropertiesPtr> network_props) {
-  std::vector<NetworkState> active_networks;
+    std::vector<network_config::mojom::NetworkStatePropertiesPtr>
+        network_props) {
+  std::vector<mojom::NetworkPtr> active_networks;
   for (const auto& prop : network_props) {
-    NetworkState state;
-    state.name = prop->name;
-    state.type = prop->type;
-    state.connection_state = prop->connection_state;
-    active_networks.push_back(std::move(state));
+    active_networks.push_back(
+        mojom::Network::New(prop->connection_state, prop->name, prop->type));
   }
-
   network_health_state_.active_networks.swap(active_networks);
 }
 
 void NetworkHealth::OnDeviceStateListReceived(
-    std::vector<DeviceStatePropertiesPtr> device_props) {
-  std::vector<DeviceState> devices;
+    std::vector<network_config::mojom::DeviceStatePropertiesPtr> device_props) {
+  std::vector<mojom::DevicePtr> devices;
   for (const auto& prop : device_props) {
-    DeviceState device;
-    device.mac_address = prop->mac_address.value_or("");
-    device.type = prop->type;
-    device.state = prop->device_state;
-    devices.push_back(std::move(device));
+    devices.push_back(mojom::Device::New(
+        prop->device_state, prop->mac_address.value_or(""), prop->type));
   }
-
   network_health_state_.devices.swap(devices);
 }
 
 void NetworkHealth::OnActiveNetworksChanged(
-    std::vector<NetworkStatePropertiesPtr> network_props) {
+    std::vector<network_config::mojom::NetworkStatePropertiesPtr>
+        network_props) {
   OnActiveNetworksReceived(std::move(network_props));
 }
 
@@ -92,8 +81,10 @@ void NetworkHealth::OnDeviceStateListChanged() {
 
 void NetworkHealth::RequestActiveNetworks() {
   remote_cros_network_config_->GetNetworkStateList(
-      NetworkFilter::New(FilterType::kActive, NetworkType::kAll,
-                         network_config::mojom::kNoLimit),
+      network_config::mojom::NetworkFilter::New(
+          network_config::mojom::FilterType::kActive,
+          network_config::mojom::NetworkType::kAll,
+          network_config::mojom::kNoLimit),
       base::BindOnce(&NetworkHealth::OnActiveNetworksReceived,
                      base::Unretained(this)));
 }
@@ -103,4 +94,5 @@ void NetworkHealth::RequestDeviceStateList() {
       &NetworkHealth::OnDeviceStateListReceived, base::Unretained(this)));
 }
 
+}  // namespace network_health
 }  // namespace chromeos

chrome/browser/chromeos/net/network_health.h

@@ -8,42 +8,24 @@
 #include <string>
 #include <vector>
 
+#include "chrome/browser/chromeos/net/mojom/network_health.mojom.h"
 #include "chromeos/services/network_config/public/mojom/cros_network_config.mojom.h"
 #include "mojo/public/cpp/bindings/remote.h"
 
 namespace chromeos {
+namespace network_health {
 
-class NetworkHealth
-    : public chromeos::network_config::mojom::CrosNetworkConfigObserver {
+class NetworkHealth : public mojom::NetworkHealthService,
+                      public 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 for a single device's status.
-  struct DeviceState {
-    DeviceState();
-    ~DeviceState();
-
-    std::string mac_address;
-    chromeos::network_config::mojom::NetworkType type;
-    chromeos::network_config::mojom::DeviceStateType state;
-  };
-
   // Structure containing the current snapshot of the state of Network Health.
   struct NetworkHealthState {
     NetworkHealthState();
-    NetworkHealthState(const NetworkHealthState&);
+    NetworkHealthState(const NetworkHealthState&) = delete;
     ~NetworkHealthState();
 
-    std::vector<NetworkState> active_networks;
-    std::vector<DeviceState> devices;
+    std::vector<mojom::NetworkPtr> active_networks;
+    std::vector<mojom::DevicePtr> devices;
   };
 
   NetworkHealth();
@@ -51,26 +33,29 @@ class NetworkHealth
   ~NetworkHealth() override;
 
   // Returns the current NetworkHealthState.
-  NetworkHealthState GetNetworkHealthState();
+  const NetworkHealthState& GetNetworkHealthState();
 
   // Handler for receiving active networks.
   void OnActiveNetworksReceived(
-      std::vector<chromeos::network_config::mojom::NetworkStatePropertiesPtr>);
+      std::vector<network_config::mojom::NetworkStatePropertiesPtr>);
 
   // Handler for receiving networking devices.
   void OnDeviceStateListReceived(
-      std::vector<chromeos::network_config::mojom::DeviceStatePropertiesPtr>);
+      std::vector<network_config::mojom::DeviceStatePropertiesPtr>);
+
+  // NetworkHealthService implementation
+  void GetDeviceList(GetDeviceListCallback) override;
+  void GetActiveNetworkList(GetActiveNetworkListCallback) override;
 
   // CrosNetworkConfigObserver implementation
   void OnActiveNetworksChanged(
-      std::vector<chromeos::network_config::mojom::NetworkStatePropertiesPtr>)
-      override;
+      std::vector<network_config::mojom::NetworkStatePropertiesPtr>) override;
   void OnDeviceStateListChanged() override;
 
   // CrosNetworkConfigObserver unimplemented callbacks
   void OnNetworkStateListChanged() override {}
   void OnNetworkStateChanged(
-      chromeos::network_config::mojom::NetworkStatePropertiesPtr) override {}
+      network_config::mojom::NetworkStatePropertiesPtr) override {}
   void OnVpnProvidersChanged() override {}
   void OnNetworkCertificatesChanged() override {}
 
@@ -80,14 +65,15 @@ class NetworkHealth
   void RequestActiveNetworks();
   void RequestDeviceStateList();
 
-  mojo::Remote<chromeos::network_config::mojom::CrosNetworkConfig>
+  mojo::Remote<network_config::mojom::CrosNetworkConfig>
       remote_cros_network_config_;
-  mojo::Receiver<chromeos::network_config::mojom::CrosNetworkConfigObserver>
+  mojo::Receiver<network_config::mojom::CrosNetworkConfigObserver>
       cros_network_config_observer_receiver_{this};
 
   NetworkHealthState network_health_state_;
 };
 
+}  // namespace network_health
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_NET_NETWORK_HEALTH_H_

chrome/browser/chromeos/net/network_health_unittest.cc

@@ -24,6 +24,7 @@ constexpr char kDeviceName[] = "device_name";
 }  // namespace
 
 namespace chromeos {
+namespace network_health {
 
 class NetworkHealthTest : public ::testing::Test {
  public:
@@ -41,8 +42,9 @@ class NetworkHealthTest : public ::testing::Test {
 TEST_F(NetworkHealthTest, GetNetworkHealthSucceeds) {
   // Check that the default wifi device created by CrosNetworkConfigTestHelper
   // exists.
-  auto network_health_state = network_health_.GetNetworkHealthState();
-  ASSERT_EQ(network_health_state.devices.size(), std::size_t(1));
+  const auto& initial_network_health_state =
+      network_health_.GetNetworkHealthState();
+  ASSERT_EQ(initial_network_health_state.devices.size(), std::size_t(1));
 
   // Create an ethernet device and service, and make it the active network.
   cros_network_config_test_helper_.network_state_helper().AddDevice(
@@ -56,11 +58,12 @@ TEST_F(NetworkHealthTest, GetNetworkHealthSucceeds) {
   // Wait until the network and service have been created and configured.
   task_environment_.RunUntilIdle();
 
-  network_health_state = network_health_.GetNetworkHealthState();
-  EXPECT_EQ(network_health_state.devices.size(), std::size_t(2));
-  EXPECT_EQ(network_health_state.active_networks.size(), std::size_t(1));
-  EXPECT_EQ(network_health_state.active_networks[0].name, kServiceName);
-  EXPECT_EQ(network_health_state.devices[1].type, NetworkType::kEthernet);
+  const auto& network_health_state = network_health_.GetNetworkHealthState();
+  ASSERT_EQ(network_health_state.devices.size(), std::size_t(2));
+  ASSERT_EQ(network_health_state.active_networks.size(), std::size_t(1));
+  EXPECT_EQ(network_health_state.active_networks[0]->name, kServiceName);
+  EXPECT_EQ(network_health_state.devices[1]->type, NetworkType::kEthernet);
 }
 
+}  // namespace network_health
 }  // namespace chromeos