net: rename BoundNetLog to NetLogWithSource

components/cronet/android/cert/cert_verifier_cache_serializer_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 "components/cronet/android/cert/cert_verifier_cache_serializer.h"
 
 #include <memory>
 #include <string>
 
 #include "base/android/path_utils.h"
@@ skipping 29 matching lines @@
       net::ImportCertFromFile(net::GetTestCertsDirectory(), cert_name));
   ASSERT_TRUE(cert);
 
   net::TestCompletionCallback callback;
   std::unique_ptr<net::CertVerifier::Request> request;
 
   ignore_result(callback.GetResult(verifier->Verify(
       net::CertVerifier::RequestParams(cert.get(), hostname, 0, std::string(),
                                        net::CertificateList()),
       nullptr, verify_result, callback.callback(), &request,
-      net::BoundNetLog())));
+      net::NetLogWithSource())));
 }
 
 }  // namespace
 
 TEST(CertVerifierCacheSerializerTest, RestoreEmptyData) {
   // Restoring empty data should fail.
   cronet_pb::CertVerificationCache cert_cache;
   net::CachingCertVerifier verifier(base::MakeUnique<net::MockCertVerifier>());
   EXPECT_FALSE(DeserializeCertVerifierCache(cert_cache, &verifier));
 }
@@ skipping 39 matching lines @@
   net::X509Certificate::OSCertHandles chain;
   chain.push_back(root_cert->os_cert_handle());
   const scoped_refptr<net::X509Certificate> combined_cert =
       net::X509Certificate::CreateFromHandle(ok_cert->os_cert_handle(), chain);
   ASSERT_TRUE(combined_cert);
 
   ignore_result(callback.GetResult(verifier.Verify(
       net::CertVerifier::RequestParams(combined_cert, example2_hostname, 0,
                                        std::string(), net::CertificateList()),
       nullptr, &verifier1_result2, callback.callback(), &request,
-      net::BoundNetLog())));
+      net::NetLogWithSource())));
 
   cronet_pb::CertVerificationCache cert_cache =
       SerializeCertVerifierCache(verifier);
   // Verify two certificates are serialized.
   DCHECK_EQ(2, cert_cache.cert_entry_size());
   DCHECK_EQ(2, cert_cache.cache_entry_size());
 
   net::CachingCertVerifier verifier2(base::MakeUnique<net::MockCertVerifier>());
 
   // Populate |verifier2|'s cache.
   EXPECT_TRUE(DeserializeCertVerifierCache(cert_cache, &verifier2));
 
   // Verify the cert for www.example.com with |verifier2|.
   net::CertVerifyResult verifier2_result1;
   ASSERT_NO_FATAL_FAILURE(VerifyCert("ok_cert.pem", example_hostname,
                                      &verifier2, &verifier2_result1));
 
   // CertVerifyResult for www.example.com with |verifier2| should match
   // what was serialized with |verifier|.
   EXPECT_EQ(verifier2_result1, verifier1_result1);
 
   // Verify the cert for www2.example.com with |verifier2|.
   net::CertVerifyResult verifier2_result2;
   ignore_result(callback.GetResult(verifier2.Verify(
       net::CertVerifier::RequestParams(combined_cert, example2_hostname, 0,
                                        std::string(), net::CertificateList()),
       nullptr, &verifier2_result2, callback.callback(), &request,
-      net::BoundNetLog())));
+      net::NetLogWithSource())));
 
   // CertVerifyResult for www2.example.com with |verifier2| should match
   // what was serialized with |verifier|.
   EXPECT_EQ(verifier2_result2, verifier1_result2);
 }
 
 // A corrupted cert_entry in the serialized data should fail to be deserialized.
 // Should not deserialize a corrupted cert_entry.
 TEST(CertVerifierCacheSerializerTest, DeserializeCorruptedCerts) {
   net::CertVerifyResult verify_result;
@@ skipping 259 matching lines @@
   net::CertVerifyResult verify_result;
   net::TestCompletionCallback callback;
   std::unique_ptr<net::CertVerifier::Request> request;
 
   net::CachingCertVerifier verifier(base::MakeUnique<net::MockCertVerifier>());
   // Verify the |cert| with |trust_anchors|.
   ignore_result(callback.GetResult(verifier.Verify(
       net::CertVerifier::RequestParams(cert, "www.example.com", 0,
                                        std::string(), trust_anchors),
       nullptr, &verify_result, callback.callback(), &request,
-      net::BoundNetLog())));
+      net::NetLogWithSource())));
 
   cronet_pb::CertVerificationCache cert_cache =
       SerializeCertVerifierCache(verifier);
   DCHECK_EQ(2, cert_cache.cert_entry_size());
   DCHECK_EQ(1, cert_cache.cache_entry_size());
 
   for (int i = 0; i < cert_cache.cache_entry_size(); ++i) {
     cronet_pb::CertVerificationCacheEntry* cache_entry =
         cert_cache.mutable_cache_entry(i);
     cronet_pb::CertVerificationRequestParams* request_params =
@@ skipping 239 matching lines @@
         cert_cache.mutable_cache_entry(i);
     // Corrupt |verification_time|.
     cache_entry->clear_verification_time();
   }
 
   net::CachingCertVerifier verifier2(base::MakeUnique<net::MockCertVerifier>());
   EXPECT_FALSE(DeserializeCertVerifierCache(cert_cache, &verifier2));
 }
 
 }  // namespace cronet