Extracting NetLog inner classes into their own classes.

net/socket/transport_client_socket_pool_test_util.cc

 // Copyright 2014 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/socket/transport_client_socket_pool_test_util.h"
 
 #include <stdint.h>
 #include <string>
 #include <utility>
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "net/base/ip_address.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/load_timing_info.h"
 #include "net/base/load_timing_info_test_util.h"
+#include "net/log/net_log_source.h"
 #include "net/log/net_log_source_type.h"
+#include "net/log/net_log_with_source.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/udp/datagram_client_socket.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
 IPAddress ParseIP(const std::string& ip) {
@@ skipping 277 matching lines @@
 
 }  // namespace
 
 void TestLoadTimingInfoConnectedReused(const ClientSocketHandle& handle) {
   LoadTimingInfo load_timing_info;
   // Only pass true in as |is_reused|, as in general, HttpStream types should
   // have stricter concepts of reuse than socket pools.
   EXPECT_TRUE(handle.GetLoadTimingInfo(true, &load_timing_info));
 
   EXPECT_TRUE(load_timing_info.socket_reused);
-  EXPECT_NE(NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
+  EXPECT_NE(NetLogSource::kInvalidId, load_timing_info.socket_log_id);
 
   ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing);
   ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info);
 }
 
 void TestLoadTimingInfoConnectedNotReused(const ClientSocketHandle& handle) {
   EXPECT_FALSE(handle.is_reused());
 
   LoadTimingInfo load_timing_info;
   EXPECT_TRUE(handle.GetLoadTimingInfo(false, &load_timing_info));
 
   EXPECT_FALSE(load_timing_info.socket_reused);
-  EXPECT_NE(NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
+  EXPECT_NE(NetLogSource::kInvalidId, load_timing_info.socket_log_id);
 
   ExpectConnectTimingHasTimes(load_timing_info.connect_timing,
                               CONNECT_TIMING_HAS_DNS_TIMES);
   ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info);
 
   TestLoadTimingInfoConnectedReused(handle);
 }
 
 void SetIPv4Address(IPEndPoint* address) {
   *address = IPEndPoint(ParseIP("1.1.1.1"), 80);
@@ skipping 14 matching lines @@
       delay_(base::TimeDelta::FromMilliseconds(
           ClientSocketPool::kMaxConnectRetryIntervalMs)) {}
 
 MockTransportClientSocketFactory::~MockTransportClientSocketFactory() {}
 
 std::unique_ptr<DatagramClientSocket>
 MockTransportClientSocketFactory::CreateDatagramClientSocket(
     DatagramSocket::BindType bind_type,
     const RandIntCallback& rand_int_cb,
     NetLog* net_log,
-    const NetLog::Source& source) {
+    const NetLogSource& source) {
   NOTREACHED();
   return std::unique_ptr<DatagramClientSocket>();
 }
 
 std::unique_ptr<StreamSocket>
 MockTransportClientSocketFactory::CreateTransportClientSocket(
     const AddressList& addresses,
     std::unique_ptr<SocketPerformanceWatcher> /* socket_performance_watcher */,
     NetLog* /* net_log */,
-    const NetLog::Source& /* source */) {
+    const NetLogSource& /* source */) {
   allocation_count_++;
 
   ClientSocketType type = client_socket_type_;
   if (client_socket_types_ && client_socket_index_ < client_socket_index_max_) {
     type = client_socket_types_[client_socket_index_++];
   }
 
   switch (type) {
     case MOCK_CLIENT_SOCKET:
       return std::unique_ptr<StreamSocket>(
@@ skipping 68 matching lines @@
     run_loop_quit_closure_ = run_loop.QuitClosure();
     run_loop.Run();
     run_loop_quit_closure_.Reset();
   }
   base::Closure trigger = triggerable_sockets_.front();
   triggerable_sockets_.pop();
   return trigger;
 }
 
 }  // namespace net