Create an autofill Suggestion class

components/autofill/core/browser/autofill_external_delegate_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 <vector>
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string16.h"
@@ skipping 17 matching lines @@
 namespace autofill {
 
 namespace {
 
 // A constant value to use as the Autofill query ID.
 const int kQueryId = 5;
 
 // A constant value to use as an Autofill profile ID.
 const int kAutofillProfileId = 1;
 
+// Gmock matcher that allows checking the frontend IDs of a sequence of
+// suggestions. This wraps a GMock container matcher, converts the suggestion
+// frontend IDs to a vector of ints, and then runs the container matcher
+// against the result to test an argument. See SuggestionVectorIdsAre() below.
+class SuggestionVectorIdsAreMatcher
+    : public testing::MatcherInterface<const std::vector<Suggestion>&> {
+ public:
+  typedef std::vector<int> Container;
+  typedef testing::Matcher<Container> ContainerMatcher;
+
+  explicit SuggestionVectorIdsAreMatcher(const ContainerMatcher& seq_matcher)
+      : container_matcher_(seq_matcher) {
+  }
+
+  virtual bool MatchAndExplain(const std::vector<Suggestion>& suggestions,
+                               testing::MatchResultListener* listener) const {
+    Container frontend_ids;
+    for (const auto& suggestion : suggestions)
+      frontend_ids.push_back(suggestion.frontend_id);
+    return container_matcher_.MatchAndExplain(frontend_ids, listener);
+  }
+
+  virtual void DescribeTo(::std::ostream* os) const {
+    container_matcher_.DescribeTo(os);
+  }
+
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    container_matcher_.DescribeNegationTo(os);
+  }
+
+ private:
+  ContainerMatcher container_matcher_;
+};
+
+// Use this matcher to compare a sequence vector's IDs to a list. In an
+// EXPECT_CALL statement, use the following for an vector<Suggestion> argument
+// to compare the IDs against a constant list:
+//   SuggestionVectorIdsAre(testing::ElementsAre(1, 2, 3, 4))
+template<class EltsAreMatcher>
+inline testing::Matcher<const std::vector<Suggestion>&>
+SuggestionVectorIdsAre(const EltsAreMatcher& elts_are_matcher) {
+  return MakeMatcher(
+      new SuggestionVectorIdsAreMatcher(elts_are_matcher));
+}
+
 class MockAutofillDriver : public TestAutofillDriver {
  public:
   MockAutofillDriver() {}
   // Mock methods to enable testability.
   MOCK_METHOD1(RendererShouldAcceptDataListSuggestion,
                void(const base::string16&));
   MOCK_METHOD0(RendererShouldClearFilledForm, void());
   MOCK_METHOD0(RendererShouldClearPreviewedForm, void());
   MOCK_METHOD1(RendererShouldFillFieldWithValue, void(const base::string16&));
   MOCK_METHOD1(RendererShouldPreviewFieldWithValue,
                void(const base::string16&));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockAutofillDriver);
 };
 
 class MockAutofillClient : public autofill::TestAutofillClient {
  public:
   MockAutofillClient() {}
 
   MOCK_METHOD1(ScanCreditCard,
                void(const CreditCardScanCallback& callbacK));
 
-  MOCK_METHOD7(ShowAutofillPopup,
+  MOCK_METHOD4(ShowAutofillPopup,
                void(const gfx::RectF& element_bounds,
                     base::i18n::TextDirection text_direction,
-                    const std::vector<base::string16>& values,
-                    const std::vector<base::string16>& labels,
-                    const std::vector<base::string16>& icons,
-                    const std::vector<int>& identifiers,
+                    const std::vector<Suggestion>& suggestions,
                     base::WeakPtr<AutofillPopupDelegate> delegate));
 
   MOCK_METHOD2(UpdateAutofillPopupDataListValues,
                void(const std::vector<base::string16>& values,
                     const std::vector<base::string16>& lables));
 
   MOCK_METHOD0(HideAutofillPopup, void());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockAutofillClient);
@@ skipping 66 matching lines @@
 
 // Test that our external delegate called the virtual methods at the right time.
 TEST_F(AutofillExternalDelegateUnitTest, TestExternalDelegateVirtualCalls) {
   IssueOnQuery(kQueryId);
 
   // The enums must be cast to ints to prevent compile errors on linux_rel.
   EXPECT_CALL(
       autofill_client_,
       ShowAutofillPopup(_,
                         _,
-                        _,
-                        _,
-                        _,
-                        testing::ElementsAre(
+                        SuggestionVectorIdsAre(testing::ElementsAre(
                             kAutofillProfileId,
                             static_cast<int>(POPUP_ITEM_ID_SEPARATOR),
-                            static_cast<int>(POPUP_ITEM_ID_AUTOFILL_OPTIONS)),
+                            static_cast<int>(POPUP_ITEM_ID_AUTOFILL_OPTIONS))),
                         _));
 
   // This should call ShowAutofillPopup.
-  std::vector<base::string16> autofill_item;
-  autofill_item.push_back(base::string16());
-  std::vector<int> autofill_ids;
-  autofill_ids.push_back(kAutofillProfileId);
-  external_delegate_->OnSuggestionsReturned(kQueryId,
-                                            autofill_item,
-                                            autofill_item,
-                                            autofill_item,
-                                            autofill_ids);
+  std::vector<Suggestion> autofill_item;
+  autofill_item.push_back(Suggestion());
+  autofill_item[0].frontend_id = kAutofillProfileId;
+  external_delegate_->OnSuggestionsReturned(kQueryId, autofill_item);
 
   EXPECT_CALL(*autofill_manager_,
               FillOrPreviewForm(
                   AutofillDriver::FORM_DATA_ACTION_FILL, _, _, _, _));
   EXPECT_CALL(autofill_client_, HideAutofillPopup());
 
   // This should trigger a call to hide the popup since we've selected an
   // option.
-  external_delegate_->DidAcceptSuggestion(autofill_item[0], autofill_ids[0]);
+  external_delegate_->DidAcceptSuggestion(autofill_item[0].value,
+                                          autofill_item[0].frontend_id);
 }
 
 // Test that data list elements for a node will appear in the Autofill popup.
 TEST_F(AutofillExternalDelegateUnitTest, ExternalDelegateDataList) {
   IssueOnQuery(kQueryId);
 
   std::vector<base::string16> data_list_items;
   data_list_items.push_back(base::string16());
 
   EXPECT_CALL(
       autofill_client_,
       UpdateAutofillPopupDataListValues(data_list_items, data_list_items));
 
   external_delegate_->SetCurrentDataListValues(data_list_items,
                                                data_list_items);
 
   // The enums must be cast to ints to prevent compile errors on linux_rel.
   EXPECT_CALL(
       autofill_client_,
       ShowAutofillPopup(_,
                         _,
-                        _,
-                        _,
-                        _,
-                        testing::ElementsAre(
+                        SuggestionVectorIdsAre(testing::ElementsAre(
                             static_cast<int>(POPUP_ITEM_ID_DATALIST_ENTRY),
                             static_cast<int>(POPUP_ITEM_ID_SEPARATOR),
                             kAutofillProfileId,
                             static_cast<int>(POPUP_ITEM_ID_SEPARATOR),
-                            static_cast<int>(POPUP_ITEM_ID_AUTOFILL_OPTIONS)),
+                            static_cast<int>(POPUP_ITEM_ID_AUTOFILL_OPTIONS))),
                         _));
 
   // This should call ShowAutofillPopup.
-  std::vector<base::string16> autofill_item;
-  autofill_item.push_back(base::string16());
-  std::vector<int> autofill_ids;
-  autofill_ids.push_back(kAutofillProfileId);
-  external_delegate_->OnSuggestionsReturned(kQueryId,
-                                            autofill_item,
-                                            autofill_item,
-                                            autofill_item,
-                                            autofill_ids);
+  std::vector<Suggestion> autofill_item;
+  autofill_item.push_back(Suggestion());
+  autofill_item[0].frontend_id = kAutofillProfileId;
+  external_delegate_->OnSuggestionsReturned(kQueryId, autofill_item);
 
   // Try calling OnSuggestionsReturned with no Autofill values and ensure
   // the datalist items are still shown.
   // The enum must be cast to an int to prevent compile errors on linux_rel.
   EXPECT_CALL(
       autofill_client_,
       ShowAutofillPopup(
           _,
           _,
-          _,
-          _,
-          _,
-          testing::ElementsAre(static_cast<int>(POPUP_ITEM_ID_DATALIST_ENTRY)),
+          SuggestionVectorIdsAre(testing::ElementsAre(
+              static_cast<int>(POPUP_ITEM_ID_DATALIST_ENTRY))),
           _));
 
-  autofill_item = std::vector<base::string16>();
-  autofill_ids = std::vector<int>();
-  external_delegate_->OnSuggestionsReturned(kQueryId,
-                                            autofill_item,
-                                            autofill_item,
-                                            autofill_item,
-                                            autofill_ids);
+  autofill_item.clear();
+  external_delegate_->OnSuggestionsReturned(kQueryId, autofill_item);
 }
 
 // Test that datalist values can get updated while a popup is showing.
 TEST_F(AutofillExternalDelegateUnitTest, UpdateDataListWhileShowingPopup) {
   IssueOnQuery(kQueryId);
 
-  EXPECT_CALL(autofill_client_, ShowAutofillPopup(_, _, _, _, _, _, _))
+  EXPECT_CALL(autofill_client_, ShowAutofillPopup(_, _, _, _))
       .Times(0);
 
   // Make sure just setting the data list values doesn't cause the popup to
   // appear.
   std::vector<base::string16> data_list_items;
   data_list_items.push_back(base::string16());
 
   EXPECT_CALL(
       autofill_client_,
       UpdateAutofillPopupDataListValues(data_list_items, data_list_items));
 
   external_delegate_->SetCurrentDataListValues(data_list_items,
                                                data_list_items);
 
   // The enums must be cast to ints to prevent compile errors on linux_rel.
   EXPECT_CALL(
       autofill_client_,
       ShowAutofillPopup(_,
                         _,
-                        _,
-                        _,
-                        _,
-                        testing::ElementsAre(
+                        SuggestionVectorIdsAre(testing::ElementsAre(
                             static_cast<int>(POPUP_ITEM_ID_DATALIST_ENTRY),
                             static_cast<int>(POPUP_ITEM_ID_SEPARATOR),
                             kAutofillProfileId,
                             static_cast<int>(POPUP_ITEM_ID_SEPARATOR),
-                            static_cast<int>(POPUP_ITEM_ID_AUTOFILL_OPTIONS)),
+                            static_cast<int>(POPUP_ITEM_ID_AUTOFILL_OPTIONS))),
                         _));
 
   // Ensure the popup is displayed.
-  std::vector<base::string16> autofill_item;
-  autofill_item.push_back(base::string16());
-  std::vector<int> autofill_ids;
-  autofill_ids.push_back(kAutofillProfileId);
-  external_delegate_->OnSuggestionsReturned(kQueryId,
-                                            autofill_item,
-                                            autofill_item,
-                                            autofill_item,
-                                            autofill_ids);
+  std::vector<Suggestion> autofill_item;
+  autofill_item.push_back(Suggestion());
+  autofill_item[0].frontend_id = kAutofillProfileId;
+  external_delegate_->OnSuggestionsReturned(kQueryId, autofill_item);
 
   // This would normally get called from ShowAutofillPopup, but it is mocked so
   // we need to call OnPopupShown ourselves.
   external_delegate_->OnPopupShown();
 
   // Update the current data list and ensure the popup is updated.
   data_list_items.push_back(base::string16());
 
   // The enums must be cast to ints to prevent compile errors on linux_rel.
   EXPECT_CALL(
       autofill_client_,
       UpdateAutofillPopupDataListValues(data_list_items, data_list_items));
 
   external_delegate_->SetCurrentDataListValues(data_list_items,
                                                data_list_items);
 }
 
 // Test that the Autofill popup is able to display warnings explaining why
 // Autofill is disabled for a website.
 // Regression test for http://crbug.com/247880
 TEST_F(AutofillExternalDelegateUnitTest, AutofillWarnings) {
   IssueOnQuery(kQueryId);
 
   // The enums must be cast to ints to prevent compile errors on linux_rel.
   EXPECT_CALL(
       autofill_client_,
       ShowAutofillPopup(
           _,
           _,
-          _,
-          _,
-          _,
-          testing::ElementsAre(static_cast<int>(POPUP_ITEM_ID_WARNING_MESSAGE)),
+          SuggestionVectorIdsAre(testing::ElementsAre(
+              static_cast<int>(POPUP_ITEM_ID_WARNING_MESSAGE))),
           _));
 
   // This should call ShowAutofillPopup.
-  std::vector<base::string16> autofill_item;
-  autofill_item.push_back(base::string16());
-  std::vector<int> autofill_ids;
-  autofill_ids.push_back(POPUP_ITEM_ID_WARNING_MESSAGE);
-  external_delegate_->OnSuggestionsReturned(kQueryId,
-                                            autofill_item,
-                                            autofill_item,
-                                            autofill_item,
-                                            autofill_ids);
+  std::vector<Suggestion> autofill_item;
+  autofill_item.push_back(Suggestion());
+  autofill_item[0].frontend_id = POPUP_ITEM_ID_WARNING_MESSAGE;
+  external_delegate_->OnSuggestionsReturned(kQueryId, autofill_item);
 }
 
 // Test that the Autofill popup doesn't display a warning explaining why
 // Autofill is disabled for a website when there are no Autofill suggestions.
 // Regression test for http://crbug.com/105636
 TEST_F(AutofillExternalDelegateUnitTest, NoAutofillWarningsWithoutSuggestions) {
   // This test only makes sense if we're respecting autocomplete="off".
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kRespectAutocompleteOffForAutofill))
     return;
 
   const FormData form;
   FormFieldData field;
   field.is_focusable = true;
   field.should_autocomplete = false;
   const gfx::RectF element_bounds;
 
   external_delegate_->OnQuery(kQueryId, form, field, element_bounds, true);
 
