Add remembered virtual networks to NetworkLibrary and internet options.

chrome/browser/chromeos/cros/network_library.cc

 // Copyright (c) 2011 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.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/i18n/icu_encoding_detection.h"
@@ skipping 37 matching lines @@
 //   wifi_networks_: ordered vector of WifiNetwork* entries in network_map_,
 //       in descending order of importance.
 //  CellularNetwork
 //   active_cellular_: Cellular version of wifi_.
 //   cellular_networks_: Cellular version of wifi_.
 // network_unique_id_map_: map<unique_id,Network*> for visible networks.
 // remembered_network_map_: a canonical map<path,Network*> for all networks
 //     remembered in the active Profile ("favorites").
 // remembered_wifi_networks_: ordered vector of WifiNetwork* entries in
 //     remembered_network_map_, in descending order of preference.
+// remembered_virtual_networks_: ordered vector of VirtualNetwork* entries in
+//     remembered_network_map_, in descending order of preference.
 //
 // network_manager_monitor_: a handle to the libcros network Manager handler.
 // NetworkManagerStatusChanged: This handles all messages from the Manager.
 //   Messages are parsed here and the appropriate updates are then requested.
 //
 // UpdateNetworkServiceList: This is the primary Manager handler. It handles
 //  the "Services" message which list all visible networks. The handler
 //  rebuilds the network lists without destroying existing Network structures,
 //  then requests neccessary updates to be fetched asynchronously from
 //  libcros (RequestNetworkServiceInfo).
@@ skipping 1090 matching lines @@
     bool res = info->GetWithoutPathExpansion(key, &value);
     DCHECK(res);
     if (res) {
       int index = property_index_parser().Get(key);
       if (!ParseValue(index, value))  // virtual.
         VLOG(1) << "Network: " << name()
                 << " Type: " << ConnectionTypeToString(type())
                 << " Unhandled key: " << key;
     }
   }
+  CalculateUniqueId();
 }
 
 void Network::EraseCredentials() {
 }
 
+void Network::CalculateUniqueId() {
+  unique_id_ = name_;
+}
+
 bool Network::RequiresUserProfile() const {
   return false;
 }
 
+void Network::CopyCredentialsFromRemembered(Network* remembered) {
+}
+
 void Network::SetValueProperty(const char* prop, Value* val) {
   DCHECK(prop);
   DCHECK(val);
   if (!EnsureCrosLoaded())
     return;
   chromeos::SetNetworkServiceProperty(service_path_.c_str(), prop, val);
 }
 
 void Network::ClearProperty(const char* prop) {
   DCHECK(prop);
@@ skipping 210 matching lines @@
     default:
       return Network::ParseValue(index, value);
       break;
   }
   return false;
 }
 
 void VirtualNetwork::ParseInfo(const DictionaryValue* info) {
   Network::ParseInfo(info);
   VLOG(1) << "VPN: " << name()
+          << " Server: " << server_hostname()
           << " Type: " << ProviderTypeToString(provider_type());
   if (provider_type_ == PROVIDER_TYPE_L2TP_IPSEC_PSK) {
     if (!client_cert_id_.empty())
       provider_type_ = PROVIDER_TYPE_L2TP_IPSEC_USER_CERT;
   }
 }
 
 void VirtualNetwork::EraseCredentials() {
   WipeString(&ca_cert_nss_);
   WipeString(&psk_passphrase_);
   WipeString(&client_cert_id_);
   WipeString(&user_passphrase_);
 }
 
+void VirtualNetwork::CalculateUniqueId() {
+  std::string provider_type(ProviderTypeToString(provider_type_));
+  unique_id_ = provider_type + "|" + server_hostname_;
+}
+
 bool VirtualNetwork::RequiresUserProfile() const {
   return true;
 }
 
