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

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 99 matching lines @@
 // FileWriter is an interface describing an object that drains events from a
 // WriteQueue and writes them to disk.
 class FileNetLogObserver::FileWriter {
  public:
   virtual ~FileWriter();
 
   // Writes |constants_value| to disk and opens the events array (closed in
   // Stop()).
   virtual void Initialize(std::unique_ptr<base::Value> constants_value) = 0;
 
-  // Closes the events array opened in Initialize() and writes |tab_info| to
-  // disk. If |tab_info| cannot be converted to proper JSON, then it
+  // Closes the events array opened in Initialize() and writes |polled_data| to
+  // disk. If |polled_data| cannot be converted to proper JSON, then it
   // is ignored.
-  virtual void Stop(std::unique_ptr<base::Value> tab_info) = 0;
+  virtual void Stop(std::unique_ptr<base::Value> polled_data) = 0;
 
   // Drains |queue_| from WriteQueue into a local file queue and writes the
   // events in the queue to disk.
   virtual void Flush(scoped_refptr<WriteQueue> write_queue) = 0;
 
   // Deletes all netlog files. It is not valid to call any method of
   // FileNetLogObserver after DeleteAllFiles().
   virtual void DeleteAllFiles() = 0;
 };
 
 // This implementation of FileWriter is used when the observer is in bounded
 // mode.
 // BoundedFileWriter can be constructed on any thread, and afterwards is only
 // accessed on the file thread.
 class FileNetLogObserver::BoundedFileWriter
     : public FileNetLogObserver::FileWriter {
  public:
   BoundedFileWriter(const base::FilePath& directory,
                     size_t max_file_size,
                     size_t total_num_files,
                     scoped_refptr<base::SingleThreadTaskRunner> task_runner);
 
   ~BoundedFileWriter() override;
 
   // FileNetLogObserver::FileWriter implementation
   void Initialize(std::unique_ptr<base::Value> constants_value) override;
-  void Stop(std::unique_ptr<base::Value> tab_info) override;
+  void Stop(std::unique_ptr<base::Value> polled_data) override;
   void Flush(scoped_refptr<WriteQueue> write_queue) override;
   void DeleteAllFiles() override;
 
  private:
   // Increments |current_file_idx_|, and handles the clearing and openining of
   // the new current file. Also sets |event_files_[current_file_idx_]| to point
   // to the new current file.
   void IncrementCurrentFile();
 
   // Each ScopedFILE points to a netlog event file with the file name
@@ skipping 28 matching lines @@
 class FileNetLogObserver::UnboundedFileWriter
     : public FileNetLogObserver::FileWriter {
  public:
   UnboundedFileWriter(const base::FilePath& path,
                       scoped_refptr<base::SingleThreadTaskRunner> task_runner);
 
   ~UnboundedFileWriter() override;
 
   // FileNetLogObserver::FileWriter implementation
   void Initialize(std::unique_ptr<base::Value> constants_value) override;
-  void Stop(std::unique_ptr<base::Value> tab_info) override;
+  void Stop(std::unique_ptr<base::Value> polled_data) override;
   void Flush(scoped_refptr<WriteQueue> write_queue) override;
   void DeleteAllFiles() override;
 
  private:
   base::FilePath file_path_;
   base::ScopedFILE file_;
 
   // Is set to true after the first event is written to the log file.
   bool first_event_written_;
 
@@ skipping 80 matching lines @@
   if (url_request_context) {
     DCHECK(url_request_context->CalledOnValidThread());
     std::set<URLRequestContext*> contexts;
     contexts.insert(url_request_context);
     CreateNetLogEntriesForActiveObjects(contexts, this);
   }
 
   net_log->DeprecatedAddObserver(this, capture_mode);
 }
 
-void FileNetLogObserver::StopObserving(URLRequestContext* url_request_context,
+void FileNetLogObserver::StopObserving(std::unique_ptr<base::Value> polled_data,
                                        const base::Closure& callback) {
   file_task_runner_->PostTask(
       FROM_HERE, base::Bind(&FileNetLogObserver::FileWriter::Flush,
                             base::Unretained(file_writer_), write_queue_));
 
   file_task_runner_->PostTaskAndReply(
       FROM_HERE,
-      base::Bind(
-          &FileNetLogObserver::FileWriter::Stop, base::Unretained(file_writer_),
-          base::Passed(url_request_context ? GetNetInfo(url_request_context,
-                                                        NET_INFO_ALL_SOURCES)
-                                           : nullptr)),
+      base::Bind(&FileNetLogObserver::FileWriter::Stop,
+                 base::Unretained(file_writer_), base::Passed(&polled_data)),
       callback);
 
   net_log()->DeprecatedRemoveObserver(this);
 }
 
 void FileNetLogObserver::OnAddEntry(const NetLogEntry& entry) {
   std::unique_ptr<std::string> json(new std::string);
 
   // If |entry| cannot be converted to proper JSON, ignore it.
   if (!base::JSONWriter::Write(*entry.ToValue(), json.get()))
@@ skipping 24 matching lines @@
 
   while (memory_ > memory_max_ && !queue_.empty()) {
     // Delete oldest events in the queue.
     DCHECK(queue_.front());
     memory_ -= queue_.front()->size();
     queue_.pop();
   }
 
   return queue_.size();
 }
+
 void FileNetLogObserver::WriteQueue::SwapQueue(EventQueue* local_queue) {
   DCHECK(local_queue->empty());
   base::AutoLock lock(lock_);
   queue_.swap(*local_queue);
   memory_ = 0;
 }
 
 FileNetLogObserver::WriteQueue::~WriteQueue() {}
 
 FileNetLogObserver::FileWriter::~FileWriter() {}
@@ skipping 27 matching lines @@
   std::string json;
 
   // It should always be possible to convert constants to JSON.
   if (!base::JSONWriter::Write(*constants_value, &json))
     DCHECK(false);
   fprintf(constants_file.get(), "{\"constants\":%s,\n\"events\": [\n",
           json.c_str());
 }
 
 void FileNetLogObserver::BoundedFileWriter::Stop(
-    std::unique_ptr<base::Value> tab_info) {
+    std::unique_ptr<base::Value> polled_data) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   base::ScopedFILE closing_file(
       base::OpenFile(directory_.AppendASCII("end_netlog.json"), "w"));
 
   std::string json;
-  if (tab_info)
-    base::JSONWriter::Write(*tab_info, &json);
+  if (polled_data)
+    base::JSONWriter::Write(*polled_data, &json);
 
   fprintf(closing_file.get(), "]%s}\n",
-          json.empty() ? "" : (",\"tabInfo\": " + json + "\n").c_str());
+          json.empty() ? "" : (",\n\"polledData\": " + json + "\n").c_str());
 
   // Flush all fprintfs to disk so that files can be safely accessed on
   // callback.
   event_files_.clear();
 }
 
 void FileNetLogObserver::BoundedFileWriter::IncrementCurrentFile() {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   current_file_idx_++;
@@ skipping 63 matching lines @@
   // Print constants to file and open events array.
   std::string json;
 
   // It should always be possible to convert constants to JSON.
   if (!base::JSONWriter::Write(*constants_value, &json))
     DCHECK(false);
   fprintf(file_.get(), "{\"constants\":%s,\n\"events\": [\n", json.c_str());
 }
 
 void FileNetLogObserver::UnboundedFileWriter::Stop(
-    std::unique_ptr<base::Value> tab_info) {
+    std::unique_ptr<base::Value> polled_data) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   std::string json;
-  if (tab_info)
-    base::JSONWriter::Write(*tab_info, &json);
+  if (polled_data)
+    base::JSONWriter::Write(*polled_data, &json);
 
   fprintf(file_.get(), "]%s}\n",
-          json.empty() ? "" : (",\n\"tabInfo\": " + json + "\n").c_str());
+          json.empty() ? "" : (",\n\"polledData\": " + json + "\n").c_str());
 
   // Flush all fprintfs to disk so that the file can be safely accessed on
   // callback.
   file_.reset();
 }
 
 void FileNetLogObserver::UnboundedFileWriter::Flush(
     scoped_refptr<FileNetLogObserver::WriteQueue> write_queue) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
@@ skipping 14 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