Convert all connect code to use NetworkHandler instead of NetworkLibrary

chromeos/network/network_configuration_handler.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 "chromeos/network/network_configuration_handler.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/format_macros.h"
+#include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_manager_client.h"
 #include "chromeos/dbus/shill_profile_client.h"
 #include "chromeos/dbus/shill_service_client.h"
@@ skipping 37 matching lines @@
   std::string name = NetworkState::GetNameFromProperties(properties);
   if (!name.empty()) {
     properties_copy->SetStringWithoutPathExpansion(
         flimflam::kNameProperty, name);
   }
   network_handler::GetPropertiesCallback(
       callback, error_callback, service_path, call_status,
       *properties_copy.get());
 }
 
+void SetNetworkProfileErrorCallback(
+    const std::string& service_path,
+    const std::string& profile_path,
+    const network_handler::ErrorCallback& error_callback,
+    const std::string& dbus_error_name,
+    const std::string& dbus_error_message) {
+  network_handler::ShillErrorCallbackFunction(
+      "Config.SetNetworkProfile Failed: " + profile_path,
+      service_path, error_callback,
+      dbus_error_name, dbus_error_message);
+}
+
+bool IsPassphrase(const std::string& key) {
+  return key == flimflam::kEapPrivateKeyPasswordProperty ||
+      key == flimflam::kEapPasswordProperty ||
+      key == flimflam::kL2tpIpsecPasswordProperty ||
+      key == flimflam::kOpenVPNPasswordProperty ||
+      key == flimflam::kPassphraseProperty ||
+      key == flimflam::kOpenVPNOTPProperty ||
+      key == flimflam::kEapPrivateKeyProperty ||
+      key == flimflam::kEapPrivateKeyPasswordProperty ||
+      key == flimflam::kEapPinProperty ||
+      key == flimflam::kApnPasswordProperty;
+}
+
+void LogConfigProperties(const std::string& desc,
+                         const std::string& path,
+                         const base::DictionaryValue& properties) {
+  for (base::DictionaryValue::Iterator iter(properties);
+       !iter.IsAtEnd(); iter.Advance()) {
+    std::string v = "******";
+    if (!IsPassphrase(iter.key()))
+      base::JSONWriter::Write(&iter.value(), &v);
+    NET_LOG_DEBUG(desc,  path + "." + iter.key() + "=" + v);
+  }
+}
+
 }  // namespace
 
 // Helper class to request from Shill the profile entries associated with a
 // Service and delete the service from each profile. Triggers either
 // |callback| on success or |error_callback| on failure, and calls
 // |handler|->ProfileEntryDeleterCompleted() on completion to delete itself.
 class NetworkConfigurationHandler::ProfileEntryDeleter
     : public base::SupportsWeakPtr<ProfileEntryDeleter> {
  public:
   ProfileEntryDeleter(NetworkConfigurationHandler* handler,
@@ skipping 102 matching lines @@
       dbus::ObjectPath(service_path),
       base::Bind(&GetPropertiesCallback,
                  callback, error_callback, service_path));
 }
 
 void NetworkConfigurationHandler::SetProperties(
     const std::string& service_path,
     const base::DictionaryValue& properties,
     const base::Closure& callback,
     const network_handler::ErrorCallback& error_callback) {
+  if (properties.empty()) {
+    if (!callback.is_null())
+      callback.Run();
+    return;
+  }
   NET_LOG_USER("SetProperties", service_path);
+  LogConfigProperties("SetProperty", service_path, properties);
+
   DBusThreadManager::Get()->GetShillServiceClient()->SetProperties(
       dbus::ObjectPath(service_path),
       properties,
       base::Bind(&NetworkConfigurationHandler::SetPropertiesSuccessCallback,
                  AsWeakPtr(), service_path, callback),
       base::Bind(&NetworkConfigurationHandler::SetPropertiesErrorCallback,
                  AsWeakPtr(), service_path, error_callback));
 }
 
 void NetworkConfigurationHandler::ClearProperties(
     const std::string& service_path,
     const std::vector<std::string>& names,
     const base::Closure& callback,
     const network_handler::ErrorCallback& error_callback) {
+  if (names.empty()) {
+    if (!callback.is_null())
+      callback.Run();
+    return;
+  }
   NET_LOG_USER("ClearProperties", service_path);
+  for (std::vector<std::string>::const_iterator iter = names.begin();
+       iter != names.end(); ++iter) {
+    NET_LOG_DEBUG("ClearProperty", service_path + "." + *iter);
+  }
   DBusThreadManager::Get()->GetShillServiceClient()->ClearProperties(
       dbus::ObjectPath(service_path),
       names,
       base::Bind(&NetworkConfigurationHandler::ClearPropertiesSuccessCallback,
                  AsWeakPtr(), service_path, names, callback, error_callback),
       base::Bind(&NetworkConfigurationHandler::ClearPropertiesErrorCallback,
                  AsWeakPtr(), service_path, error_callback));
 }
 
 void NetworkConfigurationHandler::CreateConfiguration(
     const base::DictionaryValue& properties,
     const network_handler::StringResultCallback& callback,
     const network_handler::ErrorCallback& error_callback) {
   ShillManagerClient* manager =
       DBusThreadManager::Get()->GetShillManagerClient();
-
   std::string type;
   properties.GetStringWithoutPathExpansion(flimflam::kTypeProperty, &type);
+
+  NET_LOG_USER("CreateConfiguration", type);
+  LogConfigProperties("Configure", type, properties);
+
   // Shill supports ConfigureServiceForProfile only for network type WiFi. In
   // all other cases, we have to rely on GetService for now. This is
   // unproblematic for VPN (user profile only), but will lead to inconsistencies
   // with WiMax, for example.
   if (type == flimflam::kTypeWifi) {
     std::string profile;
     properties.GetStringWithoutPathExpansion(flimflam::kProfileProperty,
                                              &profile);
     manager->ConfigureServiceForProfile(
         dbus::ObjectPath(profile),
@@ skipping 23 matching lines @@
         "RemoveConfiguration In-Progress", service_path, error_callback);
     return;
   }
   NET_LOG_USER("Remove Configuration", service_path);
   ProfileEntryDeleter* deleter =
       new ProfileEntryDeleter(this, service_path, callback, error_callback);
   profile_entry_deleters_[service_path] = deleter;
   deleter->Run();
 }
 
