Support filesystem files from BlobURLRequestJob

webkit/blob/blob_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/blob/blob_url_request_job.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_util_proxy.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_request_headers.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 "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_error_job.h"
 #include "net/url_request/url_request_status.h"
 #include "webkit/blob/local_file_stream_reader.h"
+#include "webkit/fileapi/file_system_context.h"
+#include "webkit/fileapi/file_system_url.h"
 
 namespace webkit_blob {
 
 namespace {
 
 const int kHTTPOk = 200;
 const int kHTTPPartialContent = 206;
 const int kHTTPNotAllowed = 403;
 const int kHTTPNotFound = 404;
 const int kHTTPMethodNotAllow = 405;
 const int kHTTPRequestedRangeNotSatisfiable = 416;
 const int kHTTPInternalError = 500;
 
 const char kHTTPOKText[] = "OK";
 const char kHTTPPartialContentText[] = "Partial Content";
 const char kHTTPNotAllowedText[] = "Not Allowed";
 const char kHTTPNotFoundText[] = "Not Found";
 const char kHTTPMethodNotAllowText[] = "Method Not Allowed";
 const char kHTTPRequestedRangeNotSatisfiableText[] =
     "Requested Range Not Satisfiable";
 const char kHTTPInternalErrorText[] = "Internal Server Error";
 
+bool IsFileType(BlobData::Item::Type type) {
+  switch (type) {
+    case BlobData::Item::TYPE_FILE:
+    case BlobData::Item::TYPE_FILE_FILESYSTEM:
+      return true;
+    default:
+      return false;
+  }
+}
+
 }  // namespace
 
 BlobURLRequestJob::BlobURLRequestJob(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate,
     BlobData* blob_data,
+    fileapi::FileSystemContext* file_system_context,
     base::MessageLoopProxy* file_thread_proxy)
     : net::URLRequestJob(request, network_delegate),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       blob_data_(blob_data),
+      file_system_context_(file_system_context),
       file_thread_proxy_(file_thread_proxy),
       total_size_(0),
       remaining_bytes_(0),
       pending_get_file_info_count_(0),
       current_item_index_(0),
       current_item_offset_(0),
       error_(false),
       headers_set_(false),
       byte_range_set_(false) {
   DCHECK(file_thread_proxy_);
@@ skipping 103 matching lines @@
 }
 
 void BlobURLRequestJob::CountSize() {
   error_ = false;
   pending_get_file_info_count_ = 0;
   total_size_ = 0;
   item_length_list_.resize(blob_data_->items().size());
 
   for (size_t i = 0; i < blob_data_->items().size(); ++i) {
     const BlobData::Item& item = blob_data_->items().at(i);
-    if (item.type() == BlobData::Item::TYPE_FILE) {
+    if (IsFileType(item.type())) {
       ++pending_get_file_info_count_;
       GetFileStreamReader(i)->GetLength(
           base::Bind(&BlobURLRequestJob::DidGetFileItemLength,
                      weak_factory_.GetWeakPtr(), i));
       continue;
     }
     // Cache the size and add it to the total size.
     int64 item_length = static_cast<int64>(item.length());
     item_length_list_[i] = item_length;
     total_size_ += item_length;
@@ skipping 37 matching lines @@
   if (result == net::ERR_UPLOAD_FILE_CHANGED) {
     NotifyFailure(net::ERR_FILE_NOT_FOUND);
     return;
   } else if (result < 0) {
     NotifyFailure(result);
     return;
   }
 
   DCHECK_LT(index, blob_data_->items().size());
   const BlobData::Item& item = blob_data_->items().at(index);
-  DCHECK(item.type() == BlobData::Item::TYPE_FILE);
+  DCHECK(IsFileType(item.type()));
 
   // If item length is -1, we need to use the file size being resolved
   // in the real time.
   int64 item_length = static_cast<int64>(item.length());
   if (item_length == -1)
     item_length = result - item.offset();
 
   // Cache the size and add it to the total size.
   DCHECK_LT(index, item_length_list_.size());
   item_length_list_[index] = item_length;
@@ skipping 13 matching lines @@
   }
 
   // Set the offset that need to jump to for the first item in the range.
   current_item_offset_ = offset;
 
   if (offset == 0)
     return;
 
   // Adjust the offset of the first stream if it is of file type.
   const BlobData::Item& item = blob_data_->items().at(current_item_index_);
-  if (item.type() == BlobData::Item::TYPE_FILE) {
+  if (IsFileType(item.type())) {
     DeleteCurrentFileReader();
     CreateFileStreamReader(current_item_index_, offset);
   }
 }
 
 bool BlobURLRequestJob::ReadItem() {
   // Are we done with reading all the blob data?
   if (remaining_bytes_ == 0)
     return true;
 
   // If we get to the last item but still expect something to read, bail out
   // since something is wrong.
   if (current_item_index_ >= blob_data_->items().size()) {
     NotifyFailure(net::ERR_FAILED);
     return false;
   }
 
   // Compute the bytes to read for current item.
   int bytes_to_read = ComputeBytesToRead();
 
   // If nothing to read for current item, advance to next item.
   if (bytes_to_read == 0) {
     AdvanceItem();
     return ReadItem();
   }
 
   // Do the reading.
   const BlobData::Item& item = blob_data_->items().at(current_item_index_);
-  switch (item.type()) {
-    case BlobData::Item::TYPE_BYTES:
-      return ReadBytesItem(item, bytes_to_read);
-    case BlobData::Item::TYPE_FILE:
-      return ReadFileItem(GetFileStreamReader(current_item_index_),
-                          bytes_to_read);
-    case BlobData::Item::TYPE_FILE_FILESYSTEM:
-    // TODO(kinuko): Support TYPE_FILE_FILESYSTEM case.
-    // http://crbug.com/141835
-    default:
-      DCHECK(false);
-      return false;
+  if (item.type() == BlobData::Item::TYPE_BYTES)
+    return ReadBytesItem(item, bytes_to_read);
+  if (IsFileType(item.type())) {
+    return ReadFileItem(GetFileStreamReader(current_item_index_),
+                        bytes_to_read);
   }
+  NOTREACHED();
+  return false;
 }
 
 void BlobURLRequestJob::AdvanceItem() {
   // Close the file if the current item is a file.
   DeleteCurrentFileReader();
 
   // Advance to the next item.
   current_item_index_++;
   current_item_offset_ = 0;
 }
@@ skipping 20 matching lines @@
   DCHECK_GE(read_buf_->BytesRemaining(), bytes_to_read);
 
   memcpy(read_buf_->data(),
          item.bytes() + item.offset() + current_item_offset_,
          bytes_to_read);
 
   AdvanceBytesRead(bytes_to_read);
   return true;
 }
 
-bool BlobURLRequestJob::ReadFileItem(LocalFileStreamReader* reader,
+bool BlobURLRequestJob::ReadFileItem(FileStreamReader* reader,
                                      int bytes_to_read) {
   DCHECK_GE(read_buf_->BytesRemaining(), bytes_to_read);
   DCHECK(reader);
   const int result = reader->Read(
       read_buf_, bytes_to_read,
       base::Bind(&BlobURLRequestJob::DidReadFile,
                  base::Unretained(this)));
   if (result >= 0) {
     // Data is immediately available.
     if (GetStatus().is_io_pending())
@@ skipping 152 matching lines @@
 
   response_info_.reset(new net::HttpResponseInfo());
   response_info_->headers = headers;
 
   set_expected_content_size(remaining_bytes_);
   headers_set_ = true;
 
   NotifyHeadersComplete();
 }
 
-LocalFileStreamReader* BlobURLRequestJob::GetFileStreamReader(size_t index) {
+FileStreamReader* BlobURLRequestJob::GetFileStreamReader(size_t index) {
   DCHECK_LT(index, blob_data_->items().size());
   const BlobData::Item& item = blob_data_->items().at(index);
-  if (item.type() != BlobData::Item::TYPE_FILE)
+  if (!IsFileType(item.type()))
     return NULL;
   if (index_to_reader_.find(index) == index_to_reader_.end())
     CreateFileStreamReader(index, 0);
   DCHECK(index_to_reader_[index]);
   return index_to_reader_[index];
 }
 
 void BlobURLRequestJob::CreateFileStreamReader(size_t index,
                                                int64 additional_offset) {
   DCHECK_LT(index, blob_data_->items().size());
   const BlobData::Item& item = blob_data_->items().at(index);
-  DCHECK_EQ(BlobData::Item::TYPE_FILE, item.type());
+  DCHECK(IsFileType(item.type()));
   DCHECK_EQ(0U, index_to_reader_.count(index));
-  // TODO(kinuko): Create appropriate FileStreamReader for TYPE_FILE_FILESYSTEM.
-  // http://crbug.com/141835
-  index_to_reader_[index] = new LocalFileStreamReader(
-      file_thread_proxy_,
-      item.path(),
-      item.offset() + additional_offset,
-      item.expected_modification_time());
+
+  FileStreamReader* reader = NULL;
+  switch (item.type()) {
+    case BlobData::Item::TYPE_FILE:
+      reader = new LocalFileStreamReader(
+          file_thread_proxy_,
+          item.path(),
+          item.offset() + additional_offset,
+          item.expected_modification_time());
+      break;
+    case BlobData::Item::TYPE_FILE_FILESYSTEM:
+      reader = file_system_context_->CreateFileStreamReader(
+          fileapi::FileSystemURL(item.url()),
+          item.offset() + additional_offset,
+          item.expected_modification_time());
+      break;
+    default:
+      NOTREACHED();
+  }
+  DCHECK(reader);
+  index_to_reader_[index] = reader;
 }
 
 }  // namespace webkit_blob