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 18 matching lines @@
                          const std::string& path,
                          const network_handler::ErrorCallback& error_callback) {
   NET_LOG_ERROR(error, path);
   if (error_callback.is_null())
     return;
   scoped_ptr<base::DictionaryValue> error_data(
       network_handler::CreateErrorData(path, error, ""));
   error_callback.Run(error, error_data.Pass());
 }
 
+bool IsPassphrase(const std::string& key) {
+  return key == flimflam::kEapPrivateKeyPasswordProperty ||

[gauravsh, 2013/08/02 23:40:22]

Looking at service_constants.h, should the following also be filtered out?
- EapClientPrivateKey
- EapPinProperty
- ApnPasswordProperty

[stevenjb, 2013/08/06 00:32:48]

Added.

+      key == flimflam::kEapPasswordProperty ||
+      key == flimflam::kL2tpIpsecPasswordProperty ||
+      key == flimflam::kOpenVPNPasswordProperty ||
+      key == flimflam::kPassphraseProperty ||
+      key == flimflam::kOpenVPNOTPProperty;
+}
+
 }  // 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 103 matching lines @@
       base::Bind(&network_handler::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) {
   NET_LOG_USER("SetProperties", service_path);
+  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("SetProperty",  service_path + "." + iter.key() + "=" + v);
+  }
   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) {
   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);
+  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("Configure",  type + "." + iter.key() + "=" + v);
+  }
+
   // 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 141 matching lines @@
 
 // static
 NetworkConfigurationHandler* NetworkConfigurationHandler::InitializeForTest(
     NetworkStateHandler* network_state_handler) {
   NetworkConfigurationHandler* handler = new NetworkConfigurationHandler();
   handler->Init(network_state_handler);
   return handler;
 }
 
 }  // namespace chromeos