Add remembered virtual networks to NetworkLibrary and internet options.

chrome/browser/chromeos/cros/network_library.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_
 #define CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_
 #pragma once
 
 #include <string>
 #include <vector>
@@ skipping 309 matching lines @@
   bool notify_failure() const { return notify_failure_; }
   const std::string& profile_path() const { return profile_path_; }
   NetworkProfileType profile_type() const { return profile_type_; }
 
   const std::string& unique_id() const { return unique_id_; }
 
   void set_notify_failure(bool state) { notify_failure_ = state; }
 
   // We don't have a setter for |favorite_| because to unfavorite a network is
   // equivalent to forget a network, so we call forget network on cros for
-  // that.  See ForgetWifiNetwork().
+  // that.  See ForgetNetwork().
 
   void SetAutoConnect(bool auto_connect);
 
   void SetName(const std::string& name);
 
   void SetSaveCredentials(bool save_credentials);
 
   // Return a string representation of the state code.
   std::string GetStateString() const;
 
   // Return a string representation of the error code.
   std::string GetErrorString() const;
 
   // Return true if the network must be in the user profile (e.g. has certs).
   virtual bool RequiresUserProfile() const;
 
+  // Copy any credentials from a remembered network that are unset in |this|.
+  virtual void CopyCredentialsFromRemembered(Network* remembered);
+
   // Static helper function.
   static bool IsConnectingState(ConnectionState state) {
     return (state == STATE_ASSOCIATION ||
             state == STATE_CONFIGURATION ||
             state == STATE_CARRIER);
   }
 
   // Sends the well-known TPM PIN to flimflam via D-Bus, because flimflam may
   // need it to access client certificates in the TPM for 802.1X, VPN, etc.
   void SendTpmPin(const std::string& tpm_pin);
 
  protected:
   Network(const std::string& service_path, ConnectionType type);
 
   // Parse name/value pairs from libcros.
   virtual bool ParseValue(int index, const Value* value);
   virtual void ParseInfo(const DictionaryValue* info);
 
   // Erase cached credentials, used when "Save password" is unchecked.
   virtual void EraseCredentials();
 
