Replace OncNetworkParser by the new ONC translator.

chrome/browser/chromeos/cros/network_library_impl_stub.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/network_library_impl_stub.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
+#include "base/stl_util.h"
 #include "chrome/browser/chromeos/cros/native_network_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/public/browser/browser_thread.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 using content::BrowserThread;
 
 namespace {
 
 bool IsEthernetEnabled() {
@@ skipping 17 matching lines @@
   if (IsEthernetEnabled())
     check_portal_list_ = "ethernet,wifi,cellular";
   else
     check_portal_list_ = "wifi,cellular";
 }
 
 NetworkLibraryImplStub::~NetworkLibraryImplStub() {
   disabled_wifi_networks_.clear();
   disabled_cellular_networks_.clear();
   disabled_wimax_networks_.clear();
+  STLDeleteValues(&service_configurations_);
 }
 
 void NetworkLibraryImplStub::Init() {
   is_locked_ = false;
 
   // Devices
   int devices = (1 << TYPE_WIFI) | (1 << TYPE_CELLULAR) | (1 << TYPE_WIMAX);
   if (IsEthernetEnabled())
     devices |= 1 << TYPE_ETHERNET;
   available_devices_ = devices;
@@ skipping 64 matching lines @@
   wifi2->set_encryption(SECURITY_NONE);
   AddStubNetwork(wifi2, PROFILE_SHARED);
 
   WifiNetwork* wifi3 = new WifiNetwork("wifi3");
   wifi3->set_name("Fake WiFi3 Encrypted with a long name");
   wifi3->set_strength(60);
   wifi3->set_encryption(SECURITY_WEP);
   wifi3->set_passphrase_required(true);
   AddStubNetwork(wifi3, PROFILE_USER);
 
+  CertificatePattern pattern;
+  IssuerSubjectPattern issuer;
+  issuer.set_organization("Google, Inc.");
+  pattern.set_issuer(issuer);
+  std::vector<std::string> enrollment_uris;
+  enrollment_uris.push_back("http://youtu.be/dQw4w9WgXcQ");
+  enrollment_uris.push_back("chrome-extension://abc/keygen-cert.html");
+  pattern.set_enrollment_uri_list(enrollment_uris);
+
   WifiNetwork* wifi_cert_pattern = new WifiNetwork("wifi_cert_pattern");
   wifi_cert_pattern->set_name("Fake WiFi CertPattern 802.1x");
   wifi_cert_pattern->set_strength(50);
   wifi_cert_pattern->set_connectable(false);
   wifi_cert_pattern->set_encryption(SECURITY_8021X);
   wifi_cert_pattern->SetEAPMethod(EAP_METHOD_TLS);
   wifi_cert_pattern->SetEAPUseSystemCAs(true);
   wifi_cert_pattern->SetEAPIdentity("user@example.com");
   wifi_cert_pattern->SetEAPPhase2Auth(EAP_PHASE_2_AUTH_AUTO);
   wifi_cert_pattern->set_client_cert_type(CLIENT_CERT_TYPE_PATTERN);
-  CertificatePattern pattern;
-  IssuerSubjectPattern subject;
-  subject.set_organization("Google Inc");
-  pattern.set_subject(subject);
-  std::vector<std::string> enrollment_uris;
-  enrollment_uris.push_back("http://www.google.com/chromebook");
-  pattern.set_enrollment_uri_list(enrollment_uris);
   wifi_cert_pattern->set_client_cert_pattern(pattern);
   wifi_cert_pattern->set_eap_save_credentials(true);
 
   AddStubNetwork(wifi_cert_pattern, PROFILE_USER);
 
   WifiNetwork* wifi4 = new WifiNetwork("wifi4");
   wifi4->set_name("Fake WiFi4 802.1x");
   wifi4->set_strength(50);
   wifi4->set_connectable(false);
   wifi4->set_encryption(SECURITY_8021X);
@@ skipping 107 matching lines @@
 
   VirtualNetwork* vpn4 = new VirtualNetwork("vpn4");
   vpn4->set_name("Fake VPN4 (policy-managed)");
   vpn4->set_server_hostname("vpn4server.fake.com");
   vpn4->set_provider_type(PROVIDER_TYPE_OPEN_VPN);
   NetworkUIData vpn4_ui_data;
   vpn4_ui_data.set_onc_source(onc::ONC_SOURCE_DEVICE_POLICY);
   vpn4->set_ui_data(vpn4_ui_data);
   AddStubNetwork(vpn4, PROFILE_USER);
 
+  VirtualNetwork* vpn_cert_pattern = new VirtualNetwork("vpn_cert_pattern");
+  vpn_cert_pattern->set_name("Fake VPN CertPattern");
+  vpn_cert_pattern->set_server_hostname("vpn4server.fake.com");
+  vpn_cert_pattern->set_provider_type(PROVIDER_TYPE_OPEN_VPN);
+  vpn_cert_pattern->set_client_cert_type(CLIENT_CERT_TYPE_PATTERN);
+  vpn_cert_pattern->set_client_cert_pattern(pattern);
+
+  AddStubNetwork(vpn_cert_pattern, PROFILE_USER);
+
   wifi_scanning_ = false;
   offline_mode_ = false;
 
   // Ensure our active network is connected and vice versa, otherwise our
   // autotest browser_tests sometimes conclude the device is offline.
   CHECK(active_network()->connected())
       << "Active: " << active_network()->name();
   CHECK(connected_network()->is_active());
 
   std::string test_blob(
@@ skipping 83 matching lines @@
     remembered_vpn->set_ui_data(vpn_ui_data);
     remembered = remembered_vpn;
   }
   if (remembered) {
     remembered->set_name(network->name());
     remembered->set_unique_id(network->unique_id());
     // ValidateAndAddRememberedNetwork will insert the network into the right
     // remembered_*_networks_ list and the remembered_network_map_.
     if (!ValidateAndAddRememberedNetwork(remembered))
       NOTREACHED();
+    remembered->set_profile_path(profile->path);
+    remembered->set_profile_type(profile->type);
   }
 }
 
 void NetworkLibraryImplStub::ConnectToNetwork(Network* network) {
   std::string passphrase;
   if (network->type() == TYPE_WIFI) {
     WifiNetwork* wifi = static_cast<WifiNetwork*>(network);
     if (wifi->passphrase_required())
       passphrase = wifi->passphrase();
   } else if (network->type() == TYPE_WIMAX) {
@@ skipping 69 matching lines @@
     const std::string& service_path) {}
 
 void NetworkLibraryImplStub::MonitorNetworkDeviceStart(
     const std::string& device_path) {}
 
 void NetworkLibraryImplStub::MonitorNetworkDeviceStop(
     const std::string& device_path) {}
 
 void NetworkLibraryImplStub::CallConfigureService(
     const std::string& identifier,
-    const DictionaryValue* info) {}
+    const DictionaryValue* info) {
+  DictionaryValue*& config_entry = service_configurations_[identifier];
+  delete config_entry;
+  config_entry = info->DeepCopy();
+}
 
 void NetworkLibraryImplStub::CallConnectToNetwork(Network* network) {
   // Immediately set the network to active to mimic shill's behavior.
   SetActiveNetwork(network->type(), network->service_path());
   // If a delay has been set (i.e. we are interactive), delay the call to
   // ConnectToNetwork (but signal observers since we changed connecting state).
   if (connect_delay_ms_) {
     // This class is a Singleton and won't be deleted until this callbacks has
     // run.
     BrowserThread::PostDelayedTask(
@@ skipping 262 matching lines @@
     dictionary->SetString(flimflam::kTypeProperty,
                           ConnectionTypeToString(network->type()));
     dictionary->SetString(flimflam::kNameProperty, network->name());
     dictionary->SetString(flimflam::kGuidProperty, network->unique_id());
     dictionary->SetString(flimflam::kStateProperty,
                           ConnectionStateToString(network->state()));
   }
   callback.Run(service_path, dictionary.get());
 }
 
+const std::map<std::string, base::DictionaryValue*>&
+NetworkLibraryImplStub::GetConfigurations() {
+  return service_configurations_;
+}
+
 }  // namespace chromeos