contacts: Strip Unicode byte order marks from strings.

chrome/browser/chromeos/gdata/gdata_contacts_service.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 "chrome/browser/chromeos/gdata/gdata_contacts_service.h"
 
 #include <cstring>
 #include <string>
 #include <map>
 #include <utility>
 
 #include "base/json/json_value_converter.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/stl_util.h"
+#include "base/string_util.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/contacts/contact.pb.h"
 #include "chrome/browser/chromeos/gdata/gdata_operation_registry.h"
 #include "chrome/browser/chromeos/gdata/gdata_operation_runner.h"
 #include "chrome/browser/chromeos/gdata/gdata_operations.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
 #include "content/public/browser/browser_thread.h"
 
@@ skipping 104 matching lines @@
     "http://schemas.google.com/contacts/2008/rel#photo";
 
 // Returns a string containing a pretty-printed JSON representation of |value|.
 std::string PrettyPrintValue(const base::Value& value) {
   std::string out;
   base::JSONWriter::WriteWithOptions(
       &value, base::JSONWriter::OPTIONS_PRETTY_PRINT, &out);
   return out;
 }
 
+// Assigns the value at |path| within |dict| to |out|, returning false if the
+// path wasn't present.  Unicode byte order marks are removed from the string.
+bool GetCleanedString(const DictionaryValue& dict,
+                      const std::string& path,
+                      std::string* out) {
+  if (!dict.GetString(path, out))
+    return false;
+
+  // The Unicode byte order mark, U+FEFF, is useless in UTF-8 strings (which are
+  // interpreted one byte at a time).
+  ReplaceSubstringsAfterOffset(out, 0, "\xEF\xBB\xBF", "");
+  return true;
+}
+
 // Returns whether an address is primary, given a dictionary representing a
 // single address.
 bool IsAddressPrimary(const DictionaryValue& address_dict) {
   std::string primary;
   address_dict.GetString(kAddressPrimaryField, &primary);
   return primary == kAddressPrimaryTrueValue;
 }
 
 // Initializes an AddressType message given a dictionary representing a single
 // address.
 void InitAddressType(const DictionaryValue& address_dict,
                      contacts::Contact_AddressType* type) {
   DCHECK(type);
   type->Clear();
 
   std::string rel;
   address_dict.GetString(kAddressRelField, &rel);
   if (rel == kAddressRelHomeValue)
     type->set_relation(contacts::Contact_AddressType_Relation_HOME);
   else if (rel == kAddressRelWorkValue)
     type->set_relation(contacts::Contact_AddressType_Relation_WORK);
   else if (rel == kAddressRelMobileValue)
     type->set_relation(contacts::Contact_AddressType_Relation_MOBILE);
   else
     type->set_relation(contacts::Contact_AddressType_Relation_OTHER);
 
-  address_dict.GetString(kAddressLabelField, type->mutable_label());
+  GetCleanedString(address_dict, kAddressLabelField, type->mutable_label());
 }
 
 // Maps the protocol from a dictionary representing a contact's IM address to a
 // contacts::Contact_InstantMessagingAddress_Protocol value.
 contacts::Contact_InstantMessagingAddress_Protocol
 GetInstantMessagingProtocol(const DictionaryValue& im_dict) {
   std::string protocol;
   im_dict.GetString(kInstantMessagingProtocolField, &protocol);
   if (protocol == kInstantMessagingProtocolAimValue)
     return contacts::Contact_InstantMessagingAddress_Protocol_AIM;
@@ skipping 63 matching lines @@
       return false;
     }
     contact->set_update_time(update_time.ToInternalValue());
   }
 
   const base::Value* deleted_value = NULL;
   contact->set_deleted(dict.Get(kDeletedField, &deleted_value));
   if (contact->deleted())
     return true;
 
