Prevent usage of web payments API over insecure HTTPS.

chrome/browser/ui/views/payments/payment_request_browsertest_base.cc

 // Copyright 2017 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/views/payments/payment_request_browsertest_base.h"
 
+#include <algorithm>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 30 matching lines @@
 
 namespace payments {
 
 PersonalDataLoadedObserverMock::PersonalDataLoadedObserverMock() {}
 PersonalDataLoadedObserverMock::~PersonalDataLoadedObserverMock() {}
 
 PaymentRequestBrowserTestBase::PaymentRequestBrowserTestBase(
     const std::string& test_file_path)
     : test_file_path_(test_file_path),
       delegate_(nullptr),
-      incognito_for_testing_(false) {}
+      is_incognito_(false),
+      is_valid_ssl_(true) {}
 PaymentRequestBrowserTestBase::~PaymentRequestBrowserTestBase() {}
 
 void PaymentRequestBrowserTestBase::SetUpCommandLine(
     base::CommandLine* command_line) {
   InProcessBrowserTest::SetUpCommandLine(command_line);
   command_line->AppendSwitch(switches::kEnableExperimentalWebPlatformFeatures);
   command_line->AppendSwitchASCII(switches::kEnableFeatures,
                                   features::kWebPayments.name);
 }
 
@@ skipping 12 matching lines @@
   // allowing the test to inject itself as a dialog observer.
   content::WebContents* web_contents = GetActiveWebContents();
   service_manager::InterfaceRegistry* registry =
       web_contents->GetMainFrame()->GetInterfaceRegistry();
   registry->RemoveInterface(payments::mojom::PaymentRequest::Name_);
   registry->AddInterface(
       base::Bind(&PaymentRequestBrowserTestBase::CreatePaymentRequestForTest,
                  base::Unretained(this), web_contents));
 }
 
-void PaymentRequestBrowserTestBase::SetIncognitoForTesting() {
-  incognito_for_testing_ = true;
+void PaymentRequestBrowserTestBase::SetIncognito() {
+  is_incognito_ = true;
+}
+
+void PaymentRequestBrowserTestBase::SetInvalidSsl() {
+  is_valid_ssl_ = false;
 }
 
 void PaymentRequestBrowserTestBase::OnCanMakePaymentCalled() {
   if (event_observer_)
     event_observer_->Observe(DialogEvent::CAN_MAKE_PAYMENT_CALLED);
 }
 
+void PaymentRequestBrowserTestBase::OnNotSupportedError() {
+  if (event_observer_)
+    event_observer_->Observe(DialogEvent::NOT_SUPPORTED_ERROR);
+}
+
 void PaymentRequestBrowserTestBase::OnDialogOpened() {
   if (event_observer_)
     event_observer_->Observe(DialogEvent::DIALOG_OPENED);
 }
 
 void PaymentRequestBrowserTestBase::OnOrderSummaryOpened() {
   if (event_observer_)
     event_observer_->Observe(DialogEvent::ORDER_SUMMARY_OPENED);
 }
 
@@ skipping 72 matching lines @@
 
   WaitForObservedEvent();
 
   // The web-modal dialog should be open.
   web_modal::WebContentsModalDialogManager* web_contents_modal_dialog_manager =
       web_modal::WebContentsModalDialogManager::FromWebContents(web_contents);
   EXPECT_TRUE(web_contents_modal_dialog_manager->IsDialogActive());
 }
 
 void PaymentRequestBrowserTestBase::ExpectBodyContains(
-    const std::vector<base::string16>& expected_strings) {
+    const std::vector<std::string>& expected_strings) {
   content::WebContents* web_contents = GetActiveWebContents();
   const std::string extract_contents_js =
       "(function() { "
       "window.domAutomationController.send(window.document.body.textContent); "
       "})()";
   std::string contents;
   EXPECT_TRUE(content::ExecuteScriptAndExtractString(
       web_contents, extract_contents_js, &contents));
-  for (const auto expected_string : expected_strings) {
-    EXPECT_NE(std::string::npos,
-              contents.find(base::UTF16ToUTF8(expected_string)))
+  for (const std::string& expected_string : expected_strings) {
+    EXPECT_NE(std::string::npos, contents.find(expected_string))
         << "String not present: " << expected_string;
   }
 }
 
+void PaymentRequestBrowserTestBase::ExpectBodyContains(
+    const std::vector<base::string16>& expected_strings) {
+  std::vector<std::string> converted(expected_strings.size());
+  std::transform(expected_strings.begin(), expected_strings.end(),
+                 converted.begin(),
+                 [](const base::string16& s) { return base::UTF16ToUTF8(s); });
+  ExpectBodyContains(converted);
+}
+
 void PaymentRequestBrowserTestBase::OpenOrderSummaryScreen() {
   ResetEventObserver(DialogEvent::ORDER_SUMMARY_OPENED);
 
   ClickOnDialogViewAndWait(DialogViewID::PAYMENT_SHEET_SUMMARY_SECTION);
 }
 
 void PaymentRequestBrowserTestBase::OpenPaymentMethodScreen() {
   ResetEventObserver(DialogEvent::PAYMENT_METHOD_OPENED);
 
   views::View* view = delegate_->dialog_view()->GetViewByID(
@@ skipping 112 matching lines @@
   EXPECT_EQ(card_count + 1, personal_data_manager->GetCreditCards().size());
 }
 
 void PaymentRequestBrowserTestBase::CreatePaymentRequestForTest(
     content::WebContents* web_contents,
     mojo::InterfaceRequest<payments::mojom::PaymentRequest> request) {
   DCHECK(web_contents);
   std::unique_ptr<TestChromePaymentRequestDelegate> delegate =
       base::MakeUnique<TestChromePaymentRequestDelegate>(
           web_contents, this /* observer */, this /* widget_observer */,
-          incognito_for_testing_);
+          is_incognito_, is_valid_ssl_);
   delegate_ = delegate.get();
   PaymentRequestWebContentsManager::GetOrCreateForWebContents(web_contents)
       ->CreatePaymentRequest(web_contents, std::move(delegate),
                              std::move(request), this);
 }
 
 void PaymentRequestBrowserTestBase::ClickOnDialogViewAndWait(
     DialogViewID view_id,
     bool wait_for_animation) {
   views::View* view =
@@ skipping 222 matching lines @@
     std::list<DialogEvent> event_sequence) {
   event_observer_ =
       base::MakeUnique<DialogEventObserver>(std::move(event_sequence));
 }
 
 void PaymentRequestBrowserTestBase::WaitForObservedEvent() {
   event_observer_->Wait();
 }
 
 }  // namespace payments