Uses child views in Autofill Popup so we can trigger

chrome/browser/ui/autofill/autofill_popup_controller_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 <stddef.h>
 
 #include <memory>
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
+#include "base/optional.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/ui/autofill/autofill_popup_controller_impl.h"
 #include "chrome/browser/ui/autofill/autofill_popup_view.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/autofill/content/browser/content_autofill_driver.h"
 #include "components/autofill/content/browser/content_autofill_driver_factory.h"
 #include "components/autofill/core/browser/autofill_external_delegate.h"
 #include "components/autofill/core/browser/autofill_manager.h"
@@ skipping 41 matching lines @@
   ~MockAutofillClient() override {}
 
   PrefService* GetPrefs() override { return prefs_.get(); }
 
  private:
   std::unique_ptr<PrefService> prefs_;
 
   DISALLOW_COPY_AND_ASSIGN(MockAutofillClient);
 };
 
+class MockAutofillPopupView : public AutofillPopupView {
+ public:
+  MockAutofillPopupView() {}
+
+  MOCK_METHOD0(Show, void());
+  MOCK_METHOD0(Hide, void());
+  MOCK_METHOD2(OnSelectedRowChanged,
+               void(base::Optional<size_t> previous_row_selection,
+                    base::Optional<size_t> current_row_selection));
+  MOCK_METHOD0(OnSuggestionsChanged, void());
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockAutofillPopupView);
+};
+
 class TestAutofillPopupController : public AutofillPopupControllerImpl {
  public:
   TestAutofillPopupController(
       base::WeakPtr<AutofillExternalDelegate> external_delegate,
       const gfx::RectF& element_bounds)
       : AutofillPopupControllerImpl(external_delegate,
                                     NULL,
                                     NULL,
                                     element_bounds,
                                     base::i18n::UNKNOWN_DIRECTION) {}
   ~TestAutofillPopupController() override {}
 
   // Making protected functions public for testing
   using AutofillPopupControllerImpl::GetLineCount;
   using AutofillPopupControllerImpl::GetSuggestionAt;
   using AutofillPopupControllerImpl::GetElidedValueAt;
   using AutofillPopupControllerImpl::GetElidedLabelAt;
   using AutofillPopupControllerImpl::selected_line;
   using AutofillPopupControllerImpl::SetSelectedLine;
   using AutofillPopupControllerImpl::SelectNextLine;
   using AutofillPopupControllerImpl::SelectPreviousLine;
   using AutofillPopupControllerImpl::RemoveSelectedLine;
   using AutofillPopupControllerImpl::popup_bounds;
   using AutofillPopupControllerImpl::element_bounds;
   using AutofillPopupControllerImpl::SetValues;
   using AutofillPopupControllerImpl::GetWeakPtr;
-  MOCK_METHOD1(InvalidateRow, void(size_t));
-  MOCK_METHOD0(UpdateBoundsAndRedrawPopup, void());
+  MOCK_METHOD0(OnSuggestionsChanged, void());
   MOCK_METHOD0(Hide, void());
 
   void DoHide() {
     AutofillPopupControllerImpl::Hide();
   }
+};
 
