This moves the ONC parsing code into chromeos/network/onc

chrome/browser/chromeos/cros/onc_network_parser_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 "chrome/browser/chromeos/cros/onc_network_parser.h"
 
 #include <cert.h>
 #include <keyhi.h>
 #include <pk11pub.h>
 
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/cros/certificate_pattern.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/network_library.h"
-#include "chrome/browser/chromeos/cros/onc_constants.h"
 #include "chrome/browser/chromeos/login/mock_user_manager.h"
-#include "chrome/browser/chromeos/network_settings/onc_utils.h"
 #include "chrome/browser/net/pref_proxy_config_tracker_impl.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/net/x509_certificate_model.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_pref_service.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/network/onc/onc_constants.h"
+#include "chromeos/network/onc/onc_utils.h"
 #include "content/public/test/test_browser_thread.h"
 #include "crypto/nss_util.h"
 #include "net/base/cert_type.h"
 #include "net/base/crypto_module.h"
 #include "net/base/nss_cert_database.h"
 #include "net/base/x509_certificate.h"
 #include "net/proxy/proxy_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
@@ skipping 28 matching lines @@
   }
 
   virtual void TearDown() {
     EXPECT_TRUE(CleanupSlotContents(slot_->os_module_handle()));
     EXPECT_EQ(0U, ListCertsInSlot(slot_->os_module_handle()).size());
   }
 
   virtual scoped_ptr<base::ListValue> ReadNetworkConfigs(
       const std::string& filename) {
       FilePath path;
-      std::string error;
       PathService::Get(chrome::DIR_TEST_DATA, &path);
       path = path.AppendASCII("chromeos").AppendASCII("cros").Append(filename);
       CHECK(file_util::PathExists(path))
         << "Couldn't find test data file " << path.value();
       std::string contents;
       CHECK(file_util::ReadFileToString(path, &contents))
         << "Unable to read test data file " << path.value();
 
       scoped_ptr<base::DictionaryValue> root =
-          onc::ReadDictionaryFromJson(contents, &error);
-      CHECK(root.get() != NULL) << "ONC is not a valid json dictionary: "
-                                << error;
+          onc::ReadDictionaryFromJson(contents);
+      CHECK(root.get() != NULL) << "ONC is not a valid JSON dictionary.";
 
       base::ListValue* network_configs;
       CHECK(root->GetListWithoutPathExpansion(onc::kNetworkConfigurations,
                                               &network_configs));
       return make_scoped_ptr(network_configs->DeepCopy());
   }
 
   const base::Value* GetExpectedProperty(const Network* network,
                                          PropertyIndex index,
                                          base::Value::Type expected_type);
