Revert of Enable Expect-Staple in SSLClientSocket.

net/http/transport_security_state_unittest.cc

 // Copyright (c) 2012 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 "net/http/transport_security_state.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 346 matching lines @@
   }
 
   static void EnableStaticPins(TransportSecurityState* state) {
     state->enable_static_pins_ = true;
   }
 
   static void EnableStaticExpectCT(TransportSecurityState* state) {
     state->enable_static_expect_ct_ = true;
   }
 
-  static void SetEnableStaticExpectStaple(TransportSecurityState* state,
-                                          bool enabled) {
-    state->enable_static_expect_staple_ = enabled;
+  static void EnableStaticExpectStaple(TransportSecurityState* state) {
+    state->enable_static_expect_staple_ = true;
   }
 
   static HashValueVector GetSampleSPKIHashes() {
     HashValueVector spki_hashes;
     HashValue hash(HASH_VALUE_SHA256);
     memset(hash.data(), 0, hash.size());
     spki_hashes.push_back(hash);
     return spki_hashes;
   }
 
@@ skipping 1455 matching lines @@
   EXPECT_EQ(kExpectCTStaticHostname, expect_ct_state.domain);
   EXPECT_EQ(GURL(kExpectCTStaticReportURI), expect_ct_state.report_uri);
   EXPECT_FALSE(
       GetExpectCTState(&state, "pinning-test.badssl.com", &expect_ct_state));
 }
 
 // Tests that static (preloaded) expect staple state is read correctly.
 TEST_F(TransportSecurityStateTest, PreloadedExpectStaple) {
   TransportSecurityState state;
   TransportSecurityState::ExpectStapleState expect_staple_state;
-  TransportSecurityStateTest::SetEnableStaticExpectStaple(&state, false);
   EXPECT_FALSE(GetExpectStapleState(&state, kExpectStapleStaticHostname,
                                     &expect_staple_state));
-  TransportSecurityStateTest::SetEnableStaticExpectStaple(&state, true);
+  TransportSecurityStateTest::EnableStaticExpectStaple(&state);
   EXPECT_TRUE(GetExpectStapleState(&state, kExpectStapleStaticHostname,
                                    &expect_staple_state));
   EXPECT_EQ(kExpectStapleStaticHostname, expect_staple_state.domain);
   EXPECT_EQ(GURL(kExpectStapleStaticReportURI), expect_staple_state.report_uri);
   EXPECT_FALSE(expect_staple_state.include_subdomains);
   EXPECT_FALSE(GetExpectStapleState(&state, "pinning-test.badssl.com",
                                     &expect_staple_state));
   std::string subdomain = "subdomain.";
   subdomain += kExpectStapleStaticHostname;
   EXPECT_FALSE(GetExpectStapleState(&state, subdomain, &expect_staple_state));
 }
 
 TEST_F(TransportSecurityStateTest, PreloadedExpectStapleIncludeSubdomains) {
   TransportSecurityState state;
-  TransportSecurityStateTest::SetEnableStaticExpectStaple(&state, true);
+  TransportSecurityStateTest::EnableStaticExpectStaple(&state);
   TransportSecurityState::ExpectStapleState expect_staple_state;
   std::string subdomain = "subdomain.";
   subdomain += kExpectStapleStaticIncludeSubdomainsHostname;
   EXPECT_TRUE(GetExpectStapleState(&state, subdomain, &expect_staple_state));
   EXPECT_EQ(kExpectStapleStaticIncludeSubdomainsHostname,
             expect_staple_state.domain);
   EXPECT_TRUE(expect_staple_state.include_subdomains);
   EXPECT_EQ(GURL(kExpectStapleStaticReportURI), expect_staple_state.report_uri);
 }
 
