Add ongoing events to net-export log when logging starts

net/log/file_net_log_observer.cc

 // Copyright 2016 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 "net/log/file_net_log_observer.h"
 
 #include <limits>
 #include <memory>
 #include <queue>
 #include <set>
@@ skipping 199 matching lines @@
   // Is set to true after the first event is written to the log file.
   bool first_event_written_;
 
   // Task runner from the file thread.
   const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(UnboundedFileWriter);
 };
 
 FileNetLogObserver::FileNetLogObserver(
-    scoped_refptr<base::SingleThreadTaskRunner> file_task_runner)
-    : file_task_runner_(file_task_runner) {}
+    scoped_refptr<base::SingleThreadTaskRunner> file_task_runner,
+    const base::FilePath& directory,
+    size_t max_total_size,
+    size_t total_num_files,
+    std::unique_ptr<base::Value> constants)
+    : file_task_runner_(file_task_runner) {
+  DCHECK_GT(total_num_files, 0u);
+  // The BoundedFileWriter uses a soft limit to write events to file that allows
+  // the size of the file to exceed the limit, but the WriteQueue uses a hard
+  // limit which the size of |WriteQueue::queue_| cannot exceed. Thus, the
+  // BoundedFileWriter may write more events to file than can be contained by
+  // the WriteQueue if they have the same size limit. The maximum size of the
+  // WriteQueue is doubled to allow |WriteQueue::queue_| to hold enough events
+  // for the BoundedFileWriter to fill all files. As long as all events have
+  // sizes <= the size of an individual event file, the discrepancy between the
+  // hard limit and the soft limit will not cause an issue.
+  // TODO(dconnol): Handle the case when the WriteQueue  still doesn't
+  // contain enough events to fill all files, because of very large events
+  // relative to file size.
+  file_writer_ =
+      new BoundedFileWriter(directory, max_total_size / total_num_files,
+                            total_num_files, file_task_runner_);
+  write_queue_ = new WriteQueue(max_total_size * 2);
+
+  InitializeFileWriter(std::move(constants));
+}
+
+FileNetLogObserver::FileNetLogObserver(
+    scoped_refptr<base::SingleThreadTaskRunner> file_task_runner,
+    const base::FilePath& log_path,
+    std::unique_ptr<base::Value> constants)
+    : file_task_runner_(file_task_runner) {
+  file_writer_ = new UnboundedFileWriter(log_path, file_task_runner_);
+  write_queue_ = new WriteQueue(std::numeric_limits<size_t>::max());
+
+  InitializeFileWriter(std::move(constants));
+}
 
 FileNetLogObserver::~FileNetLogObserver() {
   if (net_log()) {
     // StopObserving was not called.
     file_task_runner_->PostTask(
         FROM_HERE, base::Bind(&FileNetLogObserver::FileWriter::DeleteAllFiles,
                               base::Unretained(file_writer_)));
     net_log()->DeprecatedRemoveObserver(this);
   }
-
   file_task_runner_->DeleteSoon(FROM_HERE, file_writer_);
 }
 
