net: Stop using base::WorkerPool from UploadFileElementReader

net/base/upload_file_element_reader.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 "net/base/upload_file_element_reader.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/location.h"
 #include "base/task_runner_util.h"
-#include "base/threading/worker_pool.h"
 #include "net/base/file_stream.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 
 namespace net {
 
 namespace {
 
 // In tests, this value is used to override the return value of
 // UploadFileElementReader::GetContentLength() when set to non-zero.
 uint64 overriding_content_length = 0;
 
 // This function is used to implement Init().
+template<typename FileStreamDeleter>
 int InitInternal(const FilePath& path,
                  uint64 range_offset,
                  uint64 range_length,
                  const base::Time& expected_modification_time,
-                 UploadFileElementReader::ScopedFileStreamPtr* out_file_stream,
+                 scoped_ptr<FileStream, FileStreamDeleter>* out_file_stream,
                  uint64* out_content_length) {
   scoped_ptr<FileStream> file_stream(new FileStream(NULL));
   int64 rv = file_stream->OpenSync(
       path, base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ);
   if (rv != OK) {
     // If the file can't be opened, we'll just upload an empty file.
     DLOG(WARNING) << "Failed to open \"" << path.value()
                   << "\" for reading: " << rv;
     file_stream.reset();
   } else if (range_offset) {
@@ skipping 45 matching lines @@
     DCHECK(file_stream);  // file_stream is non-null if content_length_ > 0.
     result = file_stream->ReadSync(buf->data(), num_bytes_to_read);
     if (result == 0)  // Reached end-of-file earlier than expected.
       result = ERR_UPLOAD_FILE_CHANGED;
   }
   return result;
 }
 
 }  // namespace
 
+UploadFileElementReader::FileStreamDeleter::FileStreamDeleter(
+    base::TaskRunner* task_runner) : task_runner_(task_runner) {
+  DCHECK(task_runner_);
+}
+
+UploadFileElementReader::FileStreamDeleter::~FileStreamDeleter() {}
+
 void UploadFileElementReader::FileStreamDeleter::operator() (
     FileStream* file_stream) const {
   if (file_stream) {
-    base::WorkerPool::PostTask(FROM_HERE,
-                               base::Bind(&base::DeletePointer<FileStream>,
-                                          file_stream),
-                               true /* task_is_slow */);
+    task_runner_->PostTask(FROM_HERE,
+                           base::Bind(&base::DeletePointer<FileStream>,
+                                      file_stream));
   }
 }
 
 UploadFileElementReader::UploadFileElementReader(
+    base::TaskRunner* task_runner,
     const FilePath& path,
     uint64 range_offset,
     uint64 range_length,
     const base::Time& expected_modification_time)
-    : path_(path),
+    : task_runner_(task_runner),
+      path_(path),
       range_offset_(range_offset),
       range_length_(range_length),
       expected_modification_time_(expected_modification_time),
+      file_stream_(NULL, FileStreamDeleter(task_runner_)),
       content_length_(0),
       bytes_remaining_(0),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
+  DCHECK(task_runner_);
 }
 
 UploadFileElementReader::~UploadFileElementReader() {
 }
 
 const UploadFileElementReader* UploadFileElementReader::AsFileReader() const {
   return this;
 }
 
 int UploadFileElementReader::Init(const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   Reset();
 
-  ScopedFileStreamPtr* file_stream = new ScopedFileStreamPtr;
+  ScopedFileStreamPtr* file_stream =
+      new ScopedFileStreamPtr(NULL, FileStreamDeleter(task_runner_));
   uint64* content_length = new uint64;
   const bool posted = base::PostTaskAndReplyWithResult(
-      base::WorkerPool::GetTaskRunner(true /* task_is_slow */),
+      task_runner_,
       FROM_HERE,
-      base::Bind(&InitInternal,
+      base::Bind(&InitInternal<FileStreamDeleter>,
                  path_,
                  range_offset_,
                  range_length_,
                  expected_modification_time_,
                  file_stream,
                  content_length),
       base::Bind(&UploadFileElementReader::OnInitCompleted,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Owned(file_stream),
                  base::Owned(content_length),
@@ skipping 18 matching lines @@
   DCHECK(!callback.is_null());
 
   if (BytesRemaining() == 0)
     return 0;
 
   // Save the value of file_stream_.get() before base::Passed() invalidates it.
   FileStream* file_stream_ptr = file_stream_.get();
   // Pass the ownership of file_stream_ to the worker pool to safely perform
   // operation even when |this| is destructed before the read completes.
   const bool posted = base::PostTaskAndReplyWithResult(
-      base::WorkerPool::GetTaskRunner(true /* task_is_slow */),
+      task_runner_,
       FROM_HERE,
       base::Bind(&ReadInternal,
                  scoped_refptr<IOBuffer>(buf),
                  buf_length,
                  BytesRemaining(),
                  file_stream_ptr),
       base::Bind(&UploadFileElementReader::OnReadCompleted,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(&file_stream_),
                  callback));
@@ skipping 57 matching lines @@
 }
 
 UploadFileElementReaderSync::~UploadFileElementReaderSync() {
 }
 
 int UploadFileElementReaderSync::Init(const CompletionCallback& callback) {
   bytes_remaining_ = 0;
   content_length_ = 0;
   file_stream_.reset();
 
-  UploadFileElementReader::ScopedFileStreamPtr file_stream;
-
   const int result = InitInternal(path_, range_offset_, range_length_,
                                   expected_modification_time_,
-                                  &file_stream, &content_length_);
-  file_stream_.reset(file_stream.release());
+                                  &file_stream_, &content_length_);
   bytes_remaining_ = GetContentLength();
   return result;
 }
 
 uint64 UploadFileElementReaderSync::GetContentLength() const {
   return content_length_;
 }
 
 uint64 UploadFileElementReaderSync::BytesRemaining() const {
   return bytes_remaining_;
 }
 
 int UploadFileElementReaderSync::Read(IOBuffer* buf,
                                       int buf_length,
                                       const CompletionCallback& callback) {
   const int result = ReadInternal(buf, buf_length, BytesRemaining(),
                                   file_stream_.get());
   if (result > 0) {
     DCHECK_GE(static_cast<int>(bytes_remaining_), result);
     bytes_remaining_ -= result;
   }
   return result;
 }
 
 }  // namespace net