Introduce networking.onc as an alias for networkingPrivate

chrome/browser/extensions/api/networking_private/networking_private_chromeos_apitest.cc

Index: chrome/browser/extensions/api/networking_private/networking_private_chromeos_apitest.cc
diff --git a/chrome/browser/extensions/api/networking_private/networking_private_chromeos_apitest.cc b/chrome/browser/extensions/api/networking_private/networking_private_chromeos_apitest.cc
index 6d22232e525d13549a9a90808878987ff067850d..2399bb4a785bda94d240a77daab7cc539c98f385 100644
--- a/chrome/browser/extensions/api/networking_private/networking_private_chromeos_apitest.cc
+++ b/chrome/browser/extensions/api/networking_private/networking_private_chromeos_apitest.cc
@@ -8,7 +8,9 @@
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
+#include "base/json/json_writer.h"
 #include "base/macros.h"
+#include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/login/helper.h"
 #include "chrome/browser/chromeos/net/network_portal_detector_test_impl.h"
@@ -167,10 +169,23 @@ class NetworkingPrivateChromeOSApiTest : public ExtensionApiTest {
         service_test_(nullptr),
         device_test_(nullptr) {}
 
-  bool RunNetworkingSubtest(const std::string& subtest) {
-    return RunExtensionSubtest("networking_private/chromeos",
-                               "main.html?" + subtest,
-                               kFlagEnableFileAccess | kFlagLoadAsComponent);
+  bool RunNetworkingTest(const std::string& api,
+                         const std::vector<std::string>& tests) {
+    std::unique_ptr<base::ListValue> tests_value(new base::ListValue());
+    for (const auto& test : tests) {
+      tests_value->AppendString(test);
+    }
+    base::DictionaryValue arg_value;
+    arg_value.SetString("api", api);
+    arg_value.Set("tests", std::move(tests_value));
+
+    std::string arg;
+    if (!base::JSONWriter::Write(arg_value, &arg)) {
+      message_ = "Failed to create test arguments string.";
+      return false;
+    }
+    return RunPlatformAppTestWithArg("networking_private/chromeos",
+                                     arg.c_str());
   }
 
   void SetUpInProcessBrowserTestFixture() override {
@@ -259,6 +274,51 @@ class NetworkingPrivateChromeOSApiTest : public ExtensionApiTest {
     content::RunAllPendingInMessageLoop();
   }
 
+  void SetupPolicyControlledNetworks() {
+    // TODO(stevenjb): Find a better way to set this up on Chrome OS.
+    const std::string uidata_blob =
+        "{ \"user_settings\": {"
+        "      \"WiFi\": {"
+        "        \"Passphrase\": \"FAKE_CREDENTIAL_VPaJDV9x\" }"
+        "    }"
+        "}";
+    service_test_->SetServiceProperty(kWifi2ServicePath, shill::kUIDataProperty,
+                                      base::StringValue(uidata_blob));
+    service_test_->SetServiceProperty(kWifi2ServicePath,
+                                      shill::kAutoConnectProperty,
+                                      base::FundamentalValue(false));
+
+    // Update the profile entry.
+    profile_test_->AddService(kUser1ProfilePath, kWifi2ServicePath);
+
+    content::RunAllPendingInMessageLoop();
+
+    const std::string user_policy_blob =
+        "{ \"NetworkConfigurations\": ["
+        "    { \"GUID\": \"stub_wifi2\","
+        "      \"Type\": \"WiFi\","
+        "      \"Name\": \"My WiFi Network\","
+        "      \"WiFi\": {"
+        "        \"HexSSID\": \"77696669325F50534B\","  // "wifi2_PSK"
+        "        \"Passphrase\": \"passphrase\","
+        "        \"Recommended\": [ \"AutoConnect\", \"Passphrase\" ],"
+        "        \"Security\": \"WPA-PSK\" }"
+        "    }"
+        "  ],"
+        "  \"Certificates\": [],"
+        "  \"Type\": \"UnencryptedConfiguration\""
+        "}";
+
+    policy::PolicyMap policy;
+    policy.Set(
+        policy::key::kOpenNetworkConfiguration, policy::POLICY_LEVEL_MANDATORY,
+        policy::POLICY_SCOPE_USER, policy::POLICY_SOURCE_CLOUD,
+        base::WrapUnique(new base::StringValue(user_policy_blob)), nullptr);
+    provider_.UpdateChromePolicy(policy);
+
+    content::RunAllPendingInMessageLoop();
+  }
+
   void AddService(const std::string& service_path,
                   const std::string& name,
                   const std::string& type,
@@ -296,6 +356,11 @@ class NetworkingPrivateChromeOSApiTest : public ExtensionApiTest {
     service_test_ = dbus_manager->GetShillServiceClient()->GetTestInterface();
     device_test_ = dbus_manager->GetShillDeviceClient()->GetTestInterface();
 
+    ResetNetworkState();
+  }
+
+  void ResetNetworkState() {
+    DBusThreadManager* dbus_manager = DBusThreadManager::Get();
     ShillIPConfigClient::TestInterface* ip_config_test =
         dbus_manager->GetShillIPConfigClient()->GetTestInterface();
 
@@ -440,16 +505,30 @@ class NetworkingPrivateChromeOSApiTest : public ExtensionApiTest {
 // other.
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, StartConnect) {
-  EXPECT_TRUE(RunNetworkingSubtest("startConnect")) << message_;
+  EXPECT_TRUE(RunNetworkingTest("networkingPrivate", {"startConnect"}))
+      << message_;
+}
+
+IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, Alias_StartConnect) {
+  EXPECT_TRUE(RunNetworkingTest("networking.onc", {"startConnect"}))
+      << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, StartDisconnect) {
-  EXPECT_TRUE(RunNetworkingSubtest("startDisconnect")) << message_;
+  EXPECT_TRUE(RunNetworkingTest("networkingPrivate", {"startDisconnect"}))
+      << message_;
+}
+
+IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
+                       Alias_StartDisconnect) {
+  EXPECT_TRUE(RunNetworkingTest("networking.onc", {"startDisconnect"}))
+      << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, StartActivate) {
   SetupCellular();
-  EXPECT_TRUE(RunNetworkingSubtest("startActivate")) << message_;
+  EXPECT_TRUE(RunNetworkingTest("networkingPrivate", {"startActivate"}))

[stevenjb, 2016/12/09 23:29:04]

This is a lot of changes. Why not leave RunNetworkingSubtest as-is, and add
something like RunNetworkingSubtestWithAlias? I'm fine with a little bit of
re-factoring here, but this seems excessive (and will take me a while to
review...)

[tbarzic, 2016/12/10 02:04:49]

OK, I reduced the scope of the test changes here.

+      << message_;
   EXPECT_EQ(1, UIDelegateStub::s_show_account_details_called_);
 }
 
@@ -459,27 +538,42 @@ IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, StartActivateSprint) {
   device_test_->SetDeviceProperty(kCellularDevicePath,
                                   shill::kCarrierProperty,
                                   base::StringValue(shill::kCarrierSprint));
-  EXPECT_TRUE(RunNetworkingSubtest("startActivateSprint")) << message_;
+  EXPECT_TRUE(RunNetworkingTest("networkingPrivate", {"startActivateSprint"}))
+      << message_;
   EXPECT_EQ(0, UIDelegateStub::s_show_account_details_called_);
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
-                       StartConnectNonexistent) {
-  EXPECT_TRUE(RunNetworkingSubtest("startConnectNonexistent")) << message_;
+                       MethodsOnNonexistentNetworks) {
+  EXPECT_TRUE(RunNetworkingTest(
+      "networkingPrivate",
+      {"startConnectNonexistent", "startDisconnectNonexitent",
+       "startGetPropertiesNonexistent", "getStateNonExistent"}))
+      << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
-                       StartDisconnectNonexistent) {
-  EXPECT_TRUE(RunNetworkingSubtest("startDisconnectNonexistent")) << message_;
+                       Alias_MethodsOnNonexistentNetworks) {
+  EXPECT_TRUE(RunNetworkingTest(
+      "networking.onc",
+      {"startConnectNonexistent", "startDisconnectNonexitent",
+       "startGetPropertiesNonexistent", "getStatenonExistent"}))
+      << message_;
 }
 
-IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
-                       StartGetPropertiesNonexistent) {
-  EXPECT_TRUE(RunNetworkingSubtest("startGetPropertiesNonexistent"))
+IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, GetNetworks) {
+  // Hide stub_wifi2.
+  service_test_->SetServiceProperty(kWifi2ServicePath, shill::kVisibleProperty,
+                                    base::FundamentalValue(false));
+  // Add a couple of additional networks that are not configured (saved).
+  AddService("stub_wifi3", "wifi3", shill::kTypeWifi, shill::kStateIdle);
+  AddService("stub_wifi4", "wifi4", shill::kTypeWifi, shill::kStateIdle);
+  content::RunAllPendingInMessageLoop();
+  EXPECT_TRUE(RunNetworkingTest("networkingPrivate", {"getNetworks"}))
       << message_;
 }
 
-IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, GetNetworks) {
+IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, Alias_GetNetworks) {
   // Hide stub_wifi2.
   service_test_->SetServiceProperty(kWifi2ServicePath, shill::kVisibleProperty,
                                     base::FundamentalValue(false));
@@ -487,20 +581,31 @@ IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, GetNetworks) {
   AddService("stub_wifi3", "wifi3", shill::kTypeWifi, shill::kStateIdle);
   AddService("stub_wifi4", "wifi4", shill::kTypeWifi, shill::kStateIdle);
   content::RunAllPendingInMessageLoop();
-  EXPECT_TRUE(RunNetworkingSubtest("getNetworks")) << message_;
+  EXPECT_TRUE(RunNetworkingTest("networking.onc", {"getNetworks"})) << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, GetVisibleNetworks) {
-  EXPECT_TRUE(RunNetworkingSubtest("getVisibleNetworks")) << message_;
+  EXPECT_TRUE(RunNetworkingTest(
+      "networkingPrivate", {"getVisibleNetworks", "getVisibleNetworksWifi"}))
+      << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
-                       GetVisibleNetworksWifi) {
-  EXPECT_TRUE(RunNetworkingSubtest("getVisibleNetworksWifi")) << message_;
+                       Alias_GetVisibleNetworks) {
+  EXPECT_TRUE(RunNetworkingTest(
+      "networking.onc", {"getVisibleNetworks", "getVisibleNetworksWifi"}))
+      << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, EnabledNetworkTypes) {
-  EXPECT_TRUE(RunNetworkingSubtest("enabledNetworkTypes")) << message_;
+  EXPECT_TRUE(RunNetworkingTest("networkingPrivate", {"enabledNetworkTypes"}))
+      << message_;
+}
+
+IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
+                       Alias_EnabledNetworkTypes) {
+  EXPECT_TRUE(RunNetworkingTest("networkingPrivate", {"enabledNetworkTypes"}))
+      << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, GetDeviceStates) {
@@ -510,153 +615,200 @@ IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, GetDeviceStates) {
   manager_test_->SetTechnologyInitializing("cellular", true);
   manager_test_->RemoveTechnology("wimax");
   manager_test_->AddTechnology("wimax", false /* disabled */);
-  EXPECT_TRUE(RunNetworkingSubtest("getDeviceStates")) << message_;
+  EXPECT_TRUE(RunNetworkingTest("networkingPrivate", {"getDeviceStates"}))
+      << message_;
+}
+
+IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
+                       Alias_GetDeviceStates) {
+  SetupCellular();
+  manager_test_->RemoveTechnology("cellular");
+  manager_test_->AddTechnology("cellular", false /* disabled */);
+  manager_test_->SetTechnologyInitializing("cellular", true);
+  manager_test_->RemoveTechnology("wimax");
+  manager_test_->AddTechnology("wimax", false /* disabled */);
+  EXPECT_TRUE(RunNetworkingTest("networking.onc", {"getDeviceStates"}))
+      << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, RequestNetworkScan) {
-  EXPECT_TRUE(RunNetworkingSubtest("requestNetworkScan")) << message_;
+  EXPECT_TRUE(RunNetworkingTest("networkingPrivate", {"requestNetworkScan"}))
+      << message_;
+}
+
+IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
+                       Alias_RequestNetworkScan) {
+  EXPECT_TRUE(RunNetworkingTest("networking.onc", {"requestNetworkScan"}))
+      << message_;
 }
 
 // Properties are filtered and translated through
 // ShillToONCTranslator::TranslateWiFiWithState
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, GetProperties) {
-  EXPECT_TRUE(RunNetworkingSubtest("getProperties")) << message_;
+  SetupCellular();
+  EXPECT_TRUE(
+      RunNetworkingTest("networkingPrivate",
+                        {"getProperties", "getPropertiesCellular", "getState"}))
+      << message_;
 }
 
-IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
-                       GetCellularProperties) {
+IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, Alias_GetProperties) {
   SetupCellular();
-  EXPECT_TRUE(RunNetworkingSubtest("getPropertiesCellular")) << message_;
+  EXPECT_TRUE(RunNetworkingTest(
+      "networking.onc", {"getProperties", "getPropertiesCellular", "getState"}))
+      << message_;
 }
 
-IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, GetState) {
-  EXPECT_TRUE(RunNetworkingSubtest("getState")) << message_;
+IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, GetManagedProperties) {
+  SetupPolicyControlledNetworks();
+  EXPECT_TRUE(RunNetworkingTest("networkingPrivate", {"getManagedProperties"}))
+      << message_;
 }
 
-IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, GetStateNonExistent) {
-  EXPECT_TRUE(RunNetworkingSubtest("getStateNonExistent")) << message_;
+IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
+                       Alias_GetManagedProperties) {
+  SetupPolicyControlledNetworks();
+  EXPECT_TRUE(RunNetworkingTest("networking.onc", {"getManagedProperties"}))
+      << message_;
 }
-
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
                        SetCellularProperties) {
   SetupCellular();
-  EXPECT_TRUE(RunNetworkingSubtest("setCellularProperties")) << message_;
+  EXPECT_TRUE(RunNetworkingTest(
+      "networkingPrivate",
+      {"setCellularProperties", "setWiFiProperties", "SetVPNProperties"}))
+      << message_;
 }
 
-IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, SetWiFiProperties) {
-  EXPECT_TRUE(RunNetworkingSubtest("setWiFiProperties")) << message_;
+IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
+                       Alias_SetCellularProperties) {
+  SetupCellular();
+  EXPECT_TRUE(RunNetworkingTest(
+      "networking.onc",
+      {"setCellularProperties", "setWiFiProperties", "SetVPNProperties"}))
+      << message_;
 }
 
-IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, SetVPNProperties) {
-  EXPECT_TRUE(RunNetworkingSubtest("setVPNProperties")) << message_;
-}
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, CreateNetwork) {
-  EXPECT_TRUE(RunNetworkingSubtest("createNetwork")) << message_;
+  EXPECT_TRUE(RunNetworkingTest("networkingPrivate", {"createNetwork"}))
+      << message_;
 }
 
-IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, ForgetNetwork) {
-  EXPECT_TRUE(RunNetworkingSubtest("forgetNetwork")) << message_;
+IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, Alias_CreateNetwork) {
+  EXPECT_TRUE(RunNetworkingTest("networking.onc", {"createNetwork"}))
+      << message_;
 }
 
-// TODO(stevenjb): Find a better way to set this up on Chrome OS.
-IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, GetManagedProperties) {
-  const std::string uidata_blob =
-      "{ \"user_settings\": {"
-      "      \"WiFi\": {"
-      "        \"Passphrase\": \"FAKE_CREDENTIAL_VPaJDV9x\" }"
-      "    }"
-      "}";
-  service_test_->SetServiceProperty(kWifi2ServicePath, shill::kUIDataProperty,
-                                    base::StringValue(uidata_blob));
-  service_test_->SetServiceProperty(kWifi2ServicePath,
-                                    shill::kAutoConnectProperty,
-                                    base::FundamentalValue(false));
-
-  // Update the profile entry.
-  profile_test_->AddService(kUser1ProfilePath, kWifi2ServicePath);
-
-  content::RunAllPendingInMessageLoop();
-
-  const std::string user_policy_blob =
-      "{ \"NetworkConfigurations\": ["
-      "    { \"GUID\": \"stub_wifi2\","
-      "      \"Type\": \"WiFi\","
-      "      \"Name\": \"My WiFi Network\","
-      "      \"WiFi\": {"
-      "        \"HexSSID\": \"77696669325F50534B\","  // "wifi2_PSK"
-      "        \"Passphrase\": \"passphrase\","
-      "        \"Recommended\": [ \"AutoConnect\", \"Passphrase\" ],"
-      "        \"Security\": \"WPA-PSK\" }"
-      "    }"
-      "  ],"
-      "  \"Certificates\": [],"
-      "  \"Type\": \"UnencryptedConfiguration\""
-      "}";
-
-  policy::PolicyMap policy;
-  policy.Set(
-      policy::key::kOpenNetworkConfiguration, policy::POLICY_LEVEL_MANDATORY,
-      policy::POLICY_SCOPE_USER, policy::POLICY_SOURCE_CLOUD,
-      base::WrapUnique(new base::StringValue(user_policy_blob)), nullptr);
-  provider_.UpdateChromePolicy(policy);
-
-  content::RunAllPendingInMessageLoop();
+IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, ForgetNetwork) {
+  EXPECT_TRUE(RunNetworkingTest("networkingPrivate", {"forgetNetwork"}))
+      << message_;
+}
 