+void VirtualNetwork::CopyCredentialsFromRemembered(Network* remembered) {
+  DCHECK(remembered->type() == TYPE_VPN);
+  VirtualNetwork* remembered_vpn = static_cast<VirtualNetwork*>(remembered);
+  VLOG(1) << "Copy VPN credentials: " << name()
+          << " username: " << remembered_vpn->username();
+  if (ca_cert_nss_.empty())
+    ca_cert_nss_ = remembered_vpn->ca_cert_nss();
+  if (psk_passphrase_.empty())
+    psk_passphrase_ = remembered_vpn->psk_passphrase();
+  if (client_cert_id_.empty())
+    client_cert_id_ = remembered_vpn->client_cert_id();
+  if (username_.empty())
+    username_ = remembered_vpn->username();
+  if (user_passphrase_.empty())
+    user_passphrase_ = remembered_vpn->user_passphrase();
+}
+
 bool VirtualNetwork::NeedMoreInfoToConnect() const {
   if (server_hostname_.empty() || username_.empty() || user_passphrase_.empty())
     return true;
   switch (provider_type_) {
     case PROVIDER_TYPE_L2TP_IPSEC_PSK:
       if (psk_passphrase_.empty())
         return true;
       break;
     case PROVIDER_TYPE_L2TP_IPSEC_USER_CERT:
     case PROVIDER_TYPE_OPEN_VPN:
@@ skipping 522 matching lines @@
     : WirelessNetwork(service_path, TYPE_WIFI),
       encryption_(SECURITY_NONE),
       passphrase_required_(false),
       eap_method_(EAP_METHOD_UNKNOWN),
       eap_phase_2_auth_(EAP_PHASE_2_AUTH_AUTO),
       eap_use_system_cas_(true) {
 }
 
 WifiNetwork::~WifiNetwork() {}
 
-// Called from ParseNetwork after calling ParseInfo.
 void WifiNetwork::CalculateUniqueId() {
   ConnectionSecurity encryption = encryption_;
   // Flimflam treats wpa and rsn as psk internally, so convert those types
   // to psk for unique naming.
   if (encryption == SECURITY_WPA || encryption == SECURITY_RSN)
     encryption = SECURITY_PSK;
   std::string security = std::string(SecurityToString(encryption));
   unique_id_ = security + "|" + name_;
 }
 
@@ skipping 113 matching lines @@
     case PROPERTY_INDEX_EAP_PIN:
     case PROPERTY_INDEX_EAP_KEY_MGMT:
       // These properties are currently not used in the UI.
       return true;
     default:
       return WirelessNetwork::ParseValue(index, value);
   }
   return false;
 }
 
