Move Shill property utility functions to a new separate file.

chromeos/network/network_state.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_state.h"
 
-#include "base/i18n/icu_encoding_detection.h"
-#include "base/i18n/icu_string_conversions.h"
-#include "base/json/json_writer.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
-#include "base/strings/utf_string_conversion_utils.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_profile_handler.h"
 #include "chromeos/network/network_util.h"
 #include "chromeos/network/onc/onc_utils.h"
+#include "chromeos/network/shill_property_util.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace {
 
 const char kErrorUnknown[] = "Unknown";
 
 bool ConvertListValueToStringVector(const base::ListValue& string_list,
                                     std::vector<std::string>* result) {
   for (size_t i = 0; i < string_list.GetSize(); ++i) {
     std::string str;
     if (!string_list.GetString(i, &str))
       return false;
     result->push_back(str);
   }
   return true;
 }
 
-// Replace non UTF8 characters in |str| with a replacement character.
-std::string ValidateUTF8(const std::string& str) {
-  std::string result;
-  for (int32 index = 0; index < static_cast<int32>(str.size()); ++index) {
-    uint32 code_point_out;
-    bool is_unicode_char = base::ReadUnicodeCharacter(str.c_str(), str.size(),
-                                                      &index, &code_point_out);
-    const uint32 kFirstNonControlChar = 0x20;
-    if (is_unicode_char && (code_point_out >= kFirstNonControlChar)) {
-      base::WriteUnicodeCharacter(code_point_out, &result);
-    } else {
-      const uint32 kReplacementChar = 0xFFFD;
-      // Puts kReplacementChar if character is a control character [0,0x20)
-      // or is not readable UTF8.
-      base::WriteUnicodeCharacter(kReplacementChar, &result);
-    }
-  }
-  return result;
-}
-
 bool IsCaCertNssSet(const base::DictionaryValue& properties) {
   std::string ca_cert_nss;
   if (properties.GetStringWithoutPathExpansion(flimflam::kEapCaCertNssProperty,
                                                &ca_cert_nss) &&
       !ca_cert_nss.empty()) {
     return true;
   }
 
   const base::DictionaryValue* provider = NULL;
   properties.GetDictionaryWithoutPathExpansion(flimflam::kProviderProperty,
@@ skipping 112 matching lines @@
       // Warning: The DictionaryValue returned from
       // ReadDictionaryFromJson/JSONParser is an optimized derived class that
       // doesn't allow releasing ownership of nested values. A Swap in the wrong
       // order leads to memory access errors.
       proxy_config_.MergeDictionary(proxy_config_dict.get());
     } else {
       NET_LOG_ERROR("Failed to parse " + key, path());
     }
     return true;
   } else if (key == flimflam::kUIDataProperty) {
-    if (!GetUIDataFromValue(value, &ui_data_)) {
+    if (!shill_property_util::GetUIDataFromValue(value, &ui_data_)) {
       NET_LOG_ERROR("Failed to parse " + key, path());
       return false;
     }
     return true;
   } else if (key == flimflam::kNetworkTechnologyProperty) {
     return GetStringValue(key, value, &network_technology_);
   } else if (key == flimflam::kDeviceProperty) {
     return GetStringValue(key, value, &device_path_);
   } else if (key == flimflam::kGuidProperty) {
     return GetStringValue(key, value, &guid_);
@@ skipping 134 matching lines @@
     result += dns_servers_[i];
   }
   return result;
 }
 
 std::string NetworkState::GetNetmask() const {
   return network_util::PrefixLengthToNetmask(prefix_length_);
 }
 
 bool NetworkState::UpdateName(const base::DictionaryValue& properties) {
-  std::string updated_name = GetNameFromProperties(path(), properties);
+  std::string updated_name =
+      shill_property_util::GetNameFromProperties(path(), properties);
   if (updated_name != name()) {
     set_name(updated_name);
     return true;
   }
   return false;
 }
 
 // static
