Fix race causing crash in net::FileNetLogObserver shutdown

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 247 matching lines @@
       new WriteQueue(std::numeric_limits<size_t>::max()));
 
   return std::unique_ptr<FileNetLogObserver>(
       new FileNetLogObserver(file_task_runner, std::move(file_writer),
                              std::move(write_queue), std::move(constants)));
 }
 
 FileNetLogObserver::~FileNetLogObserver() {
   if (net_log()) {
     // StopObserving was not called.
+    net_log()->DeprecatedRemoveObserver(this);
     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::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) {
+  net_log()->DeprecatedRemoveObserver(this);
+
   file_task_runner_->PostTaskAndReply(
       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()))
     return;
 
   size_t queue_size = write_queue_->AddEntryToQueue(std::move(json));
@@ skipping 130 matching lines @@
 }
 
 void FileNetLogObserver::BoundedFileWriter::Flush(
     scoped_refptr<FileNetLogObserver::WriteQueue> write_queue) {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
   EventQueue local_file_queue;
   write_queue->SwapQueue(&local_file_queue);
 
   std::string to_print;
+  CHECK(!event_files_.empty());
   size_t file_size = ftell(event_files_[current_file_idx_].get());
   size_t memory_freed = 0;
 
   while (!local_file_queue.empty()) {
     if (file_size >= max_file_size_) {
       // The current file is full. Start a new current file.
       IncrementCurrentFile();
       file_size = 0;
     }
     fprintf(event_files_[current_file_idx_].get(), "%s,\n",
@@ skipping 80 matching lines @@
 void FileNetLogObserver::UnboundedFileWriter::DeleteAllFiles() {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
   // Reset |file_| to release the file handle so base::DeleteFile can
   // safely access it.
   file_.reset();
   base::DeleteFile(file_path_, false);
 }
 
 }  // namespace net