This updates the StaticIP configuration UI to match new mocks.

chrome/browser/chromeos/cros/network_library_impl_cros.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_IMPL_CROS_H_
 #define CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_IMPL_CROS_H_
 
 #include "chrome/browser/chromeos/cros/network_library_impl_base.h"
 
 namespace chromeos {
 
 class NetworkLibraryImplCros : public NetworkLibraryImplBase  {
  public:
   NetworkLibraryImplCros();
   virtual ~NetworkLibraryImplCros();
 
+  // Structure used to pass IP parameter info to a DoSetIPParameters callback,
+  // since Bind only takes up to six parameters.
+  struct IPParameterInfo {
+    std::string address;
+    std::string netmask;
+    std::string gateway;
+    std::string name_servers;
+    int dhcp_usage_mask;
+  };
+
   virtual void Init() OVERRIDE;
   virtual bool IsCros() const OVERRIDE;
 
   //////////////////////////////////////////////////////////////////////////////
   // NetworkLibraryImplBase implementation.
 
   virtual void MonitorNetworkStart(const std::string& service_path) OVERRIDE;
   virtual void MonitorNetworkStop(const std::string& service_path) OVERRIDE;
   virtual void MonitorNetworkDeviceStart(
       const std::string& device_path) OVERRIDE;
   virtual void MonitorNetworkDeviceStop(
       const std::string& device_path) OVERRIDE;
 
   virtual void CallConfigureService(const std::string& identifier,
-                                    const DictionaryValue* info) OVERRIDE;
+                                    const base::DictionaryValue* info) OVERRIDE;
   virtual void CallConnectToNetwork(Network* network) OVERRIDE;
   virtual void CallRequestWifiNetworkAndConnect(
       const std::string& ssid, ConnectionSecurity security) OVERRIDE;
   virtual void CallRequestVirtualNetworkAndConnect(
       const std::string& service_name,
       const std::string& server_hostname,
       ProviderType provider_type) OVERRIDE;
   virtual void CallDeleteRememberedNetwork(
       const std::string& profile_path,
       const std::string& service_path) OVERRIDE;
@@ skipping 24 matching lines @@
   virtual void CallEnableNetworkDeviceType(
       ConnectionType device, bool enable) OVERRIDE;
   virtual void CallRemoveNetwork(const Network* network) OVERRIDE;
 
   virtual void EnableOfflineMode(bool enable) OVERRIDE;
 
   virtual NetworkIPConfigVector GetIPConfigs(
       const std::string& device_path,
       std::string* hardware_address,
       HardwareAddressFormat format) OVERRIDE;
-  virtual void SetIPConfig(const NetworkIPConfig& ipconfig) OVERRIDE;
+  virtual void SetIPParameters(const std::string& service_path,
+                               const std::string& address,
+                               const std::string& netmask,
+                               const std::string& gateway,
+                               const std::string& name_servers,
+                               int dhcp_usage_mask) OVERRIDE;
 
   //////////////////////////////////////////////////////////////////////////////
   // Callbacks.
   void UpdateNetworkStatus(
       const std::string& path, const std::string& key, const Value& value);
 
   void UpdateNetworkDeviceStatus(
       const std::string& path, const std::string& key, const Value& value);
   // Cellular specific updates. Returns false if update was ignored / reverted
   // and notification should be skipped.
@@ skipping 22 matching lines @@
   void NetworkManagerUpdate(const std::string& manager_path,
                             const base::DictionaryValue* properties);
 
   void NetworkServiceUpdate(const std::string& service_path,
                             const base::DictionaryValue* properties);
   void RememberedNetworkServiceUpdate(const std::string& service_path,
                                       const base::DictionaryValue* properties);
   void NetworkDeviceUpdate(const std::string& device_path,
                            const base::DictionaryValue* properties);
 
+  // Second half of setting IP Parameters.  SetIPParameters above kicks off
+  // an async information fetch, and this completes the operation when that
+  // fetch is complete.
+  void SetIPParametersCallback(const IPParameterInfo& info,
+                               const std::string& service_path,
+                               const base::DictionaryValue* properties);

[stevenjb, 2012/08/13 17:43:44]

Does this need to be part of the public API? If so, then I suggest having
SetIPParameters also use IPParemeterInfo. Otherwise I would make this and
IPParemeterInfo private (and forward declare IPParemeterInfo, defining it in the
C++ file).

[Greg Spencer (Chromium), 2012/08/13 23:53:44]

No, I guess it doesn't.  I had thought that it needed to be public for Bind to
work, but I guess not.  Fixed.

+
   // Second half of refreshing IPConfig for a network.  Refreshes all IP config
   // paths found in properties.
   void RefreshIPConfigCallback(const std::string& device_path,
                                const base::DictionaryValue* properties);
 
  private:
   // This processes all Manager update messages.
   bool NetworkManagerStatusChanged(const std::string& key, const Value* value);
-  void ParseNetworkManager(const DictionaryValue& dict);
-  void UpdateTechnologies(const ListValue* technologies, int* bitfieldp);
-  void UpdateAvailableTechnologies(const ListValue* technologies);
-  void UpdateEnabledTechnologies(const ListValue* technologies);
-  void UpdateConnectedTechnologies(const ListValue* technologies);
+  void ParseNetworkManager(const base::DictionaryValue& dict);
+  void UpdateTechnologies(const base::ListValue* technologies, int* bitfieldp);
+  void UpdateAvailableTechnologies(const base::ListValue* technologies);
+  void UpdateEnabledTechnologies(const base::ListValue* technologies);
+  void UpdateConnectedTechnologies(const base::ListValue* technologies);
 
   // Update network lists.
-  void UpdateNetworkServiceList(const ListValue* services);
-  void UpdateWatchedNetworkServiceList(const ListValue* services);
+  void UpdateNetworkServiceList(const base::ListValue* services);
+  void UpdateWatchedNetworkServiceList(const base::ListValue* services);
   Network* ParseNetwork(const std::string& service_path,
-                        const DictionaryValue& info);
+                        const base::DictionaryValue& info);
 
-  void UpdateRememberedNetworks(const ListValue* profiles);
+  void UpdateRememberedNetworks(const base::ListValue* profiles);
   void RequestRememberedNetworksUpdate();
   void UpdateProfile(const std::string& profile_path,
-                     const DictionaryValue* properties);
+                     const base::DictionaryValue* properties);
   Network* ParseRememberedNetwork(const std::string& service_path,
-                                  const DictionaryValue& info);
+                                  const base::DictionaryValue& info);
 
   // NetworkDevice list management functions.
-  void UpdateNetworkDeviceList(const ListValue* devices);
+  void UpdateNetworkDeviceList(const base::ListValue* devices);
   void ParseNetworkDevice(const std::string& device_path,
-                          const DictionaryValue& info);
+                          const base::DictionaryValue& info);
 
   // Empty device observer to ensure that device property updates are received.
   class NetworkLibraryDeviceObserver : public NetworkDeviceObserver {
    public:
     virtual ~NetworkLibraryDeviceObserver() {}
     virtual void OnNetworkDeviceChanged(
         NetworkLibrary* cros, const NetworkDevice* device) OVERRIDE {}
   };
 
   typedef std::map<std::string, CrosNetworkWatcher*> NetworkWatcherMap;
@@ skipping 14 matching lines @@
 
   // Map of monitored devices.
   NetworkWatcherMap monitored_devices_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkLibraryImplCros);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_IMPL_CROS_H_