Enable bounded mode logging on chrome://net-export.

There is an option to configure the maximum size of the NetLog. The
default is 100MiB.

This is a re-land that was originally reviewed at https://chromium-review.googlesource.com/c/571514/

TBR=xunjieli@chromium.org

Bug: 679030
Change-Id: Ibf4fd80bca9ecd2d7899bc7039a930bbfc70ffa0
Reviewed-on: https://chromium-review.googlesource.com/580030Reviewed-by: Eric Roman <eroman@chromium.org>
Commit-Queue: Eric Roman <eroman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#488371}

chrome/browser/ui/webui/net_export_ui.cc

@@ -149,10 +149,12 @@ class NetExportMessageHandler
                  net_log::NetExportFileWriter::StateObserver>
       state_observer_manager_;
 
-  // The capture mode the user chose in the UI when logging started is cached
-  // here and is read after a file path is chosen in the save dialog.
-  // Its value is only valid while the save dialog is open on the desktop UI.
+  // The capture mode and file size bound that the user chose in the UI when
+  // logging started is cached here and is read after a file path is chosen in
+  // the save dialog. Their values are only valid while the save dialog is open
+  // on the desktop UI.
   net::NetLogCaptureMode capture_mode_;
+  size_t max_log_file_size_;
 
   scoped_refptr<ui::SelectFileDialog> select_file_dialog_;
 
