Remove most of NetworkUIData.

chromeos/network/network_connection_handler_unittest.cc

 // Copyright (c) 2012 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 "chromeos/network/network_connection_handler.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
@@ skipping 73 matching lines @@
         dbus_manager->GetShillManagerClient()->GetTestInterface();
     test_service_client_ =
         dbus_manager->GetShillServiceClient()->GetTestInterface();
 
     test_manager_client_->AddTechnology(shill::kTypeWifi, true /* enabled */);
     dbus_manager->GetShillDeviceClient()->GetTestInterface()->AddDevice(
         "/device/wifi1", shill::kTypeWifi, "wifi_device1");
     test_manager_client_->AddTechnology(shill::kTypeCellular,
                                         true /* enabled */);
     dbus_manager->GetShillProfileClient()->GetTestInterface()->AddProfile(
-        "profile_path", std::string() /* shared profile */);
+        "shared_profile_path", std::string() /* shared profile */);
+    dbus_manager->GetShillProfileClient()->GetTestInterface()->AddProfile(
+        "user_profile_path", user_.username_hash());
 
     base::RunLoop().RunUntilIdle();
     LoginState::Initialize();
     network_state_handler_.reset(NetworkStateHandler::InitializeForTest());
     network_config_handler_.reset(
         NetworkConfigurationHandler::InitializeForTest(
             network_state_handler_.get()));
 
     network_profile_handler_.reset(new NetworkProfileHandler());
     network_profile_handler_->Init();
@@ skipping 108 matching lines @@
 
     scoped_refptr<net::CryptoModule> module(
         net::CryptoModule::CreateFromHandle(nssdb->GetPrivateSlot().get()));
     ASSERT_EQ(
         net::OK,
         nssdb->ImportFromPKCS12(module, pkcs12_data, base::string16(), false,
                                 loaded_certs));
     ASSERT_EQ(1U, loaded_certs->size());
   }
 
-  void SetupPolicy() {
-    const char* kNetworkConfigs =
-        "[ { \"GUID\": \"wifi1\","
-        "    \"Name\": \"wifi1\","
-        "    \"Type\": \"WiFi\","
-        "    \"WiFi\": {"
-        "      \"Security\": \"WPA-PSK\","
-        "      \"SSID\": \"wifi1\","
-        "      \"Passphrase\": \"passphrase\""
-        "    }"
-        "} ]";
-
+  void SetupPolicy(const std::string& network_configs_json,
+                   const base::DictionaryValue& global_config,
+                   bool user_policy) {
     std::string error;
     scoped_ptr<base::Value> network_configs_value(
-        base::JSONReader::ReadAndReturnError(
-            kNetworkConfigs, base::JSON_ALLOW_TRAILING_COMMAS, NULL, &error));
+        base::JSONReader::ReadAndReturnError(network_configs_json,
+                                             base::JSON_ALLOW_TRAILING_COMMAS,
+                                             NULL,
+                                             &error));
     ASSERT_TRUE(network_configs_value) << error;
 
     base::ListValue* network_configs = NULL;
     ASSERT_TRUE(network_configs_value->GetAsList(&network_configs));
 
-    base::DictionaryValue global_config;
-    global_config.SetBooleanWithoutPathExpansion(
-        ::onc::global_network_config::kAllowOnlyPolicyNetworksToAutoconnect,
-        true);
-
-    managed_config_handler_->SetPolicy(::onc::ONC_SOURCE_USER_POLICY,
-                                       "", // userhash
-                                       *network_configs,
-                                       global_config);
+    if (user_policy) {
+      managed_config_handler_->SetPolicy(
+          ::onc::ONC_SOURCE_USER_POLICY,
+          user_.username_hash(),
+          *network_configs,
+          global_config);
+    } else {
+      managed_config_handler_->SetPolicy(::onc::ONC_SOURCE_DEVICE_POLICY,
+                                         std::string(),  // no username hash
+                                         *network_configs,
+                                         global_config);
+    }
     base::RunLoop().RunUntilIdle();
   }
 
   scoped_ptr<NetworkStateHandler> network_state_handler_;
   scoped_ptr<NetworkConfigurationHandler> network_config_handler_;
   scoped_ptr<NetworkConnectionHandler> network_connection_handler_;
   scoped_ptr<ManagedNetworkConfigurationHandlerImpl> managed_config_handler_;
   scoped_ptr<NetworkProfileHandler> network_profile_handler_;
   crypto::ScopedTestNSSChromeOSUser user_;
   ShillManagerClient::TestInterface* test_manager_client_;
