net: Stop using base::WorkerPool from UploadFileElementReader

webkit/glue/resource_request_body.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 "webkit/glue/resource_request_body.h"
 
 #include "base/logging.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_data_stream.h"
 #include "net/base/upload_file_element_reader.h"
 #include "webkit/blob/blob_storage_controller.h"
+#include "webkit/fileapi/file_system_context.h"
+#include "webkit/fileapi/file_system_task_runners.h"
 
 using webkit_blob::BlobData;
 using webkit_blob::BlobStorageController;
 
 namespace webkit_glue {
 
 namespace {
 
 // A subclass of net::UploadBytesElementReader which owns ResourceRequestBody.
 class BytesElementReader : public net::UploadBytesElementReader {
@@ skipping 12 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(BytesElementReader);
 };
 
 // A subclass of net::UploadFileElementReader which owns ResourceRequestBody.
 // This class is necessary to ensure the BlobData and any attached shareable
 // files survive until upload completion.
 class FileElementReader : public net::UploadFileElementReader {
  public:
   FileElementReader(ResourceRequestBody* resource_request_body,
+                    base::TaskRunner* task_runner,
                     const ResourceRequestBody::Element& element)
-      : net::UploadFileElementReader(element.path(),
+      : net::UploadFileElementReader(task_runner,
+                                     element.path(),
                                      element.offset(),
                                      element.length(),
                                      element.expected_modification_time()),
         resource_request_body_(resource_request_body) {
     DCHECK_EQ(ResourceRequestBody::Element::TYPE_FILE, element.type());
   }
 
   virtual ~FileElementReader() {}
 
  private:
@@ skipping 30 matching lines @@
 void ResourceRequestBody::AppendFileSystemFileRange(
     const GURL& url, uint64 offset, uint64 length,
     const base::Time& expected_modification_time) {
   elements_.push_back(Element());
   elements_.back().SetToFileSystemUrlRange(url, offset, length,
                                            expected_modification_time);
 }
 
 net::UploadDataStream*
 ResourceRequestBody::ResolveElementsAndCreateUploadDataStream(
-    BlobStorageController* blob_controller) {
+    BlobStorageController* blob_controller,
+    fileapi::FileSystemContext* file_system_context) {
   // Resolve all blob elements.
   std::vector<const Element*> resolved_elements;
   for (size_t i = 0; i < elements_.size(); ++i) {
     const Element& element = elements_[i];
     if (element.type() == Element::TYPE_BLOB) {
       ResolveBlobReference(blob_controller, element.url(), &resolved_elements);
     } else {
       // No need to resolve, just append the element.
       resolved_elements.push_back(&element);
     }
   }
 
   ScopedVector<net::UploadElementReader> element_readers;
   for (size_t i = 0; i < resolved_elements.size(); ++i) {
     const Element& element = *resolved_elements[i];
     switch (element.type()) {
       case Element::TYPE_BYTES:
         element_readers.push_back(new BytesElementReader(this, element));
         break;
       case Element::TYPE_FILE:
-        element_readers.push_back(new FileElementReader(this, element));
+        element_readers.push_back(new FileElementReader(
+            this,
+            file_system_context->task_runners()->file_task_runner(),

[kinuko, 2013/01/07 08:16:22]

While I can see why you wanted to pass file_system_context to this method for
future use it feels a bit weird to me using the FileSystemContext's task runner
for TYPE_FILE here (as it's not necessarily for fileapi files).  At least in
this patch shouldn't we simply pass in a task runner?

[hashimoto, 2013/01/07 09:12:33]

Done.

When we support Filesystem files, are we going to replace the TaskRunner with
FileSystemContext, or pass both TaskRunner and FileSystemContext?

[kinuko, 2013/01/08 03:32:48]

To me passing both sounds more reasonable, though it's a bit unfortunate.

+            element));
         break;
       case Element::TYPE_FILE_FILESYSTEM:
         // TODO(kinuko): Resolve FileSystemURL before creating UploadData.
         NOTREACHED();
         break;
       case Element::TYPE_BLOB:
         // Blob elements should be resolved beforehand.
         NOTREACHED();
         break;
       case Element::TYPE_UNKNOWN:
@@ skipping 26 matching lines @@
 
   // Append the elements in the referred blob data.
   for (size_t i = 0; i < blob_data->items().size(); ++i) {
     const BlobData::Item& item = blob_data->items().at(i);
     DCHECK_NE(BlobData::Item::TYPE_BLOB, item.type());
     resolved_elements->push_back(&item);
   }
 }
 
 }  // namespace webkit_glue