@@ skipping 149 matching lines @@
 
 class ExpectStapleErrorResponseTest
     : public TransportSecurityStateTest,
       public testing::WithParamInterface<ExpectStapleErrorResponseData> {};
 
 // For every |response_status| indicating an OCSP response was provided, but had
 // some sort of parsing/validation error, test that the ExpectStaple report is
 // serialized correctly.
 TEST_P(ExpectStapleErrorResponseTest, CheckResponseStatusSerialization) {
   TransportSecurityState state;
-  TransportSecurityStateTest::SetEnableStaticExpectStaple(&state, true);
+  TransportSecurityStateTest::EnableStaticExpectStaple(&state);
   MockCertificateReportSender reporter;
   ExpectStapleErrorResponseData test = GetParam();
 
   std::string ocsp_response;
   if (test.response_status != OCSPVerifyResult::MISSING)
     ocsp_response = "dummy_response";
 
   // Two dummy certs to use as the server-sent and validated chains. The
   // contents don't matter.
   scoped_refptr<X509Certificate> cert1 =
@@ skipping 34 matching lines @@
 
 class ExpectStapleErrorCertStatusTest
     : public TransportSecurityStateTest,
       public testing::WithParamInterface<ExpectStapleErrorCertStatusData> {};
 
 // Test that |revocation_status| is serialized into the |cert-status| field of
 // the Expect-Staple report whenever |response_status| is PROVIDED and
 // |revocation_status| != GOOD.
 TEST_P(ExpectStapleErrorCertStatusTest, CheckCertStatusSerialization) {
   TransportSecurityState state;
-  TransportSecurityStateTest::SetEnableStaticExpectStaple(&state, true);
+  TransportSecurityStateTest::EnableStaticExpectStaple(&state);
   MockCertificateReportSender reporter;
   ExpectStapleErrorCertStatusData test = GetParam();
   std::string ocsp_response = "dummy_response";
 
   // Two dummy certs to use as the server-sent and validated chains. The
   // contents don't matter.
   scoped_refptr<X509Certificate> cert1 =
       ImportCertFromFile(GetTestCertsDirectory(), "test_mail_google_com.pem");
   scoped_refptr<X509Certificate> cert2 =
       ImportCertFromFile(GetTestCertsDirectory(), "expired_cert.pem");
@@ skipping 19 matching lines @@
                                                   ocsp_response, "PROVIDED",
                                                   test.cert_status_string));
 };
 
 INSTANTIATE_TEST_CASE_P(ExpectStaple,
                         ExpectStapleErrorCertStatusTest,
                         testing::ValuesIn(kExpectStapleErrorCertStatusData));
 
 TEST_F(TransportSecurityStateTest, ExpectStapleDoesNotReportValidStaple) {
   TransportSecurityState state;
-  TransportSecurityStateTest::SetEnableStaticExpectStaple(&state, true);
+  TransportSecurityStateTest::EnableStaticExpectStaple(&state);
   MockCertificateReportSender reporter;
   state.SetReportSender(&reporter);
 
   // Baked-in preloaded Expect-Staple test hosts.
   HostPortPair host_port(kExpectStapleStaticHostname, 443);
 
   // Two dummy certs to use as the server-sent and validated chains. The
   // contents don't matter.
   scoped_refptr<X509Certificate> cert1 =
       ImportCertFromFile(GetTestCertsDirectory(), "test_mail_google_com.pem");
@@ skipping 14 matching lines @@
   EXPECT_TRUE(reporter.latest_report().empty());
 
   ssl_info.is_issued_by_known_root = false;
   state.CheckExpectStaple(host_port, ssl_info, ocsp_response);
   EXPECT_EQ(GURL(), reporter.latest_report_uri());
   EXPECT_TRUE(reporter.latest_report().empty());
 }
 
 TEST_F(TransportSecurityStateTest, ExpectStapleRequiresPreload) {
   TransportSecurityState state;
-  TransportSecurityStateTest::SetEnableStaticExpectStaple(&state, true);
+  TransportSecurityStateTest::EnableStaticExpectStaple(&state);
   MockCertificateReportSender reporter;
   state.SetReportSender(&reporter);
 
   HostPortPair host_port("not-preloaded.host.example", 443);
 
   // Two dummy certs to use as the server-sent and validated chains. The
   // contents don't matter.
   scoped_refptr<X509Certificate> cert1 =
       ImportCertFromFile(GetTestCertsDirectory(), "test_mail_google_com.pem");
   scoped_refptr<X509Certificate> cert2 =
@@ skipping 145 matching lines @@
   base::FieldTrialList::CreateFieldTrial("EnforceCTForProblematicRoots",
                                          "disabled");
 
   EXPECT_FALSE(
       state.ShouldRequireCT("www.example.com", before_cert.get(), hashes));
   EXPECT_FALSE(
       state.ShouldRequireCT("www.example.com", after_cert.get(), hashes));
 }
 
 }  // namespace net