Break large blobs into multiple ipcs during creation.

content/common/webblobregistry_impl.cc

Index: content/common/webblobregistry_impl.cc
===================================================================
--- content/common/webblobregistry_impl.cc	(revision 104763)
+++ content/common/webblobregistry_impl.cc	(working copy)
@@ -5,11 +5,13 @@
 #include "content/common/webblobregistry_impl.h"
 
 #include "base/memory/ref_counted.h"
+#include "base/shared_memory.h"
 #include "content/common/webblob_messages.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebBlobData.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURL.h"
 #include "webkit/blob/blob_data.h"
+#include "webkit/glue/webkit_glue.h"
 
 using WebKit::WebBlobData;
 using WebKit::WebString;
@@ -24,16 +26,103 @@
 
 void WebBlobRegistryImpl::registerBlobURL(
     const WebURL& url, WebBlobData& data) {
-  scoped_refptr<webkit_blob::BlobData> blob_data(
-      new webkit_blob::BlobData(data));
-  sender_->Send(new BlobHostMsg_RegisterBlobUrl(url, blob_data));
+  sender_->Send(new BlobHostMsg_StartBuildingBlob(url));
+  size_t i = 0;
+  WebBlobData::Item data_item;
+  while (data.itemAt(i++, data_item)) {
+    webkit_blob::BlobData::Item item;
+    switch (data_item.type) {
+      case WebBlobData::Item::TypeData: {
+        // WebBlobData does not allow partial data items.
+        DCHECK(!data_item.offset && data_item.length == -1);
+        const size_t kLargeSizeThreshold = 250 * 1024;
+        if (data_item.data.size() < kLargeSizeThreshold) {
+          item.SetToData(data_item.data.data(), data_item.data.size());
+          sender_->Send(new BlobHostMsg_AppendBlobDataItem(url, item));
+        } else {
+          // We handle larger amounts of data via SharedMemory instead of
+          // writing it directly to the IPC channel.
+          const size_t kMaxSharedMemorySize = 10 * 1024 * 1024;

[jam, 2011/10/11 01:56:51]

now that you're using shared memory, why are you still looping for 10MB at a
time instead of just sending it all at once?

[michaeln, 2011/10/11 02:15:29]

Right now, mostly to avoid very large contiguous blocks. But eventually, the
brower-side should spill over to disk as the blob grows, feeding it
incrementally should help make that go more in parallel.

Maybe 10M is too small, but some upper bound would be good i think.

WebCore::BlobBuilder doesn't call out to chrome until it's ready push the whole
thing over. I intend to make that code more incremental too, calling out to
chrome prior to the whole thing being done.

+          size_t data_size = data_item.data.size();
+          const char* data_ptr = data_item.data.data();
+          size_t shared_memory_size = std::min(data_size, kMaxSharedMemorySize);
+          scoped_ptr<base::SharedMemory> shared_memory(
+              AllocateSharedMemory(shared_memory_size));
+          CHECK(shared_memory.get());
+          while (data_size) {
+            size_t chunk_size = std::min(data_size, shared_memory_size);
+            memcpy(shared_memory->memory(), data_ptr, chunk_size);
+            sender_->Send(new BlobHostMsg_SyncAppendSharedMemory(
+                url, shared_memory->handle(), chunk_size));
+            data_size -= chunk_size;
+            data_ptr += chunk_size;
+          }
+        }
+        break;
+      }
+      case WebBlobData::Item::TypeFile:
+        item.SetToFile(
+            webkit_glue::WebStringToFilePath(data_item.filePath),
+            static_cast<uint64>(data_item.offset),
+            static_cast<uint64>(data_item.length),
+            base::Time::FromDoubleT(data_item.expectedModificationTime));
+        sender_->Send(new BlobHostMsg_AppendBlobDataItem(url, item));
+        break;
+      case WebBlobData::Item::TypeBlob:
+        if (data_item.length) {
+          item.SetToBlob(
+              data_item.blobURL,
+              static_cast<uint64>(data_item.offset),
+              static_cast<uint64>(data_item.length));
+        }
+        sender_->Send(new BlobHostMsg_AppendBlobDataItem(url, item));
+        break;
+      default:
+        NOTREACHED();
+    }
+  }
+  sender_->Send(new BlobHostMsg_FinishBuildingBlob(
+      url, data.contentType().utf8().data()));
 }
 
+base::SharedMemory* WebBlobRegistryImpl::AllocateSharedMemory(
+    size_t buf_size) {
+  scoped_ptr<base::SharedMemory> shared_buf;
+#if defined(OS_WIN)
+  shared_buf.reset(new base::SharedMemory);
+  if (!shared_buf->CreateAndMapAnonymous(buf_size)) {
+    NOTREACHED();
+    return NULL;
+  }
+#else
+  // On POSIX, we need to ask the browser to create the shared memory for us,
+  // since this is blocked by the sandbox.
+  base::SharedMemoryHandle shared_mem_handle;
+  if (sender_->Send(new BlobHostMsg_SyncAllocateSharedMemory(
+                            buf_size, &shared_mem_handle))) {
+    if (base::SharedMemory::IsHandleValid(shared_mem_handle)) {
+      shared_buf.reset(new base::SharedMemory(shared_mem_handle, false));
+      if (!shared_buf->Map(buf_size)) {
+        NOTREACHED() << "Map failed";
+        return NULL;
+      }
+    } else {
+      NOTREACHED() << "Browser failed to allocate shared memory";
+      return NULL;
+    }
+  } else {
+    NOTREACHED() << "Browser allocation request message failed";
+    return NULL;
+  }
+#endif
+  return shared_buf.release();
+}
+
 void WebBlobRegistryImpl::registerBlobURL(
     const WebURL& url, const WebURL& src_url) {
-  sender_->Send(new BlobHostMsg_RegisterBlobUrlFrom(url, src_url));
+  sender_->Send(new BlobHostMsg_CloneBlob(url, src_url));
 }
 
 void WebBlobRegistryImpl::unregisterBlobURL(const WebURL& url) {
-  sender_->Send(new BlobHostMsg_UnregisterBlobUrl(url));
+  sender_->Send(new BlobHostMsg_RemoveBlob(url));
 }