Ignore OnBubbleHidden() event when the password bubble is reopened.

chrome/browser/ui/passwords/manage_passwords_bubble_model_unittest.cc

 // Copyright 2014 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 "chrome/browser/ui/passwords/manage_passwords_bubble_model.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/simple_test_clock.h"
 #include "chrome/browser/password_manager/password_store_factory.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/sync/profile_sync_test_util.h"
-#include "chrome/browser/ui/passwords/manage_passwords_ui_controller_mock.h"
+#include "chrome/browser/ui/passwords/passwords_model_delegate_mock.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/browser_sync/browser/profile_sync_service_mock.h"
 #include "components/password_manager/core/browser/mock_password_store.h"
 #include "components/password_manager/core/browser/password_bubble_experiment.h"
 #include "components/password_manager/core/browser/password_manager_metrics_util.h"
 #include "components/password_manager/core/browser/password_manager_test_utils.h"
 #include "components/password_manager/core/browser/statistics_table.h"
 #include "components/password_manager/core/common/credential_manager_types.h"
 #include "components/password_manager/core/common/password_manager_pref_names.h"
 #include "components/password_manager/core/common/password_manager_ui.h"
 #include "components/prefs/pref_service.h"
 #include "components/variations/variations_associated_data.h"
+#include "content/public/browser/web_contents.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/web_contents_tester.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using password_bubble_experiment::kBrandingExperimentName;
 using password_bubble_experiment::kChromeSignInPasswordPromoExperimentName;
 using password_bubble_experiment::kChromeSignInPasswordPromoThresholdParam;
 using password_bubble_experiment::kSmartLockBrandingGroupName;
 using password_bubble_experiment::kSmartLockBrandingSavePromptOnlyGroupName;
@@ skipping 47 matching lines @@
 }  // namespace
 
 class ManagePasswordsBubbleModelTest : public ::testing::Test {
  public:
   ManagePasswordsBubbleModelTest() : field_trials_(nullptr) {}
   ~ManagePasswordsBubbleModelTest() override = default;
 
   void SetUp() override {
     test_web_contents_.reset(
         content::WebContentsTester::CreateTestWebContents(&profile_, nullptr));
-    // Create the test UIController here so that it's bound to
-    // |test_web_contents_| and therefore accessible to the model.
-    new testing::StrictMock<ManagePasswordsUIControllerMock>(
-        test_web_contents_.get());
+    mock_delegate_.reset(new testing::StrictMock<PasswordsModelDelegateMock>);
     PasswordStoreFactory::GetInstance()->SetTestingFactoryAndUse(
         profile(),
         password_manager::BuildPasswordStore<
             content::BrowserContext,
             testing::StrictMock<password_manager::MockPasswordStore>>);
   }
 
   void TearDown() override {
-    // Reset WebContents first. It can happen if the user closes the tab.
-    test_web_contents_.reset();
+    // Reset the delegate first. It can happen if the user closes the tab.
+    mock_delegate_.reset();
     model_.reset();
     variations::testing::ClearAllVariationIDs();
     variations::testing::ClearAllVariationParams();
   }
 
   PrefService* prefs() { return profile_.GetPrefs(); }
 
   TestingProfile* profile() { return &profile_; }
 
   password_manager::MockPasswordStore* GetStore() {
     return static_cast<password_manager::MockPasswordStore*>(
         PasswordStoreFactory::GetInstance()
             ->GetForProfile(profile(), ServiceAccessType::EXPLICIT_ACCESS)
             .get());
   }
 
-  ManagePasswordsUIControllerMock* controller() {
-    return static_cast<ManagePasswordsUIControllerMock*>(
-        PasswordsModelDelegateFromWebContents(test_web_contents_.get()));
+  PasswordsModelDelegateMock* controller() {
+    return mock_delegate_.get();
   }
 
-  content::WebContents* test_web_contents() { return test_web_contents_.get(); }
-
   ManagePasswordsBubbleModel* model() { return model_.get(); }
 
   void SetUpWithState(password_manager::ui::State state,
                       ManagePasswordsBubbleModel::DisplayReason reason);
   void PretendPasswordWaiting();
   void PretendUpdatePasswordWaiting();
   void PretendAutoSigningIn();
   void PretendManagingPasswords();
 
   void DestroyModel();
   void DestroyModelExpectReason(
       password_manager::metrics_util::UIDismissalReason dismissal_reason);
 
   static password_manager::InteractionsStats GetTestStats();
   static autofill::PasswordForm GetPendingPassword();
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
   TestingProfile profile_;
   std::unique_ptr<content::WebContents> test_web_contents_;
   base::FieldTrialList field_trials_;
   std::unique_ptr<ManagePasswordsBubbleModel> model_;
+  std::unique_ptr<PasswordsModelDelegateMock> mock_delegate_;
 };
 
 void ManagePasswordsBubbleModelTest::SetUpWithState(
     password_manager::ui::State state,
     ManagePasswordsBubbleModel::DisplayReason reason) {
-  ManagePasswordsUIControllerMock* mock = controller();
   GURL origin(kSiteOrigin);
-  EXPECT_CALL(*mock, GetOrigin()).WillOnce(ReturnRef(origin));
-  EXPECT_CALL(*mock, GetState()).WillOnce(Return(state));
-  EXPECT_CALL(*mock, OnBubbleShown());
+  EXPECT_CALL(*controller(), GetOrigin()).WillOnce(ReturnRef(origin));
+  EXPECT_CALL(*controller(), GetState()).WillOnce(Return(state));
+  EXPECT_CALL(*controller(), OnBubbleShown());
+  EXPECT_CALL(*controller(), GetWebContents()).WillRepeatedly(
+      Return(test_web_contents_.get()));
   model_.reset(
-      new ManagePasswordsBubbleModel(test_web_contents_.get(), reason));
-  ASSERT_TRUE(testing::Mock::VerifyAndClearExpectations(mock));
+      new ManagePasswordsBubbleModel(mock_delegate_->AsWeakPtr(), reason));
+  ASSERT_TRUE(testing::Mock::VerifyAndClearExpectations(controller()));
+  EXPECT_CALL(*controller(), GetWebContents()).WillRepeatedly(
+      Return(test_web_contents_.get()));
 }
 
 void ManagePasswordsBubbleModelTest::PretendPasswordWaiting() {
   autofill::PasswordForm form = GetPendingPassword();
   EXPECT_CALL(*controller(), GetPendingPassword()).WillOnce(ReturnRef(form));
   std::vector<const autofill::PasswordForm*> forms;
   EXPECT_CALL(*controller(), GetCurrentForms()).WillOnce(ReturnRef(forms));
   password_manager::InteractionsStats stats = GetTestStats();
   EXPECT_CALL(*controller(), GetCurrentInteractionStats())
       .WillOnce(Return(&stats));
@@ skipping 20 matching lines @@
 
 void ManagePasswordsBubbleModelTest::PretendManagingPasswords() {
   autofill::PasswordForm form = GetPendingPassword();
   std::vector<const autofill::PasswordForm*> forms(1, &form);
   EXPECT_CALL(*controller(), GetCurrentForms()).WillOnce(ReturnRef(forms));
   SetUpWithState(password_manager::ui::MANAGE_STATE,
                  ManagePasswordsBubbleModel::USER_ACTION);
 }
 
 void ManagePasswordsBubbleModelTest::DestroyModel() {
-  ManagePasswordsUIControllerMock* mock =
-      test_web_contents_ ? controller() : nullptr;
-  if (mock)
-    EXPECT_CALL(*mock, OnBubbleHidden());
+  EXPECT_CALL(*controller(), OnBubbleHidden());
   model_.reset();
-  if (mock)
-    ASSERT_TRUE(testing::Mock::VerifyAndClearExpectations(mock));
+  ASSERT_TRUE(testing::Mock::VerifyAndClearExpectations(controller()));
 }
 
 void ManagePasswordsBubbleModelTest::DestroyModelExpectReason(
     password_manager::metrics_util::UIDismissalReason dismissal_reason) {
   base::HistogramTester histogram_tester;
   DestroyModel();
   histogram_tester.ExpectUniqueSample(kUIDismissalReasonMetric,
                                       dismissal_reason, 1);
 }
 
@@ skipping 340 matching lines @@
      ManageLinkTarget::SETTINGS_PAGE},
     {nullptr, SmartLockStatus::DISABLE, ManageLinkTarget::SETTINGS_PAGE},
     {"Default", SmartLockStatus::DISABLE, ManageLinkTarget::SETTINGS_PAGE},
 };
 
 }  // namespace
 
 INSTANTIATE_TEST_CASE_P(Default,
                         ManagePasswordsBubbleModelManageLinkTest,
                         ::testing::ValuesIn(kManageLinkTestCases));