net: Implement canceling of all async operations in FileStream.

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.
 //
@@ skipping 11 matching lines @@
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/platform_file.h"
 #include "base/string_util.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/worker_pool.h"
 #include "base/threading/thread_restrictions.h"
 #include "build/build_config.h"
 #include "googleurl/src/gurl.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"
 
 #if defined(OS_WIN)
@@ skipping 41 matching lines @@
 
   base::Lock lock_;
   MessageLoop* owner_loop_;
 };
 
 URLRequestFileJob::URLRequestFileJob(URLRequest* request,
                                      NetworkDelegate* network_delegate,
                                      const FilePath& file_path)
     : URLRequestJob(request, network_delegate),
       file_path_(file_path),
-      stream_(NULL),
       is_directory_(false),
       remaining_bytes_(0) {
 }
 
 // static
 URLRequestJob* URLRequestFileJob::Factory(URLRequest* request,
                                           NetworkDelegate* network_delegate,
                                           const std::string& scheme) {
   FilePath file_path;
   const bool is_file = FileURLToFilePath(request->url(), &file_path);
@@ skipping 22 matching lines @@
 void URLRequestFileJob::Start() {
   DCHECK(!async_resolver_);
   async_resolver_ = new AsyncResolver(this);
   base::WorkerPool::PostTask(
       FROM_HERE,
       base::Bind(&AsyncResolver::Resolve, async_resolver_.get(), file_path_),
       true);
 }
 
 void URLRequestFileJob::Kill() {
-  // URL requests should not block on the disk!
-  //   http://code.google.com/p/chromium/issues/detail?id=59849
-  base::ThreadRestrictions::ScopedAllowIO allow_io;
-  stream_.CloseSync();
+  stream_.reset();
 
   if (async_resolver_) {
     async_resolver_->Cancel();
     async_resolver_ = NULL;
   }
 
   URLRequestJob::Kill();
 }
 
 bool URLRequestFileJob::ReadRawData(IOBuffer* dest, int dest_size,
                                     int *bytes_read) {
   DCHECK_NE(dest_size, 0);
   DCHECK(bytes_read);
   DCHECK_GE(remaining_bytes_, 0);
 
   if (remaining_bytes_ < dest_size)
     dest_size = static_cast<int>(remaining_bytes_);
 
   // If we should copy zero bytes because |remaining_bytes_| is zero, short
   // circuit here.
   if (!dest_size) {
     *bytes_read = 0;
     return true;
   }
 
-  int rv = stream_.Read(dest, dest_size,
-                        base::Bind(&URLRequestFileJob::DidRead,
-                                   base::Unretained(this)));
+  int rv = stream_->Read(dest, dest_size,
+                         base::Bind(&URLRequestFileJob::DidRead,
+                                    base::Unretained(this)));
   if (rv >= 0) {
     // Data is immediately available.
     *bytes_read = rv;
     remaining_bytes_ -= rv;
     DCHECK_GE(remaining_bytes_, 0);
     return true;
   }
 
   // Otherwise, a read error occured.  We may just need to wait...
   if (rv == ERR_IO_PENDING) {
@@ skipping 96 matching lines @@
   // trailing slash.
   // If a directory does not exist, we return ERR_FILE_NOT_FOUND. Otherwise,
   // we will append trailing slash and redirect to FileDirJob.
   // A special case is "\" on Windows. We should resolve as invalid.
   // However, Windows resolves "\" to "C:\", thus reports it as existent.
   // So what happens is we append it with trailing slash and redirect it to
   // FileDirJob where it is resolved as invalid.
   if (!exists) {
     rv = ERR_FILE_NOT_FOUND;
   } else if (!is_directory_) {
+    stream_.reset(new FileStream(NULL));
+
     // URL requests should not block on the disk!
     //   http://code.google.com/p/chromium/issues/detail?id=59849
     base::ThreadRestrictions::ScopedAllowIO allow_io;
 
     int flags = base::PLATFORM_FILE_OPEN |
                 base::PLATFORM_FILE_READ |
                 base::PLATFORM_FILE_ASYNC;
-    rv = stream_.OpenSync(file_path_, flags);
+    rv = stream_->OpenSync(file_path_, flags);
   }
 
   if (rv != OK) {
     NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, rv));
     return;
   }
 
   if (!byte_range_.ComputeBounds(file_info.size)) {
     NotifyDone(URLRequestStatus(URLRequestStatus::FAILED,
                ERR_REQUEST_RANGE_NOT_SATISFIABLE));
     return;
   }
 
   remaining_bytes_ = byte_range_.last_byte_position() -
                      byte_range_.first_byte_position() + 1;
   DCHECK_GE(remaining_bytes_, 0);
 
   // URL requests should not block on the disk!
   //   http://code.google.com/p/chromium/issues/detail?id=59849
   {
     base::ThreadRestrictions::ScopedAllowIO allow_io;
     // Do the seek at the beginning of the request.
     if (remaining_bytes_ > 0 &&
         byte_range_.first_byte_position() != 0 &&
         byte_range_.first_byte_position() !=
-        stream_.SeekSync(FROM_BEGIN, byte_range_.first_byte_position())) {
+        stream_->SeekSync(FROM_BEGIN, byte_range_.first_byte_position())) {
       NotifyDone(URLRequestStatus(URLRequestStatus::FAILED,
                                   ERR_REQUEST_RANGE_NOT_SATISFIABLE));
       return;
     }
   }
 
   set_expected_content_size(remaining_bytes_);
   NotifyHeadersComplete();
 }
 
 void URLRequestFileJob::DidRead(int result) {
   if (result > 0) {
     SetStatus(URLRequestStatus());  // Clear the IO_PENDING status
   } else if (result == 0) {
     NotifyDone(URLRequestStatus());
   } else {
     NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, result));
   }
 
   remaining_bytes_ -= result;
   DCHECK_GE(remaining_bytes_, 0);
 
   NotifyReadComplete(result);
 }
 
 }  // namespace net