Set HexSSID in network config before matching it against policies

extensions/browser/api/networking_private/networking_private_chromeos_unittest.cc

Index: extensions/browser/api/networking_private/networking_private_chromeos_unittest.cc
diff --git a/extensions/browser/api/networking_private/networking_private_chromeos_unittest.cc b/extensions/browser/api/networking_private/networking_private_chromeos_unittest.cc
index 6bed63200f9235161eae415ca9b73c42546e2b2b..aeba373ac970780b9ab48c222db80484bf6a7f9a 100644
--- a/extensions/browser/api/networking_private/networking_private_chromeos_unittest.cc
+++ b/extensions/browser/api/networking_private/networking_private_chromeos_unittest.cc
@@ -5,6 +5,7 @@
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_device_client.h"
@@ -15,6 +16,7 @@
 #include "chromeos/network/network_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
+#include "components/onc/onc_constants.h"
 #include "extensions/browser/api/networking_private/networking_private_api.h"
 #include "extensions/browser/api_unittest.h"
 #include "extensions/common/value_builder.h"
@@ -37,6 +39,12 @@ const char kPrivateWifiServicePath[] = "/service/private_wifi";
 const char kPrivateWifiGuid[] = "private_wifi_guid";
 const char kPrivateWifiName[] = "private_wifi";
 
