Rename AutofillManagerDelegate to AutofillClient.

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>
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "components/autofill/core/browser/autocomplete_history_manager.h"
+#include "components/autofill/core/browser/autofill_client.h"
 #include "components/autofill/core/browser/autofill_data_model.h"
 #include "components/autofill/core/browser/autofill_external_delegate.h"
 #include "components/autofill/core/browser/autofill_field.h"
-#include "components/autofill/core/browser/autofill_manager_delegate.h"
 #include "components/autofill/core/browser/autofill_manager_test_delegate.h"
 #include "components/autofill/core/browser/autofill_metrics.h"
 #include "components/autofill/core/browser/autofill_profile.h"
 #include "components/autofill/core/browser/autofill_type.h"
 #include "components/autofill/core/browser/credit_card.h"
 #include "components/autofill/core/browser/form_structure.h"
 #include "components/autofill/core/browser/personal_data_manager.h"
 #include "components/autofill/core/browser/phone_number.h"
 #include "components/autofill/core/browser/phone_number_i18n.h"
 #include "components/autofill/core/browser/popup_item_ids.h"
@@ skipping 95 matching lines @@
     const std::string& app_locale,
     FormStructure* submitted_form) {
   // For each field in the |submitted_form|, extract the value.  Then for each
   // profile or credit card, identify any stored types that match the value.
   for (size_t i = 0; i < submitted_form->field_count(); ++i) {
     AutofillField* field = submitted_form->field(i);
     ServerFieldTypeSet matching_types;
 
     // If it's a password field, set the type directly.
     if (field->form_control_type == "password") {
-      matching_types.insert(autofill::PASSWORD);
+      matching_types.insert(PASSWORD);
     } else {
       base::string16 value;
       base::TrimWhitespace(field->value, base::TRIM_ALL, &value);
       for (std::vector<AutofillProfile>::const_iterator it = profiles.begin();
            it != profiles.end(); ++it) {
         it->GetMatchingTypes(value, app_locale, &matching_types);
       }
       for (std::vector<CreditCard>::const_iterator it = credit_cards.begin();
             it != credit_cards.end(); ++it) {
         it->GetMatchingTypes(value, app_locale, &matching_types);
       }
     }
 
     if (matching_types.empty())
       matching_types.insert(UNKNOWN_TYPE);
 
     field->set_possible_types(matching_types);
   }
 }
 
 }  // namespace
 
 AutofillManager::AutofillManager(
     AutofillDriver* driver,
-    autofill::AutofillManagerDelegate* delegate,
+    AutofillClient* client,
     const std::string& app_locale,
     AutofillDownloadManagerState enable_download_manager)
     : driver_(driver),
-      manager_delegate_(delegate),
+      client_(client),
       app_locale_(app_locale),
