Revert of Set HexSSID in network config before matching it against policies

extensions/browser/api/networking_private/networking_private_chromeos_unittest.cc

 // Copyright 2017 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 "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"
 #include "chromeos/dbus/shill_profile_client.h"
 #include "chromeos/dbus/shill_service_client.h"
 #include "chromeos/login/login_state.h"
 #include "chromeos/network/managed_network_configuration_handler.h"
 #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"
 #include "third_party/cros_system_api/dbus/shill/dbus-constants.h"
 
 namespace extensions {
 
 namespace {
 
 const char kUserHash[] = "test_user_hash";
 const char kUserProfilePath[] = "/network_profile/user/shill";
 
 const char kWifiDevicePath[] = "/device/stub_wifi_device";
 
 const char kSharedWifiServicePath[] = "/service/shared_wifi";
 const char kSharedWifiGuid[] = "shared_wifi_guid";
 const char kSharedWifiName[] = "shared_wifi";
 
 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 {
  public:
   NetworkingPrivateApiTest() {}
   ~NetworkingPrivateApiTest() override {}
 
   void SetUp() override {
     ApiUnitTest::SetUp();
 
@@ skipping 71 matching lines @@
                                       shill::kProfileProperty,
                                       base::Value(kUserProfilePath));
     profile_test_->AddService(kUserProfilePath, kPrivateWifiServicePath);
   }
 
   void SetUpNetworkPolicy() {
     chromeos::ManagedNetworkConfigurationHandler* config_handler =
         chromeos::NetworkHandler::Get()
             ->managed_network_configuration_handler();
 
-    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,
+                              base::ListValue(), base::DictionaryValue());
 
-    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, "",
-                              *device_policy_onc, base::DictionaryValue());
+                              base::ListValue(), base::DictionaryValue());
   }
 
   void AddSharedNetworkToUserProfile() {
     service_test_->SetServiceProperty(kSharedWifiServicePath,
                                       shill::kProfileProperty,
                                       base::Value(kUserProfilePath));
     profile_test_->AddService(kUserProfilePath, kSharedWifiServicePath);
 
     base::RunLoop().RunUntilIdle();
   }
