Convert all connect code to use NetworkHandler instead of NetworkLibrary

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_ui_data.h"
 #include "chromeos/network/network_util.h"
 #include "chromeos/network/onc/onc_utils.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 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;
@@ skipping 17 matching lines @@
     } 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;
 }
 
-// Returns a new NetworkUIData* if |ui_data_value| is a valid NetworkUIData
-// dictionary string, otherwise returns NULL.
-chromeos::NetworkUIData* CreateUIDataFromValue(
-    const base::Value& ui_data_value) {
-  std::string ui_data_str;
-  if (!ui_data_value.GetAsString(&ui_data_str))
-    return NULL;
-  if (ui_data_str.empty())
-    return new chromeos::NetworkUIData();
-
-  scoped_ptr<base::DictionaryValue> ui_data_dict(
-      chromeos::onc::ReadDictionaryFromJson(ui_data_str));
-  if (!ui_data_dict)
-    return NULL;
-  return new chromeos::NetworkUIData(*ui_data_dict);
-}
-
 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 16 matching lines @@
 
 }  // namespace
 
 namespace chromeos {
 
 NetworkState::NetworkState(const std::string& path)
     : ManagedState(MANAGED_TYPE_NETWORK, path),
       auto_connect_(false),
       favorite_(false),
       priority_(0),
-      onc_source_(onc::ONC_SOURCE_NONE),
       prefix_length_(0),
       signal_strength_(0),
       connectable_(false),
       activate_over_non_cellular_networks_(false),
       cellular_out_of_credits_(false),
       has_ca_cert_nss_(false) {
 }
 
 NetworkState::~NetworkState() {
 }
@@ skipping 55 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 (!GetOncSource(value, &onc_source_)) {
+    if (!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 109 matching lines @@
 
 bool NetworkState::IsConnectedState() const {
   return StateIsConnected(connection_state_);
 }
 
 bool NetworkState::IsConnectingState() const {
   return StateIsConnecting(connection_state_);
 }
 
 bool NetworkState::IsManaged() const {
-  return onc_source_ == onc::ONC_SOURCE_DEVICE_POLICY ||
-         onc_source_ == onc::ONC_SOURCE_USER_POLICY;
+  return ui_data_.onc_source() == onc::ONC_SOURCE_DEVICE_POLICY ||
+         ui_data_.onc_source() == onc::ONC_SOURCE_USER_POLICY;
 }
 
 bool NetworkState::IsPrivate() const {
   return !profile_path_.empty() &&
       profile_path_ != NetworkProfileHandler::kSharedProfilePath;
 }
 
 std::string NetworkState::GetDnsServersAsString() const {
   std::string result;
   for (size_t i = 0; i < dns_servers_.size(); ++i) {
@@ skipping 100 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);
 }
 
 // static
-bool NetworkState::GetOncSource(const base::Value& ui_data_value,
-                                onc::ONCSource* out) {
-  scoped_ptr<NetworkUIData> ui_data(CreateUIDataFromValue(ui_data_value));
-  if (!ui_data)
+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;
-  *out = ui_data->onc_source();
+  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