Move Shill property utility functions to a new separate file.

chromeos/network/managed_network_configuration_handler_impl.cc

 // Copyright 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_impl.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/guid.h"
-#include "base/json/json_writer.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "chromeos/dbus/dbus_method_call_status.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"
 #include "chromeos/network/network_configuration_handler.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_policy_observer.h"
 #include "chromeos/network/network_profile.h"
 #include "chromeos/network/network_profile_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_ui_data.h"
 #include "chromeos/network/onc/onc_constants.h"
 #include "chromeos/network/onc/onc_merger.h"
 #include "chromeos/network/onc/onc_normalizer.h"
 #include "chromeos/network/onc/onc_signature.h"
 #include "chromeos/network/onc/onc_translator.h"
 #include "chromeos/network/onc/onc_utils.h"
 #include "chromeos/network/onc/onc_validator.h"
+#include "chromeos/network/shill_property_util.h"
 #include "dbus/object_path.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
 // These are error strings used for error callbacks. None of these error
 // messages are user-facing: they should only appear in logs.
 const char kInvalidUserSettingsMessage[] = "User settings are invalid.";
@@ skipping 29 matching lines @@
                       const network_handler::ErrorCallback& error_callback) {
   NET_LOG_ERROR(error_name, error_message);
   error_callback.Run(
       error_name,
       make_scoped_ptr(
           network_handler::CreateErrorData(service_path,
                                            error_name,
                                            error_message)));
 }
 
-// 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);
-}
-
 void LogErrorWithDict(const tracked_objects::Location& from_where,
                       const std::string& error_name,
                       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;
@@ skipping 110 matching lines @@
     // Shill's GetProperties doesn't return credentials. Masking credentials
     // instead of just removing them, allows remembering if a credential is set
     // or not.
     scoped_ptr<base::DictionaryValue> sanitized_settings(
         onc::MaskCredentialsInOncObject(onc::kNetworkConfigurationSignature,
                                         *settings,
                                         kFakeCredential));
     ui_data->set_user_settings(sanitized_settings.Pass());
   }
 
-  SetUIData(*ui_data, shill_dictionary.get());
+  shill_property_util::SetUIData(*ui_data, shill_dictionary.get());
 
   VLOG(2) << "Created Shill properties: " << *shill_dictionary;
 
   return shill_dictionary.Pass();
 }
 
 // Returns true if |policy| matches |actual_network|, which must be part of a
 // ONC NetworkConfiguration. This should be the only such matching function
 // within Chrome. Shill does such matching in several functions for network
 // identification. For compatibility, we currently should stick to Shill's
@@ skipping 166 matching lines @@
   std::string profile_path;
   shill_properties.GetStringWithoutPathExpansion(flimflam::kProfileProperty,
                                                  &profile_path);
   const NetworkProfile* profile =
       network_profile_handler_->GetProfileForPath(profile_path);
   if (!profile) {
     LOG(ERROR) << "No or no known profile received for service "
             << service_path << ".";
   }
 
-  scoped_ptr<NetworkUIData> ui_data = GetUIData(shill_properties);
+  scoped_ptr<NetworkUIData> ui_data =
+      shill_property_util::GetUIDataFromProperties(shill_properties);
 
   const base::DictionaryValue* user_settings = NULL;
   const base::DictionaryValue* shared_settings = NULL;
 
   if (ui_data && profile) {
     if (profile->type() == NetworkProfile::TYPE_SHARED)
       shared_settings = ui_data->user_settings();
     else if (profile->type() == NetworkProfile::TYPE_USER)
       user_settings = ui_data->user_settings();
     else
@@ skipping 451 matching lines @@
 
   std::string old_guid;
   if (!onc_part->GetStringWithoutPathExpansion(onc::network_config::kGUID,
                                                &old_guid)) {
     VLOG(1) << "Entry " << entry << " of profile " << profile_.ToDebugString()
             << " doesn't contain a GUID.";
     // This might be an entry of an older ChromeOS version. Assume it to be
     // unmanaged.
   }
 
-  scoped_ptr<NetworkUIData> ui_data = GetUIData(entry_properties);
+  scoped_ptr<NetworkUIData> ui_data =
+      shill_property_util::GetUIDataFromProperties(entry_properties);
   if (!ui_data) {
     VLOG(1) << "Entry " << entry << " of profile " << profile_.ToDebugString()
             << " contains no or no valid UIData.";
     // This might be an entry of an older ChromeOS version. Assume it to be
     // unmanaged. It's an inconsistency if there is a GUID but no UIData, thus
     // clear the GUID just in case.
     old_guid.clear();
   }
 
   bool was_managed = !old_guid.empty() && ui_data &&
@@ skipping 117 matching lines @@
 
     VLOG(1) << "Creating new configuration managed by policy " << *it
             << " in profile " << profile_.ToDebugString() << ".";
 
     CreateAndWriteNewShillConfiguration(
         *it, *policy, NULL /* no user settings */);
   }
 }
 
 }  // namespace chromeos