Move net-export thread-hopping code into NetLogFileWriter and add IO polled data.

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 <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/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/write_to_file_net_log_observer.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_log {
 
-// Path of logs if relative to default temporary directory of
+// 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.
+// chrome/android/java/res/xml/file_paths.xml. Only used if not saving log file
+// to a custom path.
 base::FilePath::CharType kLogRelativePath[] =
     FILE_PATH_LITERAL("net-export/chrome-net-export-log.json");
 
 // Old path used by net-export. Used to delete old files.
 // TODO(mmenke): Should remove at some point. Added in M46.
 base::FilePath::CharType kOldLogRelativePath[] =
     FILE_PATH_LITERAL("chrome-net-export-log.json");
 
+// Adds net info from net::GetNetInfo() to |polled_data|. Must run on the
+// |net_task_runner_| of NetLogFileWriter.
+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;
+}
+
+// If running on a POSIX OS, this sets all the permission flags of the file at
+// |path| to 1. Returns false if file does not exist.
+bool SetPosixFilePermissionsAll(const base::FilePath& path) {
+  if (!base::PathExists(path))
+    return false;
+#if defined(OS_POSIX)
+  return base::SetPosixFilePermissions(path, base::FILE_PERMISSION_MASK);
+#else
+  return true;
+#endif
+}
+
 NetLogFileWriter::~NetLogFileWriter() {
   if (write_to_file_observer_)
-    write_to_file_observer_->StopObserving(nullptr);
-}
-
-void NetLogFileWriter::ProcessCommand(Command command) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  if (!EnsureInit())
-    return;
-
-  switch (command) {
-    case DO_START_LOG_BYTES:
-      StartNetLog(LOG_TYPE_LOG_BYTES);
-      break;
-    case DO_START:
-      StartNetLog(LOG_TYPE_NORMAL);
-      break;
-    case DO_START_STRIP_PRIVATE_DATA:
-      StartNetLog(LOG_TYPE_STRIP_PRIVATE_DATA);
-      break;
-    case DO_STOP:
-      StopNetLog();
-      break;
-    default:
-      NOTREACHED();
-      break;
-  }
-}
-
-bool NetLogFileWriter::GetFilePath(base::FilePath* path) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  if (log_type_ == LOG_TYPE_NONE || state_ == STATE_LOGGING)
-    return false;
-
-  if (!NetExportLogExists())
-    return false;
-
-  DCHECK(!log_path_.empty());
-#if defined(OS_POSIX)
-  // Users, group and others can read, write and traverse.
-  int mode = base::FILE_PERMISSION_MASK;
-  base::SetPosixFilePermissions(log_path_, mode);
-#endif  // defined(OS_POSIX)
-
-  *path = log_path_;
-  return true;
-}
-
-base::DictionaryValue* NetLogFileWriter::GetState() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  base::DictionaryValue* dict = new base::DictionaryValue;
-
-  EnsureInit();
-
-#ifndef NDEBUG
-  dict->SetString("file", log_path_.LossyDisplayName());
-#endif  // NDEBUG
-
-  switch (state_) {
-    case STATE_NOT_LOGGING:
-      dict->SetString("state", "NOT_LOGGING");
-      break;
-    case STATE_LOGGING:
-      dict->SetString("state", "LOGGING");
-      break;
-    case STATE_UNINITIALIZED:
-      dict->SetString("state", "UNINITIALIZED");
-      break;
-  }
-
-  switch (log_type_) {
-    case LOG_TYPE_NONE:
-      dict->SetString("logType", "NONE");
-      break;
-    case LOG_TYPE_UNKNOWN:
-      dict->SetString("logType", "UNKNOWN");
-      break;
-    case LOG_TYPE_LOG_BYTES:
-      dict->SetString("logType", "LOG_BYTES");
-      break;
-    case LOG_TYPE_NORMAL:
-      dict->SetString("logType", "NORMAL");
-      break;
-    case LOG_TYPE_STRIP_PRIVATE_DATA:
-      dict->SetString("logType", "STRIP_PRIVATE_DATA");
-      break;
-  }
-
-  return dict;
+    write_to_file_observer_->StopObserving(nullptr, base::Bind([] {}));
 }
 
 NetLogFileWriter::NetLogFileWriter(
     ChromeNetLog* chrome_net_log,
     const base::CommandLine::StringType& command_line_string,
     const std::string& channel_string)
     : state_(STATE_UNINITIALIZED),
