mac: Add histograms to measure impact of Address Book integration.

components/autofill/core/browser/personal_data_manager_mac.mm

 // 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 "components/autofill/core/browser/personal_data_manager.h"
 
 #include <math.h>
 
 #import <AddressBook/AddressBook.h>
 
 #include "base/format_macros.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #import "base/mac/scoped_nsexception_enabler.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
+#include "base/time/time.h"
 #include "components/autofill/core/browser/autofill_country.h"
 #include "components/autofill/core/browser/autofill_profile.h"
 #include "components/autofill/core/browser/autofill_type.h"
 #include "components/autofill/core/browser/form_structure.h"
 #include "components/autofill/core/browser/phone_number.h"
 #include "components/autofill/core/common/autofill_pref_names.h"
 #include "components/autofill/core/common/form_data.h"
 #include "grit/components_strings.h"
 #include "ui/base/l10n/l10n_util_mac.h"
 
@@ skipping 38 matching lines @@
   return pref_service->GetBoolean(prefs::kAutofillUseMacAddressBook);
 }
 
 // Records a UMA metric indicating whether an attempt to access the Address
 // Book was skipped because doing so would cause the Address Book permissions
 // prompt to incorrectly appear.
 void RecordAccessSkipped(bool skipped) {
   UMA_HISTOGRAM_BOOLEAN("Autofill.AddressBook.AccessSkipped", skipped);
 }
 
+// Emits a histogram indicating whether the Address Book contained a me-card.
+void EmitAddressBookContainedMeCard(bool containedMeCard) {
+  UMA_HISTOGRAM_BOOLEAN("Autofill.MacAddressBook.ContainedMeCard",
+                        containedMeCard);
+}
+
+// Emits a histogram indicating whether the me-card had a name.
+void EmitMeCardHadName(bool hadName) {
+  UMA_HISTOGRAM_BOOLEAN("Autofill.MacAddressBook.MeCard.HadName",
+                        hadName);
+}
+
+// Emits a histogram indicating whether the me-card had an address.
+void EmitMeCardHadAddress(bool hadAddress) {
+  UMA_HISTOGRAM_BOOLEAN("Autofill.MacAddressBook.MeCard.HadAddress",
+                        hadAddress);
+}
+
+// Emits a histogram indicating whether the me-card had an email.
+void EmitMeCardHadEmail(bool hadEmail) {
+  UMA_HISTOGRAM_BOOLEAN("Autofill.MacAddressBook.MeCard.HadEmail",
+                        hadEmail);
+}
+
+// Emits a histogram indicating whether the me-card had a phone number.
+void EmitMeCardHadPhoneNumber(bool hadPhoneNumber) {
+  UMA_HISTOGRAM_BOOLEAN("Autofill.MacAddressBook.MeCard.HadPhoneNumber",
+                        hadPhoneNumber);
+}
+
 ABAddressBook* GetAddressBook(PrefService* pref_service) {
   bool first_access = !HasQueriedMacAddressBook(pref_service);
 
+  base::Time start_time = base::Time::Now();
   // +[ABAddressBook sharedAddressBook] throws an exception internally in
   // circumstances that aren't clear. The exceptions are only observed in crash
   // reports, so it is unknown whether they would be caught by AppKit and nil
   // returned, or if they would take down the app. In either case, avoid
   // crashing. http://crbug.com/129022
   ABAddressBook* addressBook = base::mac::RunBlockIgnoringExceptions(
       ^{ return [ABAddressBook sharedAddressBook]; });
   UMA_HISTOGRAM_BOOLEAN("Autofill.AddressBookAvailable", addressBook != nil);
 
+  if (!g_accessed_address_book) {
+    // The amount of time that the access takes gives a good indication as to
+    // whether the user was shown a prompt.
+    UMA_HISTOGRAM_TIMES("Autofill.MacAddressBook.AccessTime",
+                        base::Time::Now() - start_time);
+  }
+
   if (first_access) {
     UMA_HISTOGRAM_BOOLEAN("Autofill.AddressBookAvailableOnFirstAttempt",
                           addressBook != nil);
   }
 
   g_accessed_address_book = true;
   pref_service->SetBoolean(prefs::kAutofillMacAddressBookQueried, true);
   return addressBook;
 }
 
@@ skipping 13 matching lines @@
       : profiles_(*profiles) {
   }
   virtual ~AuxiliaryProfilesImpl() {}
 
   // Import the "me" card from the Mac Address Book and fill in |profiles_|.
   void GetAddressBookMeCard(const std::string& app_locale,
                             PrefService* pref_service,
                             bool record_metrics);
 
  private:
