Fix Autofill crash on mac address book entries

components/autofill/core/browser/autofill_manager.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_manager.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <map>
@@ skipping 573 matching lines @@
       unmasking_field_ = field;
       real_pan_client_.Prepare();
       client()->ShowUnmaskPrompt(unmasking_card_,
                                  weak_ptr_factory_.GetWeakPtr());
       credit_card_form_event_logger_->OnDidSelectMaskedServerCardSuggestion();
       return;
     }
     credit_card_form_event_logger_->OnDidFillSuggestion(credit_card);
   }
 
-  FillOrPreviewDataModelForm(action, query_id, form, field, &credit_card,
+  FillOrPreviewDataModelForm(action, query_id, form, field, credit_card,
                              variant, true /* is_credit_card */);
 }
 
 void AutofillManager::FillOrPreviewProfileForm(
     AutofillDriver::RendererFormDataAction action,
     int query_id,
     const FormData& form,
     const FormFieldData& field,
     const AutofillProfile& profile,
     size_t variant) {
   if (action == AutofillDriver::FORM_DATA_ACTION_FILL)
     address_form_event_logger_->OnDidFillSuggestion(profile);
 
-  FillOrPreviewDataModelForm(action, query_id, form, field, &profile, variant,
+  FillOrPreviewDataModelForm(action, query_id, form, field, profile, variant,
                              false /* is_credit_card */);
 }
 
 void AutofillManager::FillOrPreviewForm(
     AutofillDriver::RendererFormDataAction action,
     int query_id,
     const FormData& form,
     const FormFieldData& field,
     int unique_id) {
   if (!IsValidFormData(form) || !IsValidFormFieldData(field))
@@ skipping 17 matching lines @@
 void AutofillManager::FillCreditCardForm(int query_id,
                                          const FormData& form,
                                          const FormFieldData& field,
                                          const CreditCard& credit_card) {
   if (!IsValidFormData(form) || !IsValidFormFieldData(field) ||
       !driver_->RendererIsAvailable()) {
     return;
   }
 
   FillOrPreviewDataModelForm(AutofillDriver::FORM_DATA_ACTION_FILL, query_id,
-                             form, field, &credit_card, 0, true);
+                             form, field, credit_card, 0, true);
 }
 
 void AutofillManager::OnDidPreviewAutofillFormData() {
   if (test_delegate_)
     test_delegate_->DidPreviewFormData();
 }
 
 void AutofillManager::OnDidFillAutofillFormData(const TimeTicks& timestamp) {
   if (test_delegate_)
     test_delegate_->DidFillFormData();
@@ skipping 375 matching lines @@
   if (base::IsValidGUID(credit_card_id.guid))
     *credit_card = personal_data_->GetCreditCardByGUID(credit_card_id.guid);
   return !!*credit_card;
 }
 
 void AutofillManager::FillOrPreviewDataModelForm(
     AutofillDriver::RendererFormDataAction action,
     int query_id,
     const FormData& form,
     const FormFieldData& field,
-    const AutofillDataModel* data_model,
+    const AutofillDataModel& data_model,
     size_t variant,
     bool is_credit_card) {
   FormStructure* form_structure = NULL;
   AutofillField* autofill_field = NULL;
   if (!GetCachedFormAndField(form, field, &form_structure, &autofill_field))
     return;
 
   DCHECK(form_structure);
   DCHECK(autofill_field);
 
   FormData result = form;
 
   base::string16 profile_full_name;
   std::string profile_language_code;
   if (!is_credit_card) {
-    profile_full_name = data_model->GetInfo(
+    profile_full_name = data_model.GetInfo(
         AutofillType(NAME_FULL), app_locale_);
     profile_language_code =
-        static_cast<const AutofillProfile*>(data_model)->language_code();
+        static_cast<const AutofillProfile*>(&data_model)->language_code();
   }
 
-  if (action == AutofillDriver::FORM_DATA_ACTION_FILL)
-    personal_data_->RecordUseOf(*data_model);
-
   // If the relevant section is auto-filled, we should fill |field| but not the
   // rest of the form.
   if (SectionIsAutofilled(*form_structure, form, autofill_field->section())) {
     for (std::vector<FormFieldData>::iterator iter = result.fields.begin();
          iter != result.fields.end(); ++iter) {
       if (iter->SameFieldAs(field)) {
-        base::string16 value = data_model->GetInfoForVariant(
+        base::string16 value = data_model.GetInfoForVariant(
             autofill_field->Type(), variant, app_locale_);
         if (AutofillField::FillFormField(*autofill_field,
                                          value,
                                          profile_language_code,
                                          app_locale_,
                                          &(*iter))) {
           // Mark the cached field as autofilled, so that we can detect when a
           // user edits an autofilled field (for metrics).
           autofill_field->is_autofilled = true;
 
           // Mark the field as autofilled when a non-empty value is assigned to
           // it. This allows the renderer to distinguish autofilled fields from
           // fields with non-empty values, such as select-one fields.
           iter->is_autofilled = true;
 
           if (!is_credit_card && !value.empty())
             client_->DidFillOrPreviewField(value, profile_full_name);
         }
         break;
       }
     }
 
     driver_->SendFormDataToRenderer(query_id, action, result);
+
+    // Note that this may invalidate |data_model|, particularly if it is a Mac
+    // address book entry.
+    if (action == AutofillDriver::FORM_DATA_ACTION_FILL)
+      personal_data_->RecordUseOf(data_model);

[Evan Stade, 2015/02/18 21:05:35]

as you can see, the meat of the change is moving this call to after the last use
of |data_model|

+
     return;
   }
 
   // Cache the field type for the field from which the user initiated autofill.
   FieldTypeGroup initiating_group_type = autofill_field->Type().group();
   DCHECK_EQ(form_structure->field_count(), form.fields.size());
   for (size_t i = 0; i < form_structure->field_count(); ++i) {
     if (form_structure->field(i)->section() != autofill_field->section())
       continue;
 
     DCHECK(form_structure->field(i)->SameFieldAs(result.fields[i]));
 
     const AutofillField* cached_field = form_structure->field(i);
     FieldTypeGroup field_group_type = cached_field->Type().group();
 
     if (field_group_type == NO_GROUP)
       continue;
 
     // If the field being filled is either
     //   (a) the field that the user initiated the fill from, or
     //   (b) part of the same logical unit, e.g. name or phone number,
     // then take the multi-profile "variant" into account.
     // Otherwise fill with the default (zeroth) variant.
     size_t use_variant = 0;
     if (result.fields[i].SameFieldAs(field) ||
         field_group_type == initiating_group_type) {
       use_variant = variant;
     }
-    base::string16 value = data_model->GetInfoForVariant(
+    base::string16 value = data_model.GetInfoForVariant(
         cached_field->Type(), use_variant, app_locale_);
     if (is_credit_card &&
         cached_field->Type().GetStorableType() ==
             CREDIT_CARD_VERIFICATION_CODE) {
-      // If this is |unmasking_card_|, |unmask_response_,cvc| should be
+      // If this is |unmasking_card_|, |unmask_response_.cvc| should be
       // non-empty and vice versa.
       value = unmask_response_.cvc;
-      DCHECK_EQ(&unmasking_card_ == data_model, value.empty());
+      DCHECK_EQ(unmasking_card_ == data_model, !value.empty());
     }
 
     // Must match ForEachMatchingFormField() in form_autofill_util.cc.
     // Only notify autofilling of empty fields and the field that initiated
     // the filling (note that "select-one" controls may not be empty but will
     // still be autofilled).
     bool should_notify =
         !is_credit_card &&
         !value.empty() &&
         (result.fields[i].SameFieldAs(field) ||
@@ skipping 17 matching lines @@
         client_->DidFillOrPreviewField(value, profile_full_name);
     }
   }
 
   autofilled_form_signatures_.push_front(form_structure->FormSignature());
   // Only remember the last few forms that we've seen, both to avoid false
   // positives and to avoid wasting memory.
   if (autofilled_form_signatures_.size() > kMaxRecentFormSignaturesToRemember)
     autofilled_form_signatures_.pop_back();
 
+  // Note that this may invalidate |data_model|, particularly if it is a Mac
+  // address book entry.
+  if (action == AutofillDriver::FORM_DATA_ACTION_FILL)
+    personal_data_->RecordUseOf(data_model);
+
   driver_->SendFormDataToRenderer(query_id, action, result);
 }
 
 bool AutofillManager::FindCachedForm(const FormData& form,
                                      FormStructure** form_structure) const {
   // Find the FormStructure that corresponds to |form|.
   // Scan backward through the cached |form_structures_|, as updated versions of
   // forms are added to the back of the list, whereas original versions of these
   // forms might appear toward the beginning of the list.  The communication
   // protocol with the crowdsourcing server does not permit us to discard the
@@ skipping 275 matching lines @@
     return false;
 
   // Disregard forms that we wouldn't ever autofill in the first place.
   if (!form.ShouldBeParsed())
     return false;
 
   return true;
 }
 
 }  // namespace autofill