+const char kManagedUserWifiGuid[] = "managed_user_wifi_guid";
+const char kManagedUserWifiSsid[] = "managed_user_wifi";
+
+const char kManagedDeviceWifiGuid[] = "managed_device_wifi_guid";
+const char kManagedDeviceWifiSsid[] = "managed_device_wifi";
+
 }  // namespace
 
 class NetworkingPrivateApiTest : public ApiUnitTest {
@@ -128,11 +136,45 @@ class NetworkingPrivateApiTest : public ApiUnitTest {
         chromeos::NetworkHandler::Get()
             ->managed_network_configuration_handler();
 
-    config_handler->SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUserHash,
-                              base::ListValue(), base::DictionaryValue());
+    const std::string user_policy_ssid = kManagedUserWifiSsid;
+    std::unique_ptr<base::ListValue> user_policy_onc =
+        ListBuilder()
+            .Append(DictionaryBuilder()
+                        .Set("GUID", kManagedUserWifiGuid)
+                        .Set("Type", "WiFi")
+                        .Set("WiFi",
+                             DictionaryBuilder()
+                                 .Set("Passphrase", "fake")
+                                 .Set("SSID", user_policy_ssid)
+                                 .Set("HexSSID",
+                                      base::HexEncode(user_policy_ssid.c_str(),
+                                                      user_policy_ssid.size()))
+                                 .Set("Security", "WPA-PSK")
+                                 .Build())
+                        .Build())
+            .Build();
 
+    config_handler->SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUserHash,
+                              *user_policy_onc, base::DictionaryValue());
+
+    const std::string device_policy_ssid = kManagedDeviceWifiSsid;
+    std::unique_ptr<base::ListValue> device_policy_onc =
+        ListBuilder()
+            .Append(DictionaryBuilder()
+                        .Set("GUID", kManagedDeviceWifiGuid)
+                        .Set("Type", "WiFi")
+                        .Set("WiFi",
+                             DictionaryBuilder()
+                                 .Set("SSID", device_policy_ssid)
+                                 .Set("HexSSID", base::HexEncode(
+                                                     device_policy_ssid.c_str(),
+                                                     device_policy_ssid.size()))
+                                 .Set("Security", "None")
+                                 .Build())
+                        .Build())
+            .Build();
     config_handler->SetPolicy(::onc::ONC_SOURCE_DEVICE_POLICY, "",
-                              base::ListValue(), base::DictionaryValue());
+                              *device_policy_onc, base::DictionaryValue());
   }
 
   void AddSharedNetworkToUserProfile() {
@@ -284,4 +326,133 @@ TEST_F(NetworkingPrivateApiTest, CreatePrivateNetwork) {
   EXPECT_EQ(2, GetNetworkPriority(network));
 }
 
+TEST_F(NetworkingPrivateApiTest, CreatePrivateNetwork_NonMatchingSsids) {
+  const std::string network_ssid = "new_wifi_config";
+  const std::string network_hex_ssid =
+      base::HexEncode(network_ssid.c_str(), network_ssid.size());
+  std::unique_ptr<base::Value> result = RunFunctionAndReturnValue(
+      new NetworkingPrivateCreateNetworkFunction(),
+      base::StringPrintf("[false, {"
+                         "  \"Priority\": 1,"
+                         "  \"Type\": \"WiFi\","
+                         "  \"WiFi\": {"
+                         "    \"SSID\": \"New WiFi\","
+                         "    \"HexSSID\": \"%s\","
+                         "    \"Security\": \"WPA-PSK\""
+                         "}}]",
+                         network_hex_ssid.c_str()));
+
+  ASSERT_TRUE(result);
+  ASSERT_TRUE(result->is_string());
+
+  // Test the created config can be changed now.
+  const std::string guid = result->GetString();
+  const chromeos::NetworkState* network = chromeos::NetworkHandler::Get()
+                                              ->network_state_handler()
+                                              ->GetNetworkStateFromGuid(guid);
+  ASSERT_TRUE(network);
+  EXPECT_TRUE(network->IsPrivate());
+  EXPECT_EQ(1, GetNetworkPriority(network));
+  EXPECT_EQ(network_hex_ssid, network->GetHexSsid());
+  EXPECT_EQ(network_ssid, network->name());
+}
+
+TEST_F(NetworkingPrivateApiTest,
+       CreateAlreadyConfiguredUserPrivateNetwork_BySsid) {
+  EXPECT_EQ("NetworkAlreadyConfigured",
+            RunFunctionAndReturnError(
+                new NetworkingPrivateCreateNetworkFunction(),
+                base::StringPrintf("[false, {"
+                                   "  \"Priority\": 1,"
+                                   "  \"Type\": \"WiFi\","
+                                   "  \"WiFi\": {"
+                                   "    \"SSID\": \"%s\","
+                                   "    \"Security\": \"WPA-PSK\""
+                                   "}}]",
+                                   kManagedUserWifiSsid)));
+}
+
+TEST_F(NetworkingPrivateApiTest,
+       CreateAlreadyConfiguredUserPrivateNetwork_ByHexSsid) {
+  std::string network_hex_ssid =
+      base::HexEncode(kManagedUserWifiSsid, sizeof(kManagedUserWifiSsid) - 1);
+  EXPECT_EQ("NetworkAlreadyConfigured",
+            RunFunctionAndReturnError(
+                new NetworkingPrivateCreateNetworkFunction(),
+                base::StringPrintf("[false, {"
+                                   "  \"Priority\": 1,"
+                                   "  \"Type\": \"WiFi\","
+                                   "  \"WiFi\": {"
+                                   "    \"HexSSID\": \"%s\","
+                                   "    \"Security\": \"WPA-PSK\""
+                                   "}}]",
+                                   network_hex_ssid.c_str())));
+}
+
+TEST_F(NetworkingPrivateApiTest,
+       CreateAlreadyConfiguredUserPrivateNetwork_NonMatchingSsids) {
+  std::string network_hex_ssid =
+      base::HexEncode(kManagedUserWifiSsid, sizeof(kManagedUserWifiSsid) - 1);
+  // HexSSID should take presedence over SSID.
+  EXPECT_EQ("NetworkAlreadyConfigured",
+            RunFunctionAndReturnError(
+                new NetworkingPrivateCreateNetworkFunction(),
+                base::StringPrintf("[false, {"
+                                   "  \"Priority\": 1,"
+                                   "  \"Type\": \"WiFi\","
+                                   "  \"WiFi\": {"
+                                   "    \"SSID\": \"wrong_ssid\","
+                                   "    \"HexSSID\": \"%s\","
+                                   "    \"Security\": \"WPA-PSK\""
+                                   "}}]",
+                                   network_hex_ssid.c_str())));
+}
+
+TEST_F(NetworkingPrivateApiTest,
+       CreateAlreadyConfiguredUserPrivateNetwork_ByHexSSID) {
+  std::string network_hex_ssid =
+      base::HexEncode(kManagedUserWifiSsid, sizeof(kManagedUserWifiSsid) - 1);
+  EXPECT_EQ("NetworkAlreadyConfigured",
+            RunFunctionAndReturnError(
+                new NetworkingPrivateCreateNetworkFunction(),
+                base::StringPrintf("[false, {"
+                                   "  \"Priority\": 1,"
+                                   "  \"Type\": \"WiFi\","
+                                   "  \"WiFi\": {"
+                                   "    \"HexSSID\": \"%s\","
+                                   "    \"Security\": \"WPA-PSK\""
+                                   "}}]",
+                                   network_hex_ssid.c_str())));
+}
+
+TEST_F(NetworkingPrivateApiTest, CreateAlreadyConfiguredDeviceNetwork) {
+  EXPECT_EQ(
+      "NetworkAlreadyConfigured",
+      RunFunctionAndReturnError(new NetworkingPrivateCreateNetworkFunction(),
+                                base::StringPrintf("[false, {"
+                                                   "  \"Priority\": 1,"
+                                                   "  \"Type\": \"WiFi\","
+                                                   "  \"WiFi\": {"
+                                                   "    \"SSID\": \"%s\""
+                                                   "}}]",
+                                                   kManagedDeviceWifiSsid)));
+}
+
+TEST_F(NetworkingPrivateApiTest,
+       CreateAlreadyConfiguredDeviceNetwork_ByHexSSID) {
+  std::string network_hex_ssid = base::HexEncode(
+      kManagedDeviceWifiSsid, sizeof(kManagedDeviceWifiSsid) - 1);
+  EXPECT_EQ("NetworkAlreadyConfigured",
+            RunFunctionAndReturnError(
+                new NetworkingPrivateCreateNetworkFunction(),
+                base::StringPrintf("[false, {"
+                                   "  \"Priority\": 1,"
+                                   "  \"Type\": \"WiFi\","
+                                   "  \"WiFi\": {"
+                                   "    \"HexSSID\": \"%s\","
+                                   "    \"Security\": \"WPA-PSK\""
+                                   "}}]",
+                                   network_hex_ssid.c_str())));
+}
+
 }  // namespace extensions