Move Credentials when migrating to HSTS page

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/password_store_factory.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_io_data.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"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_utils.h"
+#include "net/cert/cert_verify_result.h"
+#include "net/http/transport_security_state.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_getter.h"
 
 namespace {
 
 // A helper class that synchronously waits until the password store handles a
 // GetLogins() request.
 class PasswordStoreResultsObserver
     : public password_manager::PasswordStoreConsumer {
  public:
   PasswordStoreResultsObserver() = default;
 
   void OnGetPasswordStoreResults(
       std::vector<std::unique_ptr<autofill::PasswordForm>> results) override {
     run_loop_.Quit();
   }
 
   void Wait() { run_loop_.Run(); }
 
  private:
   base::RunLoop run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(PasswordStoreResultsObserver);
 };
 
+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) {
 }
 NavigationObserver::~NavigationObserver() {
 }
 
@@ skipping 70 matching lines @@
       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);
 }
 
 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();
 }
 
 content::RenderViewHost* PasswordManagerBrowserTestBase::RenderViewHost() {
   return WebContents()->GetRenderViewHost();
 }
 
 void PasswordManagerBrowserTestBase::NavigateToFile(const std::string& path) {
   NavigationObserver observer(WebContents());
@@ skipping 128 matching lines @@
       "  var element = document.getElementById('%s');"
       "window.domAutomationController.send(element && element.value == '%s');",
       iframe_id.c_str(), iframe_id.c_str(), element_id.c_str(),
       element_id.c_str(), expected_value.c_str());
   bool return_value = false;
   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
       RenderViewHost(), value_check_script, &return_value));
   EXPECT_TRUE(return_value) << "element_id = " << element_id
                             << ", expected_value = " << expected_value;
 }
+
+void PasswordManagerBrowserTestBase::AddHSTSHost(const std::string& host) {
+  base::RunLoop run_loop;
+
+  content::BrowserThread::PostTaskAndReply(
+      content::BrowserThread::IO, FROM_HERE,
+      base::Bind(&AddHSTSHostImpl,
+                 make_scoped_refptr(browser()->profile()->GetRequestContext()),
+                 host),
+      run_loop.QuitClosure());
+
+  run_loop.Run();
+}