Add NetworkConnectionHandler class

chromeos/network/managed_network_configuration_handler.cc

 // Copyright (c) 2013 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/managed_network_configuration_handler.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 70 matching lines @@
                       const network_handler::ErrorCallback& error_callback) {
   network_event_log::AddEntry(kLogModule, error_name, error_message);
   error_callback.Run(
       error_name,
       make_scoped_ptr(
           network_handler::CreateErrorData(service_path,
                                            error_name,
                                            error_message)));
 }
 
-// Returns the NetworkUIData parsed from the UIData property of
-// |shill_dictionary|. If parsing fails or the field doesn't exist, returns
-// NULL.
-scoped_ptr<NetworkUIData> GetUIData(
-    const base::DictionaryValue& shill_dictionary) {
-  std::string ui_data_blob;
-  if (shill_dictionary.GetStringWithoutPathExpansion(
-          flimflam::kUIDataProperty,
-          &ui_data_blob) &&
-      !ui_data_blob.empty()) {
-    scoped_ptr<base::DictionaryValue> ui_data_dict =
-        onc::ReadDictionaryFromJson(ui_data_blob);
-    if (ui_data_dict)
-      return make_scoped_ptr(new NetworkUIData(*ui_data_dict));
-    else
-      LOG(ERROR) << "UIData is not a valid JSON dictionary.";
-  }
-  return scoped_ptr<NetworkUIData>();
-}
-
 // Sets the UIData property in |shill_dictionary| to the serialization of
 // |ui_data|.
 void SetUIData(const NetworkUIData& ui_data,
                base::DictionaryValue* shill_dictionary) {
   base::DictionaryValue ui_data_dict;
   ui_data.FillDictionary(&ui_data_dict);
   std::string ui_data_blob;
   base::JSONWriter::Write(&ui_data_dict, &ui_data_blob);
   shill_dictionary->SetStringWithoutPathExpansion(flimflam::kUIDataProperty,
                                                   ui_data_blob);
 }
 
 // A dummy callback to ignore the result of Shill calls.
 void IgnoreString(const std::string& str) {
 }
 
 void LogErrorWithDict(const tracked_objects::Location& from_where,
                       const std::string& error_name,
-                      const scoped_ptr<base::DictionaryValue> error_data) {
+                      scoped_ptr<base::DictionaryValue> error_data) {
   LOG(ERROR) << from_where.ToString() << ": " << error_name;
 }
 
 void LogErrorMessage(const tracked_objects::Location& from_where,
                      const std::string& error_name,
                      const std::string& error_message) {
   LOG(ERROR) << from_where.ToString() << ": " << error_message;
 }
 
 // Removes all kFakeCredential values from sensitive fields (determined by
@@ skipping 81 matching lines @@
 
   scoped_ptr<base::DictionaryValue> shill_dictionary(
       onc::TranslateONCObjectToShill(&onc::kNetworkConfigurationSignature,
                                      *effective));
 
   shill_dictionary->SetStringWithoutPathExpansion(flimflam::kProfileProperty,
                                                   profile_path);
 
   scoped_ptr<NetworkUIData> ui_data;
   if (policy)
-    ui_data = CreateUIDataFromONC(onc_source, *policy);
+    ui_data = NetworkUIData::CreateUIDataFromONC(onc_source, *policy);
   else
     ui_data.reset(new NetworkUIData());
 
   if (settings) {
     // Shill doesn't know that sensitive data is contained in the UIData
     // property and might write it into logs or other insecure places. Thus, we
     // have to remove or mask credentials.
     //
     // Shill's GetProperties doesn't return credentials. Masking credentials
     // instead of just removing them, allows remembering if a credential is set
@@ skipping 81 matching lines @@
   delete g_configuration_handler_instance;
   g_configuration_handler_instance = NULL;
 }
 
 // static
 ManagedNetworkConfigurationHandler* ManagedNetworkConfigurationHandler::Get() {
   CHECK(g_configuration_handler_instance);
   return g_configuration_handler_instance;
 }
 
+// static
+scoped_ptr<NetworkUIData> ManagedNetworkConfigurationHandler::GetUIData(
+    const base::DictionaryValue& shill_dictionary) {
+  std::string ui_data_blob;
+  if (shill_dictionary.GetStringWithoutPathExpansion(
+          flimflam::kUIDataProperty,
+          &ui_data_blob) &&
+      !ui_data_blob.empty()) {
+    scoped_ptr<base::DictionaryValue> ui_data_dict =
+        onc::ReadDictionaryFromJson(ui_data_blob);
+    if (ui_data_dict)
+      return make_scoped_ptr(new NetworkUIData(*ui_data_dict));
+    else
+      LOG(ERROR) << "UIData is not a valid JSON dictionary.";
+  }
+  LOG(ERROR) << "JSON dictionary has no UIData blob: " << shill_dictionary;
+  return scoped_ptr<NetworkUIData>();
+}
+
 void ManagedNetworkConfigurationHandler::GetManagedProperties(
     const std::string& service_path,
     const network_handler::DictionaryResultCallback& callback,
     const network_handler::ErrorCallback& error_callback) {
   if (!user_policies_initialized_ || !device_policies_initialized_) {
     RunErrorCallback(service_path,
                      kPoliciesNotInitialized,
                      kPoliciesNotInitializedMessage,
                      error_callback);
     return;
@@ skipping 162 matching lines @@
   scoped_ptr<base::DictionaryValue> shill_dictionary(
       CreateShillConfiguration(state->profile_path(), guid, policy,
                                &user_settings));
 
   NetworkConfigurationHandler::Get()->SetProperties(service_path,
                                                     *shill_dictionary,
                                                     callback,
                                                     error_callback);
 }
 
-void ManagedNetworkConfigurationHandler::Connect(
-    const std::string& service_path,
-    const base::Closure& callback,
-    const network_handler::ErrorCallback& error_callback) const {
-  NetworkConfigurationHandler::Get()->Connect(service_path,
-                                              callback,
-                                              error_callback);
-}
-
-void ManagedNetworkConfigurationHandler::Disconnect(
-    const std::string& service_path,
-    const base::Closure& callback,
-    const network_handler::ErrorCallback& error_callback) const {
-  NetworkConfigurationHandler::Get()->Disconnect(service_path,
-                                                 callback,
-                                                 error_callback);
-}
-
 void ManagedNetworkConfigurationHandler::CreateConfiguration(
     const base::DictionaryValue& properties,
     const network_handler::StringResultCallback& callback,
     const network_handler::ErrorCallback& error_callback) const {
   std::string profile_path = kUserProfilePath;
   const PolicyMap* policies_by_guid = GetPoliciesForProfile(profile_path);
 
   if (!policies_by_guid) {
     RunErrorCallback("",
                      kPoliciesNotInitialized,
@@ skipping 328 matching lines @@
       device_policies_initialized_(false),
       weak_ptr_factory_(this) {
 }
 
 ManagedNetworkConfigurationHandler::~ManagedNetworkConfigurationHandler() {
   STLDeleteValues(&user_policies_by_guid_);
   STLDeleteValues(&device_policies_by_guid_);
 }
 
 }  // namespace chromeos