-void WifiNetwork::ParseInfo(const DictionaryValue* info) {
-  Network::ParseInfo(info);
-  CalculateUniqueId();
-}
-
 const std::string& WifiNetwork::GetPassphrase() const {
   if (!user_passphrase_.empty())
     return user_passphrase_;
   return passphrase_;
 }
 
 void WifiNetwork::SetPassphrase(const std::string& passphrase) {
   // Set the user_passphrase_ only; passphrase_ stores the flimflam value.
   // If the user sets an empty passphrase, restore it to the passphrase
   // remembered by flimflam.
@@ skipping 153 matching lines @@
   if (error_ == ERROR_BAD_PASSPHRASE || error_ == ERROR_BAD_WEPKEY)
     return true;
   // For 802.1x networks, configuration is required if connectable is false.
   if (encryption_ == SECURITY_8021X)
     return !connectable_;
   return passphrase_required_;
 }
 
 bool WifiNetwork::RequiresUserProfile() const {
   // 8021X requires certificates which are only stored for individual users.
-  if (encryption_ == SECURITY_8021X)
+  if (encryption_ == SECURITY_8021X &&
+      (eap_method_ == EAP_METHOD_TLS ||
+       !eap_client_cert_pkcs11_id().empty()))
     return true;
   return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkLibrary
 
 class NetworkLibraryImpl : public NetworkLibrary  {
  public:
   NetworkLibraryImpl()
@@ skipping 239 matching lines @@
   }
 
   virtual const CellularNetworkVector& cellular_networks() const {
     return cellular_networks_;
   }
 
   virtual const VirtualNetworkVector& virtual_networks() const {
     return virtual_networks_;
   }
 
+  virtual const VirtualNetworkVector& remembered_virtual_networks() const {
+    return remembered_virtual_networks_;
+  }
+
   /////////////////////////////////////////////////////////////////////////////
 
   virtual const NetworkDevice* FindNetworkDeviceByPath(
       const std::string& path) const {
     NetworkDeviceMap::const_iterator iter = device_map_.find(path);
     if (iter != device_map_.end())
       return iter->second;
     LOG(WARNING) << "Device path not found: " << path;
     return NULL;
   }
@@ skipping 65 matching lines @@
 
   virtual Network* FindNetworkFromRemembered(
       const Network* remembered) const {
     NetworkMap::const_iterator found =
         network_unique_id_map_.find(remembered->unique_id());
     if (found != network_unique_id_map_.end())
       return found->second;
     return NULL;
   }
 
+  Network* FindRememberedFromNetwork(const Network* network) const {
+    for (NetworkMap::const_iterator iter = remembered_network_map_.begin();
+         iter != remembered_network_map_.end(); ++iter) {
+      if (iter->second->unique_id() == network->unique_id())
+        return iter->second;
+    }
+    return NULL;
+  }
+
   virtual Network* FindRememberedNetworkByPath(const std::string& path) const {
     NetworkMap::const_iterator iter = remembered_network_map_.find(path);
     if (iter != remembered_network_map_.end())
       return iter->second;
     return NULL;
   }
 
   virtual const CellularDataPlanVector* GetDataPlans(
       const std::string& path) const {
     CellularDataPlanMap::const_iterator iter = data_plan_map_.find(path);
@@ skipping 523 matching lines @@
           active_wifi_ = NULL;
         else if (found_network == active_cellular_)
           active_cellular_ = NULL;
         else if (found_network == active_virtual_)
           active_virtual_ = NULL;
       }
       NotifyNetworkManagerChanged(true);  // Forced update.
     }
   }
 
-  virtual void ForgetWifiNetwork(const std::string& service_path) {
+  virtual void ForgetNetwork(const std::string& service_path) {
     if (!EnsureCrosLoaded())
       return;
     // Remove network from remembered list and notify observers.
-    DeleteRememberedWifiNetwork(service_path);
+    DeleteRememberedNetwork(service_path);
     NotifyNetworkManagerChanged(true);  // Forced update.
   }
 
   // Note: currently there is no way to change the profile of a network
   // unless it is visible (i.e. in network_map_). We change the profile by
   // setting the Profile property of the visible network.
   // See chromium-os:15523.
   virtual void SetNetworkProfile(const std::string& service_path,
                                  NetworkProfileType type) {
     Network* network = FindNetworkByPath(service_path);
@@ skipping 482 matching lines @@
   }
 
   static void RememberedNetworkServiceUpdate(void* object,
                                              const char* service_path,
                                              const Value* info) {
     NetworkLibraryImpl* networklib = static_cast<NetworkLibraryImpl*>(object);
     DCHECK(networklib);
     if (service_path) {
       if (!info) {
         // Remembered network no longer exists.
-        networklib->DeleteRememberedWifiNetwork(std::string(service_path));
+        networklib->DeleteRememberedNetwork(std::string(service_path));
       } else {
         DCHECK_EQ(info->GetType(), Value::TYPE_DICTIONARY);
         const DictionaryValue* dict = static_cast<const DictionaryValue*>(info);
         networklib->ParseRememberedNetwork(std::string(service_path), dict);
       }
     }
   }
 
   static void NetworkDeviceUpdate(void* object,
                                   const char* device_path,
@@ skipping 133 matching lines @@
           data_plan_map_.find(network->service_path());
       if (found != data_plan_map_.end()) {
         CellularDataPlanVector* data_plans = found->second;
         delete data_plans;
         data_plan_map_.erase(found);
       }
     }
     delete network;
   }
 
