Remove the file thread dependency from FileNetLogObserver.

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>
 #include <utility>
 #include <vector>
 
 #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/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
+#include "base/task_scheduler/task_scheduler.h"
 #include "base/threading/thread.h"
 #include "base/values.h"
 #include "net/base/test_completion_callback.h"
 #include "net/log/net_log_entry.h"
 #include "net/log/net_log_event_type.h"
 #include "net/log/net_log_parameters_callback.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"
@@ skipping 118 matching lines @@
 }
 
 // Used for tests that are common to both bounded and unbounded modes of the
 // the FileNetLogObserver. The param is true if bounded mode is used.
 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());
   }
 
   void CreateAndStartObserving(std::unique_ptr<base::Value> constants) {
     bool bounded = GetParam();
     if (bounded) {
       logger_ = FileNetLogObserver::CreateBounded(
-          file_thread_->task_runner(), bounded_log_dir_, kLargeFileSize,
-          kTotalNumFiles, std::move(constants));
+          bounded_log_dir_, kLargeFileSize, kTotalNumFiles,
+          std::move(constants));
     } else {
-      logger_ = FileNetLogObserver::CreateUnbounded(file_thread_->task_runner(),
-                                                    unbounded_log_path_,
+      logger_ = FileNetLogObserver::CreateUnbounded(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 {
       base::ReadFileToString(unbounded_log_path_, &input);
     }
     return ParseNetLogString(input, root, events);
   }
 
   bool LogFilesExist() {
+    // The log files are written by a sequenced task runner. Drain all the
+    // scheduled tasks to ensure that the file writing ones have run before
+    // checking if they exist.
+    base::TaskScheduler::GetInstance()->FlushForTesting();
+
     bool bounded = GetParam();
     if (bounded) {
       if (base::PathExists(bounded_log_dir_.AppendASCII("constants.json")) ||
           base::PathExists(bounded_log_dir_.AppendASCII("end_netlog.json")))
         return true;
       for (int i = 0; i < kTotalNumFiles; i++) {
         if (base::PathExists(bounded_log_dir_.AppendASCII(
                 "event_file_" + std::to_string(i) + ".json")))
           return true;
       }
       return false;
     } else {
       return base::PathExists(unbounded_log_path_);
     }
   }
 
  protected:
   NetLog net_log_;
-  std::unique_ptr<base::Thread> file_thread_;
   std::unique_ptr<FileNetLogObserver> logger_;
 
  private:
   base::ScopedTempDir temp_dir_;
   base::FilePath bounded_log_dir_;
   base::FilePath unbounded_log_path_;
 };
 
 // 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());
   }
 
   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));
+        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);
   }
 
   base::FilePath GetEventFilePath(int index) const {
     return bounded_log_dir_.AppendASCII("event_file_" + std::to_string(index) +
                                         ".json");
   }
 
   static int64_t GetFileSize(const base::FilePath& path) {
     int64_t file_size;
     EXPECT_TRUE(base::GetFileSize(path, &file_size));
     return file_size;
   }
 
  protected:
   NetLog net_log_;
-  std::unique_ptr<base::Thread> file_thread_;
   std::unique_ptr<FileNetLogObserver> logger_;
 
  private:
   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));
 
+// Tests deleting a FileNetLogObserver without first calling StopObserving().
 TEST_P(FileNetLogObserverTest, ObserverDestroyedWithoutStopObserving) {
   CreateAndStartObserving(nullptr);
 
   // Send dummy event
   AddEntries(logger_.get(), 1, kDummyEventSize);
 
+  // The log files should have been started.
+  ASSERT_TRUE(LogFilesExist());
+
   logger_.reset();
-  file_thread_.reset();
 
+  // When the logger is re-set without having called StopObserving(), the
+  // partially written log files are deleted.
   ASSERT_FALSE(LogFilesExist());
 }
 
 TEST_P(FileNetLogObserverTest, GeneratesValidJSONWithNoEvents) {
   TestClosure closure;
 
   CreateAndStartObserving(nullptr);
 
   logger_->StopObserving(nullptr, closure.closure());
 
@@ skipping 496 matching lines @@
 
 void AddEntriesViaNetLog(NetLog* net_log, int num_entries) {
   for (int i = 0; i < num_entries; i++) {
     net_log->AddGlobalEntry(NetLogEventType::PAC_JAVASCRIPT_ERROR);
   }
 }
 
 TEST_P(FileNetLogObserverTest, AddEventsFromMultipleThreadsWithStopObserving) {
   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
+  // Start all the threads. Waiting for them to start is to hopefully 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();
   }
 
   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(&AddEntriesViaNetLog, base::Unretained(&net_log_),
                               kNumEventsAddedPerThread));
   }
 
   // Stop observing.
   TestClosure closure;
   logger_->StopObserving(nullptr, closure.closure());
   closure.WaitForResult();
 
   // Join all the threads.
   threads.clear();
+
+  ASSERT_TRUE(LogFilesExist());
 }
 
 TEST_P(FileNetLogObserverTest,
        AddEventsFromMultipleThreadsWithoutStopObserving) {
   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
+  // Start all the threads. Waiting for them to start is to hopefully 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();
   }
 
   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(&AddEntriesViaNetLog, base::Unretained(&net_log_),
                               kNumEventsAddedPerThread));
   }
 
   // Destroy logger.
   logger_.reset();
 
   // Join all the threads.
   threads.clear();
+
+  // The log file doesn't exist since StopObserving() was not called.
+  ASSERT_FALSE(LogFilesExist());
 }
 
 }  // namespace
 
 }  // namespace net