Break large blobs into multiple ipcs during creation.

webkit/blob/blob_storage_controller.cc

Index: webkit/blob/blob_storage_controller.cc
===================================================================
--- webkit/blob/blob_storage_controller.cc	(revision 102191)
+++ webkit/blob/blob_storage_controller.cc	(working copy)
@@ -37,14 +37,21 @@
 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.
@@ -54,37 +61,41 @@
   // 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(
@@ -101,7 +112,10 @@
 }
 
 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) {