Include WiFi.FrequencyList in NetworkState

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_ui_data.h"
 #include "chromeos/network/onc/onc_utils.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
+// TODO(stevenjb): Use flimflam:: property when defined in service_constants.h
+const char kWifiFrequencyListProperty[] = "WiFi.FrequencyList";

[stevenjb, 2013/06/20 20:19:30]

This will be removed before comitting

+
 namespace {
 
 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);
   }
@@ skipping 46 matching lines @@
   if (ManagedStatePropertyChanged(key, value))
     return true;
   if (key == flimflam::kSignalStrengthProperty) {
     return GetIntegerValue(key, value, &signal_strength_);
   } else if (key == flimflam::kStateProperty) {
     return GetStringValue(key, value, &connection_state_);
   } else if (key == flimflam::kConnectableProperty) {
     return GetBooleanValue(key, value, &connectable_);
   } else if (key == flimflam::kPassphraseRequiredProperty) {
     return GetBooleanValue(key, value, &passphrase_required_);
+  } else if (key == kWifiFrequencyListProperty) {
+    const base::ListValue* frequencies;
+    if (!value.GetAsList(&frequencies)) {
+      NET_LOG_ERROR("Failed to parse " + key, path());
+      return false;
+    }
+    wifi_frequencies_.clear();
+    for (base::ListValue::const_iterator iter = frequencies->begin();
+         iter != frequencies->end(); ++iter) {
+      int frequency;
+      if ((*iter)->GetAsInteger(&frequency))
+        wifi_frequencies_.push_back(frequency);
+    }
+    if (!wifi_frequencies_.empty()) {
+      std::string str;
+      base::JSONWriter::Write(frequencies, &str);
+      NET_LOG_DEBUG("WifiFrequencies for " + path(), str);
+    }
   } else if (key == flimflam::kErrorProperty) {
     return GetStringValue(key, value, &error_);
   } else if (key == shill::kErrorDetailsProperty) {
     return GetStringValue(key, value, &error_details_);
   } else if (key == IPConfigProperty(flimflam::kAddressProperty)) {
     return GetStringValue(key, value, &ip_address_);
   } else if (key == IPConfigProperty(flimflam::kNameServersProperty)) {
     dns_servers_.clear();
     const base::ListValue* dns_servers;
     if (value.GetAsList(&dns_servers))
       ConvertListValueToStringVector(*dns_servers, &dns_servers_);
     return true;
   } else if (key == flimflam::kActivationStateProperty) {
     return GetStringValue(key, value, &activation_state_);
   } else if (key == flimflam::kRoamingStateProperty) {
     return GetStringValue(key, value, &roaming_);
   } else if (key == flimflam::kSecurityProperty) {
     return GetStringValue(key, value, &security_);
   } else if (key == flimflam::kAutoConnectProperty) {
     return GetBooleanValue(key, value, &auto_connect_);
   } else if (key == flimflam::kFavoriteProperty) {
     return GetBooleanValue(key, value, &favorite_);
   } else if (key == flimflam::kPriorityProperty) {
     return GetIntegerValue(key, value, &priority_);
   } else if (key == flimflam::kProxyConfigProperty) {
     std::string proxy_config_str;
     if (!value.GetAsString(&proxy_config_str)) {
-      LOG(WARNING) << "Failed to parse string value for:" << key;
+      NET_LOG_ERROR("Failed to parse " + key, path());
       return false;
     }
 
     proxy_config_.Clear();
     if (proxy_config_str.empty())
       return true;
 
     scoped_ptr<base::DictionaryValue> proxy_config_dict(
         onc::ReadDictionaryFromJson(proxy_config_str));
     if (proxy_config_dict) {
       // 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 {
-      LOG(WARNING) << "Failed to parse dictionary value for: " << key;
+      NET_LOG_ERROR("Failed to parse " + key, path());
     }
     return true;
   } else if (key == flimflam::kUIDataProperty) {
     std::string ui_data_str;
     if (!value.GetAsString(&ui_data_str)) {
-      LOG(WARNING) << "Failed to parse string value for:" << key;
+      NET_LOG_ERROR("Failed to parse " + key, path());
       return false;
     }
 
     onc_source_ = onc::ONC_SOURCE_NONE;
     if (ui_data_str.empty())
       return true;
 
     scoped_ptr<base::DictionaryValue> ui_data_dict(
         onc::ReadDictionaryFromJson(ui_data_str));
     if (ui_data_dict)
       onc_source_ = NetworkUIData(*ui_data_dict).onc_source();
     else
-      LOG(WARNING) << "Failed to parse dictionary value for: " << key;
+      NET_LOG_ERROR("Failed to parse " + key, path());
     return true;
   } else if (key == flimflam::kNetworkTechnologyProperty) {
     return GetStringValue(key, value, &technology_);
   } else if (key == flimflam::kDeviceProperty) {
     return GetStringValue(key, value, &device_path_);
   } else if (key == flimflam::kGuidProperty) {
     return GetStringValue(key, value, &guid_);
   } else if (key == flimflam::kProfileProperty) {
     return GetStringValue(key, value, &profile_path_);
   } else if (key == shill::kActivateOverNonCellularNetworkProperty) {
@@ skipping 21 matching lines @@
   dictionary->SetStringWithoutPathExpansion(flimflam::kNameProperty, name());
   dictionary->SetStringWithoutPathExpansion(flimflam::kTypeProperty, type());
   dictionary->SetIntegerWithoutPathExpansion(flimflam::kSignalStrengthProperty,
                                              signal_strength_);
   dictionary->SetStringWithoutPathExpansion(flimflam::kStateProperty,
                                             connection_state_);
   dictionary->SetBooleanWithoutPathExpansion(flimflam::kConnectableProperty,
                                              connectable_);
   dictionary->SetBooleanWithoutPathExpansion(
       flimflam::kPassphraseRequiredProperty, passphrase_required_);
+
+  base::ListValue* frequencies = new base::ListValue;
+  for (FrequencyList::const_iterator iter = wifi_frequencies_.begin();
+       iter != wifi_frequencies_.end(); ++iter) {
+    frequencies->AppendInteger(*iter);
+  }
+  dictionary->SetWithoutPathExpansion(kWifiFrequencyListProperty, frequencies);
+
   dictionary->SetStringWithoutPathExpansion(flimflam::kErrorProperty,
                                             error_);
   dictionary->SetStringWithoutPathExpansion(shill::kErrorDetailsProperty,
                                             error_details_);
   base::DictionaryValue* ipconfig_properties = new DictionaryValue;
   ipconfig_properties->SetStringWithoutPathExpansion(flimflam::kAddressProperty,
                                                      ip_address_);
   base::ListValue* name_servers = new ListValue;
   name_servers->AppendStrings(dns_servers_);
   ipconfig_properties->SetWithoutPathExpansion(flimflam::kNameServersProperty,
@@ skipping 131 matching lines @@
           connection_state == flimflam::kStateConfiguration ||
           connection_state == flimflam::kStateCarrier);
 }
 
 // static
 std::string NetworkState::IPConfigProperty(const char* key) {
   return base::StringPrintf("%s.%s", shill::kIPConfigProperty, key);
 }
 
 }  // namespace chromeos