Break large blobs into multiple ipcs during creation.

webkit/blob/blob_storage_controller.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_storage_controller.h"
 
 #include "base/logging.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/upload_data.h"
 #include "webkit/blob/blob_data.h"
@@ skipping 19 matching lines @@
 }
 
 }  // namespace
 
 BlobStorageController::BlobStorageController() {
 }
 
 BlobStorageController::~BlobStorageController() {
 }
 
-void BlobStorageController::RegisterBlobUrl(
-    const GURL& url, const BlobData* blob_data) {
+void BlobStorageController::RegisterUnfinalizedBlobUrl(const GURL& url) {
   DCHECK(url.SchemeIs("blob"));
   DCHECK(!BlobUrlHasRef(url));
+  unfinalized_blob_map_[url.spec()] = new BlobData();
+}
 
-  scoped_refptr<BlobData> target_blob_data(new BlobData());
-  target_blob_data->set_content_type(blob_data->content_type());
-  target_blob_data->set_content_disposition(blob_data->content_disposition());
+void BlobStorageController::AppendBlobDataItem(
+    const GURL& url, const webkit_blob::BlobData::Item& item) {
+  DCHECK(url.SchemeIs("blob"));
+  DCHECK(!BlobUrlHasRef(url));
+  BlobMap::iterator found = unfinalized_blob_map_.find(url.spec());
+  if (found == unfinalized_blob_map_.end())
+    return;
+  BlobData* target_blob_data = found->second;
+  DCHECK(target_blob_data);
 
   // The blob data is stored in the "canonical" way. That is, it only contains a
   // list of Data and File items.
   // 1) The Data item is denoted by the raw data and the range.
   // 2) The File item is denoted by the file path, the range and the expected
   //    modification time.
   // All the Blob items in the passing blob data are resolved and expanded into
   // a set of Data and File items.
 
-  for (std::vector<BlobData::Item>::const_iterator iter =
-           blob_data->items().begin();
-       iter != blob_data->items().end(); ++iter) {
-    switch (iter->type()) {
-      case BlobData::TYPE_DATA: {
-        // WebBlobData does not allow partial data.
-        DCHECK(!(iter->offset()) && iter->length() == iter->data().size());
-        target_blob_data->AppendData(iter->data());
-        break;
-      }
-      case BlobData::TYPE_FILE:
-        AppendFileItem(target_blob_data,
-                       iter->file_path(),
-                       iter->offset(),
-                       iter->length(),
-                       iter->expected_modification_time());
-        break;
-      case BlobData::TYPE_BLOB: {
-        BlobData* src_blob_data = GetBlobDataFromUrl(iter->blob_url());
-        DCHECK(src_blob_data);
-        if (src_blob_data)
-          AppendStorageItems(target_blob_data.get(),
-                             src_blob_data,
-                             iter->offset(),
-                             iter->length());
-        break;
-      }
-    }
+  switch (item.type()) {
+    case BlobData::TYPE_DATA:
+      // WebBlobData does not allow partial data.
+      DCHECK(!(item.offset()) && item.length() == item.data().size());
+      target_blob_data->AppendData(item.data());

[michaeln, 2011/09/22 22:59:26]

Since there's no spilling over to disk if things get very large yet we can run
into OOM errors here and crash the browser process. It might be nice to have
some defense against that until we do spill over to disk when appropiate. Wdyt?

+      break;
+    case BlobData::TYPE_FILE:
+      AppendFileItem(target_blob_data,
+                     item.file_path(),
+                     item.offset(),
+                     item.length(),
+                     item.expected_modification_time());
+      break;
+    case BlobData::TYPE_BLOB:
+      BlobData* src_blob_data = GetBlobDataFromUrl(item.blob_url());
+      DCHECK(src_blob_data);
+      if (src_blob_data)
+        AppendStorageItems(target_blob_data,
+                           src_blob_data,
+                           item.offset(),
+                           item.length());
+      break;
   }
+}
 
-  blob_map_[url.spec()] = target_blob_data;
+void BlobStorageController::FinalizeBlob(
+    const GURL& url, const std::string& content_type) {
+  DCHECK(url.SchemeIs("blob"));
+  DCHECK(!BlobUrlHasRef(url));
+  BlobMap::iterator found = unfinalized_blob_map_.find(url.spec());
+  if (found == unfinalized_blob_map_.end())
+    return;
+  found->second->set_content_type(content_type);
+  blob_map_[url.spec()] = found->second;
+  unfinalized_blob_map_.erase(found);
 }
 
 void BlobStorageController::RegisterBlobUrlFrom(
     const GURL& url, const GURL& src_url) {
   DCHECK(url.SchemeIs("blob"));
   DCHECK(!BlobUrlHasRef(url));
 
   BlobData* blob_data = GetBlobDataFromUrl(src_url);
   DCHECK(blob_data);
   if (!blob_data)
     return;
 
   blob_map_[url.spec()] = blob_data;
 }
 
 void BlobStorageController::UnregisterBlobUrl(const GURL& url) {
+  DCHECK(url.SchemeIs("blob"));
+  DCHECK(!BlobUrlHasRef(url));
   blob_map_.erase(url.spec());
+  unfinalized_blob_map_.erase(url.spec());
 }
 
 BlobData* BlobStorageController::GetBlobDataFromUrl(const GURL& url) {
   BlobMap::iterator found = blob_map_.find(
       BlobUrlHasRef(url) ? ClearBlobUrlRef(url).spec() : url.spec());
   return (found != blob_map_.end()) ? found->second : NULL;
 }
 
 void BlobStorageController::ResolveBlobReferencesInUploadData(
     net::UploadData* upload_data) {
@@ skipping 101 matching lines @@
                                expected_modification_time);
 
   // It may be a temporary file that should be deleted when no longer needed.
   scoped_refptr<DeletableFileReference> deletable_file =
       DeletableFileReference::Get(file_path);
   if (deletable_file)
     target_blob_data->AttachDeletableFileReference(deletable_file);
 }
 
 }  // namespace webkit_blob