Add ongoing events to net-export log when logging starts

components/net_log/net_log_file_writer_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 "components/net_log/net_log_file_writer.h"
 
 #include <stdint.h>
 
 #include <memory>
 
@@ skipping 28 matching lines @@
 base::FilePath::CharType kLogRelativePath[] =
     FILE_PATH_LITERAL("net-export/chrome-net-export-log.json");
 
 const char kCaptureModeDefaultString[] = "STRIP_PRIVATE_DATA";
 const char kCaptureModeIncludeCookiesAndCredentialsString[] = "NORMAL";
 const char kCaptureModeIncludeSocketBytesString[] = "LOG_BYTES";
 
 const char kStateUninitializedString[] = "UNINITIALIZED";
 const char kStateInitializingString[] = "INITIALIZING";
 const char kStateNotLoggingString[] = "NOT_LOGGING";
+const char kStateStartingLogString[] = "STARTING_LOG";
 const char kStateLoggingString[] = "LOGGING";
 const char kStateStoppingLogString[] = "STOPPING_LOG";
 }  // namespace
 
 namespace net_log {
 
 // Sets |path| to |path_to_return| and always returns true. This function is
 // used to override NetLogFileWriter's usual getter for the default log base
 // directory.
 bool SetPathToGivenAndReturnTrue(const base::FilePath& path_to_return,
@@ skipping 246 matching lines @@
 
     return ::testing::AssertionSuccess();
   }
 
   // If |custom_log_path| is empty path, |net_log_file_writer_| will use its
   // default log path, which is cached in |default_log_path_|.
   WARN_UNUSED_RESULT ::testing::AssertionResult StartThenVerifyNewState(
       const base::FilePath& custom_log_path,
       net::NetLogCaptureMode capture_mode,
       const std::string& expected_capture_mode_string) {
-    net_log_file_writer_.StartNetLog(custom_log_path, capture_mode);
+    net_log_file_writer_.StartNetLog(custom_log_path, capture_mode, {});
     std::unique_ptr<base::DictionaryValue> state =
         test_state_observer_.WaitForNewState();
     ::testing::AssertionResult result =
-        VerifyState(std::move(state), kStateLoggingString, true, true,
-                    expected_capture_mode_string);
+        VerifyState(std::move(state), kStateStartingLogString);
     if (!result) {
       return ::testing::AssertionFailure()
              << "First state after StartNetLog() does not match expected:"
              << std::endl
              << result.message();
     }
 
+    state = test_state_observer_.WaitForNewState();
+    result = VerifyState(std::move(state), kStateLoggingString, true, true,
+                         expected_capture_mode_string);
+    if (!result) {
+      return ::testing::AssertionFailure()
+             << "Second state after StartNetLog() does not match expected:"
+             << std::endl
+             << result.message();
+    }
+
     // Make sure GetFilePath() returns empty path when logging.
     base::FilePath actual_log_path = FileWriterGetFilePathToCompletedLog();
     if (!actual_log_path.empty()) {
       return ::testing::AssertionFailure()
              << "GetFilePath() should return empty path after logging starts."
              << " Actual: " << ::testing::PrintToString(actual_log_path);
     }
 
     return ::testing::AssertionSuccess();
   }
@@ skipping 123 matching lines @@
 
   // For each capture mode, start and stop |net_log_file_writer_| in that mode.
   for (int i = 0; i < 3; ++i) {
     // StartNetLog(), should result in state change.
     ASSERT_TRUE(StartThenVerifyNewState(base::FilePath(), capture_modes[i],
                                         capture_mode_strings[i]));
 
     // Calling StartNetLog() again should be a no-op. Try doing StartNetLog()
     // with various capture modes; they should all be ignored and result in no
     // state change.
-    net_log_file_writer_.StartNetLog(base::FilePath(), capture_modes[i]);
+    net_log_file_writer_.StartNetLog(base::FilePath(), capture_modes[i], {});
     net_log_file_writer_.StartNetLog(base::FilePath(),
-                                     capture_modes[(i + 1) % 3]);
+                                     capture_modes[(i + 1) % 3], {});
     net_log_file_writer_.StartNetLog(base::FilePath(),
-                                     capture_modes[(i + 2) % 3]);
+                                     capture_modes[(i + 2) % 3], {});
 
     // StopNetLog(), should result in state change. The capture mode should
     // match that of the first StartNetLog() call (called by
     // StartThenVerifyNewState()).
     ASSERT_TRUE(StopThenVerifyNewStateAndFile(
         base::FilePath(), nullptr, nullptr, capture_mode_strings[i]));
 
     // Stopping a second time should be a no-op.
     net_log_file_writer_.StopNetLog(nullptr, nullptr);
   }
@@ skipping 170 matching lines @@
   // Trigger initialization of |net_log_file_writer_|.
   net_log_file_writer_.Initialize(file_thread_.task_runner(),
                                   net_thread_.task_runner());
 
   // Before running the main message loop, tell |net_log_file_writer_| to start
   // logging. Not running the main message loop prevents the initialization
   // process from completing, so this ensures that StartNetLog() is received
   // before |net_log_file_writer_| finishes initialization, which means this
   // should be a no-op.
   net_log_file_writer_.StartNetLog(base::FilePath(),
-                                   net::NetLogCaptureMode::Default());
+                                   net::NetLogCaptureMode::Default(), {});
 
   // Now run the main message loop. Make sure StartNetLog() was ignored by
   // checking that the next two states are "initializing" followed by
   // "not-logging".
   std::unique_ptr<base::DictionaryValue> state =
       test_state_observer_.WaitForNewState();
   ASSERT_TRUE(VerifyState(std::move(state), kStateInitializingString));
   state = test_state_observer_.WaitForNewState();
   ASSERT_TRUE(
       VerifyState(std::move(state), kStateNotLoggingString, false, false, ""));
 }
 
 TEST_F(NetLogFileWriterTest, ReceiveStartWhileStoppingLog) {
   ASSERT_TRUE(InitializeThenVerifyNewState(true, false));
 
   // Call StartNetLog() on |net_log_file_writer_| and wait for the state change.
   ASSERT_TRUE(StartThenVerifyNewState(
       base::FilePath(), net::NetLogCaptureMode::IncludeSocketBytes(),
       kCaptureModeIncludeSocketBytesString));
 
   // Tell |net_log_file_writer_| to stop logging.
   net_log_file_writer_.StopNetLog(nullptr, nullptr);
 
   // Before running the main message loop, tell |net_log_file_writer_| to start
   // logging. Not running the main message loop prevents the stopping process
   // from completing, so this ensures StartNetLog() is received before
   // |net_log_file_writer_| finishes stopping, which means this should be a
   // no-op.
   net_log_file_writer_.StartNetLog(base::FilePath(),
-                                   net::NetLogCaptureMode::Default());
+                                   net::NetLogCaptureMode::Default(), {});
 
   // Now run the main message loop. Make sure the last StartNetLog() was
   // ignored by checking that the next two states are "stopping-log" followed by
   // "not-logging". Also make sure the capture mode matches that of the first
   // StartNetLog() call (called by StartThenVerifyState()).
   std::unique_ptr<base::DictionaryValue> state =
       test_state_observer_.WaitForNewState();
   ASSERT_TRUE(VerifyState(std::move(state), kStateStoppingLogString));
   state = test_state_observer_.WaitForNewState();
   ASSERT_TRUE(VerifyState(std::move(state), kStateNotLoggingString, true, true,
                           kCaptureModeIncludeSocketBytesString));
 }
 
 }  // namespace net_log