Use FileNetLogObserver for implementing --log-net-log.

components/net_log/chrome_net_log.h

 // Copyright (c) 2012 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_CHROME_NET_LOG_H_
 #define COMPONENTS_NET_LOG_CHROME_NET_LOG_H_
 
 #include <memory>
 #include <string>
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "net/log/net_log.h"
 
 namespace base {
 class FilePath;
 class Value;
 }
 
 namespace net {
-class WriteToFileNetLogObserver;
+class FileNetLogObserver;
 class TraceNetLogObserver;
 }
 
 namespace net_log {
 
 class NetExportFileWriter;
 
 // ChromeNetLog is an implementation of NetLog that manages common observers
 // (for --log-net-log, chrome://net-export/, tracing), as well as acting as the
 // entry point for other consumers.
+//
+// Threading: the underlying net::NetLog is threadsafe. Whereas the methods
+// added by ChromeNetLog must be sequenced.

[mmenke, 2017/07/06 21:31:29]

Remove Whereas?  At least I can't recall seeing used as anything other than as a
conjunction (Which would make the second sentence a fragment), at least
excluding needlessly obscure legalese.  Seems like a fairly uncommon word,
regardless.

[eroman, 2017/07/06 21:57:54]

Done.

 class ChromeNetLog : public net::NetLog {
  public:
   ChromeNetLog();
   ~ChromeNetLog() override;
 
   // Starts streaming the NetLog events to a file on disk. This will continue
   // until the application shuts down.
-  // * |log_file| - path to write the file.
-  // * |log_file_mode| - capture mode for event granularity.
+  // * |path| - destination file path of the log file.
+  // * |capture_mode| - capture mode for event granularity.
   void StartWritingToFile(
-      const base::FilePath& log_file,
-      net::NetLogCaptureMode log_file_mode,
+      const base::FilePath& path,
+      net::NetLogCaptureMode capture_mode,
       const base::CommandLine::StringType& command_line_string,
       const std::string& channel_string);
 
   NetExportFileWriter* net_export_file_writer();
 
   // Returns a Value containing constants needed to load a log file.
   // Safe to call on any thread.
   static std::unique_ptr<base::Value> GetConstants(
       const base::CommandLine::StringType& command_line_string,
       const std::string& channel_string);
 
+  // Notify the ChromeNetLog that things are shutting-down.
+  //
+  // If ChromeNetLog does not outlive the TaskScheduler, there is no need to
+  // call this.
+  //
+  // However, if it can outlive the TaskScheduler, this should be called
+  // before the TaskScheduler is shutdown. This allows for any file writers
+  // using the BLOCK_SHUTDOWN to finish posting their writes.

[mmenke, 2017/07/06 21:31:29]

-the

[eroman, 2017/07/06 21:57:54]

Done.

+  //
+  // Not calling this is not a fatal error, however may result in an incomplete
+  // NetLog file being written to disk.
+  void ShutdownBeforeTaskScheduler();
+
  private:
-  std::unique_ptr<net::WriteToFileNetLogObserver> write_to_file_observer_;
+  // Deletes file_net_log_observer_.
+  void ClearFileNetLogObserver();
+
+  // This observer handles writing NetLogs specified via StartWritingToFile()
+  // (In Chrome this corresponds to the --log-net-log command line).
+  std::unique_ptr<net::FileNetLogObserver> file_net_log_observer_;

[mmenke, 2017/07/06 21:31:29]

I hadn't realized we had three different file writing observer classes.  :(

[eroman, 2017/07/06 21:57:54]

There are 3 observers here, but technically only 2 of them write NetLog files.

In terms of ways of writing NetLog files I guess you could count it as 3:
  * FileNetLogObserver::CreateBounded()
  * FileNetLogObserver::CreateUnbounded()
  * WriteToFileNetLogObserver

chrome://net-export uses FileNetLogObserver::CreateUnbounded(), so I probably
wouldn't count it separately here, but I guess you could.

And chrome://net-internals#export is gone now.

Unifying all this first requires getting rid of all the instantiations of
WriteToFileNetLogObserver littered across the codebase (i.e. synchronously
writing to file on calling thread)... of which this CL is one instance. Once
WriteToFileNetLogObserver is dead, we can wage a war on bounded vs unbounded and
get it down to just 1 log writer implementation/fileformat.

[mmenke, 2017/07/06 22:03:48]

I was counting NetExportFileWriter, actually.  Had forgotten it was a wrapper.

+
+  // This observer handles writing NetLogs started by chrome://net-export/
   std::unique_ptr<NetExportFileWriter> net_export_file_writer_;
+
+  // This observer forwards NetLog events to the chrome://tracing system.
   std::unique_ptr<net::TraceNetLogObserver> trace_net_log_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeNetLog);
 };
 
 }  // namespace net_log
 
 #endif  // COMPONENTS_NET_LOG_CHROME_NET_LOG_H_