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());
+
+  // StartLogging(), if executed, will always be executed asynchronously so that
+  // |state_callback| is always executed asynchronously relative to the
+  // StartNetLog() call.
+
+  base::Closure start_logging_callback = base::Bind(
+      &NetLogFileWriter::StartLogging, weak_ptr_factory_.GetWeakPtr(), log_path,
+      capture_mode, state_callback);
+
+  if (state_ == STATE_UNINITIALIZED) {
+    InitThenCallback(start_logging_callback);
+  } else if (state_ == STATE_NOT_LOGGING) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                  start_logging_callback);
+  } else {
+    RunStateCallbackAsync(state_callback);

[eroman, 2017/01/18 21:32:43]

If StartNetLog() is called multiple times the first call will post a task for
initialization, and transition state to STATE_INITIALIZING.

Until the initialization completes, each subsequent call will see
STATE_INITIALIZING and go down this path, which fetches the current state and
then calls back (which isn't quite right).

Please see my suggested solution for Init().

[wangyix1, 2017/01/19 23:09:46]

Done.

+  }
+}
+
+void NetLogFileWriter::StartLogging(const base::FilePath& log_path,
+                                    net::NetLogCaptureMode capture_mode,
+                                    const StateCallback& state_callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(file_task_runner_);
+
+  // Check if NetLogFileWriter is properly initialized.
+  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());
+
+    std::unique_ptr<base::Value> constants(
+        ChromeNetLog::GetConstants(command_line_string_, channel_string_));
+    write_to_file_observer_.reset(
+        new net::FileNetLogObserver(file_task_runner_));
+    write_to_file_observer_->StartObservingUnbounded(
+        chrome_net_log_, capture_mode, log_path_, std::move(constants),
+        nullptr);
+  } else {
+    // Only way to get here is if StartLogging() was called as a result of a

[eroman, 2017/01/18 21:32:43]

Because of when StartNetLog() posts this task, this only holds if initialization
completes before this task (otherwise this could be STATE_INITIALIZING too). We
can rely on this, but let's keep that  internal to Init().

[wangyix1, 2017/01/19 23:09:46]

Done.

+    // StartNetLog() that triggered initialization and the initialization
+    // failed. In that case, simply run |state_callback| and nothing else.
+    DCHECK_EQ(state_, STATE_UNINITIALIZED);
+  }
+
+  RunStateCallback(state_callback);
+}
+
+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::StopLogging,
+                     weak_ptr_factory_.GetWeakPtr(), state_callback));
+    } else {
+      StopLogging(state_callback, std::move(polled_data));
+    }
+  } else {
+    RunStateCallbackAsync(state_callback);
+  }
+}
+
+void NetLogFileWriter::StopLogging(
+    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());
+  if (state_ == STATE_UNINITIALIZED) {
+    InitThenCallback(base::Bind(&NetLogFileWriter::RunStateCallback,
+                                weak_ptr_factory_.GetWeakPtr(),
+                                state_callback));
+  } else {
+    RunStateCallbackAsync(state_callback);
+  }
+}
+
+std::unique_ptr<base::DictionaryValue> NetLogFileWriter::GetState() const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
+
+#ifndef NDEBUG
+  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::RunStateCallback(
+    const StateCallback& state_callback) const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  state_callback.Run(GetState());
+}
+
+void NetLogFileWriter::RunStateCallbackAsync(
+    const StateCallback& state_callback) const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  std::unique_ptr<base::DictionaryValue> state = GetState();

[eroman, 2017/01/18 21:32:43]

There are disadvantages to running this immediately (notably when deferring
because initialization is in progress).

How about:

PostTask(..., base::Bind(&RunStateCallback, state_callback));

[wangyix1, 2017/01/19 23:09:46]

Done.

+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(state_callback, base::Passed(&state)));
+}
+
+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(
+      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::InitThenCallback(const base::Closure& callback) {

[eroman, 2017/01/18 21:32:43]

Here is how I think the initialization can be handled and layered in this code.

StartNetLog(state_callback) {
  Init(base::Bind(&StartNetLogAfterInitialized, state_callback));
}

GetState(state_callback) {
  Init(base::Bind(&RunStateCallback, state_callback));
}

In StartNetLog() and GetState(), now all we do is ask to run a callback after
initialization has completed (without inspecting the state post-initialization
yet).

Init(callback) can then internalize the initialization state transitions,
schedule any tasks for initialization, and then finally invoke callback() once
initialization has run:

void Init(callback) {
  if (state_ == STATE_UNINITIALIZED) {
     state_ = STATE_INITIALIZING;
     .... post task to finish initialization ....
  } else if (state_ == STATE_INITIALIZING) {
      RunStateCallbackAsync(callback);  // HACK... but good enough
  } else {
      RunStateCallbackAsync(callback).
  }
}

This has the advantage of internalizing the state transitions to Init(), and
also handling the STATE_INITIALIZING case. Also relies on a small change to
RunStateCallbackAsync().

[wangyix1, 2017/01/19 23:09:46]

Done.

+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(file_task_runner_);
+
+  // Before posting the file thread tasks, change state to STATE_INITIALIZING so
+  // that if the NetLogFileWriter receives a command while initialization tasks
+  // are running on the file 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.
+  DCHECK_EQ(state_, STATE_UNINITIALIZED);
+  state_ = STATE_INITIALIZING;
+
+  base::PostTaskAndReplyWithResult(
+      file_task_runner_.get(), FROM_HERE,
+      base::Bind(&NetLogFileWriter::SetUpDefaultLogPath,
+                 default_log_base_directory_getter_),
+      base::Bind(&NetLogFileWriter::InitStateThenCallback,
+                 weak_ptr_factory_.GetWeakPtr(), 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::InitStateThenCallback(

[eroman, 2017/01/18 21:32:43]

These names are very difficult for me to follow because of how similar they are:

* InitStateThenCallback vs InitThenCallback()
* StartNetLog vs StartLogging
* GetState(callback) vs GetState(void)

Instead, we can pick names that are easier to see are different, and also
explain how they are different. Here is how I seem them:

* Init()
* InitAfterInitialized()
* StartNetLog()
* StartNetLogAfterInitialized()
* GetState(callback)

The pattern here is the "AfterInitialized()" flavor, which run after
initialization has completed (and are free to synchronously invoke the
user-callback)

For GetState(), I would argue we don't need two functions for this. Currently
you are sharing that between RunStateCallback() and RunStateCallbackAsync(),
however per my comment RunStateCallbackAsync() should not call GetState()
directly.

Assuming we did keep both functions, a common idiom in our code is to name
things XXX() for the main entry point, and DoXXX() for the underlying
implementation, barring a better name (so we would have GetState(callback) and
DoGetState in this case).

[wangyix1, 2017/01/19 23:09:46]

Done.

+    const base::Closure& 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_);
+  } else {
+    state_ = STATE_UNINITIALIZED;
+  }
+
+  callback.Run();
+}
+
+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 "NORMAL";
+  }
+}
+
+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::IncludeCookiesAndCredentials();
+  }
+}
+
+void NetLogFileWriter::SetDefaultLogBaseDirectoryGetter(
+    const DirectoryGetter& getter) {
+  default_log_base_directory_getter_ = getter;
 }
 
 }  // namespace net_log