@@ skipping 81 matching lines @@
   bool bool_value = false;
   value->GetAsBoolean(&bool_value);
   EXPECT_EQ(expected, bool_value);
 }
 
 void OncNetworkParserTest::TestProxySettings(const std::string filename,
                                              net::ProxyConfig* net_config) {
   // Parse Network Configuration including ProxySettings dictionary.
   scoped_ptr<base::ListValue> network_configs = ReadNetworkConfigs(filename);
   OncNetworkParser parser(*network_configs,
-                          NetworkUIData::ONC_SOURCE_USER_IMPORT);
+                          onc::ONC_SOURCE_USER_IMPORT);
 
   scoped_ptr<Network> network(parser.ParseNetwork(0, NULL));
   ASSERT_TRUE(network.get());
   EXPECT_FALSE(network->proxy_config().empty());
 
   // Deserialize ProxyConfig string property of Network into
   // ProxyConfigDictionary and decode into net::ProxyConfig.
   JSONStringValueSerializer serializer(network->proxy_config());
   scoped_ptr<Value> value(serializer.Deserialize(NULL, NULL));
   ASSERT_TRUE(value.get());
   EXPECT_TRUE(value->GetType() == Value::TYPE_DICTIONARY);
   DictionaryValue* dict = static_cast<DictionaryValue*>(value.get());
   ProxyConfigDictionary proxy_dict(dict);
   EXPECT_TRUE(PrefProxyConfigTrackerImpl::PrefConfigToNetConfig(proxy_dict,
                                                                 net_config));
 }
 
 TEST_F(OncNetworkParserTest, TestCreateNetworkWifi) {
   scoped_ptr<base::ListValue> network_configs =
       ReadNetworkConfigs("network-wifi.onc");
   OncNetworkParser parser(*network_configs,
-                          NetworkUIData::ONC_SOURCE_USER_IMPORT);
+                          onc::ONC_SOURCE_USER_IMPORT);
 
   EXPECT_EQ(1, parser.GetNetworkConfigsSize());
   scoped_ptr<Network> network(parser.ParseNetwork(0, NULL));
   ASSERT_TRUE(network.get());
 
   EXPECT_EQ(chromeos::TYPE_WIFI, network->type());
   WifiNetwork* wifi = static_cast<WifiNetwork*>(network.get());
   EXPECT_EQ(chromeos::SECURITY_WEP, wifi->encryption());
   CheckStringProperty(wifi, PROPERTY_INDEX_SECURITY, flimflam::kSecurityWep);
   EXPECT_EQ("ssid", wifi->name());
   CheckStringProperty(wifi, PROPERTY_INDEX_SSID, "ssid");
   EXPECT_FALSE(wifi->auto_connect());
   EXPECT_EQ("0x1234567890", wifi->passphrase());
   CheckStringProperty(wifi, PROPERTY_INDEX_PASSPHRASE, "0x1234567890");
 }
 
 TEST_F(OncNetworkParserTest, TestCreateNetworkEthernet) {
   scoped_ptr<base::ListValue> network_configs =
       ReadNetworkConfigs("network-ethernet.onc");
   OncNetworkParser parser(*network_configs,
-                          NetworkUIData::ONC_SOURCE_USER_IMPORT);
+                          onc::ONC_SOURCE_USER_IMPORT);
 
   EXPECT_GE(parser.GetNetworkConfigsSize(), 1);
   scoped_ptr<Network> network(parser.ParseNetwork(0, NULL));
   ASSERT_TRUE(network.get());
 
   EXPECT_EQ(chromeos::TYPE_ETHERNET, network->type());
   EthernetNetwork* ethernet = static_cast<EthernetNetwork*>(network.get());
   EXPECT_EQ(ethernet->unique_id(), "{485d6076-dd44-6b6d-69787465725f5045}");
 }
 
 TEST_F(OncNetworkParserTest, TestLoadWifiCertificatePattern) {
   scoped_ptr<base::ListValue> network_configs =
       ReadNetworkConfigs("cert-pattern.onc");
   OncNetworkParser parser(*network_configs,
-                          NetworkUIData::ONC_SOURCE_USER_IMPORT);
+                          onc::ONC_SOURCE_USER_IMPORT);
   ASSERT_TRUE(parser.parse_error().empty());
   EXPECT_EQ(1, parser.GetNetworkConfigsSize());
   scoped_ptr<Network> network(parser.ParseNetwork(0, NULL));
   ASSERT_TRUE(network.get());
 
   EXPECT_EQ(chromeos::TYPE_WIFI, network->type());
   WifiNetwork* wifi = static_cast<WifiNetwork*>(network.get());
   EXPECT_EQ(chromeos::SECURITY_8021X, wifi->encryption());
   EXPECT_EQ("WirelessNetwork", wifi->name());
   EXPECT_FALSE(wifi->auto_connect());
   EXPECT_EQ("", wifi->passphrase());
   EXPECT_EQ(chromeos::EAP_METHOD_TLS, wifi->eap_method());
   EXPECT_EQ(chromeos::CLIENT_CERT_TYPE_PATTERN, wifi->client_cert_type());
   EXPECT_EQ("Google, Inc.",
             wifi->client_cert_pattern().issuer().organization());
   ASSERT_EQ(2ul, wifi->client_cert_pattern().enrollment_uri_list().size());
   EXPECT_EQ("http://youtu.be/dQw4w9WgXcQ",
             wifi->client_cert_pattern().enrollment_uri_list()[0]);
   EXPECT_EQ("chrome-extension://abc/keygen-cert.html",
             wifi->client_cert_pattern().enrollment_uri_list()[1]);
 }
 
 
 TEST_F(OncNetworkParserTest, TestLoadVPNCertificatePattern) {
   scoped_ptr<base::ListValue> network_configs =
       ReadNetworkConfigs("cert-pattern-vpn.onc");
   OncNetworkParser parser(*network_configs,
-                          NetworkUIData::ONC_SOURCE_USER_IMPORT);
+                          onc::ONC_SOURCE_USER_IMPORT);
   ASSERT_TRUE(parser.parse_error().empty());
   EXPECT_EQ(1, parser.GetNetworkConfigsSize());
   scoped_ptr<Network> network(parser.ParseNetwork(0, NULL));
   ASSERT_TRUE(network.get());
 
   EXPECT_EQ(chromeos::TYPE_VPN, network->type());
   VirtualNetwork* vpn = static_cast<VirtualNetwork*>(network.get());
   EXPECT_EQ("MyVPN", vpn->name());
   EXPECT_FALSE(vpn->auto_connect());
   EXPECT_EQ(chromeos::CLIENT_CERT_TYPE_PATTERN, vpn->client_cert_type());
   EXPECT_EQ("Google, Inc.",
             vpn->client_cert_pattern().issuer().organization());
   ASSERT_EQ(2ul, vpn->client_cert_pattern().enrollment_uri_list().size());
   EXPECT_EQ("http://youtu.be/dQw4w9WgXcQ",
             vpn->client_cert_pattern().enrollment_uri_list()[0]);
   EXPECT_EQ("chrome-extension://abc/keygen-cert.html",
             vpn->client_cert_pattern().enrollment_uri_list()[1]);
 }
 
 TEST_F(OncNetworkParserTest, TestNoCertificatePatternForDevicePolicy) {
   scoped_ptr<base::ListValue> network_configs =
       ReadNetworkConfigs("cert-pattern.onc");
   OncNetworkParser parser(*network_configs,
-                          NetworkUIData::ONC_SOURCE_DEVICE_POLICY);
+                          onc::ONC_SOURCE_DEVICE_POLICY);
 
   // Make sure we fail when parsing a certificate pattern from a device policy
   // ONC file.
   ASSERT_TRUE(parser.parse_error().empty());
   EXPECT_EQ(1, parser.GetNetworkConfigsSize());
   scoped_ptr<Network> network(parser.ParseNetwork(0, NULL));
   ASSERT_TRUE(network.get());
 
   EXPECT_EQ(chromeos::TYPE_WIFI, network->type());
   WifiNetwork* wifi = static_cast<WifiNetwork*>(network.get());
   EXPECT_EQ(chromeos::SECURITY_8021X, wifi->encryption());
   EXPECT_EQ("WirelessNetwork", wifi->name());
   EXPECT_FALSE(wifi->auto_connect());
   EXPECT_EQ("", wifi->passphrase());
   EXPECT_EQ(chromeos::EAP_METHOD_TLS, wifi->eap_method());
   EXPECT_EQ(chromeos::CLIENT_CERT_TYPE_PATTERN, wifi->client_cert_type());
   EXPECT_EQ("", wifi->client_cert_pattern().issuer().organization());
   ASSERT_EQ(0ul, wifi->client_cert_pattern().enrollment_uri_list().size());
 }
 
 TEST_F(OncNetworkParserTest, TestCreateNetworkWifiEAP1) {
   scoped_ptr<base::ListValue> network_configs =
       ReadNetworkConfigs("network-wifi-eap1.onc");
   OncNetworkParser parser(*network_configs,
-                          NetworkUIData::ONC_SOURCE_USER_IMPORT);
+                          onc::ONC_SOURCE_USER_IMPORT);
 
   EXPECT_EQ(1, parser.GetNetworkConfigsSize());
   scoped_ptr<Network> network(parser.ParseNetwork(0, NULL));
   ASSERT_TRUE(network.get());
 
   EXPECT_EQ(chromeos::TYPE_WIFI, network->type());
   WifiNetwork* wifi = static_cast<WifiNetwork*>(network.get());
   EXPECT_EQ(chromeos::SECURITY_8021X, wifi->encryption());
   CheckStringProperty(wifi, PROPERTY_INDEX_SECURITY, flimflam::kSecurity8021x);
   EXPECT_EQ("ssid", wifi->name());
   EXPECT_EQ(true, wifi->auto_connect());
   CheckBooleanProperty(wifi, PROPERTY_INDEX_AUTO_CONNECT, true);
   EXPECT_EQ(EAP_METHOD_PEAP, wifi->eap_method());
   CheckStringProperty(wifi, PROPERTY_INDEX_EAP_METHOD,
                       flimflam::kEapMethodPEAP);
   EXPECT_FALSE(wifi->eap_use_system_cas());
 }
 
 TEST_F(OncNetworkParserTest, TestCreateNetworkWifiEAP2) {
   scoped_ptr<base::ListValue> network_configs =
       ReadNetworkConfigs("network-wifi-eap2.onc");
   OncNetworkParser parser(*network_configs,
-                          NetworkUIData::ONC_SOURCE_USER_IMPORT);
+                          onc::ONC_SOURCE_USER_IMPORT);
 
   EXPECT_EQ(1, parser.GetNetworkConfigsSize());
   scoped_ptr<Network> network(parser.ParseNetwork(0, NULL));
   ASSERT_TRUE(network.get());
 
   EXPECT_EQ(chromeos::TYPE_WIFI, network->type());
   WifiNetwork* wifi = static_cast<WifiNetwork*>(network.get());
   EXPECT_EQ(chromeos::SECURITY_8021X, wifi->encryption());
   EXPECT_EQ("ssid", wifi->name());
   EXPECT_FALSE(wifi->auto_connect());
   EXPECT_EQ(EAP_METHOD_LEAP, wifi->eap_method());
   EXPECT_EQ(true, wifi->eap_use_system_cas());
   EXPECT_EQ("user", wifi->eap_identity());
   CheckStringProperty(wifi, PROPERTY_INDEX_EAP_IDENTITY, "user");
   EXPECT_EQ("pass", wifi->eap_passphrase());
   CheckStringProperty(wifi, PROPERTY_INDEX_EAP_PASSWORD, "pass");
   EXPECT_EQ("anon", wifi->eap_anonymous_identity());
   CheckStringProperty(wifi, PROPERTY_INDEX_EAP_ANONYMOUS_IDENTITY, "anon");
 }
 
 TEST_F(OncNetworkParserTest, TestCreateNetworkUnknownFields) {
   scoped_ptr<base::ListValue> network_configs =
       ReadNetworkConfigs("network-unknown-fields.onc");
   OncNetworkParser parser(*network_configs,
-                          NetworkUIData::ONC_SOURCE_USER_IMPORT);
+                          onc::ONC_SOURCE_USER_IMPORT);
   scoped_ptr<Network> network(parser.ParseNetwork(0, NULL));
   ASSERT_TRUE(network.get());
 
   EXPECT_EQ(chromeos::TYPE_WIFI, network->type());
   WifiNetwork* wifi = static_cast<WifiNetwork*>(network.get());
   EXPECT_EQ(chromeos::SECURITY_WEP, wifi->encryption());
   EXPECT_EQ("ssid", wifi->name());
   EXPECT_EQ("z123456789012", wifi->passphrase());
 }
 
 TEST_F(OncNetworkParserTest, TestCreateNetworkOpenVPN) {
   scoped_ptr<base::ListValue> network_configs =
       ReadNetworkConfigs("network-openvpn.onc");
   OncNetworkParser parser(*network_configs,
-                          NetworkUIData::ONC_SOURCE_USER_IMPORT);
+                          onc::ONC_SOURCE_USER_IMPORT);
 
   EXPECT_EQ(1, parser.GetNetworkConfigsSize());
   scoped_ptr<Network> network(parser.ParseNetwork(0, NULL));
   ASSERT_TRUE(network.get() != NULL);
 
   EXPECT_EQ(chromeos::TYPE_VPN, network->type());
   CheckStringProperty(network.get(), PROPERTY_INDEX_TYPE, flimflam::kTypeVPN);
   VirtualNetwork* vpn = static_cast<VirtualNetwork*>(network.get());
   EXPECT_EQ("MyVPN", vpn->name());
   EXPECT_EQ(PROVIDER_TYPE_OPEN_VPN, vpn->provider_type());
