net: Stop using base::WorkerPool from UploadFileElementReader

Pass TaskRunner to ResourceRequestBody::ResolveElementsAndCreateUploadDataStream and use it for file operations.

BUG=167524
TEST=net_unittests

Review URL: https://chromiumcodereview.appspot.com/11778016

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@176063 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 61 insertions, 26 deletions

diff --git a/net/base/upload_data_stream_unittest.cc b/net/base/upload_data_stream_unittest.cc
index 4740e0a..49c8da8 100644
--- a/net/base/upload_data_stream_unittest.cc
+++ b/net/base/upload_data_stream_unittest.cc
@@ -169,6 +169,7 @@ TEST_F(UploadDataStreamTest, File) {
             file_util::WriteFile(temp_file_path, kTestData, kTestDataSize));
 
   element_readers_.push_back(new UploadFileElementReader(
+      base::MessageLoopProxy::current(),
       temp_file_path, 0, kuint64max, base::Time()));
 
   TestCompletionCallback init_callback;
@@ -202,6 +203,7 @@ TEST_F(UploadDataStreamTest, FileSmallerThanLength) {
       overriding_content_length(kFakeSize);
 
   element_readers_.push_back(new UploadFileElementReader(
+      base::MessageLoopProxy::current(),
       temp_file_path, 0, kuint64max, base::Time()));
 
   TestCompletionCallback init_callback;
@@ -313,6 +315,7 @@ TEST_F(UploadDataStreamTest, FileAndBytes) {
   const uint64 kFileRangeOffset = 1;
   const uint64 kFileRangeLength = 4;
   element_readers_.push_back(new UploadFileElementReader(
+      base::MessageLoopProxy::current(),
       temp_file_path, kFileRangeOffset, kFileRangeLength, base::Time()));
 
   element_readers_.push_back(new UploadBytesElementReader(
@@ -509,7 +512,8 @@ void UploadDataStreamTest::FileChangedHelper(const FilePath& file_path,
   // Don't use element_readers_ here, as this function is called twice, and
   // reusing element_readers_ is wrong.
   ScopedVector<UploadElementReader> element_readers;
-  element_readers.push_back(new UploadFileElementReader(file_path, 1, 2, time));
+  element_readers.push_back(new UploadFileElementReader(
+      base::MessageLoopProxy::current(), file_path, 1, 2, time));
 
   TestCompletionCallback init_callback;
   UploadDataStream stream(&element_readers, 0);
@@ -551,6 +555,7 @@ TEST_F(UploadDataStreamTest, MultipleInit) {
   element_readers_.push_back(new UploadBytesElementReader(
       kTestData, kTestDataSize));
   element_readers_.push_back(new UploadFileElementReader(
+      base::MessageLoopProxy::current(),
       temp_file_path, 0, kuint64max, base::Time()));
   UploadDataStream stream(&element_readers_, 0);
 
@@ -592,6 +597,7 @@ TEST_F(UploadDataStreamTest, MultipleInitAsync) {
   element_readers_.push_back(new UploadBytesElementReader(
       kTestData, kTestDataSize));
   element_readers_.push_back(new UploadFileElementReader(
+      base::MessageLoopProxy::current(),
       temp_file_path, 0, kuint64max, base::Time()));
   UploadDataStream stream(&element_readers_, 0);
 
@@ -630,6 +636,7 @@ TEST_F(UploadDataStreamTest, InitToReset) {
   element_readers_.push_back(new UploadBytesElementReader(
       kTestData, kTestDataSize));
   element_readers_.push_back(new UploadFileElementReader(
+      base::MessageLoopProxy::current(),
       temp_file_path, 0, kuint64max, base::Time()));
   UploadDataStream stream(&element_readers_, 0);
 
@@ -681,6 +688,7 @@ TEST_F(UploadDataStreamTest, InitDuringAsyncInit) {
   element_readers_.push_back(new UploadBytesElementReader(
       kTestData, kTestDataSize));
   element_readers_.push_back(new UploadFileElementReader(
+      base::MessageLoopProxy::current(),
       temp_file_path, 0, kuint64max, base::Time()));
   UploadDataStream stream(&element_readers_, 0);
 
@@ -724,6 +732,7 @@ TEST_F(UploadDataStreamTest, InitDuringAsyncRead) {
   element_readers_.push_back(new UploadBytesElementReader(
       kTestData, kTestDataSize));
   element_readers_.push_back(new UploadFileElementReader(
+      base::MessageLoopProxy::current(),
       temp_file_path, 0, kuint64max, base::Time()));
   UploadDataStream stream(&element_readers_, 0);
 
diff --git a/net/base/upload_file_element_reader.cc b/net/base/upload_file_element_reader.cc
index 32cb27f..0d2cff4 100644
--- a/net/base/upload_file_element_reader.cc
+++ b/net/base/upload_file_element_reader.cc
@@ -8,7 +8,6 @@
 #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"
@@ -22,11 +21,12 @@ namespace {
 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(
@@ -92,28 +92,38 @@ int ReadInternal(scoped_refptr<IOBuffer> buf,
 
 }  // 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() {
@@ -127,12 +137,13 @@ 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_,
@@ -171,7 +182,7 @@ int UploadFileElementReader::Read(IOBuffer* buf,
   // 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),
@@ -249,12 +260,9 @@ int UploadFileElementReaderSync::Init(const CompletionCallback& callback) {
   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;
 }
diff --git a/net/base/upload_file_element_reader.h b/net/base/upload_file_element_reader.h
index f85d45f..ad16bb2 100644
--- a/net/base/upload_file_element_reader.h
+++ b/net/base/upload_file_element_reader.h
@@ -8,11 +8,16 @@
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/gtest_prod_util.h"
+#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time.h"
 #include "net/base/upload_element_reader.h"
 
+namespace base {
+class TaskRunner;
+}
+
 namespace net {
 
 class FileStream;
@@ -20,16 +25,9 @@ class FileStream;
 // An UploadElementReader implementation for file.
 class NET_EXPORT UploadFileElementReader : public UploadElementReader {
  public:
-  // Deletes FileStream on the worker pool to avoid blocking the IO thread.
-  // This class is used as a template argument of scoped_ptr_malloc.
-  class FileStreamDeleter {
-   public:
-    void operator() (FileStream* file_stream) const;
-  };
-
-  typedef scoped_ptr_malloc<FileStream, FileStreamDeleter> ScopedFileStreamPtr;
-
-  UploadFileElementReader(const FilePath& path,
+  // |task_runner| is used to perform file operations. It must not be NULL.
+  UploadFileElementReader(base::TaskRunner* task_runner,
+                          const FilePath& path,
                           uint64 range_offset,
                           uint64 range_length,
                           const base::Time& expected_modification_time);
@@ -52,6 +50,20 @@ class NET_EXPORT UploadFileElementReader : public UploadElementReader {
                    const CompletionCallback& callback) OVERRIDE;
 
  private:
+  // Deletes FileStream with |task_runner| to avoid blocking the IO thread.
+  // This class is used as a template argument of scoped_ptr.
+  class FileStreamDeleter {
+   public:
+    explicit FileStreamDeleter(base::TaskRunner* task_runner);
+    ~FileStreamDeleter();
+    void operator() (FileStream* file_stream) const;
+
+   private:
+    scoped_refptr<base::TaskRunner> task_runner_;
+  };
+
+  typedef scoped_ptr<FileStream, FileStreamDeleter> ScopedFileStreamPtr;
+
   FRIEND_TEST_ALL_PREFIXES(UploadDataStreamTest, FileSmallerThanLength);
   FRIEND_TEST_ALL_PREFIXES(HttpNetworkTransactionTest,
                            UploadFileSmallerThanLength);
@@ -81,6 +93,7 @@ class NET_EXPORT UploadFileElementReader : public UploadElementReader {
     ~ScopedOverridingContentLengthForTests();
   };
 
+  scoped_refptr<base::TaskRunner> task_runner_;
   const FilePath path_;
   const uint64 range_offset_;
   const uint64 range_length_;
diff --git a/net/base/upload_file_element_reader_unittest.cc b/net/base/upload_file_element_reader_unittest.cc
index 4915635..41e69fd 100644
--- a/net/base/upload_file_element_reader_unittest.cc
+++ b/net/base/upload_file_element_reader_unittest.cc
@@ -6,6 +6,7 @@
 
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
+#include "base/message_loop_proxy.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
@@ -30,6 +31,7 @@ class UploadFileElementReaderTest : public PlatformTest {
         file_util::WriteFile(temp_file_path_, &bytes_[0], bytes_.size()));
 
     reader_.reset(new UploadFileElementReader(
+        base::MessageLoopProxy::current(),
         temp_file_path_, 0, kuint64max, base::Time()));
     TestCompletionCallback callback;
     ASSERT_EQ(ERR_IO_PENDING, reader_->Init(callback.callback()));
@@ -160,6 +162,7 @@ TEST_F(UploadFileElementReaderTest, Range) {
   const uint64 kOffset = 2;
   const uint64 kLength = bytes_.size() - kOffset * 3;
   reader_.reset(new UploadFileElementReader(
+      base::MessageLoopProxy::current(),
       temp_file_path_, kOffset, kLength, base::Time()));
   TestCompletionCallback init_callback;
   ASSERT_EQ(ERR_IO_PENDING, reader_->Init(init_callback.callback()));
@@ -185,6 +188,7 @@ TEST_F(UploadFileElementReaderTest, FileChanged) {
   const base::Time expected_modification_time =
       info.last_modified - base::TimeDelta::FromSeconds(1);
   reader_.reset(new UploadFileElementReader(
+      base::MessageLoopProxy::current(),
       temp_file_path_, 0, kuint64max, expected_modification_time));
   TestCompletionCallback init_callback;
   ASSERT_EQ(ERR_IO_PENDING, reader_->Init(init_callback.callback()));
@@ -194,6 +198,7 @@ TEST_F(UploadFileElementReaderTest, FileChanged) {
 TEST_F(UploadFileElementReaderTest, WrongPath) {
   const FilePath wrong_path(FILE_PATH_LITERAL("wrong_path"));
   reader_.reset(new UploadFileElementReader(
+      base::MessageLoopProxy::current(),
       wrong_path, 0, kuint64max, base::Time()));
   TestCompletionCallback init_callback;
   ASSERT_EQ(ERR_IO_PENDING, reader_->Init(init_callback.callback()));