Correctly Mark the new Autofill Popup as Visible when showing just passwords.

chrome/browser/autofill/autofill_external_delegate_unittest.cc

 // Copyright (c) 2012 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/memory/ref_counted.h"
 #include "base/string16.h"
 #include "chrome/browser/autofill/autofill_manager.h"
@@ skipping 22 matching lines @@
 const int kAutofillProfileId = 1;
 
 class MockAutofillExternalDelegate :
       public autofill::TestAutofillExternalDelegate {
  public:
   MockAutofillExternalDelegate(content::WebContents* web_contents,
                                AutofillManager* autofill_manger)
       : TestAutofillExternalDelegate(web_contents, autofill_manger) {}
   ~MockAutofillExternalDelegate() {}
 
+  bool popup_visible() {
+    return autofill::TestAutofillExternalDelegate::popup_visible();
+  }
+
   MOCK_METHOD4(ApplyAutofillSuggestions, void(
       const std::vector<string16>& autofill_values,
       const std::vector<string16>& autofill_labels,
       const std::vector<string16>& autofill_icons,
       const std::vector<int>& autofill_unique_ids));
 
   MOCK_METHOD0(ClearPreviewedForm, void());
 
-  MOCK_METHOD0(HideAutofillPopup, void());
-
   MOCK_METHOD1(SetBounds, void(const gfx::Rect& bounds));
 
  private:
   virtual void HideAutofillPopupInternal() {};
 };
 
 class MockAutofillManager : public AutofillManager {
  public:
   explicit MockAutofillManager(content::WebContents* web_contents,
                                autofill::AutofillManagerDelegate* delegate)
@@ skipping 79 matching lines @@
   // This should call ApplyAutofillSuggestions.
   std::vector<string16> autofill_item;
   autofill_item.push_back(string16());
   std::vector<int> autofill_ids;
   autofill_ids.push_back(kAutofillProfileId);
   external_delegate_->OnSuggestionsReturned(kQueryId,
                                             autofill_item,
                                             autofill_item,
                                             autofill_item,
                                             autofill_ids);
+  EXPECT_TRUE(external_delegate_->popup_visible());
 
-
-  EXPECT_CALL(*external_delegate_, HideAutofillPopup());
+  // Called when hiding the popup.
+  EXPECT_CALL(*external_delegate_, ClearPreviewedForm());
 
   // Called by DidAutofillSuggestions, add expectation to remove warning.
   EXPECT_CALL(*autofill_manager_, OnFillAutofillFormData(_, _, _, _));
 
   // This should trigger a call to hide the popup since
   // we've selected an option.
   external_delegate_->DidAcceptAutofillSuggestions(autofill_item[0],
                                                    autofill_ids[0], 0);
+  EXPECT_FALSE(external_delegate_->popup_visible());
 }
 
 // Test that data list elements for a node will appear in the Autofill popup.
 TEST_F(AutofillExternalDelegateUnitTest, ExternalDelegateDataList) {
   IssueOnQuery(kQueryId);
 
   std::vector<string16> data_list_items;
   data_list_items.push_back(string16());
   std::vector<int> data_list_ids;
   data_list_ids.push_back(WebAutofillClient::MenuItemIDDataListEntry);
@@ skipping 70 matching lines @@
   external_delegate_->SelectAutofillSuggestionAtIndex(
       WebAutofillClient::MenuItemIDPasswordEntry);
 
   EXPECT_CALL(*external_delegate_, ClearPreviewedForm()).Times(1);
   external_delegate_->SelectAutofillSuggestionAtIndex(1);
 }
 
 // Test that the popup is hidden once we are done editing the autofill field.
 TEST_F(AutofillExternalDelegateUnitTest,
        ExternalDelegateHidePopupAfterEditing) {
-  EXPECT_CALL(*external_delegate_, HideAutofillPopup());
+  EXPECT_CALL(*external_delegate_, SetBounds(_));
+  EXPECT_CALL(*external_delegate_, ApplyAutofillSuggestions(_, _, _, _));
+
+  autofill::GenerateTestAutofillPopup(external_delegate_.get());
+  EXPECT_TRUE(external_delegate_->popup_visible());
+
+  // Called when hiding the popup.
+  EXPECT_CALL(*external_delegate_, ClearPreviewedForm());
 
   external_delegate_->DidEndTextFieldEditing();
+
+  EXPECT_FALSE(external_delegate_->popup_visible());
 }
+
+// Test that the popup is marked as visible after recieving password
+// suggestions.
+TEST_F(AutofillExternalDelegateUnitTest, ExternalDelegatePasswordSuggestions) {
+  std::vector<string16> suggestions;
+  suggestions.push_back(string16());
+
+  FormFieldData field;
+  field.is_focusable = true;
+  field.should_autocomplete = true;
+  const gfx::Rect bounds;
+
+  EXPECT_CALL(*external_delegate_, SetBounds(bounds));
+
+  // The enums must be cast to ints to prevent compile errors on linux_rel.
+  EXPECT_CALL(*external_delegate_,
+              ApplyAutofillSuggestions(_, _, _, testing::ElementsAre(
+                  static_cast<int>(
+                      WebAutofillClient::MenuItemIDPasswordEntry))));
+
+  external_delegate_->OnShowPasswordSuggestions(suggestions,
+                                                field,
+                                                bounds);
+  EXPECT_TRUE(external_delegate_->popup_visible());
+
+  // Called by DidAutofillSuggestions, add expectation to remove warning.
+  EXPECT_CALL(*autofill_manager_, OnFillAutofillFormData(_, _, _, _));
+
+  // Called when hiding the popup.
+  EXPECT_CALL(*external_delegate_, ClearPreviewedForm());
+
+  // This should trigger a call to hide the popup since
+  // we've selected an option.
+  external_delegate_->DidAcceptAutofillSuggestions(
+      suggestions[0],
+      WebAutofillClient::MenuItemIDPasswordEntry,
+      0);
+  EXPECT_FALSE(external_delegate_->popup_visible());
+}