Rename AutofillManagerDelegate to AutofillClient.

components/autofill/core/browser/autofill_manager_unittest.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 <algorithm>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/format_macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_service.h"
 #include "base/run_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/tuple.h"
 #include "components/autofill/core/browser/autocomplete_history_manager.h"
 #include "components/autofill/core/browser/autofill_manager.h"
 #include "components/autofill/core/browser/autofill_metrics.h"
 #include "components/autofill/core/browser/autofill_profile.h"
 #include "components/autofill/core/browser/autofill_test_utils.h"
 #include "components/autofill/core/browser/credit_card.h"
 #include "components/autofill/core/browser/personal_data_manager.h"
 #include "components/autofill/core/browser/popup_item_ids.h"
+#include "components/autofill/core/browser/test_autofill_client.h"
 #include "components/autofill/core/browser/test_autofill_driver.h"
 #include "components/autofill/core/browser/test_autofill_external_delegate.h"
-#include "components/autofill/core/browser/test_autofill_manager_delegate.h"
 #include "components/autofill/core/browser/webdata/autofill_webdata_service.h"
 #include "components/autofill/core/common/autofill_pref_names.h"
 #include "components/autofill/core/common/form_data.h"
 #include "components/autofill/core/common/form_field_data.h"
 #include "grit/components_strings.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/rect.h"
 #include "url/gurl.h"
@@ skipping 309 matching lines @@
                                                   const char* year,
                                                   const char* month) {
   ExpectFilledForm(page_id, filled_form, expected_page_id,
                    "", "", "", "", "", "", "", "", "", "", "",
                    "Miku Hatsune", "4234567890654321", month, year,
                    has_address_fields, true, true);
 }
 
 class MockAutocompleteHistoryManager : public AutocompleteHistoryManager {
  public:
-  MockAutocompleteHistoryManager(AutofillDriver* driver,
-                                 AutofillManagerDelegate* delegate)
-      : AutocompleteHistoryManager(driver, delegate) {}
+  MockAutocompleteHistoryManager(AutofillDriver* driver, AutofillClient* client)
+      : AutocompleteHistoryManager(driver, client) {}
 
   MOCK_METHOD1(OnFormSubmitted, void(const FormData& form));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockAutocompleteHistoryManager);
 };
 
 class MockAutofillDriver : public TestAutofillDriver {
  public:
   MockAutofillDriver() {}
 
   // Mock methods to enable testability.
   MOCK_METHOD3(SendFormDataToRenderer, void(int query_id,
                                             RendererFormDataAction action,
                                             const FormData& data));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockAutofillDriver);
 };
 
 class TestAutofillManager : public AutofillManager {
  public:
   TestAutofillManager(AutofillDriver* driver,
-                      autofill::AutofillManagerDelegate* delegate,
+                      autofill::AutofillClient* client,
                       TestPersonalDataManager* personal_data)
-      : AutofillManager(driver, delegate, personal_data),
+      : AutofillManager(driver, client, personal_data),
         personal_data_(personal_data),
         autofill_enabled_(true) {}
   virtual ~TestAutofillManager() {}
 
   virtual bool IsAutofillEnabled() const OVERRIDE { return autofill_enabled_; }
 
   void set_autofill_enabled(bool autofill_enabled) {
     autofill_enabled_ = autofill_enabled;
   }
 
@@ skipping 179 matching lines @@
   std::vector<int> autofill_unique_ids_;
 
   DISALLOW_COPY_AND_ASSIGN(TestAutofillExternalDelegate);
 };
 
 }  // namespace
 
 class AutofillManagerTest : public testing::Test {
  public:
   virtual void SetUp() OVERRIDE {
-    autofill_delegate_.SetPrefs(test::PrefServiceForTesting());
-    personal_data_.set_database(autofill_delegate_.GetDatabase());
-    personal_data_.SetPrefService(autofill_delegate_.GetPrefs());
+    autofill_client_.SetPrefs(test::PrefServiceForTesting());
+    personal_data_.set_database(autofill_client_.GetDatabase());
+    personal_data_.SetPrefService(autofill_client_.GetPrefs());
     autofill_driver_.reset(new MockAutofillDriver());
     autofill_manager_.reset(new TestAutofillManager(
-        autofill_driver_.get(), &autofill_delegate_, &personal_data_));
+        autofill_driver_.get(), &autofill_client_, &personal_data_));
 
     external_delegate_.reset(new TestAutofillExternalDelegate(
         autofill_manager_.get(),
         autofill_driver_.get()));
     autofill_manager_->SetExternalDelegate(external_delegate_.get());
   }
 
   virtual void TearDown() OVERRIDE {
     // Order of destruction is important as AutofillManager relies on
     // PersonalDataManager to be around when it gets destroyed.
@@ skipping 61 matching lines @@
                         testing::SaveArg<2>(response_data))));
     FillAutofillFormData(input_query_id, input_form, input_field, unique_id);
   }
 
   int PackGUIDs(const GUIDPair& cc_guid, const GUIDPair& profile_guid) const {
     return autofill_manager_->PackGUIDs(cc_guid, profile_guid);
   }
 
  protected:
   base::MessageLoop message_loop_;
