Resubmit CL. See 8429004.

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 <dbus/dbus-glib.h>
 #include <dbus/dbus-gtype-specialized.h>
 #include <glib-object.h>
 
 #include <algorithm>
 #include <list>
 #include <map>
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/i18n/icu_encoding_detection.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/i18n/time_formatting.h"
+#include "base/json/json_writer.h"  // for debug output only.
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversion_utils.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/cros_settings.h"
@@ skipping 277 matching lines @@
     case Value::TYPE_BINARY:
     case Value::TYPE_LIST:
       // Other Value types shouldn't be passed through this mechanism.
       NOTREACHED() << "Unconverted Value of type: " << value->GetType();
       return new GValue();
   }
   NOTREACHED() << "Value conversion failed, type: " << value->GetType();
   return new GValue();
 }
 
+GHashTable* ConvertDictionaryValueToGValueMap(const DictionaryValue* dict) {
+  GHashTable* ghash =
+      g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
+  for (DictionaryValue::key_iterator it = dict->begin_keys();
+       it != dict->end_keys(); ++it) {
+    std::string key = *it;
+    Value* val = NULL;
+    if (dict->Get(key, &val)) {
+      g_hash_table_insert(ghash,
+                          g_strdup(const_cast<char*>(key.c_str())),
+                          ConvertValueToGValue(val));
+    }
+  }
+  return ghash;
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // FoundCellularNetwork
 
 FoundCellularNetwork::FoundCellularNetwork() {}
 
 FoundCellularNetwork::~FoundCellularNetwork() {}
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 45 matching lines @@
       auto_connect_(false),
       save_credentials_(false),
       priority_order_(0),
       added_(false),
       notify_failure_(false),
       profile_type_(PROFILE_NONE),
       service_path_(service_path),
       type_(type) {
 }
 
-Network::~Network() {}
+Network::~Network() {
+  for (PropertyMap::const_iterator props = property_map_.begin();
+       props != property_map_.end(); ++props) {
+     delete props->second;
+  }
+}
 
 void Network::SetNetworkParser(NetworkParser* parser) {
   network_parser_.reset(parser);
 }
 
+void Network::UpdatePropertyMap(PropertyIndex index, const base::Value& value) {
+  // Add the property to property_map_.  Delete previous value if necessary.
+  Value*& entry = property_map_[index];
+  delete entry;
+  entry = value.DeepCopy();
+  if (VLOG_IS_ON(2)) {
+    std::string value_json;
+    base::JSONWriter::Write(&value, true, &value_json);
+    VLOG(2) << "Updated property map on network: "
+            << unique_id() << "[" << index << "] = " << value_json;
+  }
+}
+
 void Network::SetState(ConnectionState new_state) {
   if (new_state == state_)
     return;
   ConnectionState old_state = state_;
   state_ = new_state;
   if (!IsConnectingState(new_state))
     set_connection_started(false);
   if (new_state == STATE_FAILURE) {
     if (old_state != STATE_UNKNOWN &&
         old_state != STATE_IDLE) {
@@ skipping 1057 matching lines @@
   // Called from ConnectToWifiNetwork.
   // Calls ConnectToWifiNetworkUsingConnectData if network request succeeds.
   virtual void CallRequestWifiNetworkAndConnect(
       const std::string& ssid, ConnectionSecurity security) = 0;
   // Called from ConnectToVirtualNetwork*.
   // Calls ConnectToVirtualNetworkUsingConnectData if network request succeeds.
   virtual void CallRequestVirtualNetworkAndConnect(
       const std::string& service_name,
       const std::string& server_hostname,
       ProviderType provider_type) = 0;
+  // Call to configure a wifi service. The identifier is either a service_path
+  // or a GUID. |info| is a dictionary of property values.
+  virtual void CallConfigureService(const std::string& identifier,
+                                    const DictionaryValue* info) = 0;
   // Called from NetworkConnectStart.
   // Calls NetworkConnectCompleted when the connection attept completes.
   virtual void CallConnectToNetwork(Network* network) = 0;
   // Called from DeleteRememberedNetwork.
   virtual void CallDeleteRememberedNetwork(
       const std::string& profile_path, const std::string& service_path) = 0;
 
   // Called from Enable*NetworkDevice.
   // Asynchronously enables or disables the specified device type.
   virtual void CallEnableNetworkDeviceType(
@@ skipping 1308 matching lines @@
   for (int i = 0; i < parser.GetCertificatesSize(); i++) {
     // Insert each of the available certs into the certificate DB.
     if (!parser.ParseCertificate(i)) {
       DLOG(WARNING) << "Cannot parse certificate in ONC file";
       return false;
     }
   }
 
   for (int i = 0; i < parser.GetNetworkConfigsSize(); i++) {
     // Parse Open Network Configuration blob into a temporary Network object.
-    Network* network = parser.ParseNetwork(i);
-    if (!network) {
+    scoped_ptr<Network> network(parser.ParseNetwork(i));
+    if (!network.get()) {
       DLOG(WARNING) << "Cannot parse networks in ONC file";
       return false;
     }
 
-    // TODO(chocobo): Pass parsed network values to flimflam update network.
+    DictionaryValue dict;
+    for (Network::PropertyMap::const_iterator props =
+             network->property_map_.begin();
+         props != network->property_map_.end(); ++props) {
+      std::string key =
+          NativeNetworkParser::property_mapper()->GetKey(props->first);
+      if (!key.empty())
+        dict.SetWithoutPathExpansion(key, props->second->DeepCopy());
+    }
+
+    CallConfigureService(network->unique_id(), &dict);
   }
   return parser.GetNetworkConfigsSize() != 0;
 }
 
 ////////////////////////////////////////////////////////////////////////////
 // Testing functions.
 
 bool NetworkLibraryImplBase::SetActiveNetwork(
     ConnectionType type, const std::string& service_path) {
   Network* network = NULL;
@@ skipping 478 matching lines @@
   //////////////////////////////////////////////////////////////////////////////
   // 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;
   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 43 matching lines @@
   static void PinOperationCallback(void* object,
                                    const char* path,
                                    NetworkMethodErrorType error,
                                    const char* error_message);
 
   static void CellularRegisterCallback(void* object,
                                        const char* path,
                                        NetworkMethodErrorType error,
                                        const char* error_message);
 
+  static void ConfigureServiceCallback(void* object,
+                                       const char* service_path,
+                                       NetworkMethodErrorType error,
+                                       const char* error_message);
+
   static void NetworkConnectCallback(void* object,
                                      const char* service_path,
                                      NetworkMethodErrorType error,
                                      const char* error_message);
 
   static void WifiServiceUpdateAndConnect(
       void* object, const char* service_path, GHashTable* ghash);
   static void VPNServiceUpdateAndConnect(
       void* object, const char* service_path, GHashTable* ghash);
 
@@ skipping 238 matching lines @@
       chromeos::RequestNetworkDeviceProperties(path.c_str(),
                                                &NetworkDeviceUpdate,
                                                this);
   }
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // NetworkLibraryImplBase connect implementation.
 
 // static callback
+void NetworkLibraryImplCros::ConfigureServiceCallback(
+    void* object,
+    const char* service_path,
+    NetworkMethodErrorType error,
+    const char* error_message) {
+  DCHECK(CrosLibrary::Get()->libcros_loaded());

[stevenjb, 2011/11/30 17:36:20]

nit: DCHECK is unnecessary here.

[Charlie Lee, 2011/11/30 18:01:21]

Done.

+  if (error != NETWORK_METHOD_ERROR_NONE) {
+    LOG(WARNING) << "Error from ConfigureService callback for: "
+                 << service_path
+                 << " Error: " << error << " Message: " << error_message;
+  }
+}
+
+void NetworkLibraryImplCros::CallConfigureService(const std::string& identifier,
+                                                  const DictionaryValue* info) {
+  GHashTable* ghash = ConvertDictionaryValueToGValueMap(info);
+  chromeos::ConfigureService(identifier.c_str(), ghash,
+                             ConfigureServiceCallback, this);
+}
+
+// static callback
 void NetworkLibraryImplCros::NetworkConnectCallback(
     void* object,
     const char* service_path,
     NetworkMethodErrorType error,
     const char* error_message) {
   DCHECK(CrosLibrary::Get()->libcros_loaded());
   NetworkConnectStatus status;
   if (error == NETWORK_METHOD_ERROR_NONE) {
     status = CONNECT_SUCCESS;
   } else {
@@ skipping 1066 matching lines @@
 
   // 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 {}
   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,
@@ skipping 196 matching lines @@
   vpn3->set_provider_type(PROVIDER_TYPE_OPEN_VPN);
   AddStubNetwork(vpn3, 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());
   CHECK(connected_network()->is_active());
+
+  std::string test_blob(
+        "{"
+        "  \"NetworkConfigurations\": ["
+        "    {"
+        "      \"GUID\": \"guid\","
+        "      \"Type\": \"WiFi\","
+        "      \"WiFi\": {"
+        "        \"Security\": \"WEP\","
+        "        \"SSID\": \"MySSID\","
+        "      }"
+        "    }"
+        "  ],"
+        "  \"Certificates\": []"
+        "}");
+  LoadOncNetworks(test_blob);
 }
 
 ////////////////////////////////////////////////////////////////////////////
 // NetworkLibraryImplStub private methods.
 
 void NetworkLibraryImplStub::AddStubNetwork(
     Network* network, NetworkProfileType profile_type) {
   network->priority_order_ = network_priority_order_++;
   network->CalculateUniqueId();
   if (!network->unique_id().empty())
@@ skipping 227 matching lines @@
   return impl;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 }  // namespace chromeos
 
 // Allows InvokeLater without adding refcounting. This class is a Singleton and
 // won't be deleted until its last InvokeLater is run.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(chromeos::NetworkLibraryImplBase);