[Autofill] Add metric for profile action on form submitted

components/autofill/core/browser/autofill_profile.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 "components/autofill/core/browser/autofill_profile.h"
 
 #include <algorithm>
 #include <functional>
 #include <map>
 #include <ostream>
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/guid.h"
 #include "base/i18n/case_conversion.h"
 #include "base/i18n/char_iterator.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/sha1.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversion_utils.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/autofill/core/browser/address.h"
 #include "components/autofill/core/browser/address_i18n.h"
 #include "components/autofill/core/browser/autofill_country.h"
 #include "components/autofill/core/browser/autofill_field.h"
+#include "components/autofill/core/browser/autofill_metrics.h"
 #include "components/autofill/core/browser/autofill_type.h"
 #include "components/autofill/core/browser/contact_info.h"
 #include "components/autofill/core/browser/phone_number.h"
 #include "components/autofill/core/browser/phone_number_i18n.h"
 #include "components/autofill/core/browser/state_names.h"
 #include "components/autofill/core/browser/validation.h"
 #include "components/autofill/core/common/autofill_l10n_util.h"
 #include "components/autofill/core/common/form_field_data.h"
 #include "grit/components_strings.h"
 #include "third_party/icu/source/common/unicode/uchar.h"
@@ skipping 434 matching lines @@
       if (!compare)
         compare.reset(new l10n::CaseInsensitiveCompare());
       if (!compare->StringsEqual(value, profile.GetRawInfo(type)))
         return false;
     }
   }
 
   return true;
 }
 
-void AutofillProfile::OverwriteName(const NameInfo& imported_name,
+bool AutofillProfile::OverwriteName(const NameInfo& imported_name,
                                     const std::string& app_locale) {
   if (name_.ParsedNamesAreEqual(imported_name)) {
-    if (name_.GetRawInfo(NAME_FULL).empty())
+    if (name_.GetRawInfo(NAME_FULL).empty() &&
+        !imported_name.GetRawInfo(NAME_FULL).empty()) {
       name_.SetRawInfo(NAME_FULL, imported_name.GetRawInfo(NAME_FULL));
-    return;
+      return true;
+    }
+    return false;
   }
 
   l10n::CaseInsensitiveCompare compare;
   AutofillType type = AutofillType(NAME_FULL);
   base::string16 full_name = name_.GetInfo(type, app_locale);
   if (compare.StringsEqual(full_name,
                            imported_name.GetInfo(type, app_locale))) {
     // The imported name has the same full name string as the name for this
     // profile.  Because full names are _heuristically_ parsed into
     // {first, middle, last} name components, it's possible that either the
     // existing name or the imported name was misparsed.  Prefer to keep the
     // name whose {first, middle, last} components do not match those computed
     // by the heuristic parse, as this more likely represents the correct,
     // user-input parse of the name.
     NameInfo heuristically_parsed_name;
     heuristically_parsed_name.SetInfo(type, full_name, app_locale);
     if (imported_name.ParsedNamesAreEqual(heuristically_parsed_name))
-      return;
+      return false;
   }
 
   name_ = imported_name;
+  return true;
 }
 
-void AutofillProfile::OverwriteWith(const AutofillProfile& profile,
+bool AutofillProfile::OverwriteWith(const AutofillProfile& profile,
                                     const std::string& app_locale) {
   // Verified profiles should never be overwritten with unverified data.
   DCHECK(!IsVerified() || profile.IsVerified());
   set_origin(profile.origin());
   set_language_code(profile.language_code());
   set_use_count(profile.use_count() + use_count());
   if (profile.use_date() > use_date())
     set_use_date(profile.use_date());
 
   ServerFieldTypeSet field_types;
@@ skipping 15 matching lines @@
   // previous value should not be replaced with an empty string in that case.
   if (compare.StringsEqual(
           CanonicalizeProfileString(
               profile.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS)),
           CanonicalizeProfileString(GetRawInfo(ADDRESS_HOME_STREET_ADDRESS))) &&
       profile.GetRawInfo(ADDRESS_HOME_LINE2) == base::UTF8ToUTF16("")) {
     field_types.erase(ADDRESS_HOME_LINE1);
     field_types.erase(ADDRESS_HOME_LINE2);
   }
 
-  for (const auto& iter : field_types) {
-    FieldTypeGroup group = AutofillType(iter).group();
+  bool did_overwrite = false;
+
+  for (ServerFieldTypeSet::const_iterator iter = field_types.begin();
+       iter != field_types.end(); ++iter) {
+    FieldTypeGroup group = AutofillType(*iter).group();
+
     // Special case names.
     if (group == NAME) {
-      OverwriteName(profile.name_, app_locale);
+      did_overwrite = OverwriteName(profile.name_, app_locale) || did_overwrite;
       continue;
     }
 
-    base::string16 new_value = profile.GetRawInfo(iter);
-    if (!compare.StringsEqual(GetRawInfo(iter), new_value))
-      SetRawInfo(iter, new_value);
+    base::string16 new_value = profile.GetRawInfo(*iter);
+    if (!compare.StringsEqual(GetRawInfo(*iter), new_value)) {
+      SetRawInfo(*iter, new_value);
+      did_overwrite = true;
+    }
   }
+
+  return did_overwrite;
 }
 
 bool AutofillProfile::SaveAdditionalInfo(const AutofillProfile& profile,
                                          const std::string& app_locale) {
   ServerFieldTypeSet field_types, other_field_types;
   GetNonEmptyTypes(app_locale, &field_types);
   profile.GetNonEmptyTypes(app_locale, &other_field_types);
   // The address needs to be compared line by line to take into account the
   // logic for empty fields implemented in the loop.
   field_types.erase(ADDRESS_HOME_STREET_ADDRESS);
@@ skipping 47 matching lines @@
                                  abbreviation))
           continue;
       }
       if (!compare.StringsEqual(profile.GetRawInfo(field_type),
                                 GetRawInfo(field_type))) {
         return false;
       }
     }
   }
 
-  if (!IsVerified() || profile.IsVerified())
-    OverwriteWith(profile, app_locale);
+  if (!IsVerified() || profile.IsVerified()) {
+    if (OverwriteWith(profile, app_locale)) {
+      AutofillMetrics::LogProfileActionOnFormSubmitted(
+          AutofillMetrics::EXISTING_PROFILE_UPDATED);
+    } else {
+      AutofillMetrics::LogProfileActionOnFormSubmitted(
+          AutofillMetrics::EXISTING_PROFILE_USED);
+    }
+  }
   return true;
 }
 
 // static
 bool AutofillProfile::SupportsMultiValue(ServerFieldType type) {
   FieldTypeGroup group = AutofillType(type).group();
   return group == NAME ||
          group == NAME_BILLING ||
          group == EMAIL ||
          group == PHONE_HOME ||
@@ skipping 367 matching lines @@
             << " " << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_CITY)) << " "
             << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_STATE)) << " "
             << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_ZIP)) << " "
             << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_SORTING_CODE)) << " "
             << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_COUNTRY)) << " "
             << profile.language_code() << " "
             << UTF16ToUTF8(profile.GetRawInfo(PHONE_HOME_WHOLE_NUMBER));
 }
 
 }  // namespace autofill