Add FileNetLogObserver::FileWriter::FlushThenStop(), update FileNetLogObserver::StopObserving() to …

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 111 matching lines @@
   // is ignored.
   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;
+
+  void FlushThenStop(scoped_refptr<WriteQueue> write_queue,
+                     std::unique_ptr<base::Value> polled_data);
 };
 
 // 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,
@@ skipping 150 matching lines @@
     std::set<URLRequestContext*> contexts;
     contexts.insert(url_request_context);
     CreateNetLogEntriesForActiveObjects(contexts, this);
   }
 
   net_log->DeprecatedAddObserver(this, capture_mode);
 }
 
 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(&polled_data)),
+      FROM_HERE, base::Bind(&FileNetLogObserver::FileWriter::FlushThenStop,
+                            base::Unretained(file_writer_), write_queue_,
+                            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 36 matching lines @@
   DCHECK(local_queue->empty());
   base::AutoLock lock(lock_);
   queue_.swap(*local_queue);
   memory_ = 0;
 }
 
 FileNetLogObserver::WriteQueue::~WriteQueue() {}
 
 FileNetLogObserver::FileWriter::~FileWriter() {}
 
+void FileNetLogObserver::FileWriter::FlushThenStop(
+    scoped_refptr<FileNetLogObserver::WriteQueue> write_queue,
+    std::unique_ptr<base::Value> polled_data) {
+  Flush(write_queue);
+  Stop(std::move(polled_data));
+}
+
 FileNetLogObserver::BoundedFileWriter::BoundedFileWriter(
     const base::FilePath& directory,
     size_t max_file_size,
     size_t total_num_files,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : directory_(directory),
       total_num_files_(total_num_files),
       current_file_idx_(0),
       max_file_size_(max_file_size),
       task_runner_(task_runner) {
@@ skipping 154 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