- private:
-  void ShowView() override {}
-};
+static constexpr base::Optional<size_t> kNoSelection;
 
 }  // namespace
 
 class AutofillPopupControllerUnitTest : public ChromeRenderViewHostTestHarness {
  public:
   AutofillPopupControllerUnitTest()
       : autofill_client_(new MockAutofillClient()),
         autofill_popup_controller_(NULL) {}
   ~AutofillPopupControllerUnitTest() override {}
 
   void SetUp() override {
     ChromeRenderViewHostTestHarness::SetUp();
 
     ContentAutofillDriverFactory::CreateForWebContentsAndDelegate(
         web_contents(), autofill_client_.get(), "en-US",
         AutofillManager::ENABLE_AUTOFILL_DOWNLOAD_MANAGER);
     // Make sure RenderFrame is created.
     NavigateAndCommit(GURL("about:blank"));
     ContentAutofillDriverFactory* factory =
         ContentAutofillDriverFactory::FromWebContents(web_contents());
     ContentAutofillDriver* driver =
         factory->DriverForFrame(web_contents()->GetMainFrame());
     external_delegate_.reset(
         new NiceMock<MockAutofillExternalDelegate>(
             driver->autofill_manager(),
             driver));
-
-    autofill_popup_controller_ =
-        new testing::NiceMock<TestAutofillPopupController>(
-            external_delegate_->GetWeakPtr(), gfx::RectF());
+    autofill_popup_view_.reset(new NiceMock<MockAutofillPopupView>());
+    autofill_popup_controller_ = new NiceMock<TestAutofillPopupController>(
+        external_delegate_->GetWeakPtr(), gfx::RectF());
+    autofill_popup_controller_->SetViewForTesting(autofill_popup_view());
   }
 
   void TearDown() override {
     // This will make sure the controller and the view (if any) are both
     // cleaned up.
     if (autofill_popup_controller_)
       autofill_popup_controller_->DoHide();
 
     external_delegate_.reset();
     ChromeRenderViewHostTestHarness::TearDown();
   }
 
   TestAutofillPopupController* popup_controller() {
     return autofill_popup_controller_;
   }
 
   MockAutofillExternalDelegate* delegate() {
     return external_delegate_.get();
   }
 
+  MockAutofillPopupView* autofill_popup_view() {
+    return autofill_popup_view_.get();
+  }
+
  protected:
   std::unique_ptr<MockAutofillClient> autofill_client_;
   std::unique_ptr<NiceMock<MockAutofillExternalDelegate>> external_delegate_;
-  testing::NiceMock<TestAutofillPopupController>* autofill_popup_controller_;
+  std::unique_ptr<NiceMock<MockAutofillPopupView>> autofill_popup_view_;
+  NiceMock<TestAutofillPopupController>* autofill_popup_controller_;
 };
 
 TEST_F(AutofillPopupControllerUnitTest, ChangeSelectedLine) {
   // Set up the popup.
   std::vector<Suggestion> suggestions;
   suggestions.push_back(Suggestion("", "", "", 0));
   suggestions.push_back(Suggestion("", "", "", 0));
   autofill_popup_controller_->Show(suggestions);
 
-  EXPECT_LT(autofill_popup_controller_->selected_line(), 0);
+  EXPECT_FALSE(autofill_popup_controller_->selected_line());
   // Check that there are at least 2 values so that the first and last selection
   // are different.
   EXPECT_GE(2,
       static_cast<int>(autofill_popup_controller_->GetLineCount()));
 
   // Test wrapping before the front.
   autofill_popup_controller_->SelectPreviousLine();
-  EXPECT_EQ(static_cast<int>(
-      autofill_popup_controller_->GetLineCount() - 1),
-      autofill_popup_controller_->selected_line());
+  EXPECT_EQ(autofill_popup_controller_->GetLineCount() - 1,
+            autofill_popup_controller_->selected_line().value());
 
   // Test wrapping after the end.
   autofill_popup_controller_->SelectNextLine();
-  EXPECT_EQ(0, autofill_popup_controller_->selected_line());
+  EXPECT_EQ(static_cast<size_t>(0),
+            autofill_popup_controller_->selected_line().value());
 }
 
 TEST_F(AutofillPopupControllerUnitTest, RedrawSelectedLine) {
   // Set up the popup.
   std::vector<Suggestion> suggestions;
   suggestions.push_back(Suggestion("", "", "", 0));
   suggestions.push_back(Suggestion("", "", "", 0));
   autofill_popup_controller_->Show(suggestions);
 
   // Make sure that when a new line is selected, it is invalidated so it can
   // be updated to show it is selected.
   int selected_line = 0;
-  EXPECT_CALL(*autofill_popup_controller_, InvalidateRow(selected_line));
+  EXPECT_CALL(*autofill_popup_view_,
+              OnSelectedRowChanged(kNoSelection,
+                                   base::Optional<size_t>(selected_line)));
+
   autofill_popup_controller_->SetSelectedLine(selected_line);
 
   // Ensure that the row isn't invalidated if it didn't change.
-  EXPECT_CALL(*autofill_popup_controller_,
-              InvalidateRow(selected_line)).Times(0);
+  EXPECT_CALL(*autofill_popup_view_, OnSelectedRowChanged(_, _)).Times(0);
   autofill_popup_controller_->SetSelectedLine(selected_line);
 
   // Change back to no selection.
-  EXPECT_CALL(*autofill_popup_controller_, InvalidateRow(selected_line));
-  autofill_popup_controller_->SetSelectedLine(-1);
+  EXPECT_CALL(*autofill_popup_view_,
+              OnSelectedRowChanged(base::Optional<size_t>(selected_line),
+                                   kNoSelection));
+  autofill_popup_controller_->SetSelectedLine(kNoSelection);
 }
 
 TEST_F(AutofillPopupControllerUnitTest, RemoveLine) {
   // Set up the popup.
   std::vector<Suggestion> suggestions;
   suggestions.push_back(Suggestion("", "", "", 1));
   suggestions.push_back(Suggestion("", "", "", 1));
   suggestions.push_back(Suggestion("", "", "", POPUP_ITEM_ID_AUTOFILL_OPTIONS));
   autofill_popup_controller_->Show(suggestions);
 
   // Generate a popup, so it can be hidden later. It doesn't matter what the
   // external_delegate thinks is being shown in the process, since we are just
   // testing the popup here.
   autofill::GenerateTestAutofillPopup(external_delegate_.get());
 
   // No line is selected so the removal should fail.
   EXPECT_FALSE(autofill_popup_controller_->RemoveSelectedLine());
 
   // Remove the first entry. The popup should be redrawn since its size has
   // changed.
-  EXPECT_CALL(*autofill_popup_controller_, UpdateBoundsAndRedrawPopup());
+  EXPECT_CALL(*autofill_popup_controller_, OnSuggestionsChanged());
   autofill_popup_controller_->SetSelectedLine(0);
   EXPECT_TRUE(autofill_popup_controller_->RemoveSelectedLine());
 
   // Remove the last entry. The popup should then be hidden since there are
   // no Autofill entries left.
   EXPECT_CALL(*autofill_popup_controller_, Hide());
   autofill_popup_controller_->SetSelectedLine(0);
   EXPECT_TRUE(autofill_popup_controller_->RemoveSelectedLine());
 }
 
 TEST_F(AutofillPopupControllerUnitTest, RemoveOnlyLine) {
   // Set up the popup.
   std::vector<Suggestion> suggestions;
   suggestions.push_back(Suggestion("", "", "", 1));
   autofill_popup_controller_->Show(suggestions);
 
   // Generate a popup.
   autofill::GenerateTestAutofillPopup(external_delegate_.get());
 
   // Select the only line.
   autofill_popup_controller_->SetSelectedLine(0);
+  EXPECT_CALL(*autofill_popup_view_,
+              OnSelectedRowChanged(kNoSelection, base::Optional<size_t>(0)))
+      .Times(0);
 
-  // Remove the only line. There should be no row invalidation and the popup
-  // should then be hidden since there are no Autofill entries left.
+  // Remove the only line. The popup should then be hidden since there are no
+  // Autofill entries left.
   EXPECT_CALL(*autofill_popup_controller_, Hide());
-  EXPECT_CALL(*autofill_popup_controller_, InvalidateRow(_)).Times(0);
+  EXPECT_CALL(*autofill_popup_view_,
+              OnSelectedRowChanged(base::Optional<size_t>(0), kNoSelection));
   EXPECT_TRUE(autofill_popup_controller_->RemoveSelectedLine());
 }
 
 TEST_F(AutofillPopupControllerUnitTest, SkipSeparator) {
   // Set up the popup.
   std::vector<Suggestion> suggestions;
   suggestions.push_back(Suggestion("", "", "", 1));
   suggestions.push_back(Suggestion("", "", "", POPUP_ITEM_ID_SEPARATOR));
   suggestions.push_back(Suggestion("", "", "", POPUP_ITEM_ID_AUTOFILL_OPTIONS));
   autofill_popup_controller_->Show(suggestions);
 
   autofill_popup_controller_->SetSelectedLine(0);
 
   // Make sure next skips the unselectable separator.
   autofill_popup_controller_->SelectNextLine();
-  EXPECT_EQ(2, autofill_popup_controller_->selected_line());
+  EXPECT_EQ(static_cast<size_t>(2),
+            autofill_popup_controller_->selected_line().value());
 
   // Make sure previous skips the unselectable separator.
   autofill_popup_controller_->SelectPreviousLine();
-  EXPECT_EQ(0, autofill_popup_controller_->selected_line());
+  EXPECT_EQ(static_cast<size_t>(0),
+            autofill_popup_controller_->selected_line().value());
 }
 
 TEST_F(AutofillPopupControllerUnitTest, UpdateDataListValues) {
   std::vector<Suggestion> suggestions;
   suggestions.push_back(Suggestion("", "", "", 1));
   autofill_popup_controller_->Show(suggestions);
 
   // Add one data list entry.
   base::string16 value1 = ASCIIToUTF16("data list value 1");
   std::vector<base::string16> data_list_values;
@@ skipping 92 matching lines @@
       gfx::RectF(), base::i18n::UNKNOWN_DIRECTION);
   EXPECT_TRUE(controller.get());
 
   WeakPtr<AutofillPopupControllerImpl> controller2 =
       AutofillPopupControllerImpl::GetOrCreate(
           controller, delegate.GetWeakPtr(), NULL, NULL, gfx::RectF(),
           base::i18n::UNKNOWN_DIRECTION);
   EXPECT_EQ(controller.get(), controller2.get());
   controller->Hide();
 
