AutoFill Mac dialog should be non-modal

chrome/browser/autofill/autofill_dialog_controller_mac.mm

 // Copyright (c) 2010 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.
 
 #import "chrome/browser/autofill/autofill_dialog_controller_mac.h"
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/mac_util.h"
+#include "base/singleton.h"
 #include "base/sys_string_conversions.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
 #import "chrome/browser/autofill/autofill_address_model_mac.h"
 #import "chrome/browser/autofill/autofill_address_sheet_controller_mac.h"
 #import "chrome/browser/autofill/autofill_credit_card_model_mac.h"
 #import "chrome/browser/autofill/autofill_credit_card_sheet_controller_mac.h"
 #import "chrome/browser/autofill/personal_data_manager.h"
 #include "chrome/browser/browser_process.h"
 #import "chrome/browser/cocoa/window_size_autosaver.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profile.h"
 #include "chrome/common/notification_details.h"
 #include "chrome/common/notification_observer.h"
 #include "chrome/common/pref_names.h"
 #include "grit/generated_resources.h"
 #include "grit/app_resources.h"
 #include "grit/theme_resources.h"
 
 namespace {
 
+// Type for singleton object that contains the instance of the visible
+// dialog.
+typedef std::map<Profile*, AutoFillDialogController*> ProfileControllerMap;
+
 // Update profile labels passed as |input|.  When profile data changes as a
 // result of adding new profiles, edititing existing profiles, or deleting a
 // profile, then the list of profiles need to have their derived labels
 // recomputed.
 void UpdateProfileLabels(std::vector<AutoFillProfile>* input) {
   DCHECK(input);
   std::vector<AutoFillProfile*> profiles;
   profiles.resize(input->size());
   for (size_t i = 0; i < input->size(); ++i) {
     profiles[i] = &(*input)[i];
@@ skipping 34 matching lines @@
     [delegate deleteSelection:self];
   } else {
     [super keyDown:event];
   }
 }
 
 @end
 
 // Private interface.
 @interface AutoFillDialogController (PrivateMethods)
+// Save profiles and credit card information after user modification.
+- (void)save;
+
 // Asyncronous handler for when PersonalDataManager data loads.  The
 // personal data manager notifies the dialog with this method when the
 // data loading is complete and ready to be used.
 - (void)onPersonalDataLoaded:(const std::vector<AutoFillProfile*>&)profiles
                  creditCards:(const std::vector<CreditCard*>&)creditCards;
 
+// Asyncronous handler for when PersonalDataManager data changes.  The
+// personal data manager notifies the dialog with this method when the
+// data has changed.
+- (void)onPersonalDataChanged:(const std::vector<AutoFillProfile*>&)profiles
+                  creditCards:(const std::vector<CreditCard*>&)creditCards;
+
 // Called upon changes to AutoFill preferences that should be reflected in the
 // UI.
-- (void)onPrefChanged:(const std::string&)prefName;
+- (void)preferenceDidChange:(const std::string&)preferenceName;
 
 // Returns true if |row| is an index to a valid profile in |tableView_|, and
 // false otherwise.
 - (BOOL)isProfileRow:(NSInteger)row;
 
 // Returns true if |row| is an index to the profile group row in |tableView_|,
 // and false otherwise.
 - (BOOL)isProfileGroupRow:(NSInteger)row;
 
 // Returns true if |row| is an index to a valid credit card in |tableView_|, and
@@ skipping 12 matching lines @@
 - (size_t)creditCardIndexFromRow:(NSInteger)row;
 
 // Returns the  |row| in |tableView_| that corresponds to the index |i| into
 // |profiles_|.
 - (NSInteger)rowFromProfileIndex:(size_t)i;
 
 // Returns the  |row| in |tableView_| that corresponds to the index |i| into
 // |creditCards_|.
 - (NSInteger)rowFromCreditCardIndex:(size_t)row;
 
-// Invokes the modal dialog.
-- (void)runModalDialog;
-
 @end
 
 namespace AutoFillDialogControllerInternal {
 
 // PersonalDataManagerObserver facilitates asynchronous loading of
 // PersonalDataManager data before showing the AutoFill settings data to the
 // user.  It acts as a C++-based delegate for the |AutoFillDialogController|.
 class PersonalDataManagerObserver : public PersonalDataManager::Observer {
  public:
   explicit PersonalDataManagerObserver(
       AutoFillDialogController* controller,
       PersonalDataManager* personal_data_manager,
       Profile* profile)
       : controller_(controller),
         personal_data_manager_(personal_data_manager),
         profile_(profile) {
   }
 
   virtual ~PersonalDataManagerObserver();
 
   // Notifies the observer that the PersonalDataManager has finished loading.
   virtual void OnPersonalDataLoaded();
 
+  // Notifies the observer that the PersonalDataManager data has changed.
+  virtual void OnPersonalDataChanged();
+
  private:
   // Utility method to remove |this| from |personal_data_manager_| as an
   // observer.
   void RemoveObserver();
 
   // The dialog controller to be notified when the data loading completes.
   // Weak reference.
   AutoFillDialogController* controller_;
 
   // The object in which we are registered as an observer.  We hold on to
@@ skipping 14 matching lines @@
 PersonalDataManagerObserver::~PersonalDataManagerObserver() {
   RemoveObserver();
 }
 
 void PersonalDataManagerObserver::RemoveObserver() {
   if (personal_data_manager_) {
     personal_data_manager_->RemoveObserver(this);
   }
 }
 
-// The data is ready so display our data.  Notify the dialog controller that
-// the data is ready.  Once done we clear the observer.
+// The data has been loaded, notify the controller.
 void PersonalDataManagerObserver::OnPersonalDataLoaded() {
-  RemoveObserver();
   [controller_ onPersonalDataLoaded:personal_data_manager_->web_profiles()
                         creditCards:personal_data_manager_->credit_cards()];
 }
 
+// The data has changed, notify the controller.
+void PersonalDataManagerObserver::OnPersonalDataChanged() {
+  [controller_ onPersonalDataChanged:personal_data_manager_->web_profiles()
+                         creditCards:personal_data_manager_->credit_cards()];
+}
+
 // Bridges preference changed notifications to the dialog controller.
-class PrefObserver : public NotificationObserver {
+class PreferenceObserver : public NotificationObserver {
  public:
-  explicit PrefObserver(AutoFillDialogController* controller)
+  explicit PreferenceObserver(AutoFillDialogController* controller)
       : controller_(controller) {}
 
   // Overridden from NotificationObserver:
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details) {
     if (type == NotificationType::PREF_CHANGED) {
       const std::string* pref = Details<std::string>(details).ptr();
       if (pref) {
-        [controller_ onPrefChanged:*pref];
+        [controller_ preferenceDidChange:*pref];
       }
     }
   }
 
  private:
   AutoFillDialogController* controller_;
 
-  DISALLOW_COPY_AND_ASSIGN(PrefObserver);
+  DISALLOW_COPY_AND_ASSIGN(PreferenceObserver);
 };
 
 }  // namespace AutoFillDialogControllerInternal
 
 @implementation AutoFillDialogController
 
-@synthesize autoFillEnabled = autoFillEnabled_;
 @synthesize autoFillManaged = autoFillManaged_;
 @synthesize autoFillManagedAndDisabled = autoFillManagedAndDisabled_;
-@synthesize auxiliaryEnabled = auxiliaryEnabled_;
 @synthesize itemIsSelected = itemIsSelected_;
 @synthesize multipleSelected = multipleSelected_;
 
 + (void)showAutoFillDialogWithObserver:(AutoFillDialogObserver*)observer
-               profile:(Profile*)profile
-       importedProfile:(AutoFillProfile*) importedProfile
-    importedCreditCard:(CreditCard*) importedCreditCard {
+                               profile:(Profile*)profile {
   AutoFillDialogController* controller =
       [AutoFillDialogController controllerWithObserver:observer
-                                         profile:profile
-                                 importedProfile:importedProfile
-                              importedCreditCard:importedCreditCard];
-
-  // Only run modal dialog if it is not already being shown.
-  if (![controller isWindowLoaded]) {
-    [controller runModalDialog];
-  }
+                                               profile:profile];
+  [controller runModelessDialog];
 }
 
 - (void)awakeFromNib {
   PersonalDataManager* personal_data_manager =
       profile_->GetPersonalDataManager();
   DCHECK(personal_data_manager);
 
   if (personal_data_manager->IsDataLoaded()) {
     // |personalDataManager| data is loaded, we can proceed with the contents.
     [self onPersonalDataLoaded:personal_data_manager->web_profiles()
                    creditCards:personal_data_manager->credit_cards()];
-  } else {
-    // |personalDataManager| data is NOT loaded, so we load it here, installing
-    // our observer.
-    personalDataManagerObserver_.reset(
-        new AutoFillDialogControllerInternal::PersonalDataManagerObserver(
-            self, personal_data_manager, profile_));
-    personal_data_manager->SetObserver(personalDataManagerObserver_.get());
   }
 
+  // Register as listener to listen to subsequent data change notifications.
+  personalDataManagerObserver_.reset(
+      new AutoFillDialogControllerInternal::PersonalDataManagerObserver(
+          self, personal_data_manager, profile_));
+  personal_data_manager->SetObserver(personalDataManagerObserver_.get());
+
   // Explicitly load the data in the table before window displays to avoid
   // nasty flicker as tables update.
   [tableView_ reloadData];
 
   // Set up edit when double-clicking on a table row.
   [tableView_ setDoubleAction:@selector(editSelection:)];
 }
 
 // NSWindow Delegate callback.  When the window closes the controller can
 // be released.
 - (void)windowWillClose:(NSNotification *)notification {
   [tableView_ setDataSource:nil];
   [tableView_ setDelegate:nil];
   [self autorelease];
-}
 
-// Called when the user clicks the save button.
-- (IBAction)save:(id)sender {
-  // If we have an |observer_| then communicate the changes back, unless
-  // AutoFill has been disabled through policy in the mean time.
-  if (observer_ && !autoFillManagedAndDisabled_) {
-    prefAutoFillEnabled_.SetValueIfNotManaged(autoFillEnabled_);
-    profile_->GetPrefs()->SetBoolean(prefs::kAutoFillAuxiliaryProfilesEnabled,
-                                     auxiliaryEnabled_);
-    observer_->OnAutoFillDialogApply(&profiles_, &creditCards_);
+  // Remove ourself from the map.
+  ProfileControllerMap* map = Singleton<ProfileControllerMap>::get();
+  ProfileControllerMap::iterator it = map->find(profile_);
+  if (it != map->end()) {
+    map->erase(it);
   }
-  [self closeDialog];
-}
-
-// Called when the user clicks the cancel button. All we need to do is stop
-// the modal session.
-- (IBAction)cancel:(id)sender {
-  [self closeDialog];
 }
 
 // Invokes the "Add" sheet for address information.  If user saves then the new
 // information is added to |profiles_| in |addressAddDidEnd:| method.
 - (IBAction)addNewAddress:(id)sender {
   DCHECK(!addressSheetController.get());
 
   // Create a new default address.
   string16 newName = l10n_util::GetStringUTF16(IDS_AUTOFILL_NEW_ADDRESS);
   AutoFillProfile newAddress(newName, 0);
@@ skipping 42 matching lines @@
              contextInfo:(void*)contextInfo {
   DCHECK(contextInfo == NULL);
 
   if (returnCode) {
     // Create a new address and save it to the |profiles_| list.
     AutoFillProfile newAddress(string16(), 0);
     [addressSheetController copyModelToProfile:&newAddress];
     if (!newAddress.IsEmpty()) {
       profiles_.push_back(newAddress);
 
-      // Refresh the view based on new data.
-      UpdateProfileLabels(&profiles_);
-      [tableView_ reloadData];
+      // Saving will save to the PDM and the table will refresh when PDM sends
+      // notification that the underlying model has changed.
+      [self save];
 
       // Update the selection to the newly added item.
       NSInteger row = [self rowFromProfileIndex:profiles_.size() - 1];
       [tableView_ selectRowIndexes:[NSIndexSet indexSetWithIndex:row]
               byExtendingSelection:NO];
     }
   }
   [sheet orderOut:self];
   addressSheetController.reset(nil);
 }
 
 // Add credit card sheet was dismissed.  Non-zero |returnCode| indicates a save.
 - (void)creditCardAddDidEnd:(NSWindow *)sheet
                  returnCode:(int)returnCode
                 contextInfo:(void *)contextInfo {
   DCHECK(contextInfo == NULL);
 
   if (returnCode) {
     // Create a new credit card and save it to the |creditCards_| list.
     CreditCard newCreditCard(string16(), 0);
     [creditCardSheetController copyModelToCreditCard:&newCreditCard];
     if (!newCreditCard.IsEmpty()) {
       creditCards_.push_back(newCreditCard);
 
-      // Refresh the view based on new data.
-      [tableView_ reloadData];
+      // Saving will save to the PDM and the table will refresh when PDM sends
+      // notification that the underlying model has changed.
+      [self save];
 
       // Update the selection to the newly added item.
       NSInteger row = [self rowFromCreditCardIndex:creditCards_.size() - 1];
       [tableView_ selectRowIndexes:[NSIndexSet indexSetWithIndex:row]
               byExtendingSelection:NO];
     }
   }
   [sheet orderOut:self];
   creditCardSheetController.reset(nil);
 }
@@ skipping 25 matching lines @@
   if ([self tableView:tableView_ shouldSelectRow:selectedRow-1]) {
     [tableView_ selectRowIndexes:[NSIndexSet indexSetWithIndex:selectedRow-1]
             byExtendingSelection:NO];
   } else if ([self tableView:tableView_ shouldSelectRow:selectedRow]) {
     [tableView_ selectRowIndexes:[NSIndexSet indexSetWithIndex:selectedRow]
             byExtendingSelection:NO];
   } else {
     [tableView_ deselectAll:self];
   }
 
-  UpdateProfileLabels(&profiles_);
-  [tableView_ reloadData];
+  // Saving will save to the PDM and the table will refresh when PDM sends
+  // notification that the underlying model has changed.
+  [self save];
 }
 
 // Edits the selected item, either address or credit card depending on the item
 // selected.
 - (IBAction)editSelection:(id)sender {
   NSInteger selectedRow = [tableView_ selectedRow];
   if ([self isProfileRow:selectedRow]) {
     if (!addressSheetController.get()) {
       int i = [self profileIndexFromRow:selectedRow];
 
@@ skipping 49 matching lines @@
     AutoFillProfile* profile = static_cast<AutoFillProfile*>(contextInfo);
     [addressSheetController copyModelToProfile:profile];
 
     if (profile->IsEmpty())
       [tableView_ deselectAll:self];
     profiles_.erase(
         std::remove_if(profiles_.begin(), profiles_.end(),
                        std::mem_fun_ref(&AutoFillProfile::IsEmpty)),
         profiles_.end());
 
-    UpdateProfileLabels(&profiles_);
-    [tableView_ reloadData];
+    // Saving will save to the PDM and the table will refresh when PDM sends
+    // notification that the underlying model has changed.
+    [self save];
   }
   [sheet orderOut:self];
   addressSheetController.reset(nil);
 }
 
 // Edit credit card sheet was dismissed.  Non-zero |returnCode| indicates a
 // save.
 - (void)creditCardEditDidEnd:(NSWindow *)sheet
                   returnCode:(int)returnCode
                  contextInfo:(void *)contextInfo {
   DCHECK(contextInfo != NULL);
   if (returnCode) {
     CreditCard* creditCard = static_cast<CreditCard*>(contextInfo);
     [creditCardSheetController copyModelToCreditCard:creditCard];
 
     if (creditCard->IsEmpty())
       [tableView_ deselectAll:self];
     creditCards_.erase(
         std::remove_if(
             creditCards_.begin(), creditCards_.end(),
             std::mem_fun_ref(&CreditCard::IsEmpty)),
         creditCards_.end());
-    [tableView_ reloadData];
+
+    // Saving will save to the PDM and the table will refresh when PDM sends
+    // notification that the underlying model has changed.
+    [self save];
   }
   [sheet orderOut:self];
   creditCardSheetController.reset(nil);
 }
 
 // NSTableView Delegate method.
 - (BOOL)tableView:(NSTableView *)tableView isGroupRow:(NSInteger)row {
   if ([self isProfileGroupRow:row] || [self isCreditCardGroupRow:row])
     return YES;
   return NO;
 }
 
 // NSTableView Delegate method.
 - (BOOL)tableView:(NSTableView *)tableView shouldSelectRow:(NSInteger)row {
-  return ![self tableView:tableView isGroupRow:row];
+  return [self isProfileRow:row] || [self isCreditCardRow:row];
 }
 
 // NSTableView Delegate method.
 - (id)tableView:(NSTableView *)tableView
   objectValueForTableColumn:(NSTableColumn *)tableColumn
                         row:(NSInteger)row {
   if ([[tableColumn identifier] isEqualToString:@"Spacer"])
     return @"";
 
   // Check that we're initialized before supplying data.
@@ skipping 84 matching lines @@
       // No address information in this profile; it's useless as a billing
       // address.
       continue;
     }
     [array addObject:SysUTF16ToNSString(i->Label())];
   }
 
   return array;
 }
 
+// Accessor for |autoFillEnabled| preference state.  Note: a checkbox in Nib
+// is bound to this via KVO.
+- (BOOL)autoFillEnabled {
+  return autoFillEnabled_.GetValue();
+}
+
+// Setter for |autoFillEnabled| preference state.
+- (void)setAutoFillEnabled:(BOOL)value {
+  autoFillEnabled_.SetValueIfNotManaged(value ? true : false);
+}
+
+// Accessor for |auxiliaryEnabled| preference state.  Note: a checkbox in Nib
+// is bound to this via KVO.
+- (BOOL)auxiliaryEnabled {
+  return auxiliaryEnabled_.GetValue();
+}
+
+// Setter for |auxiliaryEnabled| preference state.
+- (void)setAuxiliaryEnabled:(BOOL)value {
+  if ([self autoFillEnabled])
+    auxiliaryEnabled_.SetValueIfNotManaged(value ? true : false);
+}
+
 @end
 
 @implementation AutoFillDialogController (ExposedForUnitTests)
 
-+ (AutoFillDialogController*)controllerWithObserver:
-        (AutoFillDialogObserver*)observer
-               profile:(Profile*)profile
-       importedProfile:(AutoFillProfile*)importedProfile
-    importedCreditCard:(CreditCard*)importedCreditCard {
++ (AutoFillDialogController*)
+    controllerWithObserver:(AutoFillDialogObserver*)observer
+                   profile:(Profile*)profile {
+  profile = profile->GetOriginalProfile();
+
+  ProfileControllerMap* map = Singleton<ProfileControllerMap>::get();
+  DCHECK(map != NULL);
+  ProfileControllerMap::iterator it = map->find(profile);
+  if (it == map->end()) {
+    // We should have exactly 1 or 0 entry in the map, no more.  That is,
+    // only one profile can have the AutoFill dialog up at a time.
+    DCHECK_EQ(map->size(), 0U);
 
   // Deallocation is done upon window close.  See |windowWillClose:|.
   AutoFillDialogController* controller =
-      [[self alloc] initWithObserver:observer
-                             profile:profile
-                     importedProfile:importedProfile
-                  importedCreditCard:importedCreditCard];
-  return controller;
+      [[self alloc] initWithObserver:observer profile:profile];
+    it = map->insert(std::make_pair(profile, controller)).first;
+  }
+
+  return it->second;
 }
 
 
 // This is the designated initializer for this class.
 // |profiles| are non-retained immutable list of AutoFill profiles.
 // |creditCards| are non-retained immutable list of credit card info.
 - (id)initWithObserver:(AutoFillDialogObserver*)observer
-               profile:(Profile*)profile
-       importedProfile:(AutoFillProfile*)importedProfile
-    importedCreditCard:(CreditCard*)importedCreditCard {
+               profile:(Profile*)profile {
   DCHECK(profile);
   // Use initWithWindowNibPath: instead of initWithWindowNibName: so we
   // can override it in a unit test.
   NSString* nibpath = [mac_util::MainAppBundle()
                        pathForResource:@"AutoFillDialog"
                        ofType:@"nib"];
   if ((self = [super initWithWindowNibPath:nibpath owner:self])) {
     // Initialize member variables based on input.
     observer_ = observer;
     profile_ = profile;
-    importedProfile_ = importedProfile;
-    importedCreditCard_ = importedCreditCard;
 
     // Initialize the preference observer and watch kAutoFillEnabled.
-    prefObserver_.reset(
-        new AutoFillDialogControllerInternal::PrefObserver(self));
-    prefAutoFillEnabled_.Init(prefs::kAutoFillEnabled, profile_->GetPrefs(),
-                              prefObserver_.get());
+    preferenceObserver_.reset(
+        new AutoFillDialogControllerInternal::PreferenceObserver(self));
+    autoFillEnabled_.Init(prefs::kAutoFillEnabled, profile_->GetPrefs(),
+                          preferenceObserver_.get());
 
-    // Call onPrefChanged in order to initialize UI state of the checkbox and
-    // save button.
-    [self onPrefChanged:prefs::kAutoFillEnabled];
+    // Call |preferenceDidChange| in order to initialize UI state of the
+    // checkbox.
+    [self preferenceDidChange:prefs::kAutoFillEnabled];
 
-    // Use property here to trigger KVO binding.
-    [self setAuxiliaryEnabled:profile_->GetPrefs()->GetBoolean(
-        prefs::kAutoFillAuxiliaryProfilesEnabled)];
+    // Initialize the preference observer and watch
+    // kAutoFillAuxiliaryProfilesEnabled.
+    auxiliaryEnabled_.Init(prefs::kAutoFillAuxiliaryProfilesEnabled,
+                           profile_->GetPrefs(),
+                           preferenceObserver_.get());
+
+    // Call |preferenceDidChange| in order to initialize UI state of the
+    // checkbox.
+    [self preferenceDidChange:prefs::kAutoFillAuxiliaryProfilesEnabled];
 
     // Do not use [NSMutableArray array] here; we need predictable destruction
     // which will be prevented by having a reference held by an autorelease
     // pool.
   }
   return self;
 }
 
+// Run modeless.
+- (void)runModelessDialog {
+  // Use stored window geometry if it exists.
+  if (g_browser_process && g_browser_process->local_state()) {
+    sizeSaver_.reset([[WindowSizeAutosaver alloc]
+        initWithWindow:[self window]
+           prefService:g_browser_process->local_state()
+                  path:prefs::kAutoFillDialogPlacement]);
+  }
+
+  [self showWindow:nil];
+}
+
 // Close the dialog.
 - (void)closeDialog {
-  [[self window] close];
-  [NSApp stopModal];
+  [[self window] performClose:self];
 }
 
 - (AutoFillAddressSheetController*)addressSheetController {
   return addressSheetController.get();
 }
 
 - (AutoFillCreditCardSheetController*)creditCardSheetController {
   return creditCardSheetController.get();
 }
 
@@ skipping 18 matching lines @@
 - (void)addSelectedCreditCardAtIndex:(size_t)i {
   [tableView_ selectRowIndexes:[NSIndexSet indexSetWithIndex:
                                    [self rowFromCreditCardIndex:i]]
           byExtendingSelection:YES];
 }
 
 - (BOOL)editButtonEnabled {
   return [editButton_ isEnabled];
 }
 
+- (std::vector<AutoFillProfile>&)profiles {
+  return profiles_;
+}
+
+- (std::vector<CreditCard>&)creditCards {
+  return creditCards_;
+}
+
 @end
 
 @implementation AutoFillDialogController (PrivateMethods)
 
-// Run application modal.
-- (void)runModalDialog {
-  // Use stored window geometry if it exists.
-  if (g_browser_process && g_browser_process->local_state()) {
-    sizeSaver_.reset([[WindowSizeAutosaver alloc]
-        initWithWindow:[self window]
-           prefService:g_browser_process->local_state()
-                  path:prefs::kAutoFillDialogPlacement]);
+// Called when the user modifies the profiles or credit card information.
+- (void)save {
+  // If we have an |observer_| then communicate the changes back, unless
+  // AutoFill has been disabled through policy in the mean time.
+  if (observer_ && !autoFillManagedAndDisabled_) {
+    // Make a working copy of profiles.  |OnAutoFillDialogApply| can mutate
+    // |profiles_|.
+    std::vector<AutoFillProfile> profiles = profiles_;
+
+    // Make a working copy of credit cards.  |OnAutoFillDialogApply| can mutate
+    // |creditCards_|.
+    std::vector<CreditCard> creditCards = creditCards_;
+
+    observer_->OnAutoFillDialogApply(&profiles, &creditCards);
   }
-
-  [NSApp runModalForWindow:[self window]];
 }
 
 - (void)onPersonalDataLoaded:(const std::vector<AutoFillProfile*>&)profiles
                  creditCards:(const std::vector<CreditCard*>&)creditCards {
-  if (importedProfile_) {
-      profiles_.push_back(*importedProfile_);
-  }
+  [self onPersonalDataChanged:profiles creditCards:creditCards];
+}
 
-  if (importedCreditCard_) {
-      creditCards_.push_back(*importedCreditCard_);
-  }
+- (void)onPersonalDataChanged:(const std::vector<AutoFillProfile*>&)profiles
+                  creditCards:(const std::vector<CreditCard*>&)creditCards {
+  // Make local copy of |profiles|.
+  profiles_.clear();
+  for (std::vector<AutoFillProfile*>::const_iterator iter = profiles.begin();
+       iter != profiles.end(); ++iter)
+    profiles_.push_back(**iter);
 
-  // If we're not using imported data then use the data fetch from the web db.
-  if (!importedProfile_ && !importedCreditCard_) {
-    // Make local copy of |profiles|.
-    for (std::vector<AutoFillProfile*>::const_iterator iter = profiles.begin();
-         iter != profiles.end(); ++iter)
-      profiles_.push_back(**iter);
-
-    // Make local copy of |creditCards|.
-    for (std::vector<CreditCard*>::const_iterator iter = creditCards.begin();
-         iter != creditCards.end(); ++iter)
-      creditCards_.push_back(**iter);
-  }
+  // Make local copy of |creditCards|.
+  creditCards_.clear();
+  for (std::vector<CreditCard*>::const_iterator iter = creditCards.begin();
+       iter != creditCards.end(); ++iter)
+    creditCards_.push_back(**iter);
 
   UpdateProfileLabels(&profiles_);
+  [tableView_ reloadData];
 }
 
-- (void)onPrefChanged:(const std::string&)prefName {
-  if (prefName == prefs::kAutoFillEnabled) {
-    [self setAutoFillEnabled:prefAutoFillEnabled_.GetValue()];
-    [self setAutoFillManaged:prefAutoFillEnabled_.IsManaged()];
+- (void)preferenceDidChange:(const std::string&)preferenceName {
+  if (preferenceName == prefs::kAutoFillEnabled) {
+    [self setAutoFillEnabled:autoFillEnabled_.GetValue()];
+    [self setAutoFillManaged:autoFillEnabled_.IsManaged()];
     [self setAutoFillManagedAndDisabled:
-        prefAutoFillEnabled_.IsManaged() && !prefAutoFillEnabled_.GetValue()];
+        autoFillEnabled_.IsManaged() && !autoFillEnabled_.GetValue()];
+  } else if (preferenceName == prefs::kAutoFillAuxiliaryProfilesEnabled) {
+    [self setAuxiliaryEnabled:auxiliaryEnabled_.GetValue()];
   } else {
     NOTREACHED();
   }
 }
 
 - (BOOL)isProfileRow:(NSInteger)row {
   if (row > 0 && static_cast<size_t>(row) <= profiles_.size())
     return YES;
   return NO;
 }
@@ skipping 82 matching lines @@
   if (!image) {
     image = rb.GetNSImageNamed(IDR_INPUT_GOOD);
     DCHECK(image);
     return image;
   }
 
   return nil;
 }
 
 @end