-      personal_data_(delegate->GetPersonalDataManager()),
+      personal_data_(client->GetPersonalDataManager()),
       autocomplete_history_manager_(
-          new AutocompleteHistoryManager(driver, delegate)),
+          new AutocompleteHistoryManager(driver, client)),
       metric_logger_(new AutofillMetrics),
       has_logged_autofill_enabled_(false),
       has_logged_address_suggestions_count_(false),
       did_show_suggestions_(false),
       user_did_type_(false),
       user_did_autofill_(false),
       user_did_edit_autofilled_field_(false),
       external_delegate_(NULL),
       test_delegate_(NULL),
       weak_ptr_factory_(this) {
   if (enable_download_manager == ENABLE_AUTOFILL_DOWNLOAD_MANAGER) {
     download_manager_.reset(
-        new AutofillDownloadManager(driver,
-                                    manager_delegate_->GetPrefs(),
-                                    this));
+        new AutofillDownloadManager(driver, client_->GetPrefs(), this));
   }
 }
 
 AutofillManager::~AutofillManager() {}
 
 // static
 void AutofillManager::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterBooleanPref(
       prefs::kAutofillEnabled,
@@ skipping 28 matching lines @@
 
 void AutofillManager::SetExternalDelegate(AutofillExternalDelegate* delegate) {
   // TODO(jrg): consider passing delegate into the ctor.  That won't
   // work if the delegate has a pointer to the AutofillManager, but
   // future directions may not need such a pointer.
   external_delegate_ = delegate;
   autocomplete_history_manager_->SetExternalDelegate(delegate);
 }
 
 void AutofillManager::ShowAutofillSettings() {
-  manager_delegate_->ShowAutofillSettings();
+  client_->ShowAutofillSettings();
 }
 
 bool AutofillManager::OnFormSubmitted(const FormData& form,
                                       const TimeTicks& timestamp) {
   if (!IsValidFormData(form))
     return false;
 
   // Let Autocomplete know as well.
   autocomplete_history_manager_->OnFormSubmitted(form);
 
@@ skipping 249 matching lines @@
       if ((*iter) == field) {
         base::string16 value = data_model->GetInfoForVariant(
             autofill_field->Type(), variant, app_locale_);
         if (AutofillField::FillFormField(
             *autofill_field, value, 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;
 
           if (!is_credit_card && !value.empty())
-            manager_delegate_->DidFillOrPreviewField(value, profile_full_name);
+            client_->DidFillOrPreviewField(value, profile_full_name);
         }
         break;
       }
     }
 
     driver_->SendFormDataToRenderer(query_id, action, result);
     return;
   }
 
   // Cache the field type for the field from which the user initiated autofill.
@@ skipping 31 matching lines @@
           (result.fields[i] == field ||
            result.fields[i].form_control_type == "select-one" ||
            result.fields[i].value.empty());
       if (AutofillField::FillFormField(
           *cached_field, value, app_locale_, &result.fields[i])) {
         // Mark the cached field as autofilled, so that we can detect when a
         // user edits an autofilled field (for metrics).
         form_structure->field(i)->is_autofilled = true;
 
         if (should_notify)
-          manager_delegate_->DidFillOrPreviewField(value, profile_full_name);
+          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();
 
@@ skipping 31 matching lines @@
       metric_logger_->LogUserHappinessMetric(
           AutofillMetrics::SUGGESTIONS_SHOWN_ONCE);
     }
   }
 }
 
 void AutofillManager::OnHidePopup() {
   if (!IsAutofillEnabled())
     return;
 
-  manager_delegate_->HideAutofillPopup();
+  client_->HideAutofillPopup();
 }
 
 void AutofillManager::RemoveAutofillProfileOrCreditCard(int unique_id) {
   const AutofillDataModel* data_model = NULL;
   size_t variant = 0;
   bool unused_is_credit_card = false;
   if (!GetProfileOrCreditCard(
           unique_id, &data_model, &variant, &unused_is_credit_card)) {
     NOTREACHED();
     return;
@@ skipping 10 matching lines @@
 
 void AutofillManager::RemoveAutocompleteEntry(const base::string16& name,
                                               const base::string16& value) {
   autocomplete_history_manager_->OnRemoveAutocompleteEntry(name, value);
 }
 
 const std::vector<FormStructure*>& AutofillManager::GetFormStructures() {
   return form_structures_.get();
 }
 
-void AutofillManager::SetTestDelegate(
-    autofill::AutofillManagerTestDelegate* delegate) {
+void AutofillManager::SetTestDelegate(AutofillManagerTestDelegate* delegate) {
   test_delegate_ = delegate;
 }
 
 void AutofillManager::OnSetDataList(const std::vector<base::string16>& values,
                                     const std::vector<base::string16>& labels) {
   if (!IsValidString16Vector(values) ||
       !IsValidString16Vector(labels) ||
       values.size() != labels.size())
     return;
 
   external_delegate_->SetCurrentDataListValues(values, labels);
 }
 
 void AutofillManager::OnLoadedServerPredictions(
     const std::string& response_xml) {
   // Parse and store the server predictions.
   FormStructure::ParseQueryResponse(response_xml,
                                     form_structures_.get(),
                                     *metric_logger_);
 
   // Forward form structures to the password generation manager to detect
   // account creation forms.
-  manager_delegate_->DetectAccountCreationForms(form_structures_.get());
+  client_->DetectAccountCreationForms(form_structures_.get());
 
   // If the corresponding flag is set, annotate forms with the predicted types.
   driver_->SendAutofillTypePredictionsToRenderer(form_structures_.get());
 }
 
 void AutofillManager::OnDidEndTextFieldEditing() {
   external_delegate_->DidEndTextFieldEditing();
 }
 
 bool AutofillManager::IsAutofillEnabled() const {
-  return manager_delegate_->GetPrefs()->GetBoolean(prefs::kAutofillEnabled);
+  return client_->GetPrefs()->GetBoolean(prefs::kAutofillEnabled);
 }
 
 void AutofillManager::ImportFormData(const FormStructure& submitted_form) {
   scoped_ptr<CreditCard> imported_credit_card;
   if (!personal_data_->ImportFormData(submitted_form, &imported_credit_card))
     return;
 
   // If credit card information was submitted, we need to confirm whether to
   // save it.
   if (imported_credit_card) {
-    manager_delegate_->ConfirmSaveCreditCard(
+    client_->ConfirmSaveCreditCard(
         *metric_logger_,
         base::Bind(
             base::IgnoreResult(&PersonalDataManager::SaveImportedCreditCard),
-            base::Unretained(personal_data_), *imported_credit_card));
+            base::Unretained(personal_data_),
+            *imported_credit_card));
   }
 }
 
 // Note that |submitted_form| is passed as a pointer rather than as a reference
 // so that we can get memory management right across threads.  Note also that we
 // explicitly pass in all the time stamps of interest, as the cached ones might
 // get reset before this method executes.
 void AutofillManager::UploadFormDataAsyncCallback(
     const FormStructure* submitted_form,
     const TimeTicks& load_time,
@@ skipping 22 matching lines @@
     if (*it == form_signature)
       was_autofilled = true;
   }
 
   ServerFieldTypeSet non_empty_types;
   personal_data_->GetNonEmptyTypes(&non_empty_types);
   // Always add PASSWORD to |non_empty_types| so that if |submitted_form|
   // contains a password field it will be uploaded to the server. If
   // |submitted_form| doesn't contain a password field, there is no side
   // effect from adding PASSWORD to |non_empty_types|.
-  non_empty_types.insert(autofill::PASSWORD);
+  non_empty_types.insert(PASSWORD);
 
   download_manager_->StartUploadRequest(submitted_form, was_autofilled,
                                         non_empty_types);
 }
 
 bool AutofillManager::UploadPasswordGenerationForm(const FormData& form) {
   FormStructure form_structure(form);
 
   if (!ShouldUploadForm(form_structure))
     return false;
@@ skipping 44 matching lines @@
   did_show_suggestions_ = false;
   user_did_type_ = false;
   user_did_autofill_ = false;
   user_did_edit_autofilled_field_ = false;
   forms_loaded_timestamps_.clear();
   initial_interaction_timestamp_ = TimeTicks();
   external_delegate_->Reset();
 }
 
 AutofillManager::AutofillManager(AutofillDriver* driver,
-                                 autofill::AutofillManagerDelegate* delegate,
+                                 AutofillClient* client,
                                  PersonalDataManager* personal_data)
     : driver_(driver),
-      manager_delegate_(delegate),
+      client_(client),
       app_locale_("en-US"),
       personal_data_(personal_data),
       autocomplete_history_manager_(
-          new AutocompleteHistoryManager(driver, delegate)),
+          new AutocompleteHistoryManager(driver, client)),
       metric_logger_(new AutofillMetrics),
       has_logged_autofill_enabled_(false),
       has_logged_address_suggestions_count_(false),
       did_show_suggestions_(false),
       user_did_type_(false),
       user_did_autofill_(false),
       user_did_edit_autofilled_field_(false),
       external_delegate_(NULL),
       test_delegate_(NULL),
       weak_ptr_factory_(this) {
   DCHECK(driver_);
-  DCHECK(manager_delegate_);
+  DCHECK(client_);
 }
 
 void AutofillManager::set_metric_logger(const AutofillMetrics* metric_logger) {
   metric_logger_.reset(metric_logger);
 }
 
 bool AutofillManager::RefreshDataModels() const {
   if (!IsAutofillEnabled())
     return false;
 
@@ skipping 305 matching lines @@
     return false;
 
   // Disregard forms that we wouldn't ever autofill in the first place.
   if (!form.ShouldBeParsed(true))
     return false;
 
   return true;
 }
 
 }  // namespace autofill