Moving the autofill enum from blink side to browser side

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/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/autofill/core/browser/autofill_manager.h"
+#include "components/autofill/core/browser/popup_item_ids.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/common/form_data.h"
 #include "components/autofill/core/common/form_field_data.h"
 #include "components/autofill/core/common/password_form_fill_data.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/WebKit/public/web/WebAutofillClient.h"
 #include "ui/gfx/rect.h"
 
 using base::ASCIIToUTF16;
-using blink::WebAutofillClient;
 using testing::_;
 
 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.
@@ skipping 98 matching lines @@
   scoped_ptr<AutofillExternalDelegate> external_delegate_;
 
   base::MessageLoop message_loop_;
 };
 
 // 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(manager_delegate_,
-              ShowAutofillPopup(
-                  _, _, _, _, _,
-                  testing::ElementsAre(
-                      kAutofillProfileId,
-                      static_cast<int>(WebAutofillClient::MenuItemIDSeparator),
-                      static_cast<int>(
-                          WebAutofillClient::MenuItemIDAutofillOptions)),
-                  _));
+  EXPECT_CALL(
+      manager_delegate_,
+      ShowAutofillPopup(_,
+                        _,
+                        _,
+                        _,
+                        _,
+                        testing::ElementsAre(
+                            kAutofillProfileId,
+                            static_cast<int>(POPUP_ITEM_ID_SEPARATOR),
+                            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,
@@ skipping 16 matching lines @@
 TEST_F(AutofillExternalDelegateUnitTest, ExternalDelegateDataList) {
   IssueOnQuery(kQueryId);
 
   std::vector<base::string16> data_list_items;
   data_list_items.push_back(base::string16());
 
   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(manager_delegate_,
-              ShowAutofillPopup(
-                  _, _, _, _, _,
-                  testing::ElementsAre(
-                      static_cast<int>(
-                          WebAutofillClient::MenuItemIDDataListEntry),
-                      static_cast<int>(WebAutofillClient::MenuItemIDSeparator),
-                      kAutofillProfileId,
-                      static_cast<int>(WebAutofillClient::MenuItemIDSeparator),
-                      static_cast<int>(
-                          WebAutofillClient::MenuItemIDAutofillOptions)),
-                  _));
+  EXPECT_CALL(
+      manager_delegate_,
+      ShowAutofillPopup(_,
+                        _,
+                        _,
+                        _,
+                        _,
+                        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)),
+                        _));
 
   // 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);
 
   // 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(manager_delegate_,
-              ShowAutofillPopup(
-                  _, _, _, _, _,
-                  testing::ElementsAre(
-                      static_cast<int>(
-                          WebAutofillClient::MenuItemIDDataListEntry)),
-                  _));
+  EXPECT_CALL(
+      manager_delegate_,
+      ShowAutofillPopup(
+          _,
+          _,
+          _,
+          _,
+          _,
+          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);
 }
 
 // Test that datalist values can get updated while a popup is showing.
 TEST_F(AutofillExternalDelegateUnitTest, UpdateDataListWhileShowingPopup) {
   IssueOnQuery(kQueryId);
 
   EXPECT_CALL(manager_delegate_,
               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());
 
   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(manager_delegate_,
-              ShowAutofillPopup(
-                  _, _, _, _, _,
-                  testing::ElementsAre(
-                      static_cast<int>(
-                          WebAutofillClient::MenuItemIDDataListEntry),
-                      static_cast<int>(WebAutofillClient::MenuItemIDSeparator),
-                      kAutofillProfileId,
-                      static_cast<int>(WebAutofillClient::MenuItemIDSeparator),
-                      static_cast<int>(
-                          WebAutofillClient::MenuItemIDAutofillOptions)),
-                  _));
+  EXPECT_CALL(
+      manager_delegate_,
+      ShowAutofillPopup(_,
+                        _,
+                        _,
+                        _,
+                        _,
+                        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)),
+                        _));
 
   // 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,
