Downloads: replace BrowserThread::FILE with task scheduler.

content/browser/download/download_file_impl.cc

 // Copyright (c) 2012 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 "content/browser/download/download_file_impl.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
+#include "base/threading/sequenced_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "content/browser/byte_stream.h"
 #include "content/browser/download/download_create_info.h"
 #include "content/browser/download/download_destination_observer.h"
 #include "content/browser/download/download_interrupt_reasons_impl.h"
 #include "content/browser/download/download_net_log_parameters.h"
 #include "content/browser/download/download_stats.h"
 #include "content/browser/download/parallel_download_utils.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 89 matching lines @@
       weak_factory_(this) {
   source_streams_[save_info_->offset] = base::MakeUnique<SourceStream>(
       save_info_->offset, save_info_->length, std::move(stream_reader));
 
   download_item_net_log.AddEvent(
       net::NetLogEventType::DOWNLOAD_FILE_CREATED,
       net_log_.source().ToEventParametersCallback());
   net_log_.BeginEvent(
       net::NetLogEventType::DOWNLOAD_FILE_ACTIVE,
       download_item_net_log.source().ToEventParametersCallback());
+
+  DETACH_FROM_SEQUENCE(sequence_checker_);
 }
 
 DownloadFileImpl::~DownloadFileImpl() {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+
   net_log_.EndEvent(net::NetLogEventType::DOWNLOAD_FILE_ACTIVE);
 }
 
 void DownloadFileImpl::Initialize(
     const InitializeCallback& initialize_callback,
     const CancelRequestCallback& cancel_request_callback,
     const DownloadItem::ReceivedSlices& received_slices,
     bool is_parallelizable) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   update_timer_.reset(new base::RepeatingTimer());
   int64_t bytes_so_far = 0;
   cancel_request_callback_ = cancel_request_callback;
   received_slices_ = received_slices;
   if (IsSparseFile()) {
     for (const auto& received_slice : received_slices_) {
       bytes_so_far += received_slice.received_bytes;
     }
   } else {
@@ skipping 23 matching lines @@
 
   // Initial pull from the straw from all source streams.
   for (auto& source_stream : source_streams_)
     RegisterAndActivateStream(source_stream.second.get());
 }
 
 void DownloadFileImpl::AddByteStream(
     std::unique_ptr<ByteStreamReader> stream_reader,
     int64_t offset,
     int64_t length) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   source_streams_[offset] =
       base::MakeUnique<SourceStream>(offset, length, std::move(stream_reader));
 
   // There are writers at different offsets now, create the received slices
   // vector if necessary.
   if (received_slices_.empty() && TotalBytesReceived() > 0) {
     size_t index = AddOrMergeReceivedSliceIntoSortedArray(
         DownloadItem::ReceivedSlice(0, TotalBytesReceived()), received_slices_);
     DCHECK_EQ(index, 0u);
   }
   // If the file is initialized, start to write data, or wait until file opened.
   if (file_.in_progress())
     RegisterAndActivateStream(source_streams_[offset].get());
 }
 
 DownloadInterruptReason DownloadFileImpl::WriteDataToFile(int64_t offset,
                                                           const char* data,
                                                           size_t data_len) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+
   WillWriteToDisk(data_len);
   return file_.WriteDataToFile(offset, data, data_len);
 }
 
 bool DownloadFileImpl::CalculateBytesToWrite(SourceStream* source_stream,
                                              size_t bytes_available_to_write,
                                              size_t* bytes_to_write) {
   if (source_stream->length() == kNoBytesToWrite) {
     *bytes_to_write = 0;
     return true;
@@ skipping 57 matching lines @@
   return base::TimeDelta::FromMilliseconds(kInitialRenameRetryDelayMs) *
          (1 << attempt_number);
 }
 
 bool DownloadFileImpl::ShouldRetryFailedRename(DownloadInterruptReason reason) {
   return reason == DOWNLOAD_INTERRUPT_REASON_FILE_TRANSIENT_ERROR;
 }
 
 void DownloadFileImpl::RenameWithRetryInternal(
     std::unique_ptr<RenameParameters> parameters) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   base::FilePath new_path = parameters->new_path;
 
   if ((parameters->option & UNIQUIFY) && new_path != file_.full_path()) {
     int uniquifier =
         base::GetUniquePathNumber(new_path, base::FilePath::StringType());
     if (uniquifier > 0)
       new_path = new_path.InsertBeforeExtensionASCII(
           base::StringPrintf(" (%d)", uniquifier));
   }
 
   DownloadInterruptReason reason = file_.Rename(new_path);
 
   // Attempt to retry the rename if possible. If the rename failed and the
   // subsequent open also failed, then in_progress() would be false. We don't
   // try to retry renames if the in_progress() was false to begin with since we
   // have less assurance that the file at file_.full_path() was the one we were
   // working with.
   if (ShouldRetryFailedRename(reason) && file_.in_progress() &&
       parameters->retries_left > 0) {
     int attempt_number = kMaxRenameRetries - parameters->retries_left;
     --parameters->retries_left;
     if (parameters->time_of_first_failure.is_null())
       parameters->time_of_first_failure = base::TimeTicks::Now();
-    BrowserThread::PostDelayedTask(
-        BrowserThread::FILE,
+    base::SequencedTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&DownloadFileImpl::RenameWithRetryInternal,
                    weak_factory_.GetWeakPtr(),
                    base::Passed(std::move(parameters))),
         GetRetryDelayForFailedRename(attempt_number));
     return;
   }
 
   if (!parameters->time_of_first_failure.is_null())
     RecordDownloadFileRenameResultAfterRetry(
@@ skipping 65 matching lines @@
 
 bool DownloadFileImpl::InProgress() const {
   return file_.in_progress();
 }
 
 void DownloadFileImpl::WasPaused() {
   record_stream_bandwidth_ = false;
 }
 
 void DownloadFileImpl::StreamActive(SourceStream* source_stream) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(source_stream->stream_reader());
   base::TimeTicks start(base::TimeTicks::Now());
   base::TimeTicks now;
   scoped_refptr<net::IOBuffer> incoming_data;
   size_t incoming_data_size = 0;
   size_t total_incoming_data_size = 0;
   size_t num_buffers = 0;
   size_t bytes_to_write = 0;
   bool should_terminate = false;
   ByteStreamReader::StreamState state(ByteStreamReader::STREAM_EMPTY);
@@ skipping 62 matching lines @@
         break;
     }
     now = base::TimeTicks::Now();
   } while (state == ByteStreamReader::STREAM_HAS_DATA &&
            reason == DOWNLOAD_INTERRUPT_REASON_NONE && now - start <= delta &&
            !should_terminate);
 
   // If we're stopping to yield the thread, post a task so we come back.
   if (state == ByteStreamReader::STREAM_HAS_DATA && now - start > delta &&
       !should_terminate) {
-    BrowserThread::PostTask(
-        BrowserThread::FILE, FROM_HERE,
-        base::Bind(&DownloadFileImpl::StreamActive, weak_factory_.GetWeakPtr(),
-                   source_stream));
+    base::SequencedTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(&DownloadFileImpl::StreamActive,
+                              weak_factory_.GetWeakPtr(), source_stream));
   }
 
   if (total_incoming_data_size)
     RecordFileThreadReceiveBuffers(num_buffers);
 
   RecordContiguousWriteTime(now - start);
 
   // Take care of communication with our observer.
   if (reason != DOWNLOAD_INTERRUPT_REASON_NONE) {
     HandleStreamError(source_stream, reason);
@@ skipping 34 matching lines @@
     }
   }
   if (net_log_.IsCapturing()) {
     net_log_.AddEvent(net::NetLogEventType::DOWNLOAD_STREAM_DRAINED,
                             base::Bind(&FileStreamDrainedNetLogCallback,
                                        total_incoming_data_size, num_buffers));
   }
 }
 
 void DownloadFileImpl::RegisterAndActivateStream(SourceStream* source_stream) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+
   ByteStreamReader* stream_reader = source_stream->stream_reader();
   if (stream_reader) {
     stream_reader->RegisterCallback(base::Bind(&DownloadFileImpl::StreamActive,
                                                weak_factory_.GetWeakPtr(),
                                                source_stream));
     // Truncate |source_stream|'s length if necessary.
     for (const auto& received_slice : received_slices_) {
       source_stream->TruncateLengthWithWrittenDataBlock(
           received_slice.offset, received_slice.received_bytes);
     }
@@ skipping 69 matching lines @@
   if (slices_to_download.size() > 1) {
     // If there are 1 or more holes in the file, download is not finished.
     // Some streams might not have been added to |source_streams_| yet.
     return false;
   }
   return TotalBytesReceived() == potential_file_length_;
 }
 
 void DownloadFileImpl::HandleStreamError(SourceStream* source_stream,
                                          DownloadInterruptReason reason) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+
   source_stream->stream_reader()->RegisterCallback(base::Closure());
   source_stream->set_finished(true);
   num_active_streams_--;
 
   bool can_recover_from_error = (source_stream->length() == kNoBytesToWrite);
 
   if (IsSparseFile() && !can_recover_from_error) {
     // If a neighboring stream request is available, check if it can help
     // download all the data left by |source stream| or has already done so. We
     // want to avoid the situation that a server always fail additional requests
@@ skipping 96 matching lines @@
     const base::FilePath& new_path,
     const RenameCompletionCallback& completion_callback)
     : option(option),
       new_path(new_path),
       retries_left(kMaxRenameRetries),
       completion_callback(completion_callback) {}
 
 DownloadFileImpl::RenameParameters::~RenameParameters() {}
 
 }  // namespace content