Don't copy empty GUID in CopyIdentifyingProperties.

chromeos/network/shill_property_util.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/shill_property_util.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 25 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;
 }
 
-void CopyStringFromDictionary(const base::DictionaryValue& source,
+// If existent and non-empty, copies the string at |key| from |source| to
+// |dest|. Returns true if the string was copied.
+bool CopyStringFromDictionary(const base::DictionaryValue& source,
                               const std::string& key,
                               base::DictionaryValue* dest) {
   std::string string_value;
-  if (source.GetStringWithoutPathExpansion(key, &string_value))
-    dest->SetStringWithoutPathExpansion(key, string_value);
+  if (!source.GetStringWithoutPathExpansion(key, &string_value) ||
+      string_value.empty())
+    return false;
+  dest->SetStringWithoutPathExpansion(key, string_value);
+  return true;
 }
 
 }  // namespace
 
 std::string 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);
 
@@ skipping 106 matching lines @@
   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);
 }
 
 bool CopyIdentifyingProperties(const base::DictionaryValue& service_properties,
                                base::DictionaryValue* dest) {
+  bool success = true;
+
+  // GUID is optional.
   CopyStringFromDictionary(service_properties, flimflam::kGuidProperty, dest);
 
   std::string type;
   service_properties.GetStringWithoutPathExpansion(flimflam::kTypeProperty,
                                                    &type);
+  success &= !type.empty();
   dest->SetStringWithoutPathExpansion(flimflam::kTypeProperty, type);
   if (type == flimflam::kTypeWifi) {
-    CopyStringFromDictionary(
+    success &= CopyStringFromDictionary(
         service_properties, flimflam::kSecurityProperty, dest);
-    CopyStringFromDictionary(service_properties, flimflam::kSSIDProperty, dest);
-    CopyStringFromDictionary(service_properties, flimflam::kModeProperty, dest);
+    success &= CopyStringFromDictionary(
+        service_properties, flimflam::kSSIDProperty, dest);
+    success &= CopyStringFromDictionary(
+        service_properties, flimflam::kModeProperty, dest);
   } else if (type == flimflam::kTypeVPN) {
-    CopyStringFromDictionary(service_properties, flimflam::kNameProperty, dest);
+    success &= CopyStringFromDictionary(
+        service_properties, flimflam::kNameProperty, dest);
     // VPN Provider values are read from the "Provider" dictionary, but written
     // with the keys "Provider.Type" and "Provider.Host".
-    const base::DictionaryValue* provider_properties;
+    const base::DictionaryValue* provider_properties = NULL;
     if (!service_properties.GetDictionaryWithoutPathExpansion(
              flimflam::kProviderProperty, &provider_properties)) {
-      LOG(ERROR) << "Incomplete Shill dictionary missing VPN provider dict.";
+      NET_LOG_ERROR("CopyIdentifyingProperties", "Missing VPN provider dict");
       return false;
     }
     std::string vpn_provider_type;
     provider_properties->GetStringWithoutPathExpansion(flimflam::kTypeProperty,
                                                        &vpn_provider_type);
+    success &= !vpn_provider_type.empty();
     dest->SetStringWithoutPathExpansion(flimflam::kProviderTypeProperty,
                                         vpn_provider_type);
 
     std::string vpn_provider_host;
     provider_properties->GetStringWithoutPathExpansion(flimflam::kHostProperty,
                                                        &vpn_provider_host);
+    success &= !vpn_provider_host.empty();
     dest->SetStringWithoutPathExpansion(flimflam::kProviderHostProperty,
                                         vpn_provider_host);
   } else if (type == flimflam::kTypeEthernet ||
              type == shill::kTypeEthernetEap) {
     // Ethernet and EthernetEAP don't have any additional identifying
     // properties.
   } else {
     NOTREACHED() << "Unsupported network type " << type;
+    success = false;
   }
-  return true;
+  if (!success)
+    NET_LOG_ERROR("CopyIdentifyingProperties", "Missing required properties");
+  return success;
 }
 
 }  // namespace shill_property_util
 
 }  // namespace chromeos