Revert of CT Verify test utilities change - Moved the following common functions

net/cert/multi_log_ct_verifier_unittest.cc

 // Copyright 2013 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/cert/multi_log_ct_verifier.h"
 
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 52 matching lines @@
         der_test_cert.length());
     ASSERT_TRUE(chain_.get());
 
     embedded_sct_chain_ =
         CreateCertificateChainFromFile(GetTestCertsDirectory(),
                                        "ct-test-embedded-cert.pem",
                                        X509Certificate::FORMAT_AUTO);
     ASSERT_TRUE(embedded_sct_chain_.get());
   }
 
+  bool CheckForSingleVerifiedSCTInResult(const ct::CTVerifyResult& result) {
+    return (result.verified_scts.size() == 1U) &&
+        result.invalid_scts.empty() &&
+        result.unknown_logs_scts.empty() &&
+        result.verified_scts[0]->log_description == kLogDescription;
+  }
+
+  bool CheckForSCTOrigin(
+      const ct::CTVerifyResult& result,
+      ct::SignedCertificateTimestamp::Origin origin) {
+    return (result.verified_scts.size() > 0) &&
+        (result.verified_scts[0]->origin == origin);
+  }
+
   bool CheckForEmbeddedSCTInNetLog(TestNetLog& net_log) {
     TestNetLogEntry::List entries;
     net_log.GetEntries(&entries);
     if (entries.size() != 2)
       return false;
 
     const TestNetLogEntry& received = entries[0];
     std::string embedded_scts;
     if (!received.GetStringValue("embedded_scts", &embedded_scts))
       return false;
@@ skipping 24 matching lines @@
     }
 
     if (!parsed.GetListValue("unknown_logs_scts", &other_scts) ||
         !other_scts->empty()) {
       return false;
     }
 
     return true;
   }
 