-  TestAutofillManagerDelegate autofill_delegate_;
+  TestAutofillClient autofill_client_;
   scoped_ptr<MockAutofillDriver> autofill_driver_;
   scoped_ptr<TestAutofillManager> autofill_manager_;
   scoped_ptr<TestAutofillExternalDelegate> external_delegate_;
   TestPersonalDataManager personal_data_;
 };
 
 class TestFormStructure : public FormStructure {
  public:
   explicit TestFormStructure(const FormData& form)
       : FormStructure(form) {}
@@ skipping 857 matching lines @@
   FormData response_data;
   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
       PackGUIDs(empty, guid), &response_page_id, &response_data);
   ExpectFilledAddressFormElvis(
       response_page_id, response_data, kDefaultPageID, false);
 }
 
 // Test that we correctly fill an address form from an auxiliary profile.
 TEST_F(AutofillManagerTest, FillAddressFormFromAuxiliaryProfile) {
   personal_data_.ClearAutofillProfiles();
-  autofill_delegate_.GetPrefs()->SetBoolean(
+  autofill_client_.GetPrefs()->SetBoolean(
       ::autofill::prefs::kAutofillAuxiliaryProfilesEnabled, true);
   personal_data_.CreateTestAuxiliaryProfiles();
 
   // Set up our form data.
   FormData form;
   test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   GUIDPair guid("00000000-0000-0000-0000-000000000001", 0);
@@ skipping 735 matching lines @@
 
   // Simulate form submission. We should call into the PDM to try to save the
   // filled data.
   EXPECT_CALL(personal_data_, SaveImportedProfile(::testing::_)).Times(1);
   FormSubmitted(response_data);
 }
 
 // Test that when Autocomplete is enabled and Autofill is disabled,
 // form submissions are still received by AutocompleteHistoryManager.
 TEST_F(AutofillManagerTest, FormSubmittedAutocompleteEnabled) {
-  TestAutofillManagerDelegate delegate;
-  autofill_manager_.reset(new TestAutofillManager(
-      autofill_driver_.get(),
-      &delegate,
-      NULL));
+  TestAutofillClient client;
+  autofill_manager_.reset(
+      new TestAutofillManager(autofill_driver_.get(), &client, NULL));
   autofill_manager_->set_autofill_enabled(false);
   scoped_ptr<MockAutocompleteHistoryManager> autocomplete_history_manager;
   autocomplete_history_manager.reset(
-      new MockAutocompleteHistoryManager(autofill_driver_.get(), &delegate));
+      new MockAutocompleteHistoryManager(autofill_driver_.get(), &client));
   autofill_manager_->autocomplete_history_manager_ =
       autocomplete_history_manager.Pass();
 
   // Set up our form data.
   FormData form;
   test::CreateTestAddressFormData(&form);
   form.method = ASCIIToUTF16("GET");
   MockAutocompleteHistoryManager* m = static_cast<
       MockAutocompleteHistoryManager*>(
           autofill_manager_->autocomplete_history_manager_.get());
   EXPECT_CALL(*m,
               OnFormSubmitted(_)).Times(1);
   FormSubmitted(form);
 }
 
 // Test that when Autocomplete is enabled and Autofill is disabled,
 // Autocomplete suggestions are still received.
 TEST_F(AutofillManagerTest, AutocompleteSuggestionsWhenAutofillDisabled) {
-  TestAutofillManagerDelegate delegate;
-  autofill_manager_.reset(new TestAutofillManager(
-      autofill_driver_.get(),
-      &delegate,
-      NULL));
+  TestAutofillClient client;
+  autofill_manager_.reset(
+      new TestAutofillManager(autofill_driver_.get(), &client, NULL));
   autofill_manager_->set_autofill_enabled(false);
   autofill_manager_->SetExternalDelegate(external_delegate_.get());
 
   // Set up our form data.
   FormData form;
   test::CreateTestAddressFormData(&form);
   form.method = ASCIIToUTF16("GET");
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
   const FormFieldData& field = form.fields[0];
@@ skipping 116 matching lines @@
 
   // Simulate form submission.  We should not call into the PDM to try to save
   // the filled data, since the filled form is effectively missing an address.
   EXPECT_CALL(personal_data_, SaveImportedProfile(::testing::_)).Times(0);
   FormSubmitted(response_data);
 }
 
 // Checks that resetting the auxiliary profile enabled preference does the right
 // thing on all platforms.
 TEST_F(AutofillManagerTest, AuxiliaryProfilesReset) {
-  PrefService* prefs = autofill_delegate_.GetPrefs();
+  PrefService* prefs = autofill_client_.GetPrefs();
 #if defined(OS_MACOSX) || defined(OS_ANDROID)
   // Auxiliary profiles is implemented on Mac and Android only.
   // OSX: enables Mac Address Book integration.
   // Android: enables integration with user's contact profile.
   ASSERT_TRUE(
       prefs->GetBoolean(::autofill::prefs::kAutofillAuxiliaryProfilesEnabled));
   prefs->SetBoolean(
       ::autofill::prefs::kAutofillAuxiliaryProfilesEnabled, false);
   prefs->ClearPref(::autofill::prefs::kAutofillAuxiliaryProfilesEnabled);
   ASSERT_TRUE(
@@ skipping 339 matching lines @@
   autofill_manager_->RemoveAutofillProfileOrCreditCard(id);
 
   // TODO(csharp): Currently variants should not be deleted, but once they are
   // update these expectations.
   // http://crbug.com/124211
   EXPECT_TRUE(autofill_manager_->GetProfileWithGUID(guid.c_str()));
 }
 
 namespace {
 
-class MockAutofillManagerDelegate : public TestAutofillManagerDelegate {
+class MockAutofillClient : public TestAutofillClient {
  public:
-  MockAutofillManagerDelegate() {}
+  MockAutofillClient() {}
 
-  virtual ~MockAutofillManagerDelegate() {}
+  virtual ~MockAutofillClient() {}
 
   virtual void ShowRequestAutocompleteDialog(
       const FormData& form,
       const GURL& source_url,
       const ResultCallback& callback) OVERRIDE {
     callback.Run(user_supplied_data_ ? AutocompleteResultSuccess :
                                        AutocompleteResultErrorDisabled,
                  base::string16(),
                  user_supplied_data_.get());
   }
 
   void SetUserSuppliedData(scoped_ptr<FormStructure> user_supplied_data) {
     user_supplied_data_.reset(user_supplied_data.release());
   }
 
  private:
   scoped_ptr<FormStructure> user_supplied_data_;
 
-  DISALLOW_COPY_AND_ASSIGN(MockAutofillManagerDelegate);
+  DISALLOW_COPY_AND_ASSIGN(MockAutofillClient);
 };
 
 }  // namespace
 
 // Test our external delegate is called at the right time.
 TEST_F(AutofillManagerTest, TestExternalDelegate) {
   FormData form;
   test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
   const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);  // should call the delegate's OnQuery()
 
   EXPECT_TRUE(external_delegate_->on_query_seen());
 }
 
 }  // namespace autofill