Remove WorkerPool dependency from URLRequestFileJob.

net/url_request/url_request_file_job.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.
 
 // For loading files, we make use of overlapped i/o to ensure that reading from
 // the filesystem (e.g., a network filesystem) does not block the calling
 // thread.  An alternative approach would be to use a background thread or pool
 // of threads, but it seems better to leverage the operating system's ability
 // to do background file reads for us.
 //
 // Since overlapped reads require a 'static' buffer for the duration of the
 // asynchronous read, the URLRequestFileJob keeps a buffer as a member var.  In
 // URLRequestFileJob::Read, data is simply copied from the object's buffer into
 // the given buffer.  If there is no data to copy, the URLRequestFileJob
 // attempts to read more from the file to fill its buffer.  If reading from the
 // file does not complete synchronously, then the URLRequestFileJob waits for a
 // signal from the OS that the overlapped read has completed.  It does so by
 // leveraging the MessageLoop::WatchObject API.
 
 #include "net/url_request/url_request_file_job.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/platform_file.h"
 #include "base/strings/string_util.h"
 #include "base/synchronization/lock.h"
+#include "base/task_runner.h"
 #include "base/threading/thread_restrictions.h"
-#include "base/threading/worker_pool.h"
 #include "build/build_config.h"
 #include "net/base/file_stream.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_request_error_job.h"
 #include "net/url_request/url_request_file_dir_job.h"
 #include "url/gurl.h"
 
 #if defined(OS_WIN)
 #include "base/win/shortcut.h"
 #endif
 
 namespace net {
 
 URLRequestFileJob::FileMetaInfo::FileMetaInfo()
     : file_size(0),
       mime_type_result(false),
       file_exists(false),
       is_directory(false) {
 }
 
-URLRequestFileJob::URLRequestFileJob(URLRequest* request,
-                                     NetworkDelegate* network_delegate,
-                                     const base::FilePath& file_path)
+URLRequestFileJob::URLRequestFileJob(
+    URLRequest* request, NetworkDelegate* network_delegate,

[akalin, 2013/08/16 21:22:20]

one param per line

+    const base::FilePath& file_path,
+    const scoped_refptr<base::TaskRunner>& file_task_runner)
     : URLRequestJob(request, network_delegate),
       file_path_(file_path),
-      stream_(new FileStream(NULL)),
+      stream_(new FileStream(NULL, file_task_runner)),
+      file_task_runner_(file_task_runner),
       remaining_bytes_(0),
-      weak_ptr_factory_(this) {
-}
+      weak_ptr_factory_(this) {}
 
 void URLRequestFileJob::Start() {
   FileMetaInfo* meta_info = new FileMetaInfo();
-  base::WorkerPool::PostTaskAndReply(
+  file_task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&URLRequestFileJob::FetchMetaInfo, file_path_,
                  base::Unretained(meta_info)),
       base::Bind(&URLRequestFileJob::DidFetchMetaInfo,
                  weak_ptr_factory_.GetWeakPtr(),
-                 base::Owned(meta_info)),
-      true);
+                 base::Owned(meta_info)));
 }
 
 void URLRequestFileJob::Kill() {
   stream_.reset();
   weak_ptr_factory_.InvalidateWeakPtrs();
 
   URLRequestJob::Kill();
 }
 
 bool URLRequestFileJob::ReadRawData(IOBuffer* dest, int dest_size,
@@ skipping 205 matching lines @@
     NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, result));
   }
 
   remaining_bytes_ -= result;
   DCHECK_GE(remaining_bytes_, 0);
 
   NotifyReadComplete(result);
 }
 
 }  // namespace net