Extracting NetLog inner classes into their own classes.

net/log/net_log_unittest.cc

 // Copyright (c) 2013 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/net_log.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
@@ skipping 48 matching lines @@
   TestNetLogEntry::List entries;
   net_log.GetEntries(&entries);
   EXPECT_EQ(0u, entries.size());
 
   net_log.AddGlobalEntry(NetLogEventType::CANCELLED);
 
   net_log.GetEntries(&entries);
   ASSERT_EQ(1u, entries.size());
   EXPECT_EQ(NetLogEventType::CANCELLED, entries[0].type);
   EXPECT_EQ(NetLogSourceType::NONE, entries[0].source.type);
-  EXPECT_NE(NetLog::Source::kInvalidId, entries[0].source.id);
+  EXPECT_NE(NetLogSource::kInvalidId, entries[0].source.id);
   EXPECT_EQ(NetLogEventPhase::NONE, entries[0].phase);
   EXPECT_GE(base::TimeTicks::Now(), entries[0].time);
   EXPECT_FALSE(entries[0].params);
 }
 
 // Check that the correct CaptureMode is sent to NetLog Value callbacks.
 TEST(NetLogTest, CaptureModes) {
   NetLogCaptureMode kModes[] = {
       NetLogCaptureMode::Default(),
       NetLogCaptureMode::IncludeCookiesAndCredentials(),
       NetLogCaptureMode::IncludeSocketBytes(),
   };
 
   TestNetLog net_log;
 
   for (NetLogCaptureMode mode : kModes) {
     net_log.SetCaptureMode(mode);
     EXPECT_EQ(mode, net_log.GetObserver()->capture_mode());
 
     net_log.AddGlobalEntry(NetLogEventType::SOCKET_ALIVE,
                            base::Bind(NetCaptureModeCallback));
 
     TestNetLogEntry::List entries;
     net_log.GetEntries(&entries);
 
     ASSERT_EQ(1u, entries.size());
     EXPECT_EQ(NetLogEventType::SOCKET_ALIVE, entries[0].type);
     EXPECT_EQ(NetLogSourceType::NONE, entries[0].source.type);
-    EXPECT_NE(NetLog::Source::kInvalidId, entries[0].source.id);
+    EXPECT_NE(NetLogSource::kInvalidId, entries[0].source.id);
     EXPECT_EQ(NetLogEventPhase::NONE, entries[0].phase);
     EXPECT_GE(base::TimeTicks::Now(), entries[0].time);
 
     int logged_capture_mode;
     ASSERT_TRUE(
         entries[0].GetIntegerValue("capture_mode", &logged_capture_mode));
     EXPECT_EQ(CaptureModeToInt(mode), logged_capture_mode);
 
     net_log.Clear();
   }
 }
 
 class CountingObserver : public NetLog::ThreadSafeObserver {
  public:
   CountingObserver() : count_(0) {}
 
   ~CountingObserver() override {
     if (net_log())
       net_log()->DeprecatedRemoveObserver(this);
   }
 
-  void OnAddEntry(const NetLog::Entry& entry) override { ++count_; }
+  void OnAddEntry(const NetLogEntry& entry) override { ++count_; }
 
   int count() const { return count_; }
 
  private:
   int count_;
 };
 
 class LoggingObserver : public NetLog::ThreadSafeObserver {
  public:
   LoggingObserver() {}
 
   ~LoggingObserver() override {
     if (net_log())
       net_log()->DeprecatedRemoveObserver(this);
   }
 
-  void OnAddEntry(const NetLog::Entry& entry) override {
+  void OnAddEntry(const NetLogEntry& entry) override {
     std::unique_ptr<base::DictionaryValue> dict =
         base::DictionaryValue::From(entry.ToValue());
     ASSERT_TRUE(dict);
     values_.push_back(std::move(dict));
   }
 
   size_t GetNumValues() const { return values_.size(); }
   base::DictionaryValue* GetValue(size_t index) const {
     return values_[index].get();
   }
@@ skipping 250 matching lines @@
   NetLog net_log;
 
   // Run a bunch of threads to completion, each of which will repeatedly add
   // and remove an observer, and set its logging level.
   RunTestThreads<AddRemoveObserverTestThread>(&net_log);
 }
 
 }  // namespace
 
 }  // namespace net