-  void AddRememberedWifiNetwork(WifiNetwork* wifi) {
+  void AddRememberedNetwork(Network* network) {
     std::pair<NetworkMap::iterator,bool> result =
         remembered_network_map_.insert(
-            std::make_pair(wifi->service_path(), wifi));
+            std::make_pair(network->service_path(), network));
     DCHECK(result.second);  // Should only get called with new network.
-    remembered_wifi_networks_.push_back(wifi);
+    if (network->type() == TYPE_WIFI) {
+      remembered_wifi_networks_.push_back(
+          static_cast<WifiNetwork*>(network));
+    } else if (network->type() == TYPE_VPN) {
+      remembered_virtual_networks_.push_back(
+          static_cast<VirtualNetwork*>(network));
+    } else {
+      NOTREACHED();
+    }
     // Find service path in profiles. Flimflam does not set the Profile
     // property for remembered networks, only active networks.
     for (NetworkProfileList::iterator iter = profile_list_.begin();
          iter != profile_list_.end(); ++iter) {
       NetworkProfile& profile = *iter;
-      if (profile.services.find(wifi->service_path()) !=
+      if (profile.services.find(network->service_path()) !=
           profile.services.end()) {
-        wifi->set_profile_path(profile.path);
-        wifi->set_profile_type(profile.type);
-        VLOG(1) << "AddRememberedWifiNetwork: " << wifi->service_path()
+        network->set_profile_path(profile.path);
+        network->set_profile_type(profile.type);
+        VLOG(1) << "AddRememberedNetwork: " << network->service_path()
                 << " Profile: " << profile.path;
         break;
       }
     }
-    DCHECK(!wifi->profile_path().empty())
-        << "Wifi service path not in any profile: " << wifi->service_path();
+    DCHECK(!network->profile_path().empty())
+        << "Service path not in any profile: " << network->service_path();
   }
 
-  void DeleteRememberedWifiNetwork(const std::string& service_path) {
+  void DeleteRememberedNetwork(const std::string& service_path) {
     NetworkMap::iterator found = remembered_network_map_.find(service_path);
     if (found == remembered_network_map_.end()) {
       LOG(WARNING) << "Attempt to delete non-existant remembered network: "
                    << service_path;
       return;
     }
 
     // Delete remembered network from lists.
     Network* remembered_network = found->second;
     remembered_network_map_.erase(found);
-    WifiNetworkVector::iterator iter = std::find(
-        remembered_wifi_networks_.begin(), remembered_wifi_networks_.end(),
-        remembered_network);
-    if (iter != remembered_wifi_networks_.end())
-      remembered_wifi_networks_.erase(iter);
 
+    if (remembered_network->type() == TYPE_WIFI) {
+      WifiNetworkVector::iterator iter = std::find(
+          remembered_wifi_networks_.begin(),
+          remembered_wifi_networks_.end(),
+          remembered_network);
+      if (iter != remembered_wifi_networks_.end())
+        remembered_wifi_networks_.erase(iter);
+    } else if (remembered_network->type() == TYPE_VPN) {
+      VirtualNetworkVector::iterator iter = std::find(
+          remembered_virtual_networks_.begin(),
+          remembered_virtual_networks_.end(),
+          remembered_network);
+      if (iter != remembered_virtual_networks_.end())
+        remembered_virtual_networks_.erase(iter);
+    }
     // Delete remembered network from all profiles it is in.
     for (NetworkProfileList::iterator iter = profile_list_.begin();
          iter != profile_list_.end(); ++iter) {
       NetworkProfile& profile = *iter;
       NetworkProfile::ServiceList::iterator found =
           profile.services.find(remembered_network->service_path());
       if (found != profile.services.end()) {
         VLOG(1) << "Deleting: " << remembered_network->service_path()
                 << " From: " << profile.path;
         chromeos::DeleteServiceFromProfile(
@@ skipping 208 matching lines @@
 
     network->ParseInfo(info);  // virtual.
 
     if (!network->unique_id().empty())
       network_unique_id_map_[network->unique_id()] = network;
 
     SetProfileTypeFromPath(network);
 
     UpdateActiveNetwork(network);
 
+    // Copy remembered credentials if required.
+    Network* remembered = FindRememberedFromNetwork(network);
+    if (remembered)
+      network->CopyCredentialsFromRemembered(remembered);
+
     // Find and erase entry in update_requests, and set network priority.
     PriorityMap::iterator found2 = network_update_requests_.find(service_path);
     if (found2 != network_update_requests_.end()) {
       network->priority_order_ = found2->second;
       network_update_requests_.erase(found2);
       if (network_update_requests_.empty()) {
         // Clear wifi_scanning_ when we have no pending requests.
         wifi_scanning_ = false;
       }
     } else {
       // TODO(stevenjb): Enable warning once UpdateNetworkServiceList is fixed.
       // LOG(WARNING) << "ParseNetwork called with no update request entry: "
       //              << service_path;
     }
 
     VLOG(1) << "ParseNetwork: " << network->name()
             << " Path: " << network->service_path()
             << " Profile: " << network->profile_path_;
     NotifyNetworkManagerChanged(false);  // Not forced.
     return network;
   }
 
   // Returns NULL if |service_path| refers to a network that is not a
   // remembered type. Called from RememberedNetworkServiceUpdate.
   Network* ParseRememberedNetwork(const std::string& service_path,
                                   const DictionaryValue* info) {
-    Network* network;
+    Network* remembered;
     NetworkMap::iterator found = remembered_network_map_.find(service_path);
     if (found != remembered_network_map_.end()) {
-      network = found->second;
+      remembered = found->second;
     } else {
       ConnectionType type = ParseTypeFromDictionary(info);
-      if (type == TYPE_WIFI) {
-        network = CreateNewNetwork(type, service_path);
-        WifiNetwork* wifi = static_cast<WifiNetwork*>(network);
-        AddRememberedWifiNetwork(wifi);
+      if (type == TYPE_WIFI || type == TYPE_VPN) {
+        remembered = CreateNewNetwork(type, service_path);
+        AddRememberedNetwork(remembered);
       } else {
         VLOG(1) << "Ignoring remembered network: " << service_path
                 << " Type: " << ConnectionTypeToString(type);
         return NULL;
       }
     }
-    network->ParseInfo(info);  // virtual.
+    remembered->ParseInfo(info);  // virtual.
 
-    SetProfileTypeFromPath(network);
+    SetProfileTypeFromPath(remembered);
 
-    VLOG(1) << "ParseRememberedNetwork: " << network->name()
-            << " Path: " << network->service_path()
-            << " Profile: " << network->profile_path_;
+    VLOG(1) << "ParseRememberedNetwork: " << remembered->name()
+            << " Path: " << remembered->service_path()
+            << " Profile: " << remembered->profile_path_;
     NotifyNetworkManagerChanged(false);  // Not forced.
-    return network;
+
+    if (remembered->type() == TYPE_VPN) {
+      // VPNs are only stored in profiles. If we don't have a network for it,
+      // request one.
+      if (!FindNetworkFromRemembered(remembered)) {
+        VirtualNetwork* vpn = static_cast<VirtualNetwork*>(remembered);
+        std::string provider_type = ProviderTypeToString(vpn->provider_type());
+        VLOG(1) << "Requesting VPN: " << vpn->name()
+                << " Server: " << vpn->server_hostname()
+                << " Type: " << provider_type;
+        RequestVirtualNetwork(
+            vpn->name().c_str(),
+            vpn->server_hostname().c_str(),
+            provider_type.c_str(),
+            NetworkServiceUpdate,
+            this);
+      }
+    }
+
+    return remembered;
   }
 
   void SetProfileType(Network* network, NetworkProfileType type) {
     if (type == PROFILE_NONE) {
       network->SetProfilePath(std::string());
       network->set_profile_type(PROFILE_NONE);
     } else {
       std::string profile_path = GetProfilePath(type);
       if (!profile_path.empty()) {
         network->SetProfilePath(profile_path);
@@ skipping 41 matching lines @@
     active_cellular_ = NULL;
     active_virtual_ = NULL;
     wifi_networks_.clear();
     cellular_networks_.clear();
     virtual_networks_.clear();
   }
 
   void ClearRememberedNetworks() {
     remembered_network_map_.clear();
     remembered_wifi_networks_.clear();
+    remembered_virtual_networks_.clear();
   }
 
   void DeleteNetworks() {
     STLDeleteValues(&network_map_);
     ClearNetworks();
   }
 
   void DeleteRememberedNetworks() {
     STLDeleteValues(&remembered_network_map_);
     ClearRememberedNetworks();
@@ skipping 472 matching lines @@
     active_cellular_ = cellular1;
 
     CellularNetwork* cellular2 = new CellularNetwork("fc2");
     cellular2->set_name("Fake Cellular 2");
     cellular2->set_strength(70);
     cellular2->set_connected(true);
     cellular2->set_activation_state(ACTIVATION_STATE_ACTIVATED);
     cellular2->set_network_technology(NETWORK_TECHNOLOGY_UMTS);
     AddNetwork(cellular2);
 
-    // Remembered Networks
-    DeleteRememberedNetworks();
-    NetworkProfile profile("default", PROFILE_SHARED);
-    profile.services.insert("fw2");
-    profile_list_.push_back(profile);
-    WifiNetwork* remembered_wifi2 = new WifiNetwork("fw2");
-    remembered_wifi2->set_name("Fake Wifi 2");
-    remembered_wifi2->set_strength(70);
-    remembered_wifi2->set_connected(true);
-    remembered_wifi2->set_encryption(SECURITY_WEP);
-    AddRememberedWifiNetwork(remembered_wifi2);
-
     // VPNs.
     VirtualNetwork* vpn1 = new VirtualNetwork("fv1");
     vpn1->set_name("Fake VPN Provider 1");
     vpn1->set_server_hostname("vpn1server.fake.com");
     vpn1->set_provider_type(VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_PSK);
     vpn1->set_username("VPN User 1");
     vpn1->set_connected(false);
     AddNetwork(vpn1);
 
     VirtualNetwork* vpn2 = new VirtualNetwork("fv2");
     vpn2->set_name("Fake VPN Provider 2");
     vpn2->set_server_hostname("vpn2server.fake.com");
     vpn2->set_provider_type(VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT);
     vpn2->set_username("VPN User 2");
     vpn2->set_connected(true);
     AddNetwork(vpn2);
 
     VirtualNetwork* vpn3 = new VirtualNetwork("fv3");
     vpn3->set_name("Fake VPN Provider 3");
     vpn3->set_server_hostname("vpn3server.fake.com");
     vpn3->set_provider_type(VirtualNetwork::PROVIDER_TYPE_OPEN_VPN);
     vpn3->set_connected(false);
     AddNetwork(vpn3);
 
     active_virtual_ = vpn2;
 
+    // Remembered Networks
+    DeleteRememberedNetworks();
+    NetworkProfile profile("default", PROFILE_SHARED);
+    profile.services.insert("fw2");
+    profile.services.insert("fv2");
+    profile_list_.push_back(profile);
+    WifiNetwork* remembered_wifi2 = new WifiNetwork("fw2");
+    remembered_wifi2->set_name("Fake Wifi 2");
+    remembered_wifi2->set_encryption(SECURITY_WEP);
+    AddRememberedNetwork(remembered_wifi2);
+    VirtualNetwork* remembered_vpn2 = new VirtualNetwork("fv2");
+    remembered_vpn2->set_name("Fake VPN Provider 2");
+    remembered_vpn2->set_server_hostname("vpn2server.fake.com");
+    remembered_vpn2->set_provider_type(
+        VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT);
+    remembered_vpn2->set_connected(true);
+    AddRememberedNetwork(remembered_vpn2);
+
     wifi_scanning_ = false;
     offline_mode_ = false;
   }
 
   // Network manager observer list
   ObserverList<NetworkManagerObserver> network_manager_observers_;
 
   // Cellular data plan observer list
   ObserverList<CellularDataPlanObserver> data_plan_observers_;
 
@@ skipping 56 matching lines @@
 
   // The current connected (or connecting) cellular network.
   CellularNetwork* active_cellular_;
 
   // The list of available virtual networks.
   VirtualNetworkVector virtual_networks_;
 
   // The current connected (or connecting) virtual network.
   VirtualNetwork* active_virtual_;
 
+  // The remembered virtual networks.
+  VirtualNetworkVector remembered_virtual_networks_;
+
   // The path of the active profile (for retrieving remembered services).
   std::string active_profile_path_;
 
   // The current available network devices. Bitwise flag of ConnectionTypes.
   int available_devices_;
 
   // The current enabled network devices. Bitwise flag of ConnectionTypes.
   int enabled_devices_;
 
   // The current connected network devices. Bitwise flag of ConnectionTypes.
@@ skipping 106 matching lines @@
   }
   virtual const WifiNetworkVector& remembered_wifi_networks() const {
     return wifi_networks_;
   }
   virtual const CellularNetworkVector& cellular_networks() const {
     return cellular_networks_;
   }
   virtual const VirtualNetworkVector& virtual_networks() const {
     return virtual_networks_;
   }
+  virtual const VirtualNetworkVector& remembered_virtual_networks() const {
+    return virtual_networks_;
+  }
   virtual bool has_cellular_networks() const {
     return cellular_networks_.begin() != cellular_networks_.end();
   }
   /////////////////////////////////////////////////////////////////////////////
 
   virtual const NetworkDevice* FindNetworkDeviceByPath(
       const std::string& path) const { return NULL; }
   virtual const NetworkDevice* FindCellularDevice() const {
     return NULL;
   }
@@ skipping 62 matching lines @@
   virtual void ConnectToVirtualNetworkCert(
       const std::string& service_name,
       const std::string& server_hostname,
       const std::string& server_ca_cert_nss_nickname,
       const std::string& client_cert_pkcs11_id,
       const std::string& username,
       const std::string& user_passphrase) {}
   virtual void SignalCellularPlanPayment() {}
   virtual bool HasRecentCellularPlanPayment() { return false; }
   virtual void DisconnectFromNetwork(const Network* network) {}
-  virtual void ForgetWifiNetwork(const std::string& service_path) {}
+  virtual void ForgetNetwork(const std::string& service_path) {}
   virtual void SetNetworkProfile(const std::string& service_path,
                                  NetworkProfileType type) {}
   virtual std::string GetCellularHomeCarrierId() const { return std::string(); }
   virtual bool ethernet_available() const { return true; }
   virtual bool wifi_available() const { return false; }
   virtual bool cellular_available() const { return false; }
   virtual bool ethernet_enabled() const { return true; }
   virtual bool wifi_enabled() const { return false; }
   virtual bool cellular_enabled() const { return false; }
   virtual bool wifi_scanning() const { return false; }
@@ skipping 29 matching lines @@
     return new NetworkLibraryStubImpl();
   else
     return new NetworkLibraryImpl();
 }
 
 }  // namespace chromeos
 
 // Allows InvokeLater without adding refcounting. This class is a Singleton and
 // won't be deleted until it's last InvokeLater is run.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(chromeos::NetworkLibraryImpl);