-      log_type_(LOG_TYPE_NONE),
+      log_exists_(false),
+      log_capture_mode_known_(false),
+      log_capture_mode_(net::NetLogCaptureMode::Default()),
       chrome_net_log_(chrome_net_log),
       command_line_string_(command_line_string),
-      channel_string_(channel_string) {
-  // NetLogFileWriter can be created on one thread and used on another.
-  thread_checker_.DetachFromThread();
-}
-
-bool NetLogFileWriter::GetNetExportLogBaseDirectory(
-    base::FilePath* path) const {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  return base::GetTempDir(path);
-}
-
-net::NetLogCaptureMode NetLogFileWriter::GetCaptureModeForLogType(
-    LogType log_type) {
-  switch (log_type) {
-    case LOG_TYPE_LOG_BYTES:
-      return net::NetLogCaptureMode::IncludeSocketBytes();
-    case LOG_TYPE_NORMAL:
-      return net::NetLogCaptureMode::IncludeCookiesAndCredentials();
-    case LOG_TYPE_STRIP_PRIVATE_DATA:
-      return net::NetLogCaptureMode::Default();
-    case LOG_TYPE_NONE:
-    case LOG_TYPE_UNKNOWN:
-      NOTREACHED();
-  }
-  return net::NetLogCaptureMode::Default();
-}
-
-bool NetLogFileWriter::EnsureInit() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  if (state_ != STATE_UNINITIALIZED)
-    return true;
-
-  if (log_path_.empty() && !SetUpDefaultNetExportLogPath())
-    return false;
-
-  state_ = STATE_NOT_LOGGING;
-  if (NetExportLogExists())
-    log_type_ = LOG_TYPE_UNKNOWN;
-  else
-    log_type_ = LOG_TYPE_NONE;
-
-  return true;
-}
-
-void NetLogFileWriter::StartNetLog(LogType log_type) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  if (state_ == STATE_LOGGING)
-    return;
-
-  DCHECK_NE(STATE_UNINITIALIZED, state_);
-  DCHECK(!log_path_.empty());
-
-  // Try to make sure we can create the file.
-  // TODO(rtenneti): Find a better for doing the following. Surface some error
-  // to the user if we couldn't create the file.
-  base::ScopedFILE file(base::OpenFile(log_path_, "w"));
-  if (!file)
-    return;
-
-  log_type_ = log_type;
-  state_ = STATE_LOGGING;
-
-  std::unique_ptr<base::Value> constants(
-      ChromeNetLog::GetConstants(command_line_string_, channel_string_));
-  write_to_file_observer_.reset(new net::WriteToFileNetLogObserver());
-  write_to_file_observer_->set_capture_mode(GetCaptureModeForLogType(log_type));
-  write_to_file_observer_->StartObserving(chrome_net_log_, std::move(file),
-                                          constants.get(), nullptr);
-}
-
-void NetLogFileWriter::StopNetLog() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  if (state_ != STATE_LOGGING)
-    return;
-
-  write_to_file_observer_->StopObserving(nullptr);
+      channel_string_(channel_string),
+      default_log_base_directory_getter_(base::Bind(&base::GetTempDir)),
+      weak_ptr_factory_(this) {}
+
+void NetLogFileWriter::StartNetLog(const base::FilePath& log_path,
+                                   net::NetLogCaptureMode capture_mode,
+                                   const StateCallback& state_callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  EnsureInitThenRun(
+      base::Bind(&NetLogFileWriter::StartNetLogAfterInitialized,
+                 weak_ptr_factory_.GetWeakPtr(), log_path, capture_mode),
+      state_callback, true);
+}
+
+void NetLogFileWriter::StartNetLogAfterInitialized(

[eroman, 2017/01/21 02:17:40]

style: in chrome code we try to match the definition order in the .cc file to
the declaration order in .h. I suggest doing likewise here. (see "Code
Formatting" under
https://chromium.googlesource.com/chromium/src/+/master/styleguide/c++/c++.md)

[wangyix1, 2017/01/23 20:16:42]

Done.

+    const base::FilePath& log_path,
+    net::NetLogCaptureMode capture_mode) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(state_ != STATE_UNINITIALIZED && state_ != STATE_INITIALIZING);
+  DCHECK(file_task_runner_);
+
+  if (state_ == STATE_NOT_LOGGING) {
+    if (!log_path.empty())
+      log_path_ = log_path;
+
+    state_ = STATE_LOGGING;
+    log_exists_ = true;
+    log_capture_mode_known_ = true;
+    log_capture_mode_ = capture_mode;
+
+    DCHECK(!log_path_.empty());

[eroman, 2017/01/21 02:17:40]

[optional]  I suggest moving this up to line 103.

[wangyix1, 2017/01/23 20:16:43]

Done.

+
+    std::unique_ptr<base::Value> constants(
+        ChromeNetLog::GetConstants(command_line_string_, channel_string_));
+    write_to_file_observer_.reset(

[eroman, 2017/01/21 02:17:40]

[optional]:  write_to_file_observer_ =
base::MakeUnique<net::FileNetLogObserver>(file_task_runner_);

[wangyix1, 2017/01/23 20:16:42]

Done.

+        new net::FileNetLogObserver(file_task_runner_));
+    write_to_file_observer_->StartObservingUnbounded(
+        chrome_net_log_, capture_mode, log_path_, std::move(constants),
+        nullptr);
+  }
+}
+
+void NetLogFileWriter::StopNetLog(
+    std::unique_ptr<base::DictionaryValue> polled_data,
+    scoped_refptr<net::URLRequestContextGetter> context_getter,
+    const StateCallback& state_callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(net_task_runner_);
+  if (state_ == STATE_LOGGING) {
+    // Stopping the log requires first grabbing the net info on the net thread.
+    // Before posting that task to the net thread, change the state to
+    // STATE_STOP_LOGGING so that if the NetLogFileWriter receives a command
+    // while the net info is being retrieved on the net thread, the state can be
+    // checked and the command can be ignored. It's the responsibility of the
+    // commands (StartNetLog(), StopNetLog(), GetState()) to check the state
+    // before performing their actions.
+    state_ = STATE_STOPPING_LOG;
+
+    // StopLogging() will always execute its state callback asynchronously,
+    // which means |state_callback| will always be executed asynchronously
+    // relative to the StopNetLog() call regardless of how StopLogging() is
+    // called here.
+
+    if (context_getter) {
+      base::PostTaskAndReplyWithResult(
+          net_task_runner_.get(), FROM_HERE,
+          base::Bind(&AddNetInfo, context_getter, base::Passed(&polled_data)),
+          base::Bind(&NetLogFileWriter::StopNetLogAfterAddNetInfo,
+                     weak_ptr_factory_.GetWeakPtr(), state_callback));
+    } else {
+      StopNetLogAfterAddNetInfo(state_callback, std::move(polled_data));
+    }
+  } else {
+    // No-op; just run |state_callback| asynchronously.
+    RunStateCallbackAsync(state_callback);
+  }
+}
+
+void NetLogFileWriter::StopNetLogAfterAddNetInfo(
+    const StateCallback& state_callback,
+    std::unique_ptr<base::DictionaryValue> polled_data) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_EQ(state_, STATE_STOPPING_LOG);
+
+  write_to_file_observer_->StopObserving(
+      std::move(polled_data),
+      base::Bind(&NetLogFileWriter::ResetObserverThenSetStateNotLogging,
+                 weak_ptr_factory_.GetWeakPtr(), state_callback));
+}
+
+void NetLogFileWriter::ResetObserverThenSetStateNotLogging(
+    const StateCallback& state_callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   write_to_file_observer_.reset();
   state_ = STATE_NOT_LOGGING;
-}
-
-void NetLogFileWriter::SetUpNetExportLogPath(
-    const base::FilePath& custom_path) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  // The directory should always exist because the custom path
-  // is taken from a file selector dialog window.
-  DCHECK(base::PathExists(custom_path.DirName()));
-
-  log_path_ = custom_path;
-}
-
-bool NetLogFileWriter::SetUpDefaultNetExportLogPath() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  base::FilePath temp_dir;
-  if (!GetNetExportLogBaseDirectory(&temp_dir))
-    return false;
+
+  RunStateCallback(state_callback);
+}
+
+void NetLogFileWriter::GetState(const StateCallback& state_callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  EnsureInitThenRun(base::Bind([] {}), state_callback, false);
+}
+
+std::unique_ptr<base::DictionaryValue> NetLogFileWriter::GetState() const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue);

