net: rename BoundNetLog to NetLogWithSource

net/cert/caching_cert_verifier_unittest.cc

 // Copyright 2016 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/caching_cert_verifier.h"
 
 #include <memory>
 
 #include "base/files/file_path.h"
 #include "base/memory/ptr_util.h"
@@ skipping 54 matching lines @@
   ASSERT_TRUE(test_cert.get());
 
   int error;
   CertVerifyResult verify_result;
   TestCompletionCallback callback;
   std::unique_ptr<CertVerifier::Request> request;
 
   error = callback.GetResult(verifier_.Verify(
       CertVerifier::RequestParams(test_cert, "www.example.com", 0,
                                   std::string(), CertificateList()),
-      nullptr, &verify_result, callback.callback(), &request, BoundNetLog()));
+      nullptr, &verify_result, callback.callback(), &request,
+      NetLogWithSource()));
   ASSERT_TRUE(IsCertificateError(error));
   ASSERT_EQ(1u, verifier_.requests());
   ASSERT_EQ(0u, verifier_.cache_hits());
   ASSERT_EQ(1u, verifier_.GetCacheSize());
 
   error = verifier_.Verify(
       CertVerifier::RequestParams(test_cert, "www.example.com", 0,
                                   std::string(), CertificateList()),
-      nullptr, &verify_result, callback.callback(), &request, BoundNetLog());
+      nullptr, &verify_result, callback.callback(), &request,
+      NetLogWithSource());
   // Synchronous completion.
   ASSERT_NE(ERR_IO_PENDING, error);
   ASSERT_TRUE(IsCertificateError(error));
   ASSERT_FALSE(request);
   ASSERT_EQ(2u, verifier_.requests());
   ASSERT_EQ(1u, verifier_.cache_hits());
   ASSERT_EQ(1u, verifier_.GetCacheSize());
 }
 
 TEST_F(CachingCertVerifierTest, Visitor) {
   base::FilePath certs_dir = GetTestCertsDirectory();
   scoped_refptr<X509Certificate> test_cert(
       ImportCertFromFile(certs_dir, "ok_cert.pem"));
   ASSERT_TRUE(test_cert.get());
 
   TestCompletionCallback callback;
   std::unique_ptr<CertVerifier::Request> request;
 
   // Add some entries to the cache
   CertVerifier::RequestParams params1(test_cert, "www.example.com", 0,
                                       std::string(), CertificateList());
   CertVerifyResult result1;
-  int error1 = callback.GetResult(verifier_.Verify(params1, nullptr, &result1,
-                                                   callback.callback(),
-                                                   &request, BoundNetLog()));
+  int error1 = callback.GetResult(
+      verifier_.Verify(params1, nullptr, &result1, callback.callback(),
+                       &request, NetLogWithSource()));
   ASSERT_TRUE(IsCertificateError(error1));
   ASSERT_EQ(1u, verifier_.requests());
   ASSERT_EQ(0u, verifier_.cache_hits());
   ASSERT_EQ(1u, verifier_.GetCacheSize());
 
   CertVerifier::RequestParams params2(test_cert, "www.example.net", 0,
                                       std::string(), CertificateList());
   CertVerifyResult result2;
-  int error2 = callback.GetResult(verifier_.Verify(params2, nullptr, &result2,
-                                                   callback.callback(),
-                                                   &request, BoundNetLog()));
+  int error2 = callback.GetResult(
+      verifier_.Verify(params2, nullptr, &result2, callback.callback(),
+                       &request, NetLogWithSource()));
   ASSERT_TRUE(IsCertificateError(error2));
   ASSERT_EQ(2u, verifier_.requests());
   ASSERT_EQ(0u, verifier_.cache_hits());
   ASSERT_EQ(2u, verifier_.GetCacheSize());
 
   CertVerifier::RequestParams params3(test_cert, "www.example.org", 0,
                                       std::string(), CertificateList());
   CertVerifyResult result3;
-  int error3 = callback.GetResult(verifier_.Verify(params3, nullptr, &result3,
-                                                   callback.callback(),
-                                                   &request, BoundNetLog()));
+  int error3 = callback.GetResult(
+      verifier_.Verify(params3, nullptr, &result3, callback.callback(),
+                       &request, NetLogWithSource()));
   ASSERT_TRUE(IsCertificateError(error3));
   ASSERT_EQ(3u, verifier_.requests());
   ASSERT_EQ(0u, verifier_.cache_hits());
   ASSERT_EQ(3u, verifier_.GetCacheSize());
 
   // Iterate through all entries.
   {
     MockCacheVisitor mock_visitor;
     EXPECT_CALL(mock_visitor, VisitEntry(params1, error1, _, _, _))
         .WillOnce(Return(true));
@@ skipping 42 matching lines @@
   ASSERT_EQ(0u, verifier_.requests());
   ASSERT_EQ(0u, verifier_.cache_hits());
   ASSERT_EQ(1u, verifier_.GetCacheSize());
 
   TestCompletionCallback callback;
   std::unique_ptr<CertVerifier::Request> request;
 
   CertVerifyResult cached_result;
   int error = callback.GetResult(
       verifier_.Verify(params, nullptr, &cached_result, callback.callback(),
-                       &request, BoundNetLog()));
+                       &request, NetLogWithSource()));
   ASSERT_THAT(error, IsError(ERR_CERT_WEAK_KEY));
   EXPECT_TRUE(cached_result.has_md2);
   EXPECT_FALSE(cached_result.is_issued_by_known_root);
 
   ASSERT_EQ(1u, verifier_.requests());
   ASSERT_EQ(1u, verifier_.cache_hits());
   ASSERT_EQ(1u, verifier_.GetCacheSize());
 
   // But it should not be fine to replace it with an existing entry, even
   // if that entry is 'newer'.
   EXPECT_FALSE(verifier_.AddEntry(params, OK, result_2,
                                   now + base::TimeDelta::FromMinutes(1)));
 
   error = callback.GetResult(verifier_.Verify(params, nullptr, &cached_result,
                                               callback.callback(), &request,
-                                              BoundNetLog()));
+                                              NetLogWithSource()));
   ASSERT_THAT(error, IsError(ERR_CERT_WEAK_KEY));
   EXPECT_TRUE(cached_result.has_md2);
   EXPECT_FALSE(cached_result.is_issued_by_known_root);
 
   ASSERT_EQ(2u, verifier_.requests());
   ASSERT_EQ(2u, verifier_.cache_hits());
   ASSERT_EQ(1u, verifier_.GetCacheSize());
 }
 
 // Tests the same server certificate with different intermediate CA