-  EXPECT_CALL(autofill_client_, ShowAutofillPopup(_, _, _, _, _, _, _))
+  EXPECT_CALL(autofill_client_, ShowAutofillPopup(_, _, _, _))
       .Times(0);
   EXPECT_CALL(autofill_client_, HideAutofillPopup()).Times(1);
 
   // This should not call ShowAutofillPopup.
-  std::vector<base::string16> autofill_item;
-  autofill_item.push_back(base::string16());
-  std::vector<int> autofill_ids;
-  autofill_ids.push_back(POPUP_ITEM_ID_AUTOCOMPLETE_ENTRY);
-  external_delegate_->OnSuggestionsReturned(kQueryId,
-                                            autofill_item,
-                                            autofill_item,
-                                            autofill_item,
-                                            autofill_ids);
+  std::vector<Suggestion> autofill_item;
+  autofill_item.push_back(Suggestion());
+  autofill_item[0].frontend_id = POPUP_ITEM_ID_AUTOCOMPLETE_ENTRY;
+  external_delegate_->OnSuggestionsReturned(kQueryId, autofill_item);
 }
 
 // Test that the Autofill delegate doesn't try and fill a form with a
 // negative unique id.
 TEST_F(AutofillExternalDelegateUnitTest, ExternalDelegateInvalidUniqueId) {
   // Ensure it doesn't try to preview the negative id.
   EXPECT_CALL(*autofill_manager_, FillOrPreviewForm(_, _, _, _, _)).Times(0);
   EXPECT_CALL(*autofill_driver_, RendererShouldClearPreviewedForm()).Times(1);
   external_delegate_->DidSelectSuggestion(base::string16(), -1);
 
@@ skipping 22 matching lines @@
   EXPECT_CALL(*autofill_driver_, RendererShouldClearPreviewedForm()).Times(1);
   EXPECT_CALL(*autofill_driver_, RendererShouldPreviewFieldWithValue(
                                      ASCIIToUTF16("baz foo")));
   external_delegate_->DidSelectSuggestion(ASCIIToUTF16("baz foo"),
                                           POPUP_ITEM_ID_AUTOCOMPLETE_ENTRY);
 }
 
 // Test that the popup is hidden once we are done editing the autofill field.
 TEST_F(AutofillExternalDelegateUnitTest,
        ExternalDelegateHidePopupAfterEditing) {
-  EXPECT_CALL(autofill_client_, ShowAutofillPopup(_, _, _, _, _, _, _));
+  EXPECT_CALL(autofill_client_, ShowAutofillPopup(_, _, _, _));
   autofill::GenerateTestAutofillPopup(external_delegate_.get());
 
   EXPECT_CALL(autofill_client_, HideAutofillPopup());
   external_delegate_->DidEndTextFieldEditing();
 }
 
 // Test that the driver is directed to accept the data list after being notified
 // that the user accepted the data list suggestion.
 TEST_F(AutofillExternalDelegateUnitTest, ExternalDelegateAcceptSuggestion) {
   EXPECT_CALL(autofill_client_, HideAutofillPopup());
@@ skipping 43 matching lines @@
 
   // Set up a field that shouldn't get autocompleted or display warnings.
   const FormData form;
   FormFieldData field;
   field.is_focusable = true;
   field.should_autocomplete = false;
   const gfx::RectF element_bounds;
 
   external_delegate_->OnQuery(kQueryId, form, field, element_bounds, false);
 
-  std::vector<base::string16> autofill_items;
-  autofill_items.push_back(base::string16());
-  std::vector<int> autofill_ids;
-  autofill_ids.push_back(POPUP_ITEM_ID_AUTOCOMPLETE_ENTRY);
+  std::vector<Suggestion> autofill_items;
+  autofill_items.push_back(Suggestion());
+  autofill_items[0].frontend_id = POPUP_ITEM_ID_AUTOCOMPLETE_ENTRY;
 
   // Ensure the popup tries to hide itself, since it is not allowed to show
   // anything.
   EXPECT_CALL(autofill_client_, HideAutofillPopup());
 
-  external_delegate_->OnSuggestionsReturned(kQueryId,
-                                            autofill_items,
-                                            autofill_items,
-                                            autofill_items,
-                                            autofill_ids);
+  external_delegate_->OnSuggestionsReturned(kQueryId, autofill_items);
 }
 
 TEST_F(AutofillExternalDelegateUnitTest, IgnoreAutocompleteOffForAutofill) {
   const FormData form;
   FormFieldData field;
   field.is_focusable = true;
   field.should_autocomplete = false;
   const gfx::RectF element_bounds;
 
   external_delegate_->OnQuery(kQueryId, form, field, element_bounds, false);
 
-  std::vector<base::string16> autofill_items;
-  autofill_items.push_back(base::string16());
-  std::vector<int> autofill_ids;
-  autofill_ids.push_back(POPUP_ITEM_ID_AUTOCOMPLETE_ENTRY);
+  std::vector<Suggestion> autofill_items;
+  autofill_items.push_back(Suggestion());
+  autofill_items[0].frontend_id = POPUP_ITEM_ID_AUTOCOMPLETE_ENTRY;
 
   // Ensure the popup tries to show itself, despite autocomplete="off".
-  EXPECT_CALL(autofill_client_, ShowAutofillPopup(_, _, _, _, _, _, _));
+  EXPECT_CALL(autofill_client_, ShowAutofillPopup(_, _, _, _));
   EXPECT_CALL(autofill_client_, HideAutofillPopup()).Times(0);
 
-  external_delegate_->OnSuggestionsReturned(kQueryId,
-                                            autofill_items,
-                                            autofill_items,
-                                            autofill_items,
-                                            autofill_ids);
+  external_delegate_->OnSuggestionsReturned(kQueryId, autofill_items);
 }
 
 TEST_F(AutofillExternalDelegateUnitTest, ExternalDelegateFillFieldWithValue) {
   EXPECT_CALL(autofill_client_, HideAutofillPopup());
   base::string16 dummy_string(ASCIIToUTF16("baz foo"));
   EXPECT_CALL(*autofill_driver_,
               RendererShouldFillFieldWithValue(dummy_string));
   external_delegate_->DidAcceptSuggestion(dummy_string,
                                           POPUP_ITEM_ID_AUTOCOMPLETE_ENTRY);
 }
 
 }  // namespace autofill