Extracting NetLog inner classes into their own classes.

net/log/bounded_file_net_log_observer_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/log/bounded_file_net_log_observer.h"
 
 #include <math.h>
 
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "net/base/test_completion_callback.h"
-#include "net/log/net_log.h"
+#include "net/log/net_log_entry.h"
 #include "net/log/net_log_event_type.h"
+#include "net/log/net_log_parameters_callback_typedef.h"
+#include "net/log/net_log_source.h"
 #include "net/log/net_log_source_type.h"
 #include "net/log/net_log_util.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
@@ skipping 54 matching lines @@
   // Sends |num_entries_to_add| number of events of size |entry_size| to
   // |logger_|.
   //
   // |entry_size| must be >= 101, since the size of entries without a message,
   // |base_entry_size|, is dependent on TimeTicks formatting, and
   // |base_entry_size| can be up to 101 and cannot be shortened.
   void AddEntries(int num_entries_to_add, size_t entry_size) {
     // Get base size of event.
     const int kDummyId = 0;
     std::string message = "";
-    NetLog::ParametersCallback callback =
+    NetLogParametersCallback callback =
         NetLog::StringCallback("message", &message);
-    NetLog::Source source(NetLogSourceType::HTTP2_SESSION, kDummyId);
-    NetLog::EntryData base_entry_data(NetLogEventType::PAC_JAVASCRIPT_ERROR,
-                                      source, NetLogEventPhase::BEGIN,
-                                      base::TimeTicks::Now(), &callback);
-    NetLog::Entry base_entry(&base_entry_data,
-                             NetLogCaptureMode::IncludeSocketBytes());
+    NetLogSource source(NetLogSourceType::HTTP2_SESSION, kDummyId);
+    NetLogEntryData base_entry_data(NetLogEventType::PAC_JAVASCRIPT_ERROR,
+                                    source, NetLogEventPhase::BEGIN,
+                                    base::TimeTicks::Now(), &callback);
+    NetLogEntry base_entry(&base_entry_data,
+                           NetLogCaptureMode::IncludeSocketBytes());
     std::unique_ptr<base::Value> value(base_entry.ToValue());
     std::string json;
     base::JSONWriter::Write(*value, &json);
     size_t base_entry_size = json.size();
 
     // The maximum value of base::TimeTicks::Now() will be the maximum value of
     // int64_t, and if the maximum number of digits are included, the
     // |base_entry_size| could be up to 101 characters. Check that the event
     // format does not include additional padding.
     DCHECK_LE(base_entry_size, 101u);
 
     // |entry_size| should be at least as big as the largest possible base
     // entry.
     EXPECT_GE(entry_size, 101u);
 
     // |entry_size| cannot be smaller than the minimum event size.
     EXPECT_GE(entry_size, base_entry_size);
 
     for (int i = 0; i < num_entries_to_add; i++) {
-      source = NetLog::Source(NetLogSourceType::HTTP2_SESSION, i);
+      source = NetLogSource(NetLogSourceType::HTTP2_SESSION, i);
       std::string id = std::to_string(i);
 
       // String size accounts for the number of digits in id so that all events
       // are the same size.
       message = std::string(entry_size - base_entry_size - id.size() + 1, 'x');
       callback = NetLog::StringCallback("message", &message);
-      NetLog::EntryData entry_data(NetLogEventType::PAC_JAVASCRIPT_ERROR,
-                                   source, NetLogEventPhase::BEGIN,
-                                   base::TimeTicks::Now(), &callback);
-      NetLog::Entry entry(&entry_data, NetLogCaptureMode::IncludeSocketBytes());
+      NetLogEntryData entry_data(NetLogEventType::PAC_JAVASCRIPT_ERROR, source,
+                                 NetLogEventPhase::BEGIN,
+                                 base::TimeTicks::Now(), &callback);
+      NetLogEntry entry(&entry_data, NetLogCaptureMode::IncludeSocketBytes());
       logger_->OnAddEntry(entry);
     }
   }
 
  protected:
   base::FilePath log_path_;
   NetLog net_log_;
   std::unique_ptr<base::Thread> file_thread_;
   std::unique_ptr<BoundedFileNetLogObserver> logger_;
 
@@ skipping 703 matching lines @@
   ASSERT_EQ(1u, events->GetSize());
 
   // Make sure additional information is present, but don't validate it.
   base::DictionaryValue* tab_info;
   ASSERT_TRUE(dict->GetDictionary("tabInfo", &tab_info));
 }
 
 }  // namespace
 
 }  // namespace net