@@ skipping 29 matching lines @@
   ASSERT_TRUE(cert_chain2);
 
   int error;
   CertVerifyResult verify_result;
   TestCompletionCallback callback;
   std::unique_ptr<CertVerifier::Request> request;
 
   error = callback.GetResult(verifier_.Verify(
       CertVerifier::RequestParams(cert_chain1, "www.example.com", 0,
                                   std::string(), CertificateList()),
-      nullptr, &verify_result, callback.callback(), &request, BoundNetLog()));
+      nullptr, &verify_result, callback.callback(), &request,
+      NetLogWithSource()));
   ASSERT_TRUE(IsCertificateError(error));
   ASSERT_EQ(1u, verifier_.requests());
   ASSERT_EQ(0u, verifier_.cache_hits());
   ASSERT_EQ(1u, verifier_.GetCacheSize());
 
   error = callback.GetResult(verifier_.Verify(
       CertVerifier::RequestParams(cert_chain2, "www.example.com", 0,
                                   std::string(), CertificateList()),
-      nullptr, &verify_result, callback.callback(), &request, BoundNetLog()));
+      nullptr, &verify_result, callback.callback(), &request,
+      NetLogWithSource()));
   ASSERT_TRUE(IsCertificateError(error));
   ASSERT_EQ(2u, verifier_.requests());
   ASSERT_EQ(0u, verifier_.cache_hits());
   ASSERT_EQ(2u, verifier_.GetCacheSize());
 }
 
 }  // namespace net