-  dict.GetString(kFullNameField, contact->mutable_full_name());
-  dict.GetString(kGivenNameField, contact->mutable_given_name());
-  dict.GetString(kAdditionalNameField, contact->mutable_additional_name());
-  dict.GetString(kFamilyNameField, contact->mutable_family_name());
-  dict.GetString(kNamePrefixField, contact->mutable_name_prefix());
-  dict.GetString(kNameSuffixField, contact->mutable_name_suffix());
+  GetCleanedString(dict, kFullNameField, contact->mutable_full_name());
+  GetCleanedString(dict, kGivenNameField, contact->mutable_given_name());
+  GetCleanedString(
+      dict, kAdditionalNameField, contact->mutable_additional_name());
+  GetCleanedString(dict, kFamilyNameField, contact->mutable_family_name());
+  GetCleanedString(dict, kNamePrefixField, contact->mutable_name_prefix());
+  GetCleanedString(dict, kNameSuffixField, contact->mutable_name_suffix());
 
   const ListValue* email_list = NULL;
   if (dict.GetList(kEmailField, &email_list)) {
     for (size_t i = 0; i < email_list->GetSize(); ++i) {
       const DictionaryValue* email_dict = NULL;
       if (!email_list->GetDictionary(i, &email_dict))
         return false;
 
       contacts::Contact_EmailAddress* email = contact->add_email_addresses();
-      if (!email_dict->GetString(kEmailAddressField, email->mutable_address()))
+      if (!GetCleanedString(*email_dict,
+                            kEmailAddressField,
+                            email->mutable_address())) {
         return false;
+      }
       email->set_primary(IsAddressPrimary(*email_dict));
       InitAddressType(*email_dict, email->mutable_type());
     }
   }
 
   const ListValue* phone_list = NULL;
   if (dict.GetList(kPhoneField, &phone_list)) {
     for (size_t i = 0; i < phone_list->GetSize(); ++i) {
       const DictionaryValue* phone_dict = NULL;
       if (!phone_list->GetDictionary(i, &phone_dict))
         return false;
 
       contacts::Contact_PhoneNumber* phone = contact->add_phone_numbers();
-      if (!phone_dict->GetString(kPhoneNumberField, phone->mutable_number()))
+      if (!GetCleanedString(*phone_dict,
+                            kPhoneNumberField,
+                            phone->mutable_number())) {
         return false;
+      }
       phone->set_primary(IsAddressPrimary(*phone_dict));
       InitAddressType(*phone_dict, phone->mutable_type());
     }
   }
 
   const ListValue* address_list = NULL;
   if (dict.GetList(kPostalAddressField, &address_list)) {
     for (size_t i = 0; i < address_list->GetSize(); ++i) {
       const DictionaryValue* address_dict = NULL;
       if (!address_list->GetDictionary(i, &address_dict))
         return false;
 
       contacts::Contact_PostalAddress* address =
           contact->add_postal_addresses();
-      if (!address_dict->GetString(kPostalAddressFormattedField,
-                                   address->mutable_address())) {
+      if (!GetCleanedString(*address_dict,
+                            kPostalAddressFormattedField,
+                            address->mutable_address())) {
         return false;
       }
       address->set_primary(IsAddressPrimary(*address_dict));
       InitAddressType(*address_dict, address->mutable_type());
     }
   }
 
   const ListValue* im_list = NULL;
   if (dict.GetList(kInstantMessagingField, &im_list)) {
     for (size_t i = 0; i < im_list->GetSize(); ++i) {
       const DictionaryValue* im_dict = NULL;
       if (!im_list->GetDictionary(i, &im_dict))
         return false;
 
       contacts::Contact_InstantMessagingAddress* im =
           contact->add_instant_messaging_addresses();
-      if (!im_dict->GetString(kInstantMessagingAddressField,
-                              im->mutable_address())) {
+      if (!GetCleanedString(*im_dict,
+                            kInstantMessagingAddressField,
+                            im->mutable_address())) {
         return false;
       }
       im->set_primary(IsAddressPrimary(*im_dict));
       InitAddressType(*im_dict, im->mutable_type());
       im->set_protocol(GetInstantMessagingProtocol(*im_dict));
     }
   }
 
   return true;
 }
@@ skipping 455 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(request);
   VLOG(1) << "Download request " << request << " complete";
   if (!request->my_contacts_group_id().empty())
     cached_my_contacts_group_id_ = request->my_contacts_group_id();
   requests_.erase(request);
   delete request;
 }
 
 }  // namespace contacts