@@ skipping 19 matching lines @@
   chromeos::ShillDeviceClient::TestInterface* device_test_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateApiTest);
 };
 
 TEST_F(NetworkingPrivateApiTest, SetSharedNetworkProperties) {
   EXPECT_EQ(networking_private::kErrorAccessToSharedConfig,
             RunFunctionAndReturnError(
                 new NetworkingPrivateSetPropertiesFunction(),
                 base::StringPrintf(
-                    R"(["%s", {"WiFi": {"Passphrase": "passphrase"}}])",
+                    "[\"%s\", {\"WiFi\": {\"Passphrase\": \"passphrase\"}}]",
                     kSharedWifiGuid)));
 }
 
 TEST_F(NetworkingPrivateApiTest, SetPrivateNetworkPropertiesWebUI) {
   scoped_refptr<NetworkingPrivateSetPropertiesFunction> set_properties =
       new NetworkingPrivateSetPropertiesFunction();
   set_properties->set_source_context_type(Feature::WEBUI_CONTEXT);
 
   RunFunction(
       set_properties.get(),
-      base::StringPrintf(R"(["%s", {"Priority": 0}])", kSharedWifiGuid));
+      base::StringPrintf("[\"%s\", {\"Priority\": 0}]", kSharedWifiGuid));
   EXPECT_EQ(ExtensionFunction::SUCCEEDED, *set_properties->response_type());
 
   const chromeos::NetworkState* network =
       chromeos::NetworkHandler::Get()
           ->network_state_handler()
           ->GetNetworkStateFromGuid(kSharedWifiGuid);
   ASSERT_TRUE(network);
   EXPECT_FALSE(network->IsPrivate());
   EXPECT_EQ(0, GetNetworkPriority(network));
 }
 
 TEST_F(NetworkingPrivateApiTest, SetPrivateNetworkProperties) {
   scoped_refptr<NetworkingPrivateSetPropertiesFunction> set_properties =
       new NetworkingPrivateSetPropertiesFunction();
   RunFunction(
       set_properties.get(),
-      base::StringPrintf(R"(["%s", {"Priority": 0}])", kPrivateWifiGuid));
+      base::StringPrintf("[\"%s\", {\"Priority\": 0}]", kPrivateWifiGuid));
   EXPECT_EQ(ExtensionFunction::SUCCEEDED, *set_properties->response_type());
 
   const chromeos::NetworkState* network =
       chromeos::NetworkHandler::Get()
           ->network_state_handler()
           ->GetNetworkStateFromGuid(kPrivateWifiGuid);
   ASSERT_TRUE(network);
   EXPECT_TRUE(network->IsPrivate());
   EXPECT_EQ(0, GetNetworkPriority(network));
 }
 
 TEST_F(NetworkingPrivateApiTest, CreateSharedNetwork) {
   EXPECT_EQ(
       networking_private::kErrorAccessToSharedConfig,
       RunFunctionAndReturnError(new NetworkingPrivateCreateNetworkFunction(),
-                                R"([true, {
-                                     "Type": "WiFi",
-                                     "WiFi": {
-                                       "SSID": "New network",
-                                       "Security": "None"
-                                     }
-                                   }])"));
+                                "[true, {"
+                                "  \"Type\": \"WiFi\","
+                                "  \"WiFi\": {"
+                                "    \"SSID\": \"New network\","
+                                "    \"Security\": \"None\""
+                                "}}]"));
 }
 
 TEST_F(NetworkingPrivateApiTest, CreateSharedNetworkWebUI) {
   scoped_refptr<NetworkingPrivateCreateNetworkFunction> create_network =
       new NetworkingPrivateCreateNetworkFunction();
   create_network->set_source_context_type(Feature::WEBUI_CONTEXT);
 
   std::unique_ptr<base::Value> result =
       RunFunctionAndReturnValue(create_network.get(),
-                                R"([true, {
-                                     "Priority": 1,
-                                     "Type": "WiFi",
-                                     "WiFi": {
-                                       "SSID": "New network",
-                                       "Security": "None"
-                                     }
-                                   }])");
+                                "[true, {"
+                                "  \"Priority\": 1,"
+                                "  \"Type\": \"WiFi\","
+                                "  \"WiFi\": {"
+                                "    \"SSID\": \"New network\","
+                                "    \"Security\": \"None\""
+                                "}}]");
 
   ASSERT_TRUE(result);
   ASSERT_TRUE(result->is_string());
 
   std::string guid = result->GetString();
   const chromeos::NetworkState* network = chromeos::NetworkHandler::Get()
                                               ->network_state_handler()
                                               ->GetNetworkStateFromGuid(guid);
   ASSERT_TRUE(network);
   EXPECT_FALSE(network->IsPrivate());
   ASSERT_EQ(1, GetNetworkPriority(network));
 }
 
 TEST_F(NetworkingPrivateApiTest, CreatePrivateNetwork) {
   std::unique_ptr<base::Value> result =
       RunFunctionAndReturnValue(new NetworkingPrivateCreateNetworkFunction(),
-                                R"([false, {
-                                     "Priority": 1,
-                                     "Type": "WiFi",
-                                     "WiFi": {
-                                       "SSID": "New WiFi",
-                                       "Security": "WPA-PSK"
-                                     }
-                                   }])");
+                                "[false, {"
+                                "  \"Priority\": 1,"
+                                "  \"Type\": \"WiFi\","
+                                "  \"WiFi\": {"
+                                "    \"SSID\": \"New WiFi\","
+                                "    \"Security\": \"WPA-PSK\""
+                                "}}]");
 
   ASSERT_TRUE(result);
   ASSERT_TRUE(result->is_string());
 
   // Test the created config can be changed now.
   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));
 
   scoped_refptr<NetworkingPrivateSetPropertiesFunction> set_properties =
       new NetworkingPrivateSetPropertiesFunction();
 
   RunFunction(set_properties.get(),
-              base::StringPrintf(R"(["%s", {"Priority": 2}])", guid.c_str()));
+              base::StringPrintf("[\"%s\", {\"Priority\": 2}]", guid.c_str()));
   EXPECT_EQ(ExtensionFunction::SUCCEEDED, *set_properties->response_type());
 
   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(R"([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(R"([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(R"([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(R"([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(R"([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(R"([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(R"([false, {
-                                                        "Priority": 1,
-                                                        "Type": "WiFi",
-                                                        "WiFi": {
-                                                          "HexSSID": "%s",
-                                                          "Security": "WPA-PSK"
-                                                        }
-                                                      }])",
-                                                   network_hex_ssid.c_str())));
-}
-
 }  // namespace extensions