Extracting NetLog inner classes into their own classes.

net/http/http_transaction_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/http/http_transaction_test_util.h"
 
 #include <algorithm>
 #include <unordered_map>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/clock.h"
 #include "base/time/time.h"
 #include "net/base/load_flags.h"
 #include "net/base/load_timing_info.h"
 #include "net/base/net_errors.h"
 #include "net/cert/x509_certificate.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_transaction.h"
+#include "net/log/net_log.h"
+#include "net/log/net_log_source.h"
+#include "net/log/net_log_with_source.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 using MockTransactionMap =
     std::unordered_map<std::string, const MockTransaction*>;
 static MockTransactionMap mock_transactions;
 }  // namespace
 
@@ skipping 186 matching lines @@
                                                MockNetworkLayer* factory)
     : request_(nullptr),
       data_cursor_(0),
       content_length_(0),
       priority_(priority),
       read_handler_(nullptr),
       websocket_handshake_stream_create_helper_(nullptr),
       transaction_factory_(factory->AsWeakPtr()),
       received_bytes_(0),
       sent_bytes_(0),
-      socket_log_id_(NetLog::Source::kInvalidId),
+      socket_log_id_(NetLogSource::kInvalidId),
       done_reading_called_(false),
       weak_factory_(this) {}
 
 MockNetworkTransaction::~MockNetworkTransaction() {}
 
 int MockNetworkTransaction::Start(const HttpRequestInfo* request,
                                   const CompletionCallback& callback,
                                   const NetLogWithSource& net_log) {
   if (request_)
     return ERR_FAILED;
@@ skipping 106 matching lines @@
     return LOAD_STATE_READING_RESPONSE;
   return LOAD_STATE_IDLE;
 }
 
 void MockNetworkTransaction::SetQuicServerInfo(
     QuicServerInfo* quic_server_info) {
 }
 
 bool MockNetworkTransaction::GetLoadTimingInfo(
     LoadTimingInfo* load_timing_info) const {
-  if (socket_log_id_ != NetLog::Source::kInvalidId) {
+  if (socket_log_id_ != NetLogSource::kInvalidId) {
     // The minimal set of times for a request that gets a response, assuming it
     // gets a new socket.
     load_timing_info->socket_reused = false;
     load_timing_info->socket_log_id = socket_log_id_;
     load_timing_info->connect_timing.connect_start = base::TimeTicks::Now();
     load_timing_info->connect_timing.connect_end = base::TimeTicks::Now();
     load_timing_info->send_start = base::TimeTicks::Now();
     load_timing_info->send_end = base::TimeTicks::Now();
   } else {
     // If there's no valid socket ID, just use the generic socket reused values.
@@ skipping 200 matching lines @@
       content.append(buf->data(), rv);
     else if (rv < 0)
       return rv;
   } while (rv > 0);
 
   result->swap(content);
   return OK;
 }
 
 }  // namespace net