[eroman, 2017/01/21 02:17:40]

[optional]: auto dict = base::MakeUnique<base::DictionaryValue>();

[wangyix1, 2017/01/23 20:16:43]

Done.

+
+#ifndef NDEBUG

[eroman, 2017/01/21 02:17:40]

Do you know why this is only enabled in release mode?
Seems like it should be enabled everywhere.

(Fine to leave as is if like me you don't understand this.)

[wangyix1, 2017/01/23 20:16:43]

I think this is only enabled in debug mode. Having a debug msg in the net-export
ui showing the log path makes sense, so I'll leave this code as-is.

+  dict->SetString("file", log_path_.LossyDisplayName());
+#endif  // NDEBUG
+
+  switch (state_) {
+    case STATE_UNINITIALIZED:
+      dict->SetString("state", "UNINITIALIZED");
+      break;
+    case STATE_INITIALIZING:
+      dict->SetString("state", "INITIALIZING");
+      break;
+    case STATE_NOT_LOGGING:
+      dict->SetString("state", "NOT_LOGGING");
+      break;
+    case STATE_LOGGING:
+      dict->SetString("state", "LOGGING");
+      break;
+    case STATE_STOPPING_LOG:
+      dict->SetString("state", "STOPPING_LOG");
+      break;
+  }
+
+  dict->SetBoolean("logExists", log_exists_);
+  dict->SetBoolean("logCaptureModeKnown", log_capture_mode_known_);
+  dict->SetString("captureMode", CaptureModeToString(log_capture_mode_));
+
+  return dict;
+}
+
+void NetLogFileWriter::GetFilePathToCompletedLog(
+    const FilePathCallback& path_callback) const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!log_exists_ || state_ == STATE_LOGGING) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(path_callback, base::FilePath()));
+    return;
+  }
+
+  DCHECK(file_task_runner_);
+  DCHECK(!log_path_.empty());
+
+  base::PostTaskAndReplyWithResult(

[eroman, 2017/01/21 02:17:40]

[optional] Another way to express this would be:

PostTaskAndReplyWithResult(
  file_task_runner.get(), FROM_HERE,
  base::Bind(&GetPathWithAllPermissions, log_path),
  path_callback);

FilePath GetPathWithAllPermissions(path) {
   if (... failed setting file permissions on path)
      return FilePath();

   return path;
}

The advantage is not needing RunFilePathCallback() and the extra base::Bind()
here.

[wangyix1, 2017/01/23 20:16:43]

Done.

+      file_task_runner_.get(), FROM_HERE,
+      base::Bind(&SetPosixFilePermissionsAll, log_path_),
+      base::Bind(&NetLogFileWriter::RunFilePathCallback, path_callback,
+                 log_path_));
+}
+
+void NetLogFileWriter::RunFilePathCallback(
+    const FilePathCallback& path_callback,
+    const base::FilePath& path,
+    bool set_file_permissions_success) {
+  if (set_file_permissions_success)
+    path_callback.Run(path);
+  else
+    path_callback.Run(base::FilePath());
+}
+
+void NetLogFileWriter::SetTaskRunners(
+    scoped_refptr<base::SingleThreadTaskRunner> file_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> net_task_runner) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (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_);
+  net_task_runner_ = net_task_runner;
+}
+
+std::string NetLogFileWriter::CaptureModeToString(
+    net::NetLogCaptureMode capture_mode) {
+  if (capture_mode == net::NetLogCaptureMode::Default()) {
+    return "STRIP_PRIVATE_DATA";
+  } else if (capture_mode ==
+             net::NetLogCaptureMode::IncludeCookiesAndCredentials()) {
+    return "NORMAL";
+  } else if (capture_mode == net::NetLogCaptureMode::IncludeSocketBytes()) {
+    return "LOG_BYTES";
+  } else {
+    NOTREACHED();
+    return "STRIP_PRIVATE_DATA";
+  }
+}
+
+net::NetLogCaptureMode NetLogFileWriter::CaptureModeFromString(
+    const std::string& capture_mode_string) {
+  if (capture_mode_string == "STRIP_PRIVATE_DATA") {
+    return net::NetLogCaptureMode::Default();
+  } else if (capture_mode_string == "NORMAL") {
+    return net::NetLogCaptureMode::IncludeCookiesAndCredentials();
+  } else if (capture_mode_string == "LOG_BYTES") {
+    return net::NetLogCaptureMode::IncludeSocketBytes();
+  } else {
+    NOTREACHED();
+    return net::NetLogCaptureMode::Default();
+  }
+}
+
+void NetLogFileWriter::SetDefaultLogBaseDirectoryGetterForTest(
+    const DirectoryGetter& getter) {
+  default_log_base_directory_getter_ = getter;
+}
+
+void NetLogFileWriter::EnsureInitThenRun(
+    const base::Closure& after_successful_init_callback,
+    const StateCallback& state_callback,
+    bool state_callback_wait_if_already_initializing) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (state_ == STATE_UNINITIALIZED) {
+    state_ = STATE_INITIALIZING;
+    // Run initialization tasks on the file thread, then the main thread. Once
+    // finished, run |after_successful_init_callback| and |state_callback| on
+    // the main thread.
+    base::PostTaskAndReplyWithResult(
+        file_task_runner_.get(), FROM_HERE,
+        base::Bind(&NetLogFileWriter::SetUpDefaultLogPath,
+                   default_log_base_directory_getter_),
+        base::Bind(&NetLogFileWriter::SetStateAfterSetUpDefaultLogPathThenRun,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   after_successful_init_callback, state_callback));
+  } else if (state_ == STATE_INITIALIZING) {
+    // If NetLogFileWriter is already in the process of initializing due to a
+    // previous call to EnsureInitThenRun(), commands received by
+    // NetLogFileWriter should be ignored, so only |state_callback| will be
+    // executed.
+    if (state_callback_wait_if_already_initializing) {

[eroman, 2017/01/21 02:17:40]

I would say that all cases, including GetState(), can set this to true (and
hence don't need the variable). What is the scenario you are concerned with to
not wait for STATE_INITIALIZING to complete?

[wangyix1, 2017/01/23 20:16:42]

It makes more sense to me from an API perspective: I feel that GetState()
shouldn't have to wait for an initialization that it didn't trigger. Otherwise,
no state_callback would ever be called with "STATE_INITIALIZING", which means
that state could never be checked for by the user of NetLogFileWriter. So, if
initialization takes a long time or gets stuck, no state_callback will be
executed in the meantime, which makes it impossible for the caller to know
what's going on.

[wangyix1, 2017/01/25 22:48:27]

Done. Changed my mind

+      // Wait for the in-progress initialization to finish before calling
+      // |state_callback|. To do this, post a dummy task to the file thread
+      // (which is guaranteed to run after the tasks belonging to the
+      // in-progress initialization have finished), and have that dummy task
+      // post |state_callback| as a reply on the main thread.
+      file_task_runner_->PostTaskAndReply(
+          FROM_HERE, base::Bind([] {}),
+          base::Bind(&NetLogFileWriter::RunStateCallback,
+                     weak_ptr_factory_.GetWeakPtr(), state_callback));
+    } else {
+      RunStateCallbackAsync(state_callback);
+    }
+  } else {
+    // NetLogFileWriter is already fully initialized. Run
+    // |after_successful_init_callback| synchronously and |state_callback|
+    // asynchronously.
+    after_successful_init_callback.Run();
+    RunStateCallbackAsync(state_callback);
+  }
+}
+
+NetLogFileWriter::DefaultLogPathResults NetLogFileWriter::SetUpDefaultLogPath(
+    const DirectoryGetter& default_log_base_directory_getter) {
+  DefaultLogPathResults results;
+  results.default_log_path_success = false;
+  results.log_exists = false;
+
+  base::FilePath default_base_dir;
+  if (!default_log_base_directory_getter.Run(&default_base_dir))
+    return results;
 
   // Delete log file at old location, if present.
-  DeleteFile(temp_dir.Append(kOldLogRelativePath), false);
-
-  base::FilePath log_path = temp_dir.Append(kLogRelativePath);
-
-  if (!base::CreateDirectoryAndGetError(log_path.DirName(), nullptr)) {
-    return false;
-  }
-
-  log_path_ = log_path;
-  return true;
-}
-
-bool NetLogFileWriter::NetExportLogExists() const {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(!log_path_.empty());
-  return base::PathExists(log_path_);
+  base::DeleteFile(default_base_dir.Append(kOldLogRelativePath), false);
+
+  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;
+}
+
+void NetLogFileWriter::SetStateAfterSetUpDefaultLogPathThenRun(
+    const base::Closure& after_successful_init_callback,
+    const StateCallback& state_callback,
+    const DefaultLogPathResults& set_up_default_log_path_results) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_EQ(state_, STATE_INITIALIZING);
+
+  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_);
+
+    after_successful_init_callback.Run();
+  } else {
+    state_ = STATE_UNINITIALIZED;
+  }
+
+  RunStateCallback(state_callback);
+}
+
+void NetLogFileWriter::RunStateCallback(
+    const StateCallback& state_callback) const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  state_callback.Run(GetState());
+}
+
+void NetLogFileWriter::RunStateCallbackAsync(
+    const StateCallback& state_callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(&NetLogFileWriter::RunStateCallback,
+                            weak_ptr_factory_.GetWeakPtr(), state_callback));
 }
 
 }  // namespace net_log