Add ongoing events to net-export log when logging starts

components/net_log/net_log_file_writer.cc

Index: components/net_log/net_log_file_writer.cc
diff --git a/components/net_log/net_log_file_writer.cc b/components/net_log/net_log_file_writer.cc
index 8b2774910b9dba328e72c2e598f9516905dcf37c..5282a3179c534ab6c21c79bd80104c6949fbf858 100644
--- a/components/net_log/net_log_file_writer.cc
+++ b/components/net_log/net_log_file_writer.cc
@@ -4,6 +4,7 @@
 
 #include "components/net_log/net_log_file_writer.h"
 
+#include <set>
 #include <utility>
 
 #include "base/bind.h"
@@ -22,6 +23,10 @@
 #include "net/log/net_log_util.h"
 #include "net/url_request/url_request_context_getter.h"
 
+namespace net {
+class URLRequestContext;
+}
+
 namespace net_log {
 
 namespace {
@@ -62,6 +67,18 @@ NetLogFileWriter::DefaultLogPathResults SetUpDefaultLogPath(
   return results;
 }
 
+// Generates net log entries for ongoing events from |context_getters| and
+// adds them to |observer|.
+void CreateNetLogEntriesForActiveObjects(
+    const NetLogFileWriter::URLRequestContextGetterList& context_getters,
+    net::NetLog::ThreadSafeObserver* observer) {
+  std::set<net::URLRequestContext*> contexts;
+  for (const auto& getter : context_getters) {
+    contexts.insert(getter->GetURLRequestContext());
+  }
+  net::CreateNetLogEntriesForActiveObjects(contexts, observer);
+}
+
 // Adds net info from net::GetNetInfo() to |polled_data|.
 std::unique_ptr<base::DictionaryValue> AddNetInfo(
     scoped_refptr<net::URLRequestContextGetter> context_getter,
@@ -128,10 +145,10 @@ void NetLogFileWriter::Initialize(
   DCHECK(net_task_runner);
 
   if (file_task_runner_)
-    DCHECK_EQ(file_task_runner, file_task_runner_);
+    DCHECK_EQ(file_task_runner_, file_task_runner);
   file_task_runner_ = file_task_runner;
   if (net_task_runner_)
-    DCHECK_EQ(net_task_runner, net_task_runner_);
+    DCHECK_EQ(net_task_runner_, net_task_runner);
   net_task_runner_ = net_task_runner;
 
   if (state_ != STATE_UNINITIALIZED)
@@ -148,8 +165,10 @@ void NetLogFileWriter::Initialize(
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
-void NetLogFileWriter::StartNetLog(const base::FilePath& log_path,
-                                   net::NetLogCaptureMode capture_mode) {
+void NetLogFileWriter::StartNetLog(
+    const base::FilePath& log_path,
+    net::NetLogCaptureMode capture_mode,
+    const URLRequestContextGetterList& context_getters) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(file_task_runner_);
 
@@ -161,19 +180,38 @@ void NetLogFileWriter::StartNetLog(const base::FilePath& log_path,
 
   DCHECK(!log_path_.empty());
 
+  state_ = STATE_STARTING_LOG;

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

Can you explain the role of this new state?

It does seem useful for understanding the interactions with StopNetLog(). Are
there any use-cases where communicating this to the Javascript is necessary

[wangyix1, 2017/02/22 01:28:18]

This state is needed so that while pending entries are added on the net thread,
commands received on the main thread can be no-oped.  For example, suppose we do
"state_ = STATE_LOGGING" here instead. If StopNetLog() is called while
CreateNetLogEntriesForActiveObjects() is running on the net thread, it would not
be no-oped, which is incorrect.

+
+  NotifyStateObserversAsync();
+
+  std::unique_ptr<base::Value> constants(
+      ChromeNetLog::GetConstants(command_line_string_, channel_string_));
+  // Instantiate a FileNetLogObserver in unbounded mode.
+  file_net_log_observer_ = base::MakeUnique<net::FileNetLogObserver>(
+      file_task_runner_, log_path_, std::move(constants));
+
+  net_task_runner_->PostTaskAndReply(
+      FROM_HERE,
+      base::Bind(&CreateNetLogEntriesForActiveObjects, context_getters,
+                 base::Unretained(file_net_log_observer_.get())),
+      base::Bind(
+          &NetLogFileWriter::StartNetLogAfterCreateEntriesForActiveObjects,
+          weak_ptr_factory_.GetWeakPtr(), capture_mode));
+}
+
+void NetLogFileWriter::StartNetLogAfterCreateEntriesForActiveObjects(
+    net::NetLogCaptureMode capture_mode) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_EQ(STATE_STARTING_LOG, state_);
+
   state_ = STATE_LOGGING;
   log_exists_ = true;
   log_capture_mode_known_ = true;
   log_capture_mode_ = capture_mode;
 
-  NotifyStateObserversAsync();
+  NotifyStateObservers();
 
-  std::unique_ptr<base::Value> constants(
-      ChromeNetLog::GetConstants(command_line_string_, channel_string_));
-  file_net_log_observer_ =
-      base::MakeUnique<net::FileNetLogObserver>(file_task_runner_);
-  file_net_log_observer_->StartObservingUnbounded(
-      chrome_net_log_, capture_mode, log_path_, std::move(constants), nullptr);
+  file_net_log_observer_->StartObserving(chrome_net_log_, capture_mode);
 }
 
 void NetLogFileWriter::StopNetLog(
@@ -220,12 +258,18 @@ std::unique_ptr<base::DictionaryValue> NetLogFileWriter::GetState() const {
     case STATE_NOT_LOGGING:
       state_string = "NOT_LOGGING";
       break;
+    case STATE_STARTING_LOG:
+      state_string = "STARTING_LOG";
+      break;
     case STATE_LOGGING:
       state_string = "LOGGING";
       break;
     case STATE_STOPPING_LOG:
       state_string = "STOPPING_LOG";
       break;
+    default:

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

Why add the default case? We try to avoid specifying default cases, as it gives
better static checks for future-proofing code.

[wangyix1, 2017/02/22 01:28:18]

Done.

+      NOTREACHED();
+      break;
   }
   dict->SetString("state", state_string);
 
@@ -305,7 +349,7 @@ void NetLogFileWriter::NotifyStateObserversAsync() {
 void NetLogFileWriter::SetStateAfterSetUpDefaultLogPath(
     const DefaultLogPathResults& set_up_default_log_path_results) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK_EQ(state_, STATE_INITIALIZING);
+  DCHECK_EQ(STATE_INITIALIZING, state_);
 
   if (set_up_default_log_path_results.default_log_path_success) {
     state_ = STATE_NOT_LOGGING;
@@ -321,7 +365,7 @@ void NetLogFileWriter::SetStateAfterSetUpDefaultLogPath(
 void NetLogFileWriter::StopNetLogAfterAddNetInfo(
     std::unique_ptr<base::DictionaryValue> polled_data) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK_EQ(state_, STATE_STOPPING_LOG);
+  DCHECK_EQ(STATE_STOPPING_LOG, state_);
 
   file_net_log_observer_->StopObserving(
       std::move(polled_data),