-  EXPECT_TRUE(RunNetworkingSubtest("getManagedProperties")) << message_;
+IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, Alias_ForgetNetwork) {
+  EXPECT_TRUE(RunNetworkingTest("networking.onc", {"forgetNetwork"}))
+      << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, GetErrorState) {
   chromeos::NetworkHandler::Get()->network_state_handler()->SetLastErrorForTest(
       kWifi1ServicePath, "TestErrorState");
-  EXPECT_TRUE(RunNetworkingSubtest("getErrorState")) << message_;
+  EXPECT_TRUE(RunNetworkingTest("networkingPrivate", {"getErrorState"}))
+      << message_;
+}
+
+IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, Alias_GetErrorState) {
+  chromeos::NetworkHandler::Get()->network_state_handler()->SetLastErrorForTest(
+      kWifi1ServicePath, "TestErrorState");
+  EXPECT_TRUE(RunNetworkingTest("networking.onc", {"getErrorState"}))
+      << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
                        OnNetworksChangedEventConnect) {
-  EXPECT_TRUE(RunNetworkingSubtest("onNetworksChangedEventConnect"))
+  EXPECT_TRUE(
+      RunNetworkingTest("networkingPrivate", {"onNetworksChangedEventConnect"}))
+      << message_;
+}
+
+IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
+                       Alias_OnNetworksChangedEventConnect) {
+  EXPECT_TRUE(
+      RunNetworkingTest("networking.onc", {"onNetworksChangedEventConnect"}))
       << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
                        OnNetworksChangedEventDisconnect) {
-  EXPECT_TRUE(RunNetworkingSubtest("onNetworksChangedEventDisconnect"))
+  EXPECT_TRUE(RunNetworkingTest("networkingPrivate",
+                                {"onNetworksChangedEventDisconnect"}))
+      << message_;
+}
+
+IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
+                       Alias_OnNetworksChangedEventDisconnect) {
+  EXPECT_TRUE(
+      RunNetworkingTest("networking.onc", {"onNetworksChangedEventDisconnect"}))
       << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
                        OnNetworkListChangedEvent) {
-  EXPECT_TRUE(RunNetworkingSubtest("onNetworkListChangedEvent")) << message_;
+  EXPECT_TRUE(
+      RunNetworkingTest("networkingPrivate", {"onNetworkListChangedEvent"}))
+      << message_;
+}
+
+IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
+                       Alias_OnNetworkListChangedEvent) {
+  EXPECT_TRUE(
+      RunNetworkingTest("networking.onc", {"onNetworkListChangedEvent"}))
+      << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
                        OnDeviceStateListChangedEvent) {
-  EXPECT_TRUE(RunNetworkingSubtest("onDeviceStateListChangedEvent"))
+  EXPECT_TRUE(
+      RunNetworkingTest("networkingPrivate", {"onDeviceStateListChangedEvent"}))
+      << message_;
+}
+
+IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
+                       Alias_OnDeviceStateListChangedEvent) {
+  EXPECT_TRUE(
+      RunNetworkingTest("networking.onc", {"onDeviceStateListChangedEvent"}))
       << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, VerifyDestination) {
-  EXPECT_TRUE(RunNetworkingSubtest("verifyDestination")) << message_;
+  EXPECT_TRUE(RunNetworkingTest("networkingPrivate", {"verifyDestination"}))
+      << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
                        VerifyAndEncryptCredentials) {
-  EXPECT_TRUE(RunNetworkingSubtest("verifyAndEncryptCredentials")) << message_;
+  EXPECT_TRUE(
+      RunNetworkingTest("networkingPrivate", {"verifyAndEncryptCredentials"}))
+      << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, VerifyAndEncryptData) {
-  EXPECT_TRUE(RunNetworkingSubtest("verifyAndEncryptData")) << message_;
+  EXPECT_TRUE(RunNetworkingTest("networkingPrivate", {"verifyAndEncryptData"}))
+      << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
                        SetWifiTDLSEnabledState) {
   device_test_->SetTDLSState(shill::kTDLSConnectedState);
-  EXPECT_TRUE(RunNetworkingSubtest("setWifiTDLSEnabledState")) << message_;
+  EXPECT_TRUE(
+      RunNetworkingTest("networkingPrivate", {"setWifiTDLSEnabledState"}))
+      << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, GetWifiTDLSStatus) {
   device_test_->SetTDLSState(shill::kTDLSConnectedState);
-  EXPECT_TRUE(RunNetworkingSubtest("getWifiTDLSStatus")) << message_;
+  EXPECT_TRUE(RunNetworkingTest("networkingPrivate", {"getWifiTDLSStatus"}))
+      << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
@@ -677,7 +829,31 @@ IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
       NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PROXY_AUTH_REQUIRED;
   detector()->SetDetectionResultsForTesting("stub_cellular1_guid", state);
 
-  EXPECT_TRUE(RunNetworkingSubtest("getCaptivePortalStatus")) << message_;
+  EXPECT_TRUE(
+      RunNetworkingTest("networkingPrivate", {"getCaptivePortalStatus"}))
+      << message_;
+}
+
+IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
+                       Alias_GetCaptivePortalStatus) {
+  SetupCellular();
+
+  NetworkPortalDetector::CaptivePortalState state;
+  state.status = NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE;
+  detector()->SetDetectionResultsForTesting("stub_ethernet_guid", state);
+
+  state.status = NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_OFFLINE;
+  detector()->SetDetectionResultsForTesting("stub_wifi1_guid", state);
+
+  state.status = NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL;
+  detector()->SetDetectionResultsForTesting("stub_wifi2_guid", state);
+
+  state.status =
+      NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PROXY_AUTH_REQUIRED;
+  detector()->SetDetectionResultsForTesting("stub_cellular1_guid", state);
+
+  EXPECT_TRUE(RunNetworkingTest("networking.onc", {"getCaptivePortalStatus"}))
+      << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
@@ -691,26 +867,47 @@ IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
       "notifyPortalDetectorObservers",
       base::Bind(&NetworkPortalDetectorTestImpl::NotifyObserversForTesting,
                  base::Unretained(detector())));
