Eliminate c/b/chromeos/options/network_connect.cc

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"
@@ skipping 99 matching lines @@
     return GetStringValue(key, value, &connection_state_);
   } else if (key == flimflam::kConnectableProperty) {
     return GetBooleanValue(key, value, &connectable_);
   } else if (key == flimflam::kErrorProperty) {
     if (!GetStringValue(key, value, &error_))
       return false;
     // Shill uses "Unknown" to indicate an unset error state.
     if (error_ == kErrorUnknown)
       error_.clear();
     return true;
-  } 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::kGatewayProperty)) {
     return GetStringValue(key, value, &gateway_);
   } else if (key == IPConfigProperty(flimflam::kNameServersProperty)) {
     const base::ListValue* dns_servers;
     if (!value.GetAsList(&dns_servers))
       return false;
     dns_servers_.clear();
     ConvertListValueToStringVector(*dns_servers, &dns_servers_);
@@ skipping 106 matching lines @@
   dictionary->SetStringWithoutPathExpansion(flimflam::kTypeProperty, type());
   dictionary->SetIntegerWithoutPathExpansion(flimflam::kSignalStrengthProperty,
                                              signal_strength_);
   dictionary->SetStringWithoutPathExpansion(flimflam::kStateProperty,
                                             connection_state_);
   dictionary->SetBooleanWithoutPathExpansion(flimflam::kConnectableProperty,
                                              connectable_);
 
   dictionary->SetStringWithoutPathExpansion(flimflam::kErrorProperty,
                                             error_);
-  dictionary->SetStringWithoutPathExpansion(shill::kErrorDetailsProperty,
-                                            error_details_);
 
   // IPConfig properties
   base::DictionaryValue* ipconfig_properties = new base::DictionaryValue;
   ipconfig_properties->SetStringWithoutPathExpansion(flimflam::kAddressProperty,
                                                      ip_address_);
   ipconfig_properties->SetStringWithoutPathExpansion(flimflam::kGatewayProperty,
                                                      gateway_);
   base::ListValue* name_servers = new base::ListValue;
   name_servers->AppendStrings(dns_servers_);
   ipconfig_properties->SetWithoutPathExpansion(flimflam::kNameServersProperty,
@@ skipping 88 matching lines @@
     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;
+  std::string name, hex_ssid;
   properties.GetStringWithoutPathExpansion(flimflam::kNameProperty, &name);
-
-  std::string hex_ssid;
   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;
@@ skipping 81 matching lines @@
   }
   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