Prevent usage of web payments API over insecure HTTPS.

components/payments/content/payment_request_spec_unittest.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 "components/payments/content/payment_request_spec.h"
 
 #include <utility>
 
 #include "base/memory/weak_ptr.h"
 #include "components/payments/mojom/payment_request.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace payments {
 
 class PaymentRequestSpecTest : public testing::Test,
                                public PaymentRequestSpec::Observer {
  protected:
   ~PaymentRequestSpecTest() override {}
 
-  void OnInvalidSpecProvided() override {
-    on_invalid_spec_provided_called_ = true;
-  }
   void OnSpecUpdated() override { on_spec_updated_called_ = true; }
 
   void RecreateSpecWithMethodData(
       std::vector<mojom::PaymentMethodDataPtr> method_data) {
     spec_ = base::MakeUnique<PaymentRequestSpec>(
         mojom::PaymentOptions::New(), mojom::PaymentDetails::New(),
         std::move(method_data), this, "en-US");
   }
 
   void RecreateSpecWithOptionsAndDetails(mojom::PaymentOptionsPtr options,
                                          mojom::PaymentDetailsPtr details) {
     spec_ = base::MakeUnique<PaymentRequestSpec>(
         std::move(options), std::move(details),
         std::vector<mojom::PaymentMethodDataPtr>(), this, "en-US");
   }
 
   PaymentRequestSpec* spec() { return spec_.get(); }
-  bool on_invalid_spec_provided_called() {
-    return on_invalid_spec_provided_called_;
-  }
 
  private:
   std::unique_ptr<PaymentRequestSpec> spec_;
-  bool on_invalid_spec_provided_called_ = false;
   bool on_spec_updated_called_ = false;
 };
 