@@ skipping 37 matching lines @@
   CheckStringProperty(vpn, PROPERTY_INDEX_OPEN_VPN_TLSREMOTE,
                       "MyOpenVPNServer");
   EXPECT_FALSE(vpn->save_credentials());
   EXPECT_EQ("{55ca78f6-0842-4e1b-96a3-09a9e1a26ef5}", vpn->ca_cert_nss());
 }
 
 TEST_F(OncNetworkParserTest, TestCreateNetworkL2TPIPsec) {
   scoped_ptr<base::ListValue> network_configs =
       ReadNetworkConfigs("network-l2tp-ipsec.onc");
   OncNetworkParser parser(*network_configs,
-                          NetworkUIData::ONC_SOURCE_USER_IMPORT);
+                          onc::ONC_SOURCE_USER_IMPORT);
 
   EXPECT_EQ(1, parser.GetNetworkConfigsSize());
   scoped_ptr<Network> network(parser.ParseNetwork(0, NULL));
   ASSERT_TRUE(network != NULL);
 
   EXPECT_EQ(chromeos::TYPE_VPN, network->type());
   CheckStringProperty(network.get(), PROPERTY_INDEX_TYPE, flimflam::kTypeVPN);
   VirtualNetwork* vpn = static_cast<VirtualNetwork*>(network.get());
   EXPECT_EQ("MyL2TPVPN", vpn->name());
   EXPECT_EQ(PROVIDER_TYPE_L2TP_IPSEC_PSK, vpn->provider_type());