+  std::string GetSCTListWithInvalidSCT() {
+    std::string sct(ct::GetTestSignedCertificateTimestamp());
+
+    // Change a byte inside the Log ID part of the SCT so it does
+    // not match the log used in the tests
+    sct[15] = 't';
+
+    std::string sct_list;
+    ct::EncodeSCTListForTesting(sct, &sct_list);
+    return sct_list;
+  }
+
   bool VerifySinglePrecertificateChain(scoped_refptr<X509Certificate> chain,
                                        const BoundNetLog& bound_net_log,
                                        ct::CTVerifyResult* result) {
     return verifier_->Verify(chain.get(),
                              std::string(),
                              std::string(),
                              result,
                              bound_net_log) == OK;
   }
 
   bool VerifySinglePrecertificateChain(scoped_refptr<X509Certificate> chain) {
     ct::CTVerifyResult result;
     TestNetLog net_log;
     BoundNetLog bound_net_log =
         BoundNetLog::Make(&net_log, NetLog::SOURCE_CONNECT_JOB);
 
     return verifier_->Verify(chain.get(),
                              std::string(),
                              std::string(),
                              &result,
                              bound_net_log) == OK;
   }
 
   bool CheckPrecertificateVerification(scoped_refptr<X509Certificate> chain) {
     ct::CTVerifyResult result;
     TestNetLog net_log;
     BoundNetLog bound_net_log =
       BoundNetLog::Make(&net_log, NetLog::SOURCE_CONNECT_JOB);
     return (VerifySinglePrecertificateChain(chain, bound_net_log, &result) &&
-            ct::CheckForSingleVerifiedSCTInResult(result, kLogDescription) &&
-            ct::CheckForSCTOrigin(
-                result, ct::SignedCertificateTimestamp::SCT_EMBEDDED) &&
+            CheckForSingleVerifiedSCTInResult(result) &&
+            CheckForSCTOrigin(result,
+                              ct::SignedCertificateTimestamp::SCT_EMBEDDED) &&
             CheckForEmbeddedSCTInNetLog(net_log));
   }
 
   // Histogram-related helper methods
   int GetValueFromHistogram(const std::string& histogram_name,
                             int sample_index) {
     base::Histogram* histogram = static_cast<base::Histogram*>(
         base::StatisticsRecorder::FindHistogram(histogram_name));
 
     if (histogram == NULL)
@@ skipping 49 matching lines @@
 TEST_F(MultiLogCTVerifierTest,
        VerifiesEmbeddedSCTWithIntermediateAndPreCA) {
   scoped_refptr<X509Certificate> chain(CreateCertificateChainFromFile(
       GetTestCertsDirectory(),
       "ct-test-embedded-with-intermediate-preca-chain.pem",
       X509Certificate::FORMAT_AUTO));
   ASSERT_TRUE(chain.get());
   ASSERT_TRUE(CheckPrecertificateVerification(chain));
 }
 
-TEST_F(MultiLogCTVerifierTest, VerifiesSCTOverX509Cert) {
-  std::string sct_list = ct::GetSCTListForTesting();
+TEST_F(MultiLogCTVerifierTest,
+       VerifiesSCTOverX509Cert) {
+  std::string sct(ct::GetTestSignedCertificateTimestamp());
+
+  std::string sct_list;
+  ASSERT_TRUE(ct::EncodeSCTListForTesting(sct, &sct_list));
 
   ct::CTVerifyResult result;
   EXPECT_EQ(OK,
             verifier_->Verify(
                 chain_.get(), std::string(), sct_list, &result, BoundNetLog()));
-  ASSERT_TRUE(ct::CheckForSingleVerifiedSCTInResult(result, kLogDescription));
-  ASSERT_TRUE(ct::CheckForSCTOrigin(
+  ASSERT_TRUE(CheckForSingleVerifiedSCTInResult(result));
+  ASSERT_TRUE(CheckForSCTOrigin(
       result, ct::SignedCertificateTimestamp::SCT_FROM_TLS_EXTENSION));
 }
 
-TEST_F(MultiLogCTVerifierTest, IdentifiesSCTFromUnknownLog) {
-  std::string sct_list = ct::GetSCTListWithInvalidSCT();
+TEST_F(MultiLogCTVerifierTest,
+       IdentifiesSCTFromUnknownLog) {
+  std::string sct_list = GetSCTListWithInvalidSCT();
   ct::CTVerifyResult result;
 
   EXPECT_NE(OK,
             verifier_->Verify(
                 chain_.get(), std::string(), sct_list, &result, BoundNetLog()));
   EXPECT_EQ(1U, result.unknown_logs_scts.size());
   EXPECT_EQ("", result.unknown_logs_scts[0]->log_description);
 }
 
 TEST_F(MultiLogCTVerifierTest, CountsValidSCTsInStatusHistogram) {
   int num_valid_scts = NumValidSCTsInStatusHistogram();
 
   ASSERT_TRUE(VerifySinglePrecertificateChain(embedded_sct_chain_));
 
   EXPECT_EQ(num_valid_scts + 1, NumValidSCTsInStatusHistogram());
 }
 
 TEST_F(MultiLogCTVerifierTest, CountsInvalidSCTsInStatusHistogram) {
-  std::string sct_list = ct::GetSCTListWithInvalidSCT();
+  std::string sct_list = GetSCTListWithInvalidSCT();
   ct::CTVerifyResult result;
   int num_valid_scts = NumValidSCTsInStatusHistogram();
   int num_invalid_scts = GetValueFromHistogram(
       "Net.CertificateTransparency.SCTStatus", ct::SCT_STATUS_LOG_UNKNOWN);
 
   EXPECT_NE(OK,
             verifier_->Verify(
                 chain_.get(), std::string(), sct_list, &result, BoundNetLog()));
 
   ASSERT_EQ(num_valid_scts, NumValidSCTsInStatusHistogram());
@@ skipping 38 matching lines @@
   Mock::VerifyAndClearExpectations(&observer);
 
   EXPECT_CALL(observer, OnSCTVerified(embedded_sct_chain_.get(), _)).Times(0);
   verifier_->SetObserver(nullptr);
   ASSERT_TRUE(VerifySinglePrecertificateChain(embedded_sct_chain_));
 }
 
 }  // namespace
 
 }  // namespace net