@@ skipping 15 matching lines @@
                                                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(manager_delegate_,
-              ShowAutofillPopup(
-                  _, _, _, _, _,
-                  testing::ElementsAre(
-                      static_cast<int>(
-                          WebAutofillClient::MenuItemIDWarningMessage)),
-                  _));
+  EXPECT_CALL(
+      manager_delegate_,
+      ShowAutofillPopup(
+          _,
+          _,
+          _,
+          _,
+          _,
+          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(WebAutofillClient::MenuItemIDWarningMessage);
+  autofill_ids.push_back(POPUP_ITEM_ID_WARNING_MESSAGE);
   external_delegate_->OnSuggestionsReturned(kQueryId,
                                             autofill_item,
                                             autofill_item,
                                             autofill_item,
                                             autofill_ids);
 }
 
 // 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) {
   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(manager_delegate_,
               ShowAutofillPopup(_, _, _, _, _, _, _)).Times(0);
   EXPECT_CALL(manager_delegate_, 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(WebAutofillClient::MenuItemIDAutocompleteEntry);
+  autofill_ids.push_back(POPUP_ITEM_ID_AUTOCOMPLETE_ENTRY);
   external_delegate_->OnSuggestionsReturned(kQueryId,
                                             autofill_item,
                                             autofill_item,
                                             autofill_item,
                                             autofill_ids);
 }
 
 // Test that the Autofill delegate doesn't try and fill a form with a
 // negative unique id.
 TEST_F(AutofillExternalDelegateUnitTest, ExternalDelegateInvalidUniqueId) {
@@ skipping 14 matching lines @@
 
 // Test that the ClearPreview call is only sent if the form was being previewed
 // (i.e. it isn't autofilling a password).
 TEST_F(AutofillExternalDelegateUnitTest, ExternalDelegateClearPreviewedForm) {
   // Called by DidSelectSuggestion, add expectation to remove warning.
   EXPECT_CALL(*autofill_manager_, OnFillAutofillFormData(_, _, _, _));
 
   // Ensure selecting a new password entries or Autofill entries will
   // cause any previews to get cleared.
   EXPECT_CALL(*autofill_driver_, RendererShouldClearPreviewedForm()).Times(1);
-  external_delegate_->DidSelectSuggestion(
-      WebAutofillClient::MenuItemIDPasswordEntry);
-
+  external_delegate_->DidSelectSuggestion(POPUP_ITEM_ID_PASSWORD_ENTRY);
   EXPECT_CALL(*autofill_driver_, RendererShouldClearPreviewedForm()).Times(1);
   EXPECT_CALL(*autofill_driver_, SetRendererActionOnFormDataReception(
       AutofillDriver::FORM_DATA_ACTION_PREVIEW));
   external_delegate_->DidSelectSuggestion(1);
 }
 
 // Test that the popup is hidden once we are done editing the autofill field.
 TEST_F(AutofillExternalDelegateUnitTest,
        ExternalDelegateHidePopupAfterEditing) {
   EXPECT_CALL(manager_delegate_, ShowAutofillPopup(_, _, _, _, _, _, _));
@@ skipping 18 matching lines @@
   field.should_autocomplete = true;
   const gfx::RectF element_bounds;
 
   FormFieldData username_field_data;
   username_field_data.value = kUsername;
   PasswordFormFillData password_form_fill_data;
   password_form_fill_data.basic_data.fields.push_back(username_field_data);
   external_delegate_->AddPasswordFormMapping(field, password_form_fill_data);
 
   // The enums must be cast to ints to prevent compile errors on linux_rel.
-  EXPECT_CALL(manager_delegate_,
-              ShowAutofillPopup(
-                  _, _, _, _, _,
-                  testing::ElementsAre(
-                      static_cast<int>(
-                           WebAutofillClient::MenuItemIDPasswordEntry)),
-                  _));
+  EXPECT_CALL(
+      manager_delegate_,
+      ShowAutofillPopup(
+          _,
+          _,
+          _,
+          _,
+          _,
+          testing::ElementsAre(static_cast<int>(POPUP_ITEM_ID_PASSWORD_ENTRY)),
+          _));
 
   external_delegate_->OnShowPasswordSuggestions(suggestions,
                                                 realms,
                                                 field,
                                                 element_bounds);
 
   EXPECT_CALL(manager_delegate_, HideAutofillPopup());
 
   // This should trigger a call to hide the popup since
   // we've selected an option.
-  external_delegate_->DidAcceptSuggestion(
-      suggestions[0],
-      WebAutofillClient::MenuItemIDPasswordEntry);
+  external_delegate_->DidAcceptSuggestion(suggestions[0],
+                                          POPUP_ITEM_ID_PASSWORD_ENTRY);
 }
 
 // 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(manager_delegate_, HideAutofillPopup());
   base::string16 dummy_string(ASCIIToUTF16("baz qux"));
   EXPECT_CALL(*autofill_driver_,
               RendererShouldAcceptDataListSuggestion(dummy_string));
-  external_delegate_->DidAcceptSuggestion(
-      dummy_string,
-      WebAutofillClient::MenuItemIDDataListEntry);
+  external_delegate_->DidAcceptSuggestion(dummy_string,
+                                          POPUP_ITEM_ID_DATALIST_ENTRY);
 }
 
 // Test that the driver is directed to clear the form after being notified that
 // the user accepted the suggestion to clear the form.
 TEST_F(AutofillExternalDelegateUnitTest, ExternalDelegateClearForm) {
   EXPECT_CALL(manager_delegate_, HideAutofillPopup());
   EXPECT_CALL(*autofill_driver_, RendererShouldClearFilledForm());
 
-  external_delegate_->DidAcceptSuggestion(
-      base::string16(),
-      WebAutofillClient::MenuItemIDClearForm);
+  external_delegate_->DidAcceptSuggestion(base::string16(),
+                                          POPUP_ITEM_ID_CLEAR_FORM);
 }
 
 TEST_F(AutofillExternalDelegateUnitTest, ExternalDelegateHideWarning) {
   // 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(WebAutofillClient::MenuItemIDAutocompleteEntry);
+  autofill_ids.push_back(POPUP_ITEM_ID_AUTOCOMPLETE_ENTRY);
 
   // Ensure the popup tries to hide itself, since it is not allowed to show
   // anything.
   EXPECT_CALL(manager_delegate_, HideAutofillPopup());
 
   external_delegate_->OnSuggestionsReturned(kQueryId,
                                             autofill_items,
                                             autofill_items,
                                             autofill_items,
                                             autofill_ids);
 }
 
 TEST_F(AutofillExternalDelegateUnitTest, ExternalDelegateSetNodeText) {
   EXPECT_CALL(manager_delegate_, HideAutofillPopup());
   base::string16 dummy_string(ASCIIToUTF16("baz foo"));
   EXPECT_CALL(*autofill_driver_,
               RendererShouldSetNodeText(dummy_string));
-  external_delegate_->DidAcceptSuggestion(
-      dummy_string,
-      WebAutofillClient::MenuItemIDAutocompleteEntry);
+  external_delegate_->DidAcceptSuggestion(dummy_string,
+                                          POPUP_ITEM_ID_AUTOCOMPLETE_ENTRY);
 }
 
 }  // namespace autofill