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.
+  //
+  // |context_getters| is an optional list of URLRequestContextGetters used only
+  // to add log entries for ongoing events when logging starts. They are not
+  // used for retrieving polled data.
   void StartNetLog(const base::FilePath& log_path,
-                   net::NetLogCaptureMode capture_mode);
+                   net::NetLogCaptureMode capture_mode,
+                   const URLRequestContextGetterList& context_getters);
 
   // 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|.
+  // Note that StopNetLog() accepts (optionally) only one context getter for
+  // retrieving net polled data as opposed to StartNetLog() which accepts zero
+  // or more context getters for retrieving ongoing net events.
   void StopNetLog(std::unique_ptr<base::DictionaryValue> polled_data,
                   scoped_refptr<net::URLRequestContextGetter> context_getter);
 
   // Creates a DictionaryValue summary of the state of the NetLogFileWriter
   std::unique_ptr<base::DictionaryValue> GetState() const;
 
   // Gets the log filepath. |path_callback| will be used to notify the caller
   // when the filepath is retrieved. |path_callback| will be executed with an
   // empty filepath if any of the following occurs:
   // (1) The NetLogFileWriter is not initialized.
@@ skipping 26 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_