-void FileNetLogObserver::StartObservingBounded(
-    NetLog* net_log,
-    NetLogCaptureMode capture_mode,
-    const base::FilePath& directory,
-    std::unique_ptr<base::Value> constants,
-    URLRequestContext* url_request_context,
-    size_t max_total_size,
-    size_t total_num_files) {
-  DCHECK_GT(total_num_files, 0u);
-
-  file_writer_ =
-      new BoundedFileWriter(directory, max_total_size / total_num_files,
-                            total_num_files, file_task_runner_);
-
-  // The |file_writer_| uses a soft limit to write events to file that allows
-  // the size of the file to exceed the limit, but the |write_queue_| uses a
-  // hard limit which the size of the |queue_| cannot exceed. Thus, the
-  // |file_writer_| may write more events to file than can be contained by the
-  // |write_queue_| if they have the same size limit. The maximum size of the
-  // |write_queue_| is doubled to allow the |queue_| to hold enough events for
-  // the |file_writer_| to fill all files. As long as all events have sizes <=
-  // the size of an individual event file, the discrepancy between the hard
-  // limit and the soft limit will not cause an issue.
-  // TODO(dconnol): Handle the case when the |write_queue_| still doesn't
-  // contain enough events to fill all files, because of very large events
-  // relative to file size.
-  write_queue_ = new WriteQueue(max_total_size * 2);
-
-  StartObservingHelper(net_log, capture_mode, std::move(constants),
-                       url_request_context);
-}
-
-void FileNetLogObserver::StartObservingUnbounded(
-    NetLog* net_log,
-    NetLogCaptureMode capture_mode,
-    const base::FilePath& filepath,
-    std::unique_ptr<base::Value> constants,
-    URLRequestContext* url_request_context) {
-  file_writer_ = new UnboundedFileWriter(filepath, file_task_runner_);
-
-  write_queue_ = new WriteQueue(std::numeric_limits<size_t>::max());
-
-  StartObservingHelper(net_log, capture_mode, std::move(constants),
-                       url_request_context);
-}
-
-void FileNetLogObserver::StartObservingHelper(
-    NetLog* net_log,
-    NetLogCaptureMode capture_mode,
-    std::unique_ptr<base::Value> constants,
-    URLRequestContext* url_request_context) {
-  if (!constants)
-    constants = GetNetConstants();
-  file_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&FileNetLogObserver::FileWriter::Initialize,
-                 base::Unretained(file_writer_), base::Passed(&constants)));
-
-  if (url_request_context) {
-    DCHECK(url_request_context->CalledOnValidThread());
-    std::set<URLRequestContext*> contexts;
-    contexts.insert(url_request_context);
-    CreateNetLogEntriesForActiveObjects(contexts, this);
-  }
-
+void FileNetLogObserver::StartObserving(NetLog* net_log,
+                                        NetLogCaptureMode capture_mode) {
   net_log->DeprecatedAddObserver(this, capture_mode);
 }
 
 void FileNetLogObserver::StopObserving(std::unique_ptr<base::Value> polled_data,
                                        const base::Closure& callback) {
   file_task_runner_->PostTaskAndReply(
       FROM_HERE, base::Bind(&FileNetLogObserver::FileWriter::FlushThenStop,
                             base::Unretained(file_writer_), write_queue_,
                             base::Passed(&polled_data)),
       callback);
@@ skipping 14 matching lines @@
   // the queue. Because only 1 item is added to the queue at a time, if
   // queue_size > kNumWriteQueueEvents a task has already been posted, or will
   // be posted.
   if (queue_size == kNumWriteQueueEvents) {
     file_task_runner_->PostTask(
         FROM_HERE, base::Bind(&FileNetLogObserver::FileWriter::Flush,
                               base::Unretained(file_writer_), write_queue_));
   }
 }
 
+void FileNetLogObserver::InitializeFileWriter(
+    std::unique_ptr<base::Value> constants) {
+  if (!constants)
+    constants = GetNetConstants();
+  file_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&FileNetLogObserver::FileWriter::Initialize,
+                 base::Unretained(file_writer_), base::Passed(&constants)));
+}
+
 FileNetLogObserver::WriteQueue::WriteQueue(size_t memory_max)
     : memory_(0), memory_max_(memory_max) {}
 
 size_t FileNetLogObserver::WriteQueue::AddEntryToQueue(
     std::unique_ptr<std::string> event) {
   base::AutoLock lock(lock_);
 
   memory_ += event->size();
   queue_.push(std::move(event));
 
@@ skipping 192 matching lines @@
 void FileNetLogObserver::UnboundedFileWriter::DeleteAllFiles() {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   // Reset |file_| to release the file handle so base::DeleteFile can
   // safely access it.
   file_.reset();
   base::DeleteFile(file_path_, false);
 }
 
 }  // namespace net