+void NetworkConfigurationHandler::SetNetworkProfile(
+    const std::string& service_path,
+    const std::string& profile_path,
+    const base::Closure& callback,
+    const network_handler::ErrorCallback& error_callback) {
+  NET_LOG_USER("SetNetworkProfile", service_path + ": " + profile_path);
+  base::StringValue profile_path_value(profile_path);
+  DBusThreadManager::Get()->GetShillServiceClient()->SetProperty(
+      dbus::ObjectPath(service_path),
+      flimflam::kProfileProperty,
+      profile_path_value,
+      callback,
+      base::Bind(&SetNetworkProfileErrorCallback,
+                 service_path, profile_path, error_callback));
+}
+
 // NetworkConfigurationHandler Private methods
 
 NetworkConfigurationHandler::NetworkConfigurationHandler()
     : network_state_handler_(NULL) {
 }
 
 NetworkConfigurationHandler::~NetworkConfigurationHandler() {
   STLDeleteContainerPairSecondPointers(
       profile_entry_deleters_.begin(), profile_entry_deleters_.end());
 }
@@ skipping 98 matching lines @@
 
 // static
 NetworkConfigurationHandler* NetworkConfigurationHandler::InitializeForTest(
     NetworkStateHandler* network_state_handler) {
   NetworkConfigurationHandler* handler = new NetworkConfigurationHandler();
   handler->Init(network_state_handler);
   return handler;
 }
 
 }  // namespace chromeos