Rename TaskRunner::RunsTasksOnCurrentThread() in //net

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 362 matching lines @@
       current_file_idx_(0),
       max_file_size_(max_file_size),
       task_runner_(task_runner) {
   event_files_.resize(total_num_files_);
 }
 
 FileNetLogObserver::BoundedFileWriter::~BoundedFileWriter() {}
 
 void FileNetLogObserver::BoundedFileWriter::Initialize(
     std::unique_ptr<base::Value> constants_value) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
   event_files_[current_file_idx_] = base::ScopedFILE(
       base::OpenFile(directory_.AppendASCII("event_file_0.json"), "w"));
 
   base::ScopedFILE constants_file(
       base::OpenFile(directory_.AppendASCII("constants.json"), "w"));
 
   // 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(constants_file.get(), "{\"constants\":%s,\n\"events\": [\n",
           json.c_str());
 }
 
 void FileNetLogObserver::BoundedFileWriter::Stop(
     std::unique_ptr<base::Value> polled_data) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
   base::ScopedFILE closing_file(
       base::OpenFile(directory_.AppendASCII("end_netlog.json"), "w"));
 
   std::string json;
   if (polled_data)
     base::JSONWriter::Write(*polled_data, &json);
 
   fprintf(closing_file.get(), "]%s}\n",
           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());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
   current_file_idx_++;
   current_file_idx_ %= total_num_files_;
   event_files_[current_file_idx_].reset();
   event_files_[current_file_idx_] = base::ScopedFILE(base::OpenFile(
       directory_.AppendASCII("event_file_" +
                              base::SizeTToString(current_file_idx_) + ".json"),
       "w"));
 }
 
 void FileNetLogObserver::BoundedFileWriter::Flush(
     scoped_refptr<FileNetLogObserver::WriteQueue> write_queue) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
   EventQueue local_file_queue;
   write_queue->SwapQueue(&local_file_queue);
 
   std::string to_print;
   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",
             local_file_queue.front().get()->c_str());
     file_size += local_file_queue.front()->size();
     memory_freed += local_file_queue.front()->size();
     local_file_queue.pop();
   }
 }
 
 void FileNetLogObserver::BoundedFileWriter::DeleteAllFiles() {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
   // Reset |event_files_| to release all file handles so base::DeleteFile can
   // safely access files.
   event_files_.clear();
 
   base::DeleteFile(directory_.AppendASCII("constants.json"), false);
   base::DeleteFile(directory_.AppendASCII("end_netlog.json"), false);
   for (size_t i = 0; i < total_num_files_; i++) {
     base::DeleteFile(directory_.AppendASCII("event_file_" +
                                             base::SizeTToString(i) + ".json"),
                      false);
   }
 }
 
 FileNetLogObserver::UnboundedFileWriter::UnboundedFileWriter(
     const base::FilePath& path,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : file_path_(path), task_runner_(task_runner) {}
 
 FileNetLogObserver::UnboundedFileWriter::~UnboundedFileWriter() {}
 
 void FileNetLogObserver::UnboundedFileWriter::Initialize(
     std::unique_ptr<base::Value> constants_value) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
   file_.reset(base::OpenFile(file_path_, "w"));
   first_event_written_ = false;
 
   // 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> polled_data) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
   std::string json;
   if (polled_data)
     base::JSONWriter::Write(*polled_data, &json);
 
   fprintf(file_.get(), "]%s}\n",
           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());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
   EventQueue local_file_queue;
   write_queue->SwapQueue(&local_file_queue);
 
   while (!local_file_queue.empty()) {
     if (first_event_written_) {
       fputs(",\n", file_.get());
     } else {
       first_event_written_ = true;
     }
     fputs(local_file_queue.front()->c_str(), file_.get());
     local_file_queue.pop();
   }
 }
 
 void FileNetLogObserver::UnboundedFileWriter::DeleteAllFiles() {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  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