-std::string NetworkState::GetNameFromProperties(
-    const std::string& service_path,
-    const base::DictionaryValue& properties) {
-  std::string name, hex_ssid;
-  properties.GetStringWithoutPathExpansion(flimflam::kNameProperty, &name);
-  properties.GetStringWithoutPathExpansion(flimflam::kWifiHexSsid, &hex_ssid);
-
-  if (hex_ssid.empty()) {
-    if (name.empty())
-      return name;
-    // Validate name for UTF8.
-    std::string valid_ssid = ValidateUTF8(name);
-    if (valid_ssid != name) {
-      NET_LOG_DEBUG("GetNameFromProperties", base::StringPrintf(
-          "%s: UTF8: %s", service_path.c_str(), valid_ssid.c_str()));
-    }
-    return valid_ssid;
-  }
-
-  std::string ssid;
-  std::vector<uint8> raw_ssid_bytes;
-  if (base::HexStringToBytes(hex_ssid, &raw_ssid_bytes)) {
-    ssid = std::string(raw_ssid_bytes.begin(), raw_ssid_bytes.end());
-    NET_LOG_DEBUG("GetNameFromProperties", base::StringPrintf(
-        "%s: %s, SSID: %s", service_path.c_str(),
-        hex_ssid.c_str(), ssid.c_str()));
-  } else {
-    NET_LOG_ERROR("GetNameFromProperties",
-                  base::StringPrintf("%s: Error processing: %s",
-                                     service_path.c_str(), hex_ssid.c_str()));
-    return name;
-  }
-
-  if (IsStringUTF8(ssid)) {
-    if (ssid != name) {
-      NET_LOG_DEBUG("GetNameFromProperties", base::StringPrintf(
-          "%s: UTF8: %s", service_path.c_str(), ssid.c_str()));
-    }
-    return ssid;
-  }
-
-  // Detect encoding and convert to UTF-8.
-  std::string country_code;
-  properties.GetStringWithoutPathExpansion(
-      flimflam::kCountryProperty, &country_code);
-  std::string encoding;
-  if (!base::DetectEncoding(ssid, &encoding)) {
-    // TODO(stevenjb): This is currently experimental. If we find a case where
-    // base::DetectEncoding() fails, we need to figure out whether we can use
-    // country_code with ConvertToUtf8(). crbug.com/233267.
-    encoding = country_code;
-  }
-  if (!encoding.empty()) {
-    std::string utf8_ssid;
-    if (base::ConvertToUtf8AndNormalize(ssid, encoding, &utf8_ssid)) {
-      if (utf8_ssid != name) {
-        NET_LOG_DEBUG("GetNameFromProperties", base::StringPrintf(
-            "%s: Encoding=%s: %s", service_path.c_str(),
-            encoding.c_str(), utf8_ssid.c_str()));
-      }
-      return utf8_ssid;
-    }
-  }
-
-  // Unrecognized encoding. Only use raw bytes if name_ is empty.
-  NET_LOG_DEBUG("GetNameFromProperties", base::StringPrintf(
-      "%s: Unrecognized Encoding=%s: %s", service_path.c_str(),
-      encoding.c_str(), ssid.c_str()));
-  if (name.empty() && !ssid.empty())
-    return ssid;
-  return name;
-}
-
-// static
 bool NetworkState::StateIsConnected(const std::string& connection_state) {
   return (connection_state == flimflam::kStateReady ||
           connection_state == flimflam::kStateOnline ||
           connection_state == flimflam::kStatePortal);
 }
 
 // static
 bool NetworkState::StateIsConnecting(const std::string& connection_state) {
   return (connection_state == flimflam::kStateAssociation ||
           connection_state == flimflam::kStateConfiguration ||
           connection_state == flimflam::kStateCarrier);
 }
 
 // static
 std::string NetworkState::IPConfigProperty(const char* key) {
   return base::StringPrintf("%s.%s", shill::kIPConfigProperty, key);
 }
 
-// static
-bool NetworkState::GetUIDataFromValue(const base::Value& ui_data_value,
-                                      NetworkUIData* out) {
-  std::string ui_data_str;
-  if (!ui_data_value.GetAsString(&ui_data_str))
-    return false;
-  if (ui_data_str.empty()) {
-    *out = NetworkUIData();
-    return true;
-  }
-  scoped_ptr<base::DictionaryValue> ui_data_dict(
-      chromeos::onc::ReadDictionaryFromJson(ui_data_str));
-  if (!ui_data_dict)
-    return false;
-  *out = NetworkUIData(*ui_data_dict);
-  return true;
-}
-
 }  // namespace chromeos