@@ -217,12 +219,21 @@ void NetExportMessageHandler::OnEnableNotifyUIWithState(
 
 void NetExportMessageHandler::OnStartNetLog(const base::ListValue* list) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  std::string capture_mode_string;
-  bool result = list->GetString(0, &capture_mode_string);
-  DCHECK(result);
 
-  capture_mode_ =
-      net_log::NetExportFileWriter::CaptureModeFromString(capture_mode_string);
+  const base::Value::ListStorage& params = list->GetList();
+
+  // Determine the capture mode.
+  capture_mode_ = net::NetLogCaptureMode::Default();
+  if (params.size() > 0 && params[0].is_string()) {
+    capture_mode_ = net_log::NetExportFileWriter::CaptureModeFromString(
+        params[0].GetString());
+  }
+
+  // Determine the max file size.
+  max_log_file_size_ = net_log::NetExportFileWriter::kNoLimit;
+  if (params.size() > 1 && params[1].is_int() && params[1].GetInt() > 0) {
+    max_log_file_size_ = params[1].GetInt();
+  }
 
   if (UsingMobileUI()) {
     StartNetLog(base::FilePath());
@@ -321,7 +332,7 @@ void NetExportMessageHandler::StartNetLog(const base::FilePath& path) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   file_writer_->StartNetLog(
-      path, capture_mode_,
+      path, capture_mode_, max_log_file_size_,
       base::CommandLine::ForCurrentProcess()->GetCommandLineString(),
       chrome::GetChannelString(), GetURLRequestContexts());
 }

components/net_log/net_export_file_writer.cc

@@ -156,6 +156,7 @@ void NetExportFileWriter::Initialize(
 void NetExportFileWriter::StartNetLog(
     const base::FilePath& log_path,
     net::NetLogCaptureMode capture_mode,
+    size_t max_file_size,
     const base::CommandLine::StringType& command_line_string,
     const std::string& channel_string,
     const URLRequestContextGetterList& context_getters) {
@@ -177,8 +178,8 @@ void NetExportFileWriter::StartNetLog(
   std::unique_ptr<base::Value> constants(
       ChromeNetLog::GetConstants(command_line_string, channel_string));
 
-  file_net_log_observer_ =
-      net::FileNetLogObserver::CreateUnbounded(log_path_, std::move(constants));
+  file_net_log_observer_ = net::FileNetLogObserver::CreateBounded(
+      log_path_, max_file_size, std::move(constants));
 
   net_task_runner_->PostTaskAndReply(
       FROM_HERE,

components/net_log/net_export_file_writer.h

@@ -17,6 +17,7 @@
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/threading/thread_checker.h"
+#include "net/log/file_net_log_observer.h"
 #include "net/log/net_log_capture_mode.h"
 
 namespace base {
@@ -25,7 +26,6 @@ class SingleThreadTaskRunner;
 }  // namespace base
 
 namespace net {
-class FileNetLogObserver;
 class URLRequestContextGetter;
 }  // namespace net
 
@@ -55,6 +55,9 @@ class ChromeNetLog;
 // code on the |file_task_runner_| and |net_task_runner_|.
 class NetExportFileWriter {
  public:
+  // Special value meaning "can use an unlimited number of bytes".
+  static constexpr size_t kNoLimit = net::FileNetLogObserver::kNoLimit;
+
   // The observer interface to be implemented by code that wishes to be notified
   // of NetExportFileWriter's state changes.
   class StateObserver {
@@ -99,12 +102,16 @@ class NetExportFileWriter {
   // empty, the default log path is used. If NetExportFileWriter is already
   // logging, this is a no-op and |capture_mode| is ignored.
   //
+  // |max_file_size| places a bound on how large the log file can grow. To make
+  // it grow unboundedly pass kNoLimit.
+  //
   // |context_getters| is an optional list of URLRequestContextGetters used only
   // to add log entries for ongoing events when logging starts. They are not
   // used for retrieving polled data. All the contexts must be bound to the same
   // thread.
   void StartNetLog(const base::FilePath& log_path,
                    net::NetLogCaptureMode capture_mode,
+                   size_t max_file_size,
                    const base::CommandLine::StringType& command_line_string,
                    const std::string& channel_string,
                    const URLRequestContextGetterList& context_getters);

components/net_log/net_export_file_writer_unittest.cc

@@ -34,6 +34,7 @@
 namespace {
 
 const char kChannelString[] = "SomeChannel";
+const size_t kMaxLogSizeBytes = 100 * 1024 * 1024;  // 100MiB
 
 // Keep this in sync with kLogRelativePath defined in net_export_file_writer.cc.
 base::FilePath::CharType kLogRelativePath[] =
@@ -329,7 +330,7 @@ class NetExportFileWriterTest : public ::testing::Test {
       net::NetLogCaptureMode capture_mode,
       const std::string& expected_capture_mode_string,
       const URLRequestContextGetterList& context_getters) {
-    file_writer_.StartNetLog(custom_log_path, capture_mode,
+    file_writer_.StartNetLog(custom_log_path, capture_mode, kMaxLogSizeBytes,
                              base::CommandLine::StringType(), kChannelString,
                              context_getters);
     std::unique_ptr<base::DictionaryValue> state =
@@ -498,14 +499,14 @@ TEST_F(NetExportFileWriterTest, StartAndStopWithAllCaptureModes) {
     // with various capture modes; they should all be ignored and result in no
     // state change.
     file_writer_.StartNetLog(base::FilePath(), capture_modes[i],
-                             base::CommandLine::StringType(), kChannelString,
-                             URLRequestContextGetterList());
+                             kMaxLogSizeBytes, base::CommandLine::StringType(),
+                             kChannelString, URLRequestContextGetterList());
     file_writer_.StartNetLog(base::FilePath(), capture_modes[(i + 1) % 3],
-                             base::CommandLine::StringType(), kChannelString,
-                             URLRequestContextGetterList());
+                             kMaxLogSizeBytes, base::CommandLine::StringType(),
+                             kChannelString, URLRequestContextGetterList());
     file_writer_.StartNetLog(base::FilePath(), capture_modes[(i + 2) % 3],
-                             base::CommandLine::StringType(), kChannelString,
-                             URLRequestContextGetterList());
+                             kMaxLogSizeBytes, base::CommandLine::StringType(),
+                             kChannelString, URLRequestContextGetterList());
 
     // StopNetLog(), should result in state change. The capture mode should
     // match that of the first StartNetLog() call (called by
@@ -745,8 +746,8 @@ TEST_F(NetExportFileWriterTest, ReceiveStartWhileInitializing) {
   // before |file_writer_| finishes initialization, which means this
   // should be a no-op.
   file_writer_.StartNetLog(base::FilePath(), net::NetLogCaptureMode::Default(),
-                           base::CommandLine::StringType(), kChannelString,
-                           URLRequestContextGetterList());
+                           kMaxLogSizeBytes, base::CommandLine::StringType(),
+                           kChannelString, URLRequestContextGetterList());
 
   // Now run the main message loop. Make sure StartNetLog() was ignored by
   // checking that the next two states are "initializing" followed by
@@ -776,8 +777,8 @@ TEST_F(NetExportFileWriterTest, ReceiveStartWhileStoppingLog) {
   // |file_writer_| finishes stopping, which means this should be a
   // no-op.
   file_writer_.StartNetLog(base::FilePath(), net::NetLogCaptureMode::Default(),
-                           base::CommandLine::StringType(), kChannelString,
-                           URLRequestContextGetterList());
+                           kMaxLogSizeBytes, base::CommandLine::StringType(),
+                           kChannelString, URLRequestContextGetterList());
 
   // Now run the main message loop. Make sure the last StartNetLog() was
   // ignored by checking that the next two states are "stopping-log" followed by

components/net_log/resources/net_export.css

@@ -20,7 +20,7 @@ button {
   font-weight: bold;
   margin: 10px auto;
   padding: 1em;
-  width: 14em;
+  width: 15em;
 }
 
 h2 {

components/net_log/resources/net_export.html

@@ -70,6 +70,13 @@
             Include raw bytes (will include cookies and credentials)
           </label>
         </div>
+        <div>
+          <label>
+            Maximum log size (megabytes):
+            <input id='log-max-filesize' value="100" size="4" />
+            (Blank means unlimited).
+          </label>
+        </div>
       </div>
     </div>
 
@@ -136,9 +143,12 @@
 
         <div id="toobig-read-more">
           <ul>
-            <li>Compressing the log file before attaching is a good idea.</li>
-            <li>If the log file is still too big, you can try capturing again,
-              but over a shorter period of time</li>
+            <li>The maximum log size can be specified when starting
+            logging.</li>
+            <li>Compressing the log file before attaching is a good
+              idea.</li>
+            <li>Capture logs over a shorter period of time; stop
+              logging once the issue has reproduced.</li>
             <li>Existing log files can be shrunk using
               <a
                 href="https://chromium.googlesource.com/chromium/src/+/master/net/tools/truncate_net_log.py"

components/net_log/resources/net_export.js

@@ -37,6 +37,7 @@ var NetExportView = (function() {
   var kIdPrivacyReadMoreDiv = 'privacy-read-more'
   var kIdTooBigReadMoreLink = 'toobig-read-more-link';
   var kIdTooBigReadMoreDiv = 'toobig-read-more'
+  var kIdLogMaxFileSizeInput = 'log-max-filesize'
 
   /**
    * @constructor
@@ -56,9 +57,21 @@ var NetExportView = (function() {
      * Starts saving NetLog data to a file.
      */
     onStartLogging_: function() {
+      // Determine the capture mode to use.
       var logMode =
           document.querySelector('input[name="log-mode"]:checked').value;
-      chrome.send('startNetLog', [logMode]);
+
+      // Determine the maximum file size, as the number of bytes (or -1 to mean
+      // no limit)
+      var maxLogFileSizeBytes = -1;
+      var fileSizeString = $(kIdLogMaxFileSizeInput).value;
+      var numMegabytes = parseFloat(fileSizeString);
+      if (!isNaN(numMegabytes)) {
+        // Convert to an integral number of bytes.
+        maxLogFileSizeBytes = Math.round(numMegabytes * 1024 * 1024);
+      }
+
+      chrome.send('startNetLog', [logMode, maxLogFileSizeBytes]);
     },
 
     /**

ios/chrome/browser/ui/webui/net_export/net_export_ui.cc

@@ -135,14 +135,24 @@ void NetExportMessageHandler::OnEnableNotifyUIWithState(
 
 void NetExportMessageHandler::OnStartNetLog(const base::ListValue* list) {
   DCHECK_CURRENTLY_ON(web::WebThread::UI);
-  std::string capture_mode_string;
-  bool result = list->GetString(0, &capture_mode_string);
-  DCHECK(result);
 
-  net::NetLogCaptureMode capture_mode =
-      net_log::NetExportFileWriter::CaptureModeFromString(capture_mode_string);
+  const base::Value::ListStorage& params = list->GetList();
+
+  // Determine the capture mode.
+  net::NetLogCaptureMode capture_mode = net::NetLogCaptureMode::Default();
+  if (params.size() > 0 && params[0].is_string()) {
+    capture_mode = net_log::NetExportFileWriter::CaptureModeFromString(
+        params[0].GetString());
+  }
+
+  // Determine the max file size.
+  size_t max_log_file_size = net_log::NetExportFileWriter::kNoLimit;
+  if (params.size() > 1 && params[1].is_int() && params[1].GetInt() > 0) {
+    max_log_file_size = params[1].GetInt();
+  }
+
   file_writer_->StartNetLog(
-      base::FilePath(), capture_mode,
+      base::FilePath(), capture_mode, max_log_file_size,
       base::CommandLine::ForCurrentProcess()->GetCommandLineString(),
       GetChannelString(),
       {GetApplicationContext()->GetSystemURLRequestContext()});

net/log/file_net_log_observer.cc

@@ -5,7 +5,6 @@
 #include "net/log/file_net_log_observer.h"
 
 #include <algorithm>
-#include <limits>
 #include <memory>
 #include <queue>
 #include <string>
@@ -100,8 +99,6 @@ void AppendToFileThenDelete(const base::FilePath& source_path,
 
 namespace net {
 
-const size_t FileNetLogObserver::kNoLimit = std::numeric_limits<size_t>::max();
-
 // Used to store events to be written to file.
 using EventQueue = std::queue<std::unique_ptr<std::string>>;
 

net/log/file_net_log_observer.h

@@ -5,6 +5,7 @@
 #ifndef NET_LOG_FILE_NET_LOG_OBSERVER_H_
 #define NET_LOG_FILE_NET_LOG_OBSERVER_H_
 
+#include <limits>
 #include <memory>
 
 #include "base/macros.h"
@@ -36,7 +37,7 @@ class NetLogCaptureMode;
 class NET_EXPORT FileNetLogObserver : public NetLog::ThreadSafeObserver {
  public:
   // Special value meaning "can use an unlimited number of bytes".
-  static const size_t kNoLimit;
+  static constexpr size_t kNoLimit = std::numeric_limits<size_t>::max();
 
   // Creates an instance of FileNetLogObserver that writes observed netlog
   // events to |log_path|.