@@ skipping 52 matching lines @@
             GetResultAndReset());
 
   EXPECT_TRUE(Configure(kConfigRequiresActivation));
   Connect("cellular1");
   EXPECT_EQ(NetworkConnectionHandler::kErrorActivationRequired,
             GetResultAndReset());
 }
 
 namespace {
 
-const char* kConfigRequiresCertificateTemplate =
-    "{ \"GUID\": \"wifi4\", \"Type\": \"wifi\", \"Connectable\": false,"
-    "  \"Security\": \"802_1x\","
-    "  \"UIData\": \"{"
-    "    \\\"certificate_type\\\": \\\"pattern\\\","
-    "    \\\"certificate_pattern\\\": {"
-    "      \\\"Subject\\\": {\\\"CommonName\\\": \\\"%s\\\" }"
-    "   } }\" }";
+const char* kPolicyWithCertPatternTemplate =
+    "[ { \"GUID\": \"wifi4\","
+    "    \"Name\": \"wifi4\","
+    "    \"Type\": \"WiFi\","
+    "    \"WiFi\": {"
+    "      \"Security\": \"WPA-EAP\","
+    "      \"SSID\": \"wifi_ssid\","
+    "      \"EAP\": {"
+    "        \"Outer\": \"EAP-TLS\","
+    "        \"ClientCertType\": \"Pattern\","
+    "        \"ClientCertPattern\": {"
+    "          \"Subject\": {"
+    "            \"CommonName\" : \"%s\""
+    "          }"
+    "        }"
+    "      }"
+    "    }"
+    "} ]";
 
 }  // namespace
 
 // Handle certificates.
 TEST_F(NetworkConnectionHandlerTest, ConnectCertificateMissing) {
   StartCertLoader();
+  SetupPolicy(base::StringPrintf(kPolicyWithCertPatternTemplate, "unknown"),
+              base::DictionaryValue(),  // no global config
+              true);                    // load as user policy
 
-  EXPECT_TRUE(Configure(
-      base::StringPrintf(kConfigRequiresCertificateTemplate, "unknown")));
   Connect("wifi4");
   EXPECT_EQ(NetworkConnectionHandler::kErrorCertificateRequired,
             GetResultAndReset());
 }
 
 TEST_F(NetworkConnectionHandlerTest, ConnectWithCertificateSuccess) {
   StartCertLoader();
 
   net::CertificateList certs;
   ImportClientCertAndKey("websocket_client_cert.p12",
                          test_nssdb_.get(),
                          &certs);
 
-  EXPECT_TRUE(Configure(
-      base::StringPrintf(kConfigRequiresCertificateTemplate,
-                         certs[0]->subject().common_name.c_str())));
+  SetupPolicy(base::StringPrintf(kPolicyWithCertPatternTemplate,
+                                 certs[0]->subject().common_name.c_str()),
+              base::DictionaryValue(),  // no global config
+              true);                    // load as user policy
 
   Connect("wifi4");
   EXPECT_EQ(kSuccessResult, GetResultAndReset());
 }
 
 TEST_F(NetworkConnectionHandlerTest,
        ConnectWithCertificateRequestedBeforeCertsAreLoaded) {
   net::CertificateList certs;
   ImportClientCertAndKey("websocket_client_cert.p12",
                          test_nssdb_.get(),
                          &certs);
 
-  EXPECT_TRUE(Configure(
-      base::StringPrintf(kConfigRequiresCertificateTemplate,
-                         certs[0]->subject().common_name.c_str())));
+  SetupPolicy(base::StringPrintf(kPolicyWithCertPatternTemplate,
+                                 certs[0]->subject().common_name.c_str()),
+              base::DictionaryValue(),  // no global config
+              true);                    // load as user policy
 
   Connect("wifi4");
 
   // Connect request came before the cert loader loaded certificates, so the
   // connect request should have been throttled until the certificates are
   // loaded.
   EXPECT_EQ("", GetResultAndReset());
 
   StartCertLoader();
 
@@ skipping 22 matching lines @@
 }
 
 namespace {
 
 const char* kConfigUnmanagedSharedConnected =
     "{ \"GUID\": \"wifi0\", \"Type\": \"wifi\", \"State\": \"online\" }";
 const char* kConfigManagedSharedConnectable =
     "{ \"GUID\": \"wifi1\", \"Type\": \"wifi\", \"State\": \"idle\", "
     "  \"Connectable\": true }";
 
+const char* kPolicy =
+    "[ { \"GUID\": \"wifi1\","
+    "    \"Name\": \"wifi1\","
+    "    \"Type\": \"WiFi\","
+    "    \"WiFi\": {"
+    "      \"Security\": \"WPA-PSK\","
+    "      \"SSID\": \"wifi1\","
+    "      \"Passphrase\": \"passphrase\""
+    "    }"
+    "} ]";
+
 }  // namespace
 
 TEST_F(NetworkConnectionHandlerTest, ReconnectOnLoginEarlyPolicyLoading) {
   EXPECT_TRUE(Configure(kConfigUnmanagedSharedConnected));
   EXPECT_TRUE(Configure(kConfigManagedSharedConnectable));
   test_manager_client_->SetBestServiceToConnect("wifi1");
 
   // User login shouldn't trigger any change because policy is not loaded yet.
   LoginToRegularUser();
   EXPECT_EQ(shill::kStateOnline,
             GetServiceStringProperty("wifi0", shill::kStateProperty));
   EXPECT_EQ(shill::kStateIdle,
             GetServiceStringProperty("wifi1", shill::kStateProperty));
 
-  // Policy application should disconnect from the shared and unmanaged network.
-  SetupPolicy();
+  // Applying the policy which restricts autoconnect should disconnect from the
+  // shared, unmanaged network.
+  base::DictionaryValue global_config;
+  global_config.SetBooleanWithoutPathExpansion(
+      ::onc::global_network_config::kAllowOnlyPolicyNetworksToAutoconnect,
+      true);
+
+  SetupPolicy(kPolicy, global_config, false /* load as device policy */);
   EXPECT_EQ(shill::kStateIdle,
             GetServiceStringProperty("wifi0", shill::kStateProperty));
   EXPECT_EQ(shill::kStateIdle,
             GetServiceStringProperty("wifi1", shill::kStateProperty));
 
   // Certificate loading should trigger connecting to the 'best' network.
   StartCertLoader();
   EXPECT_EQ(shill::kStateIdle,
             GetServiceStringProperty("wifi0", shill::kStateProperty));
   EXPECT_EQ(shill::kStateOnline,
             GetServiceStringProperty("wifi1", shill::kStateProperty));
 }
 
 TEST_F(NetworkConnectionHandlerTest, ReconnectOnLoginLatePolicyLoading) {
   EXPECT_TRUE(Configure(kConfigUnmanagedSharedConnected));
   EXPECT_TRUE(Configure(kConfigManagedSharedConnectable));
   test_manager_client_->SetBestServiceToConnect("wifi1");
 
   // User login and certificate loading shouldn't trigger any change until the
   // policy is loaded.
   LoginToRegularUser();
   StartCertLoader();
   EXPECT_EQ(shill::kStateOnline,
             GetServiceStringProperty("wifi0", shill::kStateProperty));
   EXPECT_EQ(shill::kStateIdle,
             GetServiceStringProperty("wifi1", shill::kStateProperty));
 
-  SetupPolicy();
+  // Applying the policy which restricts autoconnect should disconnect from the
+  // shared, unmanaged network.
+  base::DictionaryValue global_config;
+  global_config.SetBooleanWithoutPathExpansion(
+      ::onc::global_network_config::kAllowOnlyPolicyNetworksToAutoconnect,
+      true);
+
+  SetupPolicy(kPolicy, global_config, false /* load as device policy */);
   EXPECT_EQ(shill::kStateIdle,
             GetServiceStringProperty("wifi0", shill::kStateProperty));
   EXPECT_EQ(shill::kStateOnline,
             GetServiceStringProperty("wifi1", shill::kStateProperty));
 }
 
 }  // namespace chromeos