Add FileReader interface and implement FileSystemFileReader

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_file_reader.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 {
 
@@ skipping 27 matching lines @@
 FileSystemURLRequestJob::~FileSystemURLRequestJob() {}
 
 void FileSystemURLRequestJob::Start() {
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&FileSystemURLRequestJob::StartAsync,
                  weak_factory_.GetWeakPtr()));
 }
 
 void FileSystemURLRequestJob::Kill() {
-  if (reader_.get() != NULL)
-    reader_.reset();
+  reader_.reset();
   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);
 
@@ skipping 62 matching lines @@
 
 int FileSystemURLRequestJob::GetResponseCode() const {
   if (response_info_.get())
     return 200;
   return URLRequestJob::GetResponseCode();
 }
 
 void FileSystemURLRequestJob::StartAsync() {
   if (!request_)
     return;
+  DCHECK(!reader_.get());
   FileSystemOperationInterface* operation =
       file_system_context_->CreateFileSystemOperation(
           request_->url(),
           file_thread_proxy_);
   if (!operation) {
     NotifyDone(URLRequestStatus(URLRequestStatus::FAILED,
                                 net::ERR_INVALID_URL));
     return;
   }
-  operation->CreateSnapshotFile(
+  operation->GetMetadata(
       request_->url(),
-      base::Bind(&FileSystemURLRequestJob::DidCreateSnapshot, this));
+      base::Bind(&FileSystemURLRequestJob::DidGetMetadata,
+                 weak_factory_.GetWeakPtr()));
 }
 
-void FileSystemURLRequestJob::DidCreateSnapshot(
+void FileSystemURLRequestJob::DidGetMetadata(
     base::PlatformFileError error_code,
     const base::PlatformFileInfo& file_info,
-    const FilePath& platform_path,
-    const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref) {
+    const FilePath& platform_path) {
   if (error_code != base::PLATFORM_FILE_OK) {
     NotifyFailed(error_code == base::PLATFORM_FILE_ERROR_INVALID_URL ?
                  net::ERR_INVALID_URL : net::ERR_FILE_NOT_FOUND);
     return;
   }
 
   // We may have been orphaned...
   if (!request_)
     return;
 
   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_) {
     NotifyHeadersComplete();
     return;
   }
 
   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()));
+  reader_.reset(new FileSystemFileReader(
+          file_thread_proxy_,
+          file_system_context_,
+          request_->url(),
+          byte_range_.first_byte_position()));
 
   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
@@ skipping 23 matching lines @@
   }
 
   return false;
 }
 
 void FileSystemURLRequestJob::NotifyFailed(int rv) {
   NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, rv));
 }
 
 }  // namespace fileapi