Enable CredentialManagerBrowserTest.ObsoleteHttpCredentialMovedOnMigrationToHstsSite

chrome/browser/password_manager/password_manager_test_base.cc

 // Copyright 2015 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/password_manager/password_manager_test_base.h"
 
 #include <string>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
+#include "chrome/browser/password_manager/chrome_password_manager_client.h"
 #include "chrome/browser/password_manager/password_store_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_io_data.h"
+#include "chrome/browser/ui/autofill/chrome_autofill_client.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/passwords/manage_passwords_ui_controller.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/autofill/core/browser/autofill_test_utils.h"
 #include "components/password_manager/core/browser/password_manager_test_utils.h"
 #include "components/password_manager/core/browser/test_password_store.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/render_frame_host.h"
@@ skipping 20 matching lines @@
   }
 
   void Wait() { run_loop_.Run(); }
 
  private:
   base::RunLoop run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(PasswordStoreResultsObserver);
 };
 
+// ManagePasswordsUIController subclass to capture the UI events.
+class CustomManagePasswordsUIController : public ManagePasswordsUIController {
+ public:
+  explicit CustomManagePasswordsUIController(
+      content::WebContents* web_contents);
+
+  void WaitForAccountChooser();
+
+ private:
+  // PasswordsClientUIDelegate:
+  bool OnChooseCredentials(
+      std::vector<std::unique_ptr<autofill::PasswordForm>> local_credentials,
+      const GURL& origin,
+      const ManagePasswordsState::CredentialsCallback& callback) override;
+
+  // The loop to be stopped when the account chooser pops up.
+  base::RunLoop* account_chooser_loop_ = nullptr;
+
+  DISALLOW_COPY_AND_ASSIGN(CustomManagePasswordsUIController);
+};
+
+CustomManagePasswordsUIController::CustomManagePasswordsUIController(
+    content::WebContents* web_contents)
+    : ManagePasswordsUIController(web_contents) {
+  // Attach CustomManagePasswordsUIController to |web_contents| so the default
+  // ManagePasswordsUIController isn't created.
+  // Do not silently replace an existing ManagePasswordsUIController because it
+  // unregisters itself in WebContentsDestroyed().
+  EXPECT_FALSE(web_contents->GetUserData(UserDataKey()));
+  web_contents->SetUserData(UserDataKey(), this);
+}
+
+void CustomManagePasswordsUIController::WaitForAccountChooser() {
+  base::RunLoop account_chooser_loop;
+  account_chooser_loop_ = &account_chooser_loop;
+  account_chooser_loop_->Run();
+}
+
+bool CustomManagePasswordsUIController::OnChooseCredentials(
+    std::vector<std::unique_ptr<autofill::PasswordForm>> local_credentials,
+    const GURL& origin,
+    const ManagePasswordsState::CredentialsCallback& callback) {
+  if (account_chooser_loop_) {
+    account_chooser_loop_->Quit();
+    account_chooser_loop_ = nullptr;
+  }
+  return ManagePasswordsUIController::OnChooseCredentials(
+      std::move(local_credentials), origin, callback);
+}
+
 void AddHSTSHostImpl(
     const scoped_refptr<net::URLRequestContextGetter>& request_context,
     const std::string& host) {
   ASSERT_TRUE(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   net::TransportSecurityState* transport_security_state =
       request_context->GetURLRequestContext()->transport_security_state();
   if (!transport_security_state) {
     ADD_FAILURE();
     return;
   }
 
   base::Time expiry = base::Time::Now() + base::TimeDelta::FromDays(1000);
   bool include_subdomains = false;
   transport_security_state->AddHSTS(host, expiry, include_subdomains);
   EXPECT_TRUE(transport_security_state->ShouldUpgradeToSSL(host));
 }
 
 }  // namespace
 
 NavigationObserver::NavigationObserver(content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
-      quit_on_entry_committed_(false),
-      message_loop_runner_(new content::MessageLoopRunner) {
-}
+      quit_on_entry_committed_(false) {}
 NavigationObserver::~NavigationObserver() {
 }
 
 void NavigationObserver::DidFinishNavigation(
     content::NavigationHandle* navigation_handle) {
   if (!navigation_handle->HasCommitted())
     return;
 
   if (quit_on_entry_committed_)
-    message_loop_runner_->Quit();
+    run_loop_.Quit();
 }
 
 void NavigationObserver::DidFinishLoad(
     content::RenderFrameHost* render_frame_host,
     const GURL& validated_url) {
   render_frame_host_ = render_frame_host;
   if (!wait_for_path_.empty()) {
     if (validated_url.path() == wait_for_path_)
-      message_loop_runner_->Quit();
+      run_loop_.Quit();
   } else if (!render_frame_host->GetParent()) {
-    message_loop_runner_->Quit();
+    run_loop_.Quit();
   }
 }
 
 void NavigationObserver::Wait() {
-  message_loop_runner_->Run();
+  run_loop_.Run();
 }
 
 BubbleObserver::BubbleObserver(content::WebContents* web_contents)
     : passwords_ui_controller_(
           ManagePasswordsUIController::FromWebContents(web_contents)) {}
 
 bool BubbleObserver::IsShowingSavePrompt() const {
   return passwords_ui_controller_->GetState() ==
       password_manager::ui::PENDING_PASSWORD_STATE;
 }
@@ skipping 15 matching lines @@
   EXPECT_FALSE(IsShowingSavePrompt());
 }
 
 void BubbleObserver::AcceptUpdatePrompt(
     const autofill::PasswordForm& form) const {
   ASSERT_TRUE(IsShowingUpdatePrompt());
   passwords_ui_controller_->UpdatePassword(form);
   EXPECT_FALSE(IsShowingUpdatePrompt());
 }
 