+  // Calculate a unique identifier for the network.
+  virtual void CalculateUniqueId();
+
   // Methods to asynchronously set network service properties
   virtual void SetStringProperty(const char* prop, const std::string& str,
                                  std::string* dest);
   virtual void SetBooleanProperty(const char* prop, bool b, bool* dest);
   virtual void SetIntegerProperty(const char* prop, int i, int* dest);
   virtual void SetValueProperty(const char* prop, Value* val);
   virtual void ClearProperty(const char* prop);
 
   // This will clear the property if string is empty. Otherwise, it will set it.
   virtual void SetOrClearStringProperty(const char* prop,
@@ skipping 94 matching lines @@
   const std::string& server_hostname() const { return server_hostname_; }
   ProviderType provider_type() const { return provider_type_; }
   const std::string& ca_cert_nss() const { return ca_cert_nss_; }
   const std::string& psk_passphrase() const { return psk_passphrase_; }
   const std::string& client_cert_id() const { return client_cert_id_; }
   const std::string& username() const { return username_; }
   const std::string& user_passphrase() const { return user_passphrase_; }
 
   // Network overrides.
   virtual bool RequiresUserProfile() const;
+  virtual void CopyCredentialsFromRemembered(Network* remembered);
 
   // Public getters.
   bool NeedMoreInfoToConnect() const;
   std::string GetProviderTypeString() const;
 
   // Public setters.
   void SetCACertNSS(const std::string& ca_cert_nss);
   void SetPSKPassphrase(const std::string& psk_passphrase);
   void SetClientCertID(const std::string& cert_id);
   void SetUsername(const std::string& username);
   void SetUserPassphrase(const std::string& user_passphrase);
 
  private:
   // Network overrides.
   virtual bool ParseValue(int index, const Value* value);
   virtual void ParseInfo(const DictionaryValue* info);
   virtual void EraseCredentials();
+  virtual void CalculateUniqueId();
 
   // VirtualNetwork private methods.
   bool ParseProviderValue(int index, const Value* value);
 
   void set_server_hostname(const std::string& server_hostname) {
     server_hostname_ = server_hostname;
   }
   void set_provider_type(ProviderType provider_type) {
     provider_type_ = provider_type;
   }
@@ skipping 214 matching lines @@
   // Return a string representation of the encryption code.
   // This not translated and should be only used for debugging purposes.
   std::string GetEncryptionString() const;
 
   // Return true if a passphrase or other input is required to connect.
   bool IsPassphraseRequired() const;
 
  private:
   // Network overrides.
   virtual void EraseCredentials();
+  virtual void CalculateUniqueId();
 
   // WirelessNetwork overrides.
   virtual bool ParseValue(int index, const Value* value);
-  virtual void ParseInfo(const DictionaryValue* info);
-
-  void CalculateUniqueId();
 
   void set_encryption(ConnectionSecurity encryption) {
     encryption_ = encryption;
   }
   void set_passphrase(const std::string& passphrase) {
     passphrase_ = passphrase;
   }
   void set_passphrase_required(bool passphrase_required) {
     passphrase_required_ = passphrase_required;
   }
@@ skipping 256 matching lines @@
 
   // Returns the list of remembered wifi networks.
   virtual const WifiNetworkVector& remembered_wifi_networks() const = 0;
 
   // Returns the current list of cellular networks.
   virtual const CellularNetworkVector& cellular_networks() const = 0;
 
   // Returns the current list of virtual networks.
   virtual const VirtualNetworkVector& virtual_networks() const = 0;
 
+  // Returns the current list of virtual networks.
+  virtual const VirtualNetworkVector& remembered_virtual_networks() const = 0;
+
   // Return a pointer to the device, if it exists, or NULL.
   virtual const NetworkDevice* FindNetworkDeviceByPath(
       const std::string& path) const = 0;
 
   // Returns device with TYPE_CELLULAR. Returns NULL if none exists.
   virtual const NetworkDevice* FindCellularDevice() const = 0;
 
   // Returns device with TYPE_ETHERNET. Returns NULL if none exists.
   virtual const NetworkDevice* FindEthernetDevice() const = 0;
 
   // Returns device with TYPE_WIFI. Returns NULL if none exists.
   virtual const NetworkDevice* FindWifiDevice() const = 0;
 
   // Return a pointer to the network, if it exists, or NULL.
   // NOTE: Never store these results, store service paths instead.
   // The pattern for doing an operation on a Network is:
   // Network* network = cros->FindNetworkByPath(service_path);
   // network->SetFoo();
   // network->Connect();
   // As long as this is done in sequence on the UI thread it will be safe;
   // the network list only gets updated on the UI thread.
   virtual Network* FindNetworkByPath(const std::string& path) const = 0;
   virtual WifiNetwork* FindWifiNetworkByPath(const std::string& path) const = 0;
   virtual CellularNetwork* FindCellularNetworkByPath(
       const std::string& path) const = 0;
   virtual VirtualNetwork* FindVirtualNetworkByPath(
       const std::string& path) const = 0;
 
-  // Returns the visible wifi network corresponding to the remembered
-  // wifi network, or NULL if the remembered network is not visible.
+  // Returns the visible network corresponding to the remembered network,
+  // or NULL if the remembered network is not visible.
   virtual Network* FindNetworkFromRemembered(
       const Network* remembered) const = 0;
 
   // Return a pointer to the remembered network, if it exists, or NULL.
   virtual Network* FindRememberedNetworkByPath(
       const std::string& path) const = 0;
 
   // Retrieves the data plans associated with |path|, NULL if there are no
   // associated plans.
   virtual const CellularDataPlanVector* GetDataPlans(
@@ skipping 100 matching lines @@
       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) = 0;
 
   // Disconnect from the specified network.
   virtual void DisconnectFromNetwork(const Network* network) = 0;
 
-  // Forget the wifi network corresponding to service_path.
-  virtual void ForgetWifiNetwork(const std::string& service_path) = 0;
+  // Forget the network corresponding to service_path.
+  virtual void ForgetNetwork(const std::string& service_path) = 0;
 
   // Move the network to the shared/global profile.
   virtual void SetNetworkProfile(const std::string& service_path,
                                  NetworkProfileType type) = 0;
 
   // Returns home carrier ID if available, otherwise empty string is returned.
   // Carrier ID format: <carrier name> (country). Ex.: "Verizon (us)".
   virtual std::string GetCellularHomeCarrierId() const = 0;
 
   virtual bool ethernet_available() const = 0;
@@ skipping 38 matching lines @@
   virtual void SetIPConfig(const NetworkIPConfig& ipconfig) = 0;
 
   // Factory function, creates a new instance and returns ownership.
   // For normal usage, access the singleton via CrosLibrary::Get().
   static NetworkLibrary* GetImpl(bool stub);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_