@@ skipping 80 matching lines @@
 }
 
 TEST(OncNetworkParserUserExpansionTest, GetUserExpandedValue) {
   ScopedMockUserManagerEnabler mock_user_manager;
   mock_user_manager.user_manager()->SetLoggedInUser("onc@example.com");
 
   EXPECT_CALL(*mock_user_manager.user_manager(), IsUserLoggedIn())
       .Times(2)
       .WillRepeatedly(Return(false));
 
-  NetworkUIData::ONCSource source = NetworkUIData::ONC_SOURCE_USER_IMPORT;
+  onc::ONCSource source = onc::ONC_SOURCE_USER_IMPORT;
 
   // Setup environment needed by UserManager.
   MessageLoop loop;
   content::TestBrowserThread ui_thread(content::BrowserThread::UI, &loop);
   base::ShadowingAtExitManager at_exit_manager;
   ScopedTestingLocalState local_state(
       static_cast<TestingBrowserProcess*>(g_browser_process));
 
   base::StringValue login_id_pattern("a ${LOGIN_ID} b");
   base::StringValue login_email_pattern("a ${LOGIN_EMAIL} b");
@@ skipping 16 matching lines @@
                 login_id_pattern, source));
   EXPECT_EQ("a onc@example.com b",
             chromeos::OncNetworkParser::GetUserExpandedValue(
                 login_email_pattern, source));
 }
 
 TEST_F(OncNetworkParserTest, TestRemoveNetworkWifi) {
   scoped_ptr<base::ListValue> network_configs =
       ReadNetworkConfigs("network-wifi-remove.onc");
   OncNetworkParser parser(*network_configs,
-                          NetworkUIData::ONC_SOURCE_USER_IMPORT);
+                          onc::ONC_SOURCE_USER_IMPORT);
   EXPECT_EQ(1, parser.GetNetworkConfigsSize());
   bool marked_for_removal = false;
   scoped_ptr<Network> network(parser.ParseNetwork(0, &marked_for_removal));
 
   EXPECT_TRUE(marked_for_removal);
   EXPECT_EQ("{485d6076-dd44-6b6d-69787465725f5045}", network->unique_id());
 }
 
 }  // namespace chromeos