Break large blobs into multiple ipcs during creation.

webkit/blob/blob_url_request_job.cc

 // Copyright (c) 2011 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/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/file_util_proxy.h"
@@ skipping 119 matching lines @@
     return;
   } else if (rv != base::PLATFORM_FILE_OK) {
     NotifyFailure(net::ERR_FAILED);
     return;
   }
 
   // Validate the expected modification time.
   // Note that the expected modification time from WebKit is based on
   // time_t precision. So we have to convert both to time_t to compare.
   const BlobData::Item& item = blob_data_->items().at(item_index_);
-  DCHECK(item.type() == BlobData::TYPE_FILE);
+  DCHECK(item.type == BlobData::TYPE_FILE);
 
-  if (!item.expected_modification_time().is_null() &&
-      item.expected_modification_time().ToTimeT() !=
+  if (!item.expected_modification_time.is_null() &&
+      item.expected_modification_time.ToTimeT() !=
           file_info.last_modified.ToTimeT()) {
     NotifyFailure(net::ERR_FILE_NOT_FOUND);
     return;
   }
 
   // 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());
+  int64 item_length = static_cast<int64>(item.length);
   if (item_length == -1)
     item_length = file_info.size;
 
   // Cache the size and add it to the total size.
   item_length_list_.push_back(item_length);
   total_size_ += item_length;
 
   // Continue counting the size for the remaining items.
   item_index_++;
   CountSize();
 }
 
 void BlobURLRequestJob::CountSize() {
   for (; item_index_ < blob_data_->items().size(); ++item_index_) {
     const BlobData::Item& item = blob_data_->items().at(item_index_);
-    int64 item_length = static_cast<int64>(item.length());
+    int64 item_length = static_cast<int64>(item.length);
 
     // If there is a file item, do the resolving.
-    if (item.type() == BlobData::TYPE_FILE) {
-      ResolveFile(item.file_path());
+    if (item.type == BlobData::TYPE_FILE) {
+      ResolveFile(item.file_path);
       return;
     }
 
     // Cache the size and add it to the total size.
     item_length_list_.push_back(item_length);
     total_size_ += item_length;
   }
 
   // Reset item_index_ since it will be reused to read the items.
   item_index_ = 0;
@@ skipping 99 matching lines @@
   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(item_index_);
-  switch (item.type()) {
+  switch (item.type) {
     case BlobData::TYPE_DATA:
       return ReadBytes(item);
     case BlobData::TYPE_FILE:
       return DispatchReadFile(item);
     default:
       DCHECK(false);
       return false;
   }
 }
 
 bool BlobURLRequestJob::ReadBytes(const BlobData::Item& item) {
   DCHECK(read_buf_remaining_bytes_ >= bytes_to_read_);
 
   memcpy(read_buf_->data() + read_buf_offset_,
-         &item.data().at(0) + item.offset() + current_item_offset_,
+         &item.data.at(0) + item.offset + current_item_offset_,
          bytes_to_read_);
 
   AdvanceBytesRead(bytes_to_read_);
   return true;
 }
 
 bool BlobURLRequestJob::DispatchReadFile(const BlobData::Item& item) {
   // If the stream already exists, keep reading from it.
   if (stream_ != NULL)
     return ReadFile(item);
 
   base::FileUtilProxy::CreateOrOpen(
-      file_thread_proxy_, item.file_path(), kFileOpenFlags,
+      file_thread_proxy_, item.file_path, kFileOpenFlags,
       callback_factory_.NewCallback(&BlobURLRequestJob::DidOpen));
   SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0));
   return false;
 }
 
 void BlobURLRequestJob::DidOpen(base::PlatformFileError rv,
                                 base::PassPlatformFile file,
                                 bool created) {
   if (rv != base::PLATFORM_FILE_OK) {
     NotifyFailure(net::ERR_FAILED);
     return;
   }
 
   DCHECK(!stream_.get());
   stream_.reset(new net::FileStream(file.ReleaseValue(), kFileOpenFlags));
 
   const BlobData::Item& item = blob_data_->items().at(item_index_);
   {
     // stream_.Seek() blocks the IO thread, see http://crbug.com/75548.

[michaeln, 2011/09/29 19:45:01]

might be nice to do the seek on the filethread prior to coming back to the io
thread...

FileUtilProxy::OpenAndSeek(path, open_flags, seek_offset)

     base::ThreadRestrictions::ScopedAllowIO allow_io;
-    int64 offset = current_item_offset_ + static_cast<int64>(item.offset());
+    int64 offset = current_item_offset_ + static_cast<int64>(item.offset);
     if (offset > 0 && offset != stream_->Seek(net::FROM_BEGIN, offset)) {
       NotifyFailure(net::ERR_FAILED);
       return;
     }
   }
 
   ReadFile(item);
 }
 
 bool BlobURLRequestJob::ReadFile(const BlobData::Item& item) {
@@ skipping 210 matching lines @@
         // We don't support multiple range requests in one single URL request,
         // because we need to do multipart encoding here.
         // TODO(jianli): Support multipart byte range requests.
         NotifyFailure(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE);
       }
     }
   }
 }
 
 }  // namespace webkit_blob