-// Test that empty method data notifies observers of an invalid spec.
+// Test that empty method data is parsed correctly.
 TEST_F(PaymentRequestSpecTest, EmptyMethodData) {
   std::vector<mojom::PaymentMethodDataPtr> method_data;
   RecreateSpecWithMethodData(std::move(method_data));
-  EXPECT_TRUE(on_invalid_spec_provided_called());
 
   // No supported card networks.
   EXPECT_EQ(0u, spec()->supported_card_networks().size());
 }
 
 TEST_F(PaymentRequestSpecTest, IsMethodSupportedThroughBasicCard) {
   mojom::PaymentMethodDataPtr entry = mojom::PaymentMethodData::New();
   entry->supported_methods.push_back("visa");
   entry->supported_methods.push_back("mastercard");
   entry->supported_methods.push_back("invalid");
@@ skipping 55 matching lines @@
   mojom::PaymentMethodDataPtr entry = mojom::PaymentMethodData::New();
   entry->supported_methods.push_back("visa");
   entry->supported_methods.push_back("mastercard");
   entry->supported_methods.push_back("invalid");
   entry->supported_methods.push_back("");
   entry->supported_methods.push_back("visa");
   std::vector<mojom::PaymentMethodDataPtr> method_data;
   method_data.push_back(std::move(entry));
 
   RecreateSpecWithMethodData(std::move(method_data));
-  EXPECT_FALSE(on_invalid_spec_provided_called());
 
   // Only "visa" and "mastercard" remain, in order.
   EXPECT_EQ(2u, spec()->supported_card_networks().size());
   EXPECT_EQ("visa", spec()->supported_card_networks()[0]);
   EXPECT_EQ("mastercard", spec()->supported_card_networks()[1]);
 }
 
 // Test that parsing supported methods in different method data entries (with
 // invalid values and duplicates) works as expected.
 TEST_F(PaymentRequestSpecTest, SupportedMethods_MultipleEntries) {
   mojom::PaymentMethodDataPtr entry = mojom::PaymentMethodData::New();
   entry->supported_methods.push_back("visa");
   mojom::PaymentMethodDataPtr entry2 = mojom::PaymentMethodData::New();
   entry2->supported_methods.push_back("mastercard");
   mojom::PaymentMethodDataPtr entry3 = mojom::PaymentMethodData::New();
   entry3->supported_methods.push_back("invalid");
 
   std::vector<mojom::PaymentMethodDataPtr> method_data;
   method_data.push_back(std::move(entry));
   method_data.push_back(std::move(entry2));
   method_data.push_back(std::move(entry3));
 
   RecreateSpecWithMethodData(std::move(method_data));
-  EXPECT_FALSE(on_invalid_spec_provided_called());
 
   // Only "visa" and "mastercard" remain, in order.
   EXPECT_EQ(2u, spec()->supported_card_networks().size());
   EXPECT_EQ("visa", spec()->supported_card_networks()[0]);
   EXPECT_EQ("mastercard", spec()->supported_card_networks()[1]);
 }
 
 // Test that parsing supported methods in different method data entries fails as
 // soon as one entry doesn't specify anything in supported_methods.
 TEST_F(PaymentRequestSpecTest, SupportedMethods_MultipleEntries_OneEmpty) {
   // First entry is valid.
   mojom::PaymentMethodDataPtr entry = mojom::PaymentMethodData::New();
   entry->supported_methods.push_back("visa");
   // Empty method data entry.
   mojom::PaymentMethodDataPtr entry2 = mojom::PaymentMethodData::New();
   // Valid one follows the empty.
   mojom::PaymentMethodDataPtr entry3 = mojom::PaymentMethodData::New();
   entry3->supported_methods.push_back("mastercard");
 
   std::vector<mojom::PaymentMethodDataPtr> method_data;
   method_data.push_back(std::move(entry));
   method_data.push_back(std::move(entry2));
   method_data.push_back(std::move(entry3));
 
   RecreateSpecWithMethodData(std::move(method_data));
-  EXPECT_TRUE(on_invalid_spec_provided_called());
 
   // Visa was parsed, but not mastercard.
   EXPECT_EQ(1u, spec()->supported_card_networks().size());
   EXPECT_EQ("visa", spec()->supported_card_networks()[0]);
 }
 
 // Test that only specifying basic-card means that all are supported.
 TEST_F(PaymentRequestSpecTest, SupportedMethods_OnlyBasicCard) {
   mojom::PaymentMethodDataPtr entry = mojom::PaymentMethodData::New();
   entry->supported_methods.push_back("basic-card");
   std::vector<mojom::PaymentMethodDataPtr> method_data;
   method_data.push_back(std::move(entry));
 
   RecreateSpecWithMethodData(std::move(method_data));
-  EXPECT_FALSE(on_invalid_spec_provided_called());
 
   // All of the basic card networks are supported.
   EXPECT_EQ(8u, spec()->supported_card_networks().size());
   EXPECT_EQ("amex", spec()->supported_card_networks()[0]);
   EXPECT_EQ("diners", spec()->supported_card_networks()[1]);
   EXPECT_EQ("discover", spec()->supported_card_networks()[2]);
   EXPECT_EQ("jcb", spec()->supported_card_networks()[3]);
   EXPECT_EQ("mastercard", spec()->supported_card_networks()[4]);
   EXPECT_EQ("mir", spec()->supported_card_networks()[5]);
   EXPECT_EQ("unionpay", spec()->supported_card_networks()[6]);
   EXPECT_EQ("visa", spec()->supported_card_networks()[7]);
 }
 
 // Test that specifying a method AND basic-card means that all are supported,
 // but with the method as first.
 TEST_F(PaymentRequestSpecTest, SupportedMethods_BasicCard_WithSpecificMethod) {
   mojom::PaymentMethodDataPtr entry = mojom::PaymentMethodData::New();
   entry->supported_methods.push_back("jcb");
   entry->supported_methods.push_back("basic-card");
   std::vector<mojom::PaymentMethodDataPtr> method_data;
   method_data.push_back(std::move(entry));
 
   RecreateSpecWithMethodData(std::move(method_data));
-  EXPECT_FALSE(on_invalid_spec_provided_called());
 
   // All of the basic card networks are supported, but JCB is first because it
   // was specified first.
   EXPECT_EQ(8u, spec()->supported_card_networks().size());
   EXPECT_EQ("jcb", spec()->supported_card_networks()[0]);
   EXPECT_EQ("amex", spec()->supported_card_networks()[1]);
   EXPECT_EQ("diners", spec()->supported_card_networks()[2]);
   EXPECT_EQ("discover", spec()->supported_card_networks()[3]);
   EXPECT_EQ("mastercard", spec()->supported_card_networks()[4]);
   EXPECT_EQ("mir", spec()->supported_card_networks()[5]);
@@ skipping 11 matching lines @@
   mojom::PaymentMethodDataPtr entry2 = mojom::PaymentMethodData::New();
   entry2->supported_methods.push_back("basic-card");
   entry2->supported_networks.push_back(mojom::BasicCardNetwork::VISA);
   entry2->supported_networks.push_back(mojom::BasicCardNetwork::MASTERCARD);
   entry2->supported_networks.push_back(mojom::BasicCardNetwork::UNIONPAY);
   std::vector<mojom::PaymentMethodDataPtr> method_data;
   method_data.push_back(std::move(entry));
   method_data.push_back(std::move(entry2));
 
   RecreateSpecWithMethodData(std::move(method_data));
-  EXPECT_FALSE(on_invalid_spec_provided_called());
 
   EXPECT_EQ(3u, spec()->supported_card_networks().size());
   EXPECT_EQ("mastercard", spec()->supported_card_networks()[0]);
   EXPECT_EQ("visa", spec()->supported_card_networks()[1]);
   EXPECT_EQ("unionpay", spec()->supported_card_networks()[2]);
 }
 
 // Test that specifying basic-card with supported networks after specifying
 // some methods
 TEST_F(PaymentRequestSpecTest,
        SupportedMethods_BasicCard_WithSupportedNetworks) {
   mojom::PaymentMethodDataPtr entry = mojom::PaymentMethodData::New();
   entry->supported_methods.push_back("basic-card");
   entry->supported_networks.push_back(mojom::BasicCardNetwork::VISA);
   entry->supported_networks.push_back(mojom::BasicCardNetwork::UNIONPAY);
   std::vector<mojom::PaymentMethodDataPtr> method_data;
   method_data.push_back(std::move(entry));
 
   RecreateSpecWithMethodData(std::move(method_data));
-  EXPECT_FALSE(on_invalid_spec_provided_called());
 
   // Only the specified networks are supported.
   EXPECT_EQ(2u, spec()->supported_card_networks().size());
   EXPECT_EQ("visa", spec()->supported_card_networks()[0]);
   EXPECT_EQ("unionpay", spec()->supported_card_networks()[1]);
 }
 
 // Test that the last shipping option is selected, even in the case of
 // updateWith.
 TEST_F(PaymentRequestSpecTest, ShippingOptionsSelection) {
@@ skipping 26 matching lines @@
   new_option2->id = "option:2";
   new_option2->selected = true;
   new_shipping_options.push_back(std::move(new_option2));
   mojom::PaymentDetailsPtr new_details = mojom::PaymentDetails::New();
   new_details->shipping_options = std::move(new_shipping_options);
 
   spec()->UpdateWith(std::move(new_details));
 }
 
 }  // namespace payments