Add ongoing events to net-export log when logging starts

components/net_log/net_log_file_writer.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 <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "components/net_log/chrome_net_log.h"
 #include "net/log/file_net_log_observer.h"
 #include "net/log/net_log_util.h"
 #include "net/url_request/url_request_context_getter.h"
 
+namespace net {
+class URLRequestContext;
+}
+
 namespace net_log {
 
 namespace {
 
 // Path of logs relative to default temporary directory given by
 // base::GetTempDir(). Must be kept in sync with
 // chrome/android/java/res/xml/file_paths.xml. Only used if not saving log file
 // to a custom path.
 const base::FilePath::CharType kLogRelativePath[] =
     FILE_PATH_LITERAL("net-export/chrome-net-export-log.json");
@@ skipping 20 matching lines @@
   results.default_log_path = default_base_dir.Append(kLogRelativePath);
   if (!base::CreateDirectoryAndGetError(results.default_log_path.DirName(),
                                         nullptr))
     return results;
 
   results.log_exists = base::PathExists(results.default_log_path);
   results.default_log_path_success = true;
   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,
     std::unique_ptr<base::DictionaryValue> polled_data) {
   DCHECK(context_getter);
   std::unique_ptr<base::DictionaryValue> net_info = net::GetNetInfo(
       context_getter->GetURLRequestContext(), net::NET_INFO_ALL_SOURCES);
   if (polled_data)
     net_info->MergeDictionary(polled_data.get());
   return net_info;
@@ skipping 46 matching lines @@
 }
 
 void NetLogFileWriter::Initialize(
     scoped_refptr<base::SingleThreadTaskRunner> file_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> net_task_runner) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(file_task_runner);
   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)
     return;
 
   state_ = STATE_INITIALIZING;
 
   NotifyStateObserversAsync();
 
   base::PostTaskAndReplyWithResult(
       file_task_runner_.get(), FROM_HERE,
       base::Bind(&SetUpDefaultLogPath, default_log_base_dir_getter_),
       base::Bind(&NetLogFileWriter::SetStateAfterSetUpDefaultLogPath,
                  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_);
 
   if (state_ != STATE_NOT_LOGGING)
     return;
 
   if (!log_path.empty())
     log_path_ = 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(
     std::unique_ptr<base::DictionaryValue> polled_data,
     scoped_refptr<net::URLRequestContextGetter> context_getter) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(net_task_runner_);
 
   if (state_ != STATE_LOGGING)
     return;
@@ skipping 26 matching lines @@
   switch (state_) {
     case STATE_UNINITIALIZED:
       state_string = "UNINITIALIZED";
       break;
     case STATE_INITIALIZING:
       state_string = "INITIALIZING";
       break;
     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);
 
   dict->SetBoolean("logExists", log_exists_);
   dict->SetBoolean("logCaptureModeKnown", log_capture_mode_known_);
   dict->SetString("captureMode", CaptureModeToString(log_capture_mode_));
 
   return dict;
 }
 
@@ skipping 59 matching lines @@
 void NetLogFileWriter::NotifyStateObserversAsync() {
   DCHECK(thread_checker_.CalledOnValidThread());
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&NetLogFileWriter::NotifyStateObservers,
                             weak_ptr_factory_.GetWeakPtr()));
 }
 
 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;
     log_path_ = set_up_default_log_path_results.default_log_path;
     log_exists_ = set_up_default_log_path_results.log_exists;
     DCHECK(!log_capture_mode_known_);
   } else {
     state_ = STATE_UNINITIALIZED;
   }
   NotifyStateObservers();
 }
 
 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),
       base::Bind(&NetLogFileWriter::ResetObserverThenSetStateNotLogging,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void NetLogFileWriter::ResetObserverThenSetStateNotLogging() {
   DCHECK(thread_checker_.CalledOnValidThread());
   file_net_log_observer_.reset();
   state_ = STATE_NOT_LOGGING;
 
   NotifyStateObservers();
 }
 
 }  // namespace net_log