net: rename BoundNetLog to NetLogWithSource

net/dns/host_resolver_impl_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/dns/host_resolver_impl.h"
 
 #include <algorithm>
 #include <memory>
 #include <string>
 #include <tuple>
@@ skipping 217 matching lines @@
         quit_on_complete_(false),
         result_(ERR_UNEXPECTED) {}
 
   int Resolve() {
     DCHECK(resolver_);
     DCHECK(!request_);
     list_ = AddressList();
     result_ = resolver_->Resolve(
         info_, priority_, &list_,
         base::Bind(&Request::OnComplete, base::Unretained(this)), &request_,
-        BoundNetLog());
+        NetLogWithSource());
     if (!list_.empty())
       EXPECT_THAT(result_, IsOk());
     return result_;
   }
 
   int ResolveFromCache() {
     DCHECK(resolver_);
     DCHECK(!request_);
-    return resolver_->ResolveFromCache(info_, &list_, BoundNetLog());
+    return resolver_->ResolveFromCache(info_, &list_, NetLogWithSource());
   }
 
   int ResolveStaleFromCache() {
     DCHECK(resolver_);
     DCHECK(!request_);
     return resolver_->ResolveStaleFromCache(info_, &list_, &staleness_,
-                                            BoundNetLog());
+                                            NetLogWithSource());
   }
 
   void ChangePriority(RequestPriority priority) {
     DCHECK(resolver_);
     DCHECK(request_);
     request_->ChangeRequestPriority(priority);
     priority_ = priority;
   }
 
   void Cancel() {
@@ skipping 189 matching lines @@
   TestHostResolverImpl(const Options& options,
                        NetLog* net_log,
                        bool ipv6_reachable)
       : HostResolverImpl(options, net_log), ipv6_reachable_(ipv6_reachable) {}
 
   ~TestHostResolverImpl() override {}
 
  private:
   const bool ipv6_reachable_;
 
-  bool IsIPv6Reachable(const BoundNetLog& net_log) override {
+  bool IsIPv6Reachable(const NetLogWithSource& net_log) override {
     return ipv6_reachable_;
   }
 };
 
 const uint16_t kLocalhostLookupPort = 80;
 
 bool HasEndpoint(const IPEndPoint& endpoint, const AddressList& addresses) {
   for (const auto& address : addresses) {
     if (endpoint == address)
       return true;
@@ skipping 130 matching lines @@
 
   void set_fallback_to_proctask(bool fallback_to_proctask) {
     DCHECK(resolver_.get());
     resolver_->fallback_to_proctask_ = fallback_to_proctask;
   }
 
   static unsigned maximum_dns_failures() {
     return HostResolverImpl::kMaximumDnsFailures;
   }
 
-  bool IsIPv6Reachable(const BoundNetLog& net_log) {
+  bool IsIPv6Reachable(const NetLogWithSource& net_log) {
     return resolver_->IsIPv6Reachable(net_log);
   }
 
   void MakeCacheStale() {
     DCHECK(resolver_.get());
     resolver_->GetHostCache()->OnNetworkChange();
   }
 
   scoped_refptr<MockHostResolverProc> proc_;
   std::unique_ptr<HostResolverImpl> resolver_;
@@ skipping 903 matching lines @@
   EXPECT_THAT(request->Resolve(), IsError(ERR_IO_PENDING));
   EXPECT_THAT(request->WaitForResult(), IsOk());
 }
 
 TEST_F(HostResolverImplTest, IsIPv6Reachable) {
   // The real HostResolverImpl is needed since TestHostResolverImpl will
   // bypass the IPv6 reachability tests.
   resolver_.reset(new HostResolverImpl(DefaultOptions(), nullptr));
 
   // Verify that two consecutive calls return the same value.
-  TestNetLog net_log;
-  BoundNetLog bound_net_log =
-      BoundNetLog::Make(&net_log, NetLogSourceType::NONE);
-  bool result1 = IsIPv6Reachable(bound_net_log);
-  bool result2 = IsIPv6Reachable(bound_net_log);
+  TestNetLog test_net_log;
+  NetLogWithSource net_log =
+      NetLogWithSource::Make(&test_net_log, NetLogSourceType::NONE);
+  bool result1 = IsIPv6Reachable(net_log);
+  bool result2 = IsIPv6Reachable(net_log);
   EXPECT_EQ(result1, result2);
 
   // Filter reachability check events and verify that there are two of them.
   TestNetLogEntry::List event_list;
-  net_log.GetEntries(&event_list);
+  test_net_log.GetEntries(&event_list);
   TestNetLogEntry::List probe_event_list;
   for (const auto& event : event_list) {
     if (event.type ==
         NetLogEventType::HOST_RESOLVER_IMPL_IPV6_REACHABILITY_CHECK) {
       probe_event_list.push_back(event);
     }
   }
   ASSERT_EQ(2U, probe_event_list.size());
 
   // Verify that the first request was not cached and the second one was.
@@ skipping 896 matching lines @@
   EXPECT_EQ(1, count2);
 
   // Make another request to make sure both callbacks were cleared.
   req = CreateRequest("just.testing", 80);
   EXPECT_THAT(req->Resolve(), IsOk());
   EXPECT_EQ(2, count1);
   EXPECT_EQ(1, count2);
 }
 
 }  // namespace net