-  testing::NiceMock<TestAutofillPopupController>* test_controller =
-      new testing::NiceMock<TestAutofillPopupController>(delegate.GetWeakPtr(),
-                                                         gfx::RectF());
+  NiceMock<TestAutofillPopupController>* test_controller =
+      new NiceMock<TestAutofillPopupController>(delegate.GetWeakPtr(),
+                                                gfx::RectF());
   EXPECT_CALL(*test_controller, Hide());
 
   gfx::RectF bounds(0.f, 0.f, 1.f, 2.f);
   base::WeakPtr<AutofillPopupControllerImpl> controller3 =
       AutofillPopupControllerImpl::GetOrCreate(
           test_controller->GetWeakPtr(),
           delegate.GetWeakPtr(),
           NULL,
           NULL,
           bounds,
           base::i18n::UNKNOWN_DIRECTION);
   EXPECT_EQ(
       bounds,
       static_cast<AutofillPopupController*>(controller3.get())->
           element_bounds());
   controller3->Hide();
 
   // Hide the test_controller to delete it.
   test_controller->DoHide();
 }
 
 TEST_F(AutofillPopupControllerUnitTest, ProperlyResetController) {
   std::vector<Suggestion> suggestions;
   suggestions.push_back(Suggestion("", "", "", 0));
   suggestions.push_back(Suggestion("", "", "", 0));
-  popup_controller()->SetValues(suggestions);
+  popup_controller()->Show(suggestions);
   popup_controller()->SetSelectedLine(0);
 
   // Now show a new popup with the same controller, but with fewer items.
   WeakPtr<AutofillPopupControllerImpl> controller =
       AutofillPopupControllerImpl::GetOrCreate(
           popup_controller()->GetWeakPtr(), delegate()->GetWeakPtr(), NULL,
           NULL, gfx::RectF(), base::i18n::UNKNOWN_DIRECTION);
-  EXPECT_NE(0, controller->selected_line());
+  EXPECT_NE(static_cast<size_t>(0), controller->selected_line().value());
   EXPECT_EQ(0u, controller->GetLineCount());
 }
 
 #if !defined(OS_ANDROID)
 TEST_F(AutofillPopupControllerUnitTest, ElideText) {
   std::vector<Suggestion> suggestions;
   suggestions.push_back(
       Suggestion("Text that will need to be trimmed",
       "Label that will be trimmed", "genericCC", 0));
   suggestions.push_back(
@@ skipping 25 matching lines @@
 
   // The second element was shorter so it should be unchanged.
   EXPECT_EQ(autofill_popup_controller_->GetSuggestionAt(1).value,
             autofill_popup_controller_->GetElidedValueAt(1));
   EXPECT_EQ(autofill_popup_controller_->GetSuggestionAt(1).label,
             autofill_popup_controller_->GetElidedLabelAt(1));
 }
 #endif
 
 }  // namespace autofill