Index: content/child/webblobregistry_impl.cc |
diff --git a/content/child/webblobregistry_impl.cc b/content/child/webblobregistry_impl.cc |
index fc5cfab18e33ff083ed1af0839b7be7ea33dab10..a51f4ec837b8bbbadf068fe8c0f3ee1c9b22fa8b 100644 |
--- a/content/child/webblobregistry_impl.cc |
+++ b/content/child/webblobregistry_impl.cc |
@@ -24,6 +24,13 @@ using WebKit::WebURL; |
namespace content { |
+namespace { |
+ |
+const size_t kLargeThresholdBytes = 250 * 1024; |
+const size_t kMaxSharedMemoryBytes = 10 * 1024 * 1024; |
+ |
+} // namespace |
+ |
WebBlobRegistryImpl::WebBlobRegistryImpl(ThreadSafeSender* sender) |
: sender_(sender) { |
} |
@@ -31,28 +38,27 @@ WebBlobRegistryImpl::WebBlobRegistryImpl(ThreadSafeSender* sender) |
WebBlobRegistryImpl::~WebBlobRegistryImpl() { |
} |
-void WebBlobRegistryImpl::SendData(const WebURL& url, |
- const WebThreadSafeData& data, |
- webkit_blob::BlobData::Item* item) { |
- const size_t kLargeThresholdBytes = 250 * 1024; |
- const size_t kMaxSharedMemoryBytes = 10 * 1024 * 1024; |
+void WebBlobRegistryImpl::SendDataForBlob(const WebURL& url, |
+ const WebThreadSafeData& data) { |
if (data.size() == 0) |
return; |
if (data.size() < kLargeThresholdBytes) { |
- item->SetToBytes(data.data(), data.size()); |
- sender_->Send(new BlobHostMsg_AppendBlobDataItem(url, *item)); |
+ webkit_blob::BlobData::Item item; |
+ item.SetToBytes(data.data(), 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. |
- size_t data_size = data.size(); |
- const char* data_ptr = data.data(); |
size_t shared_memory_size = std::min( |
- data_size, kMaxSharedMemoryBytes); |
+ data.size(), kMaxSharedMemoryBytes); |
scoped_ptr<base::SharedMemory> shared_memory( |
ChildThread::AllocateSharedMemory(shared_memory_size, |
sender_.get())); |
CHECK(shared_memory.get()); |
+ |
+ size_t data_size = data.size(); |
+ const char* data_ptr = data.data(); |
while (data_size) { |
size_t chunk_size = std::min(data_size, shared_memory_size); |
memcpy(shared_memory->memory(), data_ptr, chunk_size); |
@@ -66,70 +72,126 @@ void WebBlobRegistryImpl::SendData(const WebURL& url, |
void WebBlobRegistryImpl::registerBlobURL( |
const WebURL& url, WebBlobData& data) { |
- DCHECK(ChildThread::current()->message_loop() == |
- base::MessageLoop::current()); |
- sender_->Send(new BlobHostMsg_StartBuildingBlob(url)); |
+ DCHECK(ChildThread::current()); |
+ sender_->Send(new BlobHostMsg_StartBuilding(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); |
- SendData(url, data_item.data, &item); |
+ SendDataForBlob(url, data_item.data); |
break; |
} |
case WebBlobData::Item::TypeFile: |
if (data_item.length) { |
+ webkit_blob::BlobData::Item item; |
item.SetToFilePathRange( |
base::FilePath::FromUTF16Unsafe(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)); |
+ sender_->Send( |
+ new BlobHostMsg_AppendBlobDataItem(url, item)); |
} |
break; |
case WebBlobData::Item::TypeBlob: |
if (data_item.length) { |
+ webkit_blob::BlobData::Item item; |
item.SetToBlobUrlRange( |
data_item.blobURL, |
static_cast<uint64>(data_item.offset), |
static_cast<uint64>(data_item.length)); |
- sender_->Send(new BlobHostMsg_AppendBlobDataItem(url, item)); |
+ sender_->Send( |
+ new BlobHostMsg_AppendBlobDataItem(url, item)); |
} |
break; |
case WebBlobData::Item::TypeURL: |
if (data_item.length) { |
// We only support filesystem URL as of now. |
DCHECK(GURL(data_item.url).SchemeIsFileSystem()); |
+ webkit_blob::BlobData::Item item; |
item.SetToFileSystemUrlRange( |
data_item.url, |
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)); |
+ sender_->Send( |
+ new BlobHostMsg_AppendBlobDataItem(url, item)); |
} |
break; |
default: |
NOTREACHED(); |
} |
} |
- sender_->Send(new BlobHostMsg_FinishBuildingBlob( |
+ sender_->Send(new BlobHostMsg_FinishBuilding( |
url, data.contentType().utf8().data())); |
} |
void WebBlobRegistryImpl::registerBlobURL( |
const WebURL& url, const WebURL& src_url) { |
- DCHECK(ChildThread::current()->message_loop() == |
- base::MessageLoop::current()); |
- sender_->Send(new BlobHostMsg_CloneBlob(url, src_url)); |
+ DCHECK(ChildThread::current()); |
+ sender_->Send(new BlobHostMsg_Clone(url, src_url)); |
} |
void WebBlobRegistryImpl::unregisterBlobURL(const WebURL& url) { |
- DCHECK(ChildThread::current()->message_loop() == |
- base::MessageLoop::current()); |
- sender_->Send(new BlobHostMsg_RemoveBlob(url)); |
+ DCHECK(ChildThread::current()); |
+ sender_->Send(new BlobHostMsg_Remove(url)); |
+} |
+ |
+void WebBlobRegistryImpl::registerStreamURL( |
+ const WebURL& url, const WebString& content_type) { |
+ DCHECK(ChildThread::current()); |
+ sender_->Send(new StreamHostMsg_StartBuilding(url, content_type.utf8())); |
+} |
+ |
+void WebBlobRegistryImpl::registerStreamURL( |
+ const WebURL& url, const WebURL& src_url) { |
+ DCHECK(ChildThread::current()); |
+ sender_->Send(new StreamHostMsg_Clone(url, src_url)); |
+} |
+ |
+void WebBlobRegistryImpl::addDataToStream(const WebURL& url, |
+ WebThreadSafeData& data) { |
+ DCHECK(ChildThread::current()); |
+ if (data.size() == 0) |
+ return; |
+ if (data.size() < kLargeThresholdBytes) { |
+ webkit_blob::BlobData::Item item; |
+ item.SetToBytes(data.data(), data.size()); |
+ sender_->Send(new StreamHostMsg_AppendBlobDataItem(url, item)); |
+ } else { |
+ // We handle larger amounts of data via SharedMemory instead of |
+ // writing it directly to the IPC channel. |
+ size_t shared_memory_size = std::min( |
+ data.size(), kMaxSharedMemoryBytes); |
+ scoped_ptr<base::SharedMemory> shared_memory( |
+ ChildThread::AllocateSharedMemory(shared_memory_size, |
+ sender_.get())); |
+ CHECK(shared_memory.get()); |
+ |
+ size_t data_size = data.size(); |
+ const char* data_ptr = data.data(); |
+ 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 StreamHostMsg_SyncAppendSharedMemory( |
+ url, shared_memory->handle(), chunk_size)); |
+ data_size -= chunk_size; |
+ data_ptr += chunk_size; |
+ } |
+ } |
+} |
+ |
+void WebBlobRegistryImpl::finalizeStream(const WebURL& url) { |
+ DCHECK(ChildThread::current()); |
+ sender_->Send(new StreamHostMsg_FinishBuilding(url)); |
+} |
+ |
+void WebBlobRegistryImpl::unregisterStreamURL(const WebURL& url) { |
+ DCHECK(ChildThread::current()); |
+ sender_->Send(new StreamHostMsg_Remove(url)); |
} |
} // namespace content |