net: rename BoundNetLog to NetLogWithSource

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 <memory>
 #include <string>
 
 #include "base/files/file_path.h"
@@ skipping 94 matching lines @@
     std::string verification_status;
     if (!the_sct->GetString("verification_status", &verification_status))
       return false;
     if (verification_status != "Verified")
       return false;
 
     return true;
   }
 
   bool VerifySinglePrecertificateChain(scoped_refptr<X509Certificate> chain,
-                                       const BoundNetLog& bound_net_log,
+                                       const NetLogWithSource& net_log,
                                        ct::CTVerifyResult* result) {
-    return verifier_->Verify(chain.get(),
-                             std::string(),
-                             std::string(),
-                             result,
-                             bound_net_log) == OK;
+    return verifier_->Verify(chain.get(), std::string(), std::string(), result,
+                             net_log) == OK;
   }
 
   bool VerifySinglePrecertificateChain(scoped_refptr<X509Certificate> chain) {
     ct::CTVerifyResult result;
-    TestNetLog net_log;
-    BoundNetLog bound_net_log =
-        BoundNetLog::Make(&net_log, NetLogSourceType::CONNECT_JOB);
+    TestNetLog test_net_log;
+    NetLogWithSource net_log =
+        NetLogWithSource::Make(&test_net_log, NetLogSourceType::CONNECT_JOB);
 
-    return verifier_->Verify(chain.get(),
-                             std::string(),
-                             std::string(),
-                             &result,
-                             bound_net_log) == OK;
+    return verifier_->Verify(chain.get(), std::string(), std::string(), &result,
+                             net_log) == OK;
   }
 
   bool CheckPrecertificateVerification(scoped_refptr<X509Certificate> chain) {
     ct::CTVerifyResult result;
-    TestNetLog net_log;
-    BoundNetLog bound_net_log =
-        BoundNetLog::Make(&net_log, NetLogSourceType::CONNECT_JOB);
-    return (VerifySinglePrecertificateChain(chain, bound_net_log, &result) &&
+    TestNetLog test_net_log;
+    NetLogWithSource net_log =
+        NetLogWithSource::Make(&test_net_log, NetLogSourceType::CONNECT_JOB);
+    return (VerifySinglePrecertificateChain(chain, net_log, &result) &&
             ct::CheckForSingleVerifiedSCTInResult(result, kLogDescription) &&
             ct::CheckForSCTOrigin(
                 result, ct::SignedCertificateTimestamp::SCT_EMBEDDED) &&
-            CheckForEmbeddedSCTInNetLog(net_log));
+            CheckForEmbeddedSCTInNetLog(test_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)
       return 0;
@@ skipping 53 matching lines @@
       "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();
 
   ct::CTVerifyResult result;
-  EXPECT_EQ(OK,
-            verifier_->Verify(
-                chain_.get(), std::string(), sct_list, &result, BoundNetLog()));
+  EXPECT_EQ(OK, verifier_->Verify(chain_.get(), std::string(), sct_list,
+                                  &result, NetLogWithSource()));
   ASSERT_TRUE(ct::CheckForSingleVerifiedSCTInResult(result, kLogDescription));
   ASSERT_TRUE(ct::CheckForSCTOrigin(
       result, ct::SignedCertificateTimestamp::SCT_FROM_TLS_EXTENSION));
 }
 
 TEST_F(MultiLogCTVerifierTest, IdentifiesSCTFromUnknownLog) {
   std::string sct_list = ct::GetSCTListWithInvalidSCT();
   ct::CTVerifyResult result;
 
-  EXPECT_NE(OK,
-            verifier_->Verify(
-                chain_.get(), std::string(), sct_list, &result, BoundNetLog()));
+  EXPECT_NE(OK, verifier_->Verify(chain_.get(), std::string(), sct_list,
+                                  &result, NetLogWithSource()));
   EXPECT_EQ(1U, result.scts.size());
   EXPECT_EQ("", result.scts[0].sct->log_description);
   EXPECT_EQ(ct::SCT_STATUS_LOG_UNKNOWN, result.scts[0].status);
 }
 
 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();
   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()));
+  EXPECT_NE(OK, verifier_->Verify(chain_.get(), std::string(), sct_list,
+                                  &result, NetLogWithSource()));
 
   ASSERT_EQ(num_valid_scts, NumValidSCTsInStatusHistogram());
   ASSERT_EQ(num_invalid_scts + 1,
             GetValueFromHistogram("Net.CertificateTransparency.SCTStatus",
                                   ct::SCT_STATUS_LOG_UNKNOWN));
 }
 
 TEST_F(MultiLogCTVerifierTest, CountsSingleEmbeddedSCTInConnectionsHistogram) {
   int old_sct_count = NumConnectionsWithSingleSCT();
   ASSERT_TRUE(CheckPrecertificateVerification(embedded_sct_chain_));
@@ skipping 30 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