Add ongoing events to net-export log when logging starts

components/net_log/net_log_file_writer.h

 // 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.
 
 #ifndef COMPONENTS_NET_LOG_NET_LOG_FILE_WRITER_H_
 #define COMPONENTS_NET_LOG_NET_LOG_FILE_WRITER_H_
 
 #include <memory>
 #include <string>
 
@@ skipping 53 matching lines @@
 
   // Struct used to store the results of setting up the default log directory
   // and log path.
   struct DefaultLogPathResults {
     bool default_log_path_success;
     base::FilePath default_log_path;
     bool log_exists;
   };
 
   using FilePathCallback = base::Callback<void(const base::FilePath&)>;
-
   using DirectoryGetter = base::Callback<bool(base::FilePath*)>;
+  using URLRequestContextGetterList =
+      std::vector<scoped_refptr<net::URLRequestContextGetter>>;
 
   ~NetLogFileWriter();
 
   // Attaches a StateObserver. |observer| will be notified of state changes to
   // NetLogFileWriter. State changes may occur in response to Initiailze(),
   // StartNetLog(), or StopNetLog(). StateObserver::OnNewState() will be called
   // asynchronously relative to the command that caused the state change.
   // |observer| must remain alive until RemoveObserver() is called.
   void AddObserver(StateObserver* observer);
 
   // Detaches a StateObserver.
   void RemoveObserver(StateObserver* observer);
 
   // Initializes NetLogFileWriter if not initialized.
   //
   // Also sets the task runners used by NetLogFileWriter for doing file I/O and
   // network I/O respectively. The task runners must not be changed once set.
   // However, calling this function again with the same parameters is OK.
   void Initialize(scoped_refptr<base::SingleThreadTaskRunner> file_task_runner,
                   scoped_refptr<base::SingleThreadTaskRunner> net_task_runner);
 
   // Starts collecting NetLog data into the file at |log_path|. If |log_path| is
   // empty, the default log path is used. If NetLogFileWriter is already
   // logging, this is a no-op and |capture_mode| is ignored.
   void StartNetLog(const base::FilePath& log_path,
-                   net::NetLogCaptureMode capture_mode);
+                   net::NetLogCaptureMode capture_mode,
+                   const URLRequestContextGetterList& context_getters);

[eroman, 2017/02/21 22:14:23]

Please update the comments to mention what this does. In particular can you
clarify the following:

 * These contexts are optional
 * They are ONLY used for logging the outstanding requests when logging was
first started
 * They are not used for getting the polled data
 * Why there is an asymmetry in the API (starting takes a list, whereas stopping
takes a single one)
 * All the contexts must be bound to the same thread.

 
   // Stops collecting NetLog data into the file. It is a no-op if
   // NetLogFileWriter is currently not logging.
   //
   // |polled_data| is a JSON dictionary that will be appended to the end of the
   // log; it's for adding additional info to the log that aren't events.
   // If |context_getter| is not null, then  StopNetLog() will automatically
   // append net info (from net::GetNetInfo() retrieved using |context_getter|)
   // to |polled_data|.
   void StopNetLog(std::unique_ptr<base::DictionaryValue> polled_data,
@@ skipping 35 matching lines @@
   friend class ChromeNetLog;
   friend class NetLogFileWriterTest;
 
   // The possible logging states of NetLogFileWriter.
   enum State {
     STATE_UNINITIALIZED,
     // Currently in the process of initializing.
     STATE_INITIALIZING,
     // Not currently logging to file.
     STATE_NOT_LOGGING,
+    // Currently in the process of starting the log.
+    STATE_STARTING_LOG,
     // Currently logging to file.
     STATE_LOGGING,
     // Currently in the process of stopping the log.
     STATE_STOPPING_LOG,
   };
 
   void NotifyStateObservers();
 
   // Posts NotifyStateObservers() to the current thread.
   void NotifyStateObserversAsync();
 
   // Called internally by Initialize(). Will initialize NetLogFileWriter's state
   // variables after the default log directory is set up and the default log
-  // path is determined.
+  // path is determined on the |file_task_runner_|.
   void SetStateAfterSetUpDefaultLogPath(
       const DefaultLogPathResults& set_up_default_log_path_results);
 
-  // Called internally by StopNetLog(). Does the actual work needed by
-  // StopNetLog() outside of retrieving the net info.
+  // Called internally by StartNetLog(). Contains tasks to be done to start
+  // logging after net log entries for ongoing events are added to the log from
+  // the |net_task_runner_|.
+  void StartNetLogAfterCreateEntriesForActiveObjects(
+      net::NetLogCaptureMode capture_mode);
+
+  // Called internally by StopNetLog(). Contains tasks to be done to stop
+  // logging after net-thread polled data is retrieved on the
+  // |net_task_runner_|.
   void StopNetLogAfterAddNetInfo(
       std::unique_ptr<base::DictionaryValue> polled_data);
 
   // Contains tasks to be done after |file_net_log_observer_| has completely
   // stopped writing.
   void ResetObserverThenSetStateNotLogging();
 
   // All members are accessed solely from the main thread (the thread that
   // |thread_checker_| is bound to).
 
@@ skipping 31 matching lines @@
   DirectoryGetter default_log_base_dir_getter_;
 
   base::WeakPtrFactory<NetLogFileWriter> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(NetLogFileWriter);
 };
 
 }  // namespace net_log
 
 #endif  // COMPONENTS_NET_LOG_NET_LOG_FILE_WRITER_H_