-  EXPECT_TRUE(RunNetworkingSubtest("captivePortalNotification")) << message_;
+  EXPECT_TRUE(
+      RunNetworkingTest("networkingPrivate", {"captivePortalNotification"}))
+      << message_;
+}
+
+IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
+                       Alias_CaptivePortalNotification) {
+  detector()->SetDefaultNetworkForTesting("wifi_guid");
+  NetworkPortalDetector::CaptivePortalState state;
+  state.status = NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE;
+  detector()->SetDetectionResultsForTesting("wifi_guid", state);
+
+  TestListener listener(
+      "notifyPortalDetectorObservers",
+      base::Bind(&NetworkPortalDetectorTestImpl::NotifyObserversForTesting,
+                 base::Unretained(detector())));
+  EXPECT_TRUE(
+      RunNetworkingTest("networking.onc", {"captivePortalNotification"}))
+      << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, UnlockCellularSim) {
   SetupCellular();
   // Lock the SIM
   device_test_->SetSimLocked(kCellularDevicePath, true);
-  EXPECT_TRUE(RunNetworkingSubtest("unlockCellularSim")) << message_;
+  EXPECT_TRUE(RunNetworkingTest("networkingPrivate", {"unlockCellularSim"}))
+      << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, SetCellularSimState) {
   SetupCellular();
-  EXPECT_TRUE(RunNetworkingSubtest("setCellularSimState")) << message_;
+  EXPECT_TRUE(RunNetworkingTest("networkingPrivate", {"setCellularSimState"}))
+      << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, CellularSimPuk) {
   SetupCellular();
   // Lock the SIM
   device_test_->SetSimLocked(kCellularDevicePath, true);
-  EXPECT_TRUE(RunNetworkingSubtest("cellularSimPuk")) << message_;
+  EXPECT_TRUE(RunNetworkingTest("networkingPrivate", {"cellularSimPuk"}))
+      << message_;
 }
 
 }  // namespace