Revert 132134 - Use LocalFileReader in FileSystemURLRequestJob

webkit/fileapi/file_system_url_request_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.
 
 #include "webkit/fileapi/file_system_url_request_job.h"
 
+#include <vector>
+
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util_proxy.h"
 #include "base/message_loop.h"
 #include "base/platform_file.h"
 #include "base/threading/thread_restrictions.h"
-#include "base/time.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/mime_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_request.h"
-#include "webkit/blob/local_file_reader.h"
 #include "webkit/blob/shareable_file_reference.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_operation.h"
 #include "webkit/fileapi/file_system_util.h"
 
 using net::URLRequest;
 using net::URLRequestJob;
 using net::URLRequestStatus;
-using webkit_blob::LocalFileReader;
 
 namespace fileapi {
 
+static const int kFileFlags = base::PLATFORM_FILE_OPEN |
+                              base::PLATFORM_FILE_READ |
+                              base::PLATFORM_FILE_ASYNC;
+
 static net::HttpResponseHeaders* CreateHttpResponseHeaders() {
   // HttpResponseHeaders expects its input string to be terminated by two NULs.
   static const char kStatus[] = "HTTP/1.1 200 OK\0";
   static const size_t kStatusLen = arraysize(kStatus);
 
   net::HttpResponseHeaders* headers =
       new net::HttpResponseHeaders(std::string(kStatus, kStatusLen));
 
   // Tell WebKit never to cache this content.
   std::string cache_control(net::HttpRequestHeaders::kCacheControl);
   cache_control.append(": no-cache");
   headers->AddHeader(cache_control);
 
   return headers;
 }
 
 FileSystemURLRequestJob::FileSystemURLRequestJob(
     URLRequest* request, FileSystemContext* file_system_context,
     scoped_refptr<base::MessageLoopProxy> file_thread_proxy)
     : URLRequestJob(request),
       file_system_context_(file_system_context),
       file_thread_proxy_(file_thread_proxy),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
+      stream_(NULL),
       is_directory_(false),
       remaining_bytes_(0) {
 }
 
-FileSystemURLRequestJob::~FileSystemURLRequestJob() {}
+FileSystemURLRequestJob::~FileSystemURLRequestJob() {
+  // Since we use the two-arg constructor of FileStream, we need to call Close()
+  // manually: ~FileStream won't call it for us.
+  if (stream_ != NULL) {
+    // Close() performs file IO: crbug.com/113300.
+    base::ThreadRestrictions::ScopedAllowIO allow_io;
+    stream_->CloseSync();
+  }
+}
 
 void FileSystemURLRequestJob::Start() {
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&FileSystemURLRequestJob::StartAsync,
                  weak_factory_.GetWeakPtr()));
 }
 
 void FileSystemURLRequestJob::Kill() {
-  if (reader_.get() != NULL)
-    reader_.reset();
+  if (stream_ != NULL) {
+    // Close() performs file IO: crbug.com/113300.
+    base::ThreadRestrictions::ScopedAllowIO allow_io;
+    stream_->CloseSync();
+    stream_.reset(NULL);
+  }
   URLRequestJob::Kill();
   weak_factory_.InvalidateWeakPtrs();
 }
 
 bool FileSystemURLRequestJob::ReadRawData(net::IOBuffer* dest, int dest_size,
                                           int *bytes_read) {
   DCHECK_NE(dest_size, 0);
   DCHECK(bytes_read);
   DCHECK_GE(remaining_bytes_, 0);
 
-  if (reader_.get() == NULL)
+  if (stream_ == NULL)
     return false;
 
   if (remaining_bytes_ < dest_size)
     dest_size = static_cast<int>(remaining_bytes_);
 
   if (!dest_size) {
     *bytes_read = 0;
     return true;
   }
 
-  const int rv = reader_->Read(dest, dest_size,
-                               base::Bind(&FileSystemURLRequestJob::DidRead,
-                                          base::Unretained(this)));
+  int rv = stream_->Read(dest, dest_size,
+                         base::Bind(&FileSystemURLRequestJob::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 == net::ERR_IO_PENDING)
     SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
   else
     NotifyFailed(rv);
   return false;
 }
 
 bool FileSystemURLRequestJob::GetMimeType(std::string* mime_type) const {
   DCHECK(request_);
   FilePath virtual_path;
@@ skipping 70 matching lines @@
   is_directory_ = file_info.is_directory;
 
   // Keep the reference (if it's non-null) so that the file won't go away.
   snapshot_ref_ = file_ref;
 
   if (!byte_range_.ComputeBounds(file_info.size)) {
     NotifyFailed(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE);
     return;
   }
 
-  if (is_directory_) {
+  if (!is_directory_) {
+    base::FileUtilProxy::CreateOrOpen(
+        file_thread_proxy_, platform_path, kFileFlags,
+        base::Bind(&FileSystemURLRequestJob::DidOpen,
+                   weak_factory_.GetWeakPtr()));
+  } else {
     NotifyHeadersComplete();
+  }
+}
+
+void FileSystemURLRequestJob::DidOpen(base::PlatformFileError error_code,
+                                      base::PassPlatformFile file,
+                                      bool created) {
+  if (error_code != base::PLATFORM_FILE_OK) {
+    NotifyFailed(error_code);
     return;
   }
 
+  stream_.reset(new net::FileStream(file.ReleaseValue(), kFileFlags, NULL));
+
   remaining_bytes_ = byte_range_.last_byte_position() -
                      byte_range_.first_byte_position() + 1;
   DCHECK_GE(remaining_bytes_, 0);
 
-  DCHECK(!reader_.get());
-  reader_.reset(new LocalFileReader(
-      file_thread_proxy_, platform_path,
-      byte_range_.first_byte_position(),
-      base::Time()));
+  // TODO(adamk): Please remove this ScopedAllowIO once we support async seek
+  // on FileStream. crbug.com/113300
+  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(net::FROM_BEGIN,
+                            byte_range_.first_byte_position())) {
+    NotifyFailed(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE);
+    return;
+  }
 
   set_expected_content_size(remaining_bytes_);
   response_info_.reset(new net::HttpResponseInfo());
   response_info_->headers = CreateHttpResponseHeaders();
+
   NotifyHeadersComplete();
 }
 
 void FileSystemURLRequestJob::DidRead(int result) {
   if (result > 0)
     SetStatus(URLRequestStatus());  // Clear the IO_PENDING status
   else if (result == 0)
     NotifyDone(URLRequestStatus());
   else
     NotifyFailed(result);
@@ skipping 19 matching lines @@
   }
 
   return false;
 }
 
 void FileSystemURLRequestJob::NotifyFailed(int rv) {
   NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, rv));
 }
 
 }  // namespace fileapi