Add ongoing events to net-export log when logging starts

net/log/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/file_net_log_observer.h"
 
 #include <math.h>
 
 #include <memory>
 #include <string>
@@ skipping 144 matching lines @@
 class FileNetLogObserverTest : public ::testing::TestWithParam<bool> {
  public:
   void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     bounded_log_dir_ = temp_dir_.GetPath();
     unbounded_log_path_ = bounded_log_dir_.AppendASCII("net-log.json");
     file_thread_.reset(new base::Thread("NetLog File Thread"));
     file_thread_->StartWithOptions(
         base::Thread::Options(base::MessageLoop::TYPE_DEFAULT, 0));
     ASSERT_TRUE(file_thread_->WaitUntilThreadStarted());
-    logger_.reset(new FileNetLogObserver(file_thread_->task_runner()));
   }
 
-  void StartObserving(std::unique_ptr<base::Value> constants,
-                      URLRequestContext* url_request_context) {
+  void CreateAndStartObserving(std::unique_ptr<base::Value> constants) {
     bool bounded = GetParam();
     if (bounded) {
-      logger_->StartObservingBounded(&net_log_, NetLogCaptureMode::Default(),
-                                     bounded_log_dir_, std::move(constants),
-                                     url_request_context, kLargeFileSize,
-                                     kTotalNumFiles);
+      logger_ = FileNetLogObserver::CreateBounded(
+          file_thread_->task_runner(), bounded_log_dir_, kLargeFileSize,
+          kTotalNumFiles, std::move(constants));
     } else {
-      logger_->StartObservingUnbounded(
-          &net_log_, NetLogCaptureMode::Default(), unbounded_log_path_,
-          std::move(constants), url_request_context);
+      logger_ = FileNetLogObserver::CreateUnbounded(file_thread_->task_runner(),
+                                                    unbounded_log_path_,
+                                                    std::move(constants));
     }
+
+    logger_->StartObserving(&net_log_, NetLogCaptureMode::Default());
   }
 
   ::testing::AssertionResult ReadNetLogFromDisk(
       std::unique_ptr<base::Value>* root,
       base::ListValue** events) {
     bool bounded = GetParam();
     std::string input;
     if (bounded) {
       ReadBoundedLogFiles(bounded_log_dir_, &input);
     } else {
@@ skipping 33 matching lines @@
 // Used for tests that are exclusive to the bounded mode of FileNetLogObserver.
 class FileNetLogObserverBoundedTest : public ::testing::Test {
  public:
   void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     bounded_log_dir_ = temp_dir_.GetPath();
     file_thread_.reset(new base::Thread("NetLog File Thread"));
     file_thread_->StartWithOptions(
         base::Thread::Options(base::MessageLoop::TYPE_DEFAULT, 0));
     ASSERT_TRUE(file_thread_->WaitUntilThreadStarted());
-    logger_.reset(new FileNetLogObserver(file_thread_->task_runner()));
   }
 
-  void StartObserving(std::unique_ptr<base::Value> constants,
-                      URLRequestContext* url_request_context,
-                      int total_file_size,
-                      int num_files) {
-    logger_->StartObservingBounded(
-        &net_log_, NetLogCaptureMode::Default(), bounded_log_dir_,
-        std::move(constants), url_request_context, total_file_size, num_files);
+  void CreateAndStartObserving(std::unique_ptr<base::Value> constants,
+                               int total_file_size,
+                               int num_files) {
+    logger_ = FileNetLogObserver::CreateBounded(
+        file_thread_->task_runner(), bounded_log_dir_, total_file_size,
+        num_files, std::move(constants));
+    logger_->StartObserving(&net_log_, NetLogCaptureMode::Default());
   }
 
   ::testing::AssertionResult ReadNetLogFromDisk(
       std::unique_ptr<base::Value>* root,
       base::ListValue** events) {
     std::string input;
     ReadBoundedLogFiles(bounded_log_dir_, &input);
     return ParseNetLogString(input, root, events);
   }
 
@@ skipping 17 matching lines @@
   base::ScopedTempDir temp_dir_;
   base::FilePath bounded_log_dir_;
 };
 
 // Instantiates each FileNetLogObserverTest to use bounded and unbounded modes.
 INSTANTIATE_TEST_CASE_P(,
                         FileNetLogObserverTest,
                         ::testing::Values(true, false));
 
 TEST_P(FileNetLogObserverTest, ObserverDestroyedWithoutStopObserving) {
-  StartObserving(nullptr, nullptr);
+  CreateAndStartObserving(nullptr);
 
   // Send dummy event
   AddEntries(logger_.get(), 1, kDummyEventSize);
 
   logger_.reset();
   file_thread_.reset();
 
   ASSERT_FALSE(LogFilesExist());
 }
 
 TEST_P(FileNetLogObserverTest, GeneratesValidJSONWithNoEvents) {
   TestClosure closure;
 
-  StartObserving(nullptr, nullptr);
+  CreateAndStartObserving(nullptr);
 
   logger_->StopObserving(nullptr, closure.closure());
 
   closure.WaitForResult();
 
   std::unique_ptr<base::Value> root;
   base::ListValue* events;
   ASSERT_TRUE(ReadNetLogFromDisk(&root, &events));
 
   // Check that there are no events
   ASSERT_EQ(0u, events->GetSize());
 
   // Check that constants are printed
   base::DictionaryValue* dict;
   ASSERT_TRUE(root->GetAsDictionary(&dict));
   base::DictionaryValue* constants;
   ASSERT_TRUE(dict->GetDictionary("constants", &constants));
 }
 
 TEST_P(FileNetLogObserverTest, GeneratesValidJSONWithOneEvent) {
   TestClosure closure;
 
-  StartObserving(nullptr, nullptr);
+  CreateAndStartObserving(nullptr);
 
   // Send dummy event.
   AddEntries(logger_.get(), 1, kDummyEventSize);
 
   logger_->StopObserving(nullptr, closure.closure());
 
   closure.WaitForResult();
 
   std::unique_ptr<base::Value> root;
   base::ListValue* events;
   ASSERT_TRUE(ReadNetLogFromDisk(&root, &events));
 
   // Check that there is 1 event written.
   ASSERT_EQ(1u, events->GetSize());
 }
 
 TEST_P(FileNetLogObserverTest, CustomConstants) {
   TestClosure closure;
 
   const char kConstantString[] = "awesome constant";
   std::unique_ptr<base::Value> constants(
       new base::StringValue(kConstantString));
 
-  StartObserving(std::move(constants), nullptr);
+  CreateAndStartObserving(std::move(constants));
 
   logger_->StopObserving(nullptr, closure.closure());
 
   closure.WaitForResult();
 
   std::unique_ptr<base::Value> root;
   base::ListValue* events;
   ASSERT_TRUE(ReadNetLogFromDisk(&root, &events));
 
   // Check that custom constant was correctly printed.
   base::DictionaryValue* dict;
   ASSERT_TRUE(root->GetAsDictionary(&dict));
   std::string constants_string;
   ASSERT_TRUE(dict->GetString("constants", &constants_string));
   ASSERT_EQ(kConstantString, constants_string);
 }
 
 TEST_P(FileNetLogObserverTest, GeneratesValidJSONWithPolledData) {
   TestClosure closure;
 
-  StartObserving(nullptr, nullptr);
+  CreateAndStartObserving(nullptr);
 
   // Create dummy polled data
   const char kDummyPolledDataPath[] = "dummy_path";
   const char kDummyPolledDataString[] = "dummy_info";
   std::unique_ptr<base::DictionaryValue> dummy_polled_data =
       base::MakeUnique<base::DictionaryValue>();
   dummy_polled_data->SetString(kDummyPolledDataPath, kDummyPolledDataString);
 
   logger_->StopObserving(std::move(dummy_polled_data), closure.closure());
 
   closure.WaitForResult();
 
   std::unique_ptr<base::Value> root;
   base::ListValue* events;
   ASSERT_TRUE(ReadNetLogFromDisk(&root, &events));
 
   // Check that no events were written.
   ASSERT_EQ(0u, events->GetSize());
 
   // Make sure additional information is present and validate it.
   base::DictionaryValue* dict;
   ASSERT_TRUE(root->GetAsDictionary(&dict));
   base::DictionaryValue* polled_data;
   std::string dummy_string;
   ASSERT_TRUE(dict->GetDictionary("polledData", &polled_data));
   ASSERT_TRUE(polled_data->GetString(kDummyPolledDataPath, &dummy_string));
   ASSERT_EQ(dummy_string, kDummyPolledDataString);
 }
 
-TEST_P(FileNetLogObserverTest,
-       GeneratesValidJSONWithPolledDataWithActiveRequest) {
-  TestClosure closure;
-
-  // Create context, start a request.
-  TestURLRequestContext context(true);
-  context.set_net_log(&net_log_);
-  context.Init();
-  TestDelegate delegate;
-  delegate.set_quit_on_complete(false);
-
-  // URL doesn't matter.  Requests can't fail synchronously.
-  std::unique_ptr<URLRequest> request(
-      context.CreateRequest(GURL("blah:blah"), IDLE, &delegate));
-  request->Start();
-
-  StartObserving(nullptr, &context);
-
-  logger_->StopObserving(net::GetNetInfo(&context, NET_INFO_ALL_SOURCES),
-                         closure.closure());
-
-  closure.WaitForResult();
-
-  std::unique_ptr<base::Value> root;
-  base::ListValue* events;
-  ASSERT_TRUE(ReadNetLogFromDisk(&root, &events));
-
-  // Check that 1 event was written
-  ASSERT_EQ(1u, events->GetSize());
-
-  // Make sure additional information is present, but don't validate it.
-  base::DictionaryValue* dict;
-  ASSERT_TRUE(root->GetAsDictionary(&dict));
-  base::DictionaryValue* polled_data;
-  ASSERT_TRUE(dict->GetDictionary("polledData", &polled_data));
-}
-
 // Adds events concurrently from several different threads. The exact order of
 // events seen by this test is non-deterministic.
 TEST_P(FileNetLogObserverTest, AddEventsFromMultipleThreads) {
   const size_t kNumThreads = 10;
   std::vector<std::unique_ptr<base::Thread>> threads(kNumThreads);
   // Start all the threads. Waiting for them to start is to hopefuly improve
   // the odds of hitting interesting races once events start being added.
   for (size_t i = 0; i < threads.size(); ++i) {
     threads[i] = base::MakeUnique<base::Thread>(
         base::StringPrintf("WorkerThread%i", static_cast<int>(i)));
     threads[i]->Start();
     threads[i]->WaitUntilThreadStarted();
   }
 
-  StartObserving(nullptr, nullptr);
+  CreateAndStartObserving(nullptr);
 
   const size_t kNumEventsAddedPerThread = 200;
 
   // Add events in parallel from all the threads.
   for (size_t i = 0; i < kNumThreads; ++i) {
     threads[i]->task_runner()->PostTask(
         FROM_HERE, base::Bind(&AddEntries, base::Unretained(logger_.get()),
                               kNumEventsAddedPerThread, kDummyEventSize));
   }
 
@@ skipping 15 matching lines @@
 // Sends enough events to the observer to completely fill one file, but not
 // write any events to an additional file. Checks the file bounds.
 TEST_F(FileNetLogObserverBoundedTest, EqualToOneFile) {
   // The total size of the events is equal to the size of one file.
   // |kNumEvents| * |kEventSize| = |kTotalFileSize| / |kTotalNumEvents|
   const int kTotalFileSize = 5000;
   const int kNumEvents = 2;
   const int kEventSize = 250;
   TestClosure closure;
 
-  StartObserving(nullptr, nullptr, kTotalFileSize, kTotalNumFiles);
+  CreateAndStartObserving(nullptr, kTotalFileSize, kTotalNumFiles);
 
   AddEntries(logger_.get(), kNumEvents, kEventSize);
   logger_->StopObserving(nullptr, closure.closure());
 
   closure.WaitForResult();
 
   std::unique_ptr<base::Value> root;
   base::ListValue* events;
   ASSERT_TRUE(ReadNetLogFromDisk(&root, &events));
 
@@ skipping 26 matching lines @@
   // The total size of the events is greater than the size of one file, and
   // less than the size of two files. The total size of all events except one
   // is equal to the size of one file, so the last event will be the only event
   // in the second file.
   // (|kNumEvents| - 1) * kEventSize = |kTotalFileSize| / |kTotalNumEvents|
   const int kTotalFileSize = 6000;
   const int kNumEvents = 4;
   const int kEventSize = 200;
   TestClosure closure;
 
-  StartObserving(nullptr, nullptr, kTotalFileSize, kTotalNumFiles);
+  CreateAndStartObserving(nullptr, kTotalFileSize, kTotalNumFiles);
 
   AddEntries(logger_.get(), kNumEvents, kEventSize);
 
   logger_->StopObserving(nullptr, closure.closure());
 
   closure.WaitForResult();
 
   std::unique_ptr<base::Value> root;
   base::ListValue* events;
   ASSERT_TRUE(ReadNetLogFromDisk(&root, &events));
@@ skipping 20 matching lines @@
 
 // Sends enough events to the observer to completely fill two files.
 TEST_F(FileNetLogObserverBoundedTest, EqualToTwoFiles) {
   // The total size of the events is equal to the total size of two files.
   // |kNumEvents| * |kEventSize| = 2 * |kTotalFileSize| / |kTotalNumEvents|
   const int kTotalFileSize = 6000;
   const int kNumEvents = 6;
   const int kEventSize = 200;
   TestClosure closure;
 
-  StartObserving(nullptr, nullptr, kTotalFileSize, kTotalNumFiles);
+  CreateAndStartObserving(nullptr, kTotalFileSize, kTotalNumFiles);
 
   AddEntries(logger_.get(), kNumEvents, kEventSize);
 
   logger_->StopObserving(nullptr, closure.closure());
 
   closure.WaitForResult();
 
   std::unique_ptr<base::Value> root;
   base::ListValue* events;
   ASSERT_TRUE(ReadNetLogFromDisk(&root, &events));
@@ skipping 31 matching lines @@
 // overwritten.
 TEST_F(FileNetLogObserverBoundedTest, FillAllFilesNoOverwriting) {
   // The total size of events is equal to the total size of all files.
   // |kEventSize| * |kNumEvents| = |kTotalFileSize|
   const int kTotalFileSize = 10000;
   const int kEventSize = 200;
   const int kFileSize = kTotalFileSize / kTotalNumFiles;
   const int kNumEvents = kTotalNumFiles * ((kFileSize - 1) / kEventSize + 1);
   TestClosure closure;
 
-  StartObserving(nullptr, nullptr, kTotalFileSize, kTotalNumFiles);
+  CreateAndStartObserving(nullptr, kTotalFileSize, kTotalNumFiles);
 
   AddEntries(logger_.get(), kNumEvents, kEventSize);
 
   logger_->StopObserving(nullptr, closure.closure());
 
   closure.WaitForResult();
 
   std::unique_ptr<base::Value> root;
   base::ListValue* events;
   ASSERT_TRUE(ReadNetLogFromDisk(&root, &events));
@@ skipping 25 matching lines @@
   // The total size of events is greater than the WriteQueue's memory limit, so
   // the oldest event must be dropped from the queue and not written to any
   // file.
   // |kNumEvents| * |kEventSize| > |kTotalFileSize| * 2
   const int kTotalFileSize = 1000;
   const int kNumEvents = 11;
   const int kEventSize = 200;
   const int kFileSize = kTotalFileSize / kTotalNumFiles;
   TestClosure closure;
 
-  StartObserving(nullptr, nullptr, kTotalFileSize, kTotalNumFiles);
+  CreateAndStartObserving(nullptr, kTotalFileSize, kTotalNumFiles);
 
   AddEntries(logger_.get(), kNumEvents, kEventSize);
 
   logger_->StopObserving(nullptr, closure.closure());
 
   closure.WaitForResult();
 
   std::unique_ptr<base::Value> root;
   base::ListValue* events;
   ASSERT_TRUE(ReadNetLogFromDisk(&root, &events));
@@ skipping 30 matching lines @@
   // The total size of the events is much greater than twice the number of
   // events that can fit in the event files, to make sure that the extra events
   // are written to a file, not just dropped from the queue.
   // |kNumEvents| * |kEventSize| >= 2 * |kTotalFileSize|
   const int kTotalFileSize = 6000;
   const int kNumEvents = 60;
   const int kEventSize = 200;
   const int kFileSize = kTotalFileSize / kTotalNumFiles;
   TestClosure closure;
 
-  StartObserving(nullptr, nullptr, kTotalFileSize, kTotalNumFiles);
+  CreateAndStartObserving(nullptr, kTotalFileSize, kTotalNumFiles);
 
   AddEntries(logger_.get(), kNumEvents, kEventSize);
 
   logger_->StopObserving(nullptr, closure.closure());
 
   closure.WaitForResult();
 
   std::unique_ptr<base::Value> root;
   base::ListValue* events;
   ASSERT_TRUE(ReadNetLogFromDisk(&root, &events));
@@ skipping 51 matching lines @@
   // than twice the number of event files, so not every file will need to be
   // overwritten.
   // |kTotalFileSize| < |kNumEvents| * |kEventSize|
   // |kNumEvents| * |kEventSize| <= (2 * |kTotalNumFiles| - 1) * |kFileSize|
   const int kTotalFileSize = 6000;
   const int kNumEvents = 50;
   const int kEventSize = 200;
   const int kFileSize = kTotalFileSize / kTotalNumFiles;
   TestClosure closure;
 
-  StartObserving(nullptr, nullptr, kTotalFileSize, kTotalNumFiles);
+  CreateAndStartObserving(nullptr, kTotalFileSize, kTotalNumFiles);
 
   AddEntries(logger_.get(), kNumEvents, kEventSize);
 
   logger_->StopObserving(nullptr, closure.closure());
 
   closure.WaitForResult();
 
   std::unique_ptr<base::Value> root;
   base::ListValue* events;
   ASSERT_TRUE(ReadNetLogFromDisk(&root, &events));
@@ skipping 27 matching lines @@
   // Check that there are events written to all files.
   for (int i = 0; i < kTotalNumFiles; i++) {
     ASSERT_GE(GetFileSize(GetEventFilePath(i)),
               static_cast<int64_t>(kEventSize));
   }
 }
 
 }  // namespace
 
 }  // namespace net