-  void GetAddressBookNames(ABPerson* me,
+  bool GetAddressBookNames(ABPerson* me,
                            NSString* addressLabelRaw,
                            AutofillProfile* profile);
-  void GetAddressBookAddress(const std::string& app_locale,
+  bool GetAddressBookAddress(const std::string& app_locale,
                              NSDictionary* address,
                              AutofillProfile* profile);
-  void GetAddressBookEmail(ABPerson* me,
+  bool GetAddressBookEmail(ABPerson* me,
                            NSString* addressLabelRaw,
                            AutofillProfile* profile);
-  void GetAddressBookPhoneNumbers(ABPerson* me,
+  bool GetAddressBookPhoneNumbers(ABPerson* me,
                                   NSString* addressLabelRaw,
                                   AutofillProfile* profile);
 
  private:
   // A reference to the profiles this class populates.
   ScopedVector<AutofillProfile>& profiles_;
 
   DISALLOW_COPY_AND_ASSIGN(AuxiliaryProfilesImpl);
 };
 
@@ skipping 18 matching lines @@
       RecordAccessSkipped(true);
     return;
   }
 
   if (record_metrics)
     RecordAccessSkipped(false);
 
   ABAddressBook* addressBook = GetAddressBook(pref_service);
 
   ABPerson* me = [addressBook me];
-  if (!me)
+  if (!me) {
+    EmitAddressBookContainedMeCard(false);
     return;
+  }
 
+  EmitAddressBookContainedMeCard(true);
   ABMultiValue* addresses = [me valueForProperty:kABAddressProperty];
 
   // The number of characters at the end of the GUID to reserve for
   // distinguishing addresses within the "me" card.  Cap the number of addresses
   // we will fetch to the number that can be distinguished by this fragment of
   // the GUID.
   const size_t kNumAddressGUIDChars = 2;
   const size_t kNumHexDigits = 16;
   const size_t kMaxAddressCount = pow(kNumHexDigits, kNumAddressGUIDChars);
   NSUInteger count = MIN([addresses count], kMaxAddressCount);
+
+  bool hasName = false;
+  bool hasEmail = false;
+  bool hasAddress = false;
+  bool hasPhoneNumber = false;
   for (NSUInteger i = 0; i < count; i++) {
     NSDictionary* address = [addresses valueAtIndex:i];
     NSString* addressLabelRaw = [addresses labelAtIndex:i];
 
     // Create a new profile where the guid is set to the guid portion of the
     // |kABUIDProperty| taken from from the "me" address.  The format of
     // the |kABUIDProperty| is "<guid>:ABPerson", so we're stripping off the
     // raw guid here and using it directly, with one modification: we update the
     // last |kNumAddressGUIDChars| characters in the GUID to reflect the address
     // variant.  Note that we capped the number of addresses above, so this is
     // safe.
     const size_t kGUIDLength = 36U;
     const size_t kTrimmedGUIDLength = kGUIDLength - kNumAddressGUIDChars;
     std::string guid = base::SysNSStringToUTF8(
         [me valueForProperty:kABUIDProperty]).substr(0, kTrimmedGUIDLength);
 
     // The format string to print |kNumAddressGUIDChars| hexadecimal characters,
     // left-padded with 0's.
     const std::string kAddressGUIDFormat =
         base::StringPrintf("%%0%" PRIuS "X", kNumAddressGUIDChars);
     guid += base::StringPrintf(kAddressGUIDFormat.c_str(), i);
     DCHECK_EQ(kGUIDLength, guid.size());
 
     scoped_ptr<AutofillProfile> profile(
         new AutofillProfile(guid, kAddressBookOrigin));
     profile->set_record_type(AutofillProfile::AUXILIARY_PROFILE);
     DCHECK(base::IsValidGUID(profile->guid()));
 
     // Fill in name and company information.
-    GetAddressBookNames(me, addressLabelRaw, profile.get());
+    hasName |= GetAddressBookNames(me, addressLabelRaw, profile.get());
 
     // Fill in address information.
-    GetAddressBookAddress(app_locale, address, profile.get());
+    hasEmail |= GetAddressBookAddress(app_locale, address, profile.get());
 
     // Fill in email information.
-    GetAddressBookEmail(me, addressLabelRaw, profile.get());
+    hasAddress |= GetAddressBookEmail(me, addressLabelRaw, profile.get());
 
     // Fill in phone number information.
-    GetAddressBookPhoneNumbers(me, addressLabelRaw, profile.get());
+    hasPhoneNumber |=
+        GetAddressBookPhoneNumbers(me, addressLabelRaw, profile.get());
 
     profiles_.push_back(profile.release());
   }
+
+  EmitMeCardHadName(hasName);
+  EmitMeCardHadEmail(hasEmail);
+  EmitMeCardHadAddress(hasAddress);
+  EmitMeCardHadPhoneNumber(hasPhoneNumber);
 }
 
 // Name and company information is stored once in the Address Book against
 // multiple addresses.  We replicate that information for each profile.
 // We only propagate the company name to work profiles.
-void AuxiliaryProfilesImpl::GetAddressBookNames(
+// Returns whether |me| contains any name information.
+bool AuxiliaryProfilesImpl::GetAddressBookNames(
     ABPerson* me,
     NSString* addressLabelRaw,
     AutofillProfile* profile) {
   NSString* firstName = [me valueForProperty:kABFirstNameProperty];
   NSString* middleName = [me valueForProperty:kABMiddleNameProperty];
   NSString* lastName = [me valueForProperty:kABLastNameProperty];
   NSString* companyName = [me valueForProperty:kABOrganizationProperty];
 
   profile->SetRawInfo(NAME_FIRST, base::SysNSStringToUTF16(firstName));
   profile->SetRawInfo(NAME_MIDDLE, base::SysNSStringToUTF16(middleName));
   profile->SetRawInfo(NAME_LAST, base::SysNSStringToUTF16(lastName));
-  if ([addressLabelRaw isEqualToString:kABAddressWorkLabel])
+  bool hasValidCompanyName = false;
+  if ([addressLabelRaw isEqualToString:kABAddressWorkLabel]) {
     profile->SetRawInfo(COMPANY_NAME, base::SysNSStringToUTF16(companyName));
+    hasValidCompanyName = [companyName length] > 0;

[Ilya Sherman, 2015/05/15 21:14:58]

I don't think the company name has much to do with the metric we're adding.  For
example, my name is "Ilya Sherman", and my company name is "Google, Inc.".

[erikchen, 2015/05/15 21:37:23]

Done.

+  }
+
+  return [firstName length] > 0 || [middleName length] > 0 ||
+      [lastName length] > 0 || hasValidCompanyName;
 }
 
 // Addresss information from the Address Book may span multiple lines.
 // If it does then we represent the address with two lines in the profile.  The
 // second line we join with commas.
 // For example:  "c/o John Doe\n1122 Other Avenue\nApt #7" translates to
 // line 1: "c/o John Doe", line 2: "1122 Other Avenue, Apt #7".
-void AuxiliaryProfilesImpl::GetAddressBookAddress(const std::string& app_locale,
+// Returns whether |address| contains any address information.
+bool AuxiliaryProfilesImpl::GetAddressBookAddress(const std::string& app_locale,
                                                   NSDictionary* address,
                                                   AutofillProfile* profile) {
+  bool hasAnyAddressInformation = false;
   if (NSString* addressField = [address objectForKey:kABAddressStreetKey]) {
+    hasAnyAddressInformation |= [addressField length] > 0;
+
     // If there are newlines in the address, split into two lines.
     if ([addressField rangeOfCharacterFromSet:
             [NSCharacterSet newlineCharacterSet]].location != NSNotFound) {
       NSArray* chunks = [addressField componentsSeparatedByCharactersInSet:
           [NSCharacterSet newlineCharacterSet]];
       DCHECK([chunks count] > 1);
 
       NSString* separator =
           l10n_util::GetNSString(IDS_AUTOFILL_ADDRESS_LINE_SEPARATOR);
 
       NSString* addressField1 = [chunks objectAtIndex:0];
       NSString* addressField2 =
           [[chunks subarrayWithRange:NSMakeRange(1, [chunks count] - 1)]
               componentsJoinedByString:separator];
       profile->SetRawInfo(ADDRESS_HOME_LINE1,
                           base::SysNSStringToUTF16(addressField1));
       profile->SetRawInfo(ADDRESS_HOME_LINE2,
                           base::SysNSStringToUTF16(addressField2));
     } else {
       profile->SetRawInfo(ADDRESS_HOME_LINE1,
                           base::SysNSStringToUTF16(addressField));
     }
   }
 
-  if (NSString* city = [address objectForKey:kABAddressCityKey])
+  if (NSString* city = [address objectForKey:kABAddressCityKey]) {
+    hasAnyAddressInformation |= [city length] > 0;
     profile->SetRawInfo(ADDRESS_HOME_CITY, base::SysNSStringToUTF16(city));
+  }
 
-  if (NSString* state = [address objectForKey:kABAddressStateKey])
+  if (NSString* state = [address objectForKey:kABAddressStateKey]) {
+    hasAnyAddressInformation |= [state length] > 0;
     profile->SetRawInfo(ADDRESS_HOME_STATE, base::SysNSStringToUTF16(state));
+  }
 
-  if (NSString* zip = [address objectForKey:kABAddressZIPKey])
+  if (NSString* zip = [address objectForKey:kABAddressZIPKey]) {
+    hasAnyAddressInformation |= [zip length] > 0;
     profile->SetRawInfo(ADDRESS_HOME_ZIP, base::SysNSStringToUTF16(zip));
+  }
 
   if (NSString* country = [address objectForKey:kABAddressCountryKey]) {
+    hasAnyAddressInformation |= [country length] > 0;
     profile->SetInfo(AutofillType(ADDRESS_HOME_COUNTRY),
                      base::SysNSStringToUTF16(country),
                      app_locale);
   }
+
+  return hasAnyAddressInformation;

[Ilya Sherman, 2015/05/15 21:14:58]

I think this is perhaps too lax to be useful.  For example, I'd expect that it's
fairly common to have a country set, and maybe even a state; that's still not
too helpful for Autofill.  I'd be most interested in knowing whether there is a
"complete" address.  As a short heuristic for that, I'd check to see whether
there is a street address + city or zip.

[erikchen, 2015/05/15 21:37:23]

Done.

 }
 
 // Fills in email address matching current address label.  Note that there may
 // be multiple matching email addresses for a given label.  We take the
 // first we find (topmost) as preferred.
-void AuxiliaryProfilesImpl::GetAddressBookEmail(
+// Returns whether |me| contains an email.
+bool AuxiliaryProfilesImpl::GetAddressBookEmail(
     ABPerson* me,
     NSString* addressLabelRaw,
     AutofillProfile* profile) {
   ABMultiValue* emailAddresses = [me valueForProperty:kABEmailProperty];
   NSString* emailAddress = nil;
   for (NSUInteger j = 0, emailCount = [emailAddresses count];
        j < emailCount; j++) {
     NSString* emailAddressLabelRaw = [emailAddresses labelAtIndex:j];
     if ([emailAddressLabelRaw isEqualToString:addressLabelRaw]) {
       emailAddress = [emailAddresses valueAtIndex:j];
       break;
     }
   }
   profile->SetRawInfo(EMAIL_ADDRESS, base::SysNSStringToUTF16(emailAddress));
+  return [emailAddress length] > 0;
 }
 
 // Fills in telephone numbers.  Each of these are special cases.
 // We match two cases: home/tel, work/tel.
 // Note, we traverse in reverse order so that top values in address book
 // take priority.
-void AuxiliaryProfilesImpl::GetAddressBookPhoneNumbers(
+// Returns whether |me| contains a phone number.
+bool AuxiliaryProfilesImpl::GetAddressBookPhoneNumbers(
     ABPerson* me,
     NSString* addressLabelRaw,
     AutofillProfile* profile) {
+  bool hasPhoneNumber = false;
   ABMultiValue* phoneNumbers = [me valueForProperty:kABPhoneProperty];
   for (NSUInteger k = 0, phoneCount = [phoneNumbers count];
        k < phoneCount; k++) {
     NSUInteger reverseK = phoneCount - k - 1;
     NSString* phoneLabelRaw = [phoneNumbers labelAtIndex:reverseK];
     if ([addressLabelRaw isEqualToString:kABAddressHomeLabel] &&
         [phoneLabelRaw isEqualToString:kABPhoneHomeLabel]) {
       base::string16 homePhone = base::SysNSStringToUTF16(
           [phoneNumbers valueAtIndex:reverseK]);
       profile->SetRawInfo(PHONE_HOME_WHOLE_NUMBER, homePhone);
+      hasPhoneNumber |= !homePhone.empty();
     } else if ([addressLabelRaw isEqualToString:kABAddressWorkLabel] &&
                [phoneLabelRaw isEqualToString:kABPhoneWorkLabel]) {
       base::string16 workPhone = base::SysNSStringToUTF16(
           [phoneNumbers valueAtIndex:reverseK]);
       profile->SetRawInfo(PHONE_HOME_WHOLE_NUMBER, workPhone);
+      hasPhoneNumber |= !workPhone.empty();
     } else if ([phoneLabelRaw isEqualToString:kABPhoneMobileLabel] ||
                [phoneLabelRaw isEqualToString:kABPhoneMainLabel]) {
       base::string16 phone = base::SysNSStringToUTF16(
           [phoneNumbers valueAtIndex:reverseK]);
       profile->SetRawInfo(PHONE_HOME_WHOLE_NUMBER, phone);
+      hasPhoneNumber |= !phone.empty();
     }
   }
+  return hasPhoneNumber;
 }
 
 }  // namespace
 
 // Populate |auxiliary_profiles_| with the Address Book data.
 void PersonalDataManager::LoadAuxiliaryProfiles(bool record_metrics) const {
   AuxiliaryProfilesImpl impl(&auxiliary_profiles_);
   impl.GetAddressBookMeCard(app_locale_, pref_service_, record_metrics);
 }
 
@@ skipping 52 matching lines @@
 
 int PersonalDataManager::AccessAddressBookPromptCount() {
   return pref_service_->GetInteger(prefs::kAutofillMacAddressBookShowedCount);
 }
 
 void PersonalDataManager::BinaryChanging() {
   g_binary_changed = true;
 }
 
 }  // namespace autofill