+void BubbleObserver::WaitForAccountChooser() const {
+  if (passwords_ui_controller_->GetState() ==
+      password_manager::ui::CREDENTIAL_REQUEST_STATE)
+    return;
+  CustomManagePasswordsUIController* controller =
+      static_cast<CustomManagePasswordsUIController*>(passwords_ui_controller_);
+  controller->WaitForAccountChooser();
+}
+
 PasswordManagerBrowserTestBase::PasswordManagerBrowserTestBase()
-    : https_test_server_(net::EmbeddedTestServer::TYPE_HTTPS) {}
-PasswordManagerBrowserTestBase::~PasswordManagerBrowserTestBase() {
-}
+    : https_test_server_(net::EmbeddedTestServer::TYPE_HTTPS),
+      web_contents_(nullptr) {}
+
+PasswordManagerBrowserTestBase::~PasswordManagerBrowserTestBase() = default;
 
 void PasswordManagerBrowserTestBase::SetUpOnMainThread() {
   // Use TestPasswordStore to remove a possible race. Normally the
   // PasswordStore does its database manipulation on the DB thread, which
   // creates a possible race during navigation. Specifically the
   // PasswordManager will ignore any forms in a page if the load from the
   // PasswordStore has not completed.
   PasswordStoreFactory::GetInstance()->SetTestingFactory(
       browser()->profile(),
       password_manager::BuildPasswordStore<
           content::BrowserContext, password_manager::TestPasswordStore>);
   ASSERT_TRUE(embedded_test_server()->Start());
 
   // Setup HTTPS server serving files from standard test directory.
   static constexpr base::FilePath::CharType kDocRoot[] =
       FILE_PATH_LITERAL("chrome/test/data");
   https_test_server().ServeFilesFromSourceDirectory(base::FilePath(kDocRoot));
   ASSERT_TRUE(https_test_server().Start());
 
   // Whitelist all certs for the HTTPS server.
   auto cert = https_test_server().GetCertificate();
   net::CertVerifyResult verify_result;
   verify_result.cert_status = 0;
   verify_result.is_issued_by_known_root = true;
   verify_result.verified_cert = cert;
   mock_cert_verifier().AddResultForCert(cert.get(), verify_result, net::OK);
+
+  // Add a tab with a customized ManagePasswordsUIController. Thus, we can
+  // intercept useful UI events.
+  content::WebContents* tab =
+      browser()->tab_strip_model()->GetActiveWebContents();
+  web_contents_ = content::WebContents::Create(
+      content::WebContents::CreateParams(tab->GetBrowserContext()));
+  ASSERT_TRUE(web_contents_);
+
+  // ManagePasswordsUIController needs ChromePasswordManagerClient for logging.
+  autofill::ChromeAutofillClient::CreateForWebContents(web_contents_);
+  ChromePasswordManagerClient::CreateForWebContentsWithAutofillClient(
+      web_contents_,
+      autofill::ChromeAutofillClient::FromWebContents(web_contents_));
+  ASSERT_TRUE(ChromePasswordManagerClient::FromWebContents(web_contents_));
+  CustomManagePasswordsUIController* controller =
+      new CustomManagePasswordsUIController(web_contents_);
+  browser()->tab_strip_model()->AppendWebContents(web_contents_, true);
+  browser()->tab_strip_model()->CloseWebContentsAt(0,
+                                                   TabStripModel::CLOSE_NONE);
+  ASSERT_EQ(controller,
+            ManagePasswordsUIController::FromWebContents(web_contents_));
+  ASSERT_EQ(web_contents_,
+            browser()->tab_strip_model()->GetActiveWebContents());
+  ASSERT_FALSE(web_contents_->IsLoading());
 }
 
 void PasswordManagerBrowserTestBase::TearDownOnMainThread() {
   ASSERT_TRUE(embedded_test_server()->ShutdownAndWaitUntilComplete());
 }
 
 void PasswordManagerBrowserTestBase::SetUpInProcessBrowserTestFixture() {
   ProfileIOData::SetCertVerifierForTesting(&mock_cert_verifier_);
 }
 
 void PasswordManagerBrowserTestBase::TearDownInProcessBrowserTestFixture() {
   ProfileIOData::SetCertVerifierForTesting(nullptr);
 }
 
 content::WebContents* PasswordManagerBrowserTestBase::WebContents() {
-  return browser()->tab_strip_model()->GetActiveWebContents();
+  return web_contents_;
 }
 
 content::RenderViewHost* PasswordManagerBrowserTestBase::RenderViewHost() {
   return WebContents()->GetRenderViewHost();
 }
 
 void PasswordManagerBrowserTestBase::NavigateToFile(const std::string& path) {
+  ASSERT_EQ(web_contents_,
+            browser()->tab_strip_model()->GetActiveWebContents());
   NavigationObserver observer(WebContents());
   GURL url = embedded_test_server()->GetURL(path);
   ui_test_utils::NavigateToURL(browser(), url);
   observer.Wait();
 }
 
 void PasswordManagerBrowserTestBase::VerifyPasswordIsSavedAndFilled(
     const std::string& filename,
     const std::string& submission_script,
     const std::string& expected_element,
     const std::string& expected_value) {
   password_manager::TestPasswordStore* password_store =
       static_cast<password_manager::TestPasswordStore*>(
           PasswordStoreFactory::GetForProfile(
               browser()->profile(), ServiceAccessType::IMPLICIT_ACCESS).get());
   EXPECT_TRUE(password_store->IsEmpty());
 
   NavigateToFile(filename);
 
   NavigationObserver observer(WebContents());
   std::unique_ptr<BubbleObserver> prompt_observer(
       new BubbleObserver(WebContents()));
   ASSERT_TRUE(content::ExecuteScript(RenderViewHost(), submission_script));
   observer.Wait();
 
   prompt_observer->AcceptSavePrompt();
 
   // Spin the message loop to make sure the password store had a chance to save
   // the password.
-  base::RunLoop run_loop;
-  run_loop.RunUntilIdle();
+  WaitForPasswordStore();
   ASSERT_FALSE(password_store->IsEmpty());
 
   NavigateToFile(filename);
 
   // Let the user interact with the page, so that DOM gets modification events,
   // needed for autofilling fields.
   content::SimulateMouseClickAt(
       WebContents(), 0, blink::WebMouseEvent::Button::Left, gfx::Point(1, 1));
 
   // Wait until that interaction causes the password value to be revealed.
@@ skipping 101 matching lines @@
 
   content::BrowserThread::PostTaskAndReply(
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(&AddHSTSHostImpl,
                  make_scoped_refptr(browser()->profile()->GetRequestContext()),
                  host),
       run_loop.QuitClosure());
 
   run_loop.Run();
 }