// Copyright 2013 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 "content/child/webblobregistry_impl.h" #include "base/files/file_path.h" #include "base/guid.h" #include "base/memory/ref_counted.h" #include "base/memory/shared_memory.h" #include "base/message_loop/message_loop.h" #include "content/child/child_thread.h" #include "content/child/thread_safe_sender.h" #include "content/common/fileapi/webblob_messages.h" #include "third_party/WebKit/public/platform/WebBlobData.h" #include "third_party/WebKit/public/platform/WebString.h" #include "third_party/WebKit/public/platform/WebThreadSafeData.h" #include "third_party/WebKit/public/platform/WebURL.h" #include "webkit/common/blob/blob_data.h" using WebKit::WebBlobData; using WebKit::WebString; using WebKit::WebThreadSafeData; 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) { } WebBlobRegistryImpl::~WebBlobRegistryImpl() { } void WebBlobRegistryImpl::registerBlobData( const WebKit::WebString& uuid, const WebKit::WebBlobData& data) { const std::string uuid_str(uuid.utf8()); sender_->Send(new BlobHostMsg_StartBuilding(uuid_str)); size_t i = 0; WebBlobData::Item data_item; while (data.itemAt(i++, data_item)) { switch (data_item.type) { case WebBlobData::Item::TypeData: { // WebBlobData does not allow partial data items. DCHECK(!data_item.offset && data_item.length == -1); SendDataForBlob(uuid_str, 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(data_item.offset), static_cast(data_item.length), base::Time::FromDoubleT(data_item.expectedModificationTime)); sender_->Send( new BlobHostMsg_AppendBlobDataItem(uuid_str, item)); } break; case WebBlobData::Item::TypeBlob: if (data_item.length) { webkit_blob::BlobData::Item item; item.SetToBlobUrlRange( data_item.blobURL, static_cast(data_item.offset), static_cast(data_item.length)); sender_->Send( new BlobHostMsg_AppendBlobDataItem(uuid_str, 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(data_item.offset), static_cast(data_item.length), base::Time::FromDoubleT(data_item.expectedModificationTime)); sender_->Send( new BlobHostMsg_AppendBlobDataItem(uuid_str, item)); } break; default: NOTREACHED(); } } sender_->Send(new BlobHostMsg_FinishBuilding( uuid_str, data.contentType().utf8().data())); } void WebBlobRegistryImpl::addBlobDataRef(const WebString& uuid) { sender_->Send(new BlobHostMsg_IncrementRefCount(uuid.utf8())); } void WebBlobRegistryImpl::removeBlobDataRef(const WebString& uuid) { sender_->Send(new BlobHostMsg_DecrementRefCount(uuid.utf8())); } void WebBlobRegistryImpl::registerPublicBlobURL( const WebURL& url, const WebString& uuid) { sender_->Send(new BlobHostMsg_RegisterPublicURL(url, uuid.utf8())); } void WebBlobRegistryImpl::revokePublicBlobURL(const WebURL& url) { sender_->Send(new BlobHostMsg_RevokePublicURL(url)); } void WebBlobRegistryImpl::SendDataForBlob(const std::string& uuid_str, const WebThreadSafeData& data) { if (data.size() == 0) return; if (data.size() < kLargeThresholdBytes) { webkit_blob::BlobData::Item item; item.SetToBytes(data.data(), data.size()); sender_->Send(new BlobHostMsg_AppendBlobDataItem(uuid_str, 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 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 BlobHostMsg_SyncAppendSharedMemory( uuid_str, shared_memory->handle(), chunk_size)); data_size -= chunk_size; data_ptr += chunk_size; } } } // DEPRECATED, almost. Until blink is updated, we implement these older methods // in terms of our newer blob storage system. We create a uuid for each 'data' // we see and construct a mapping from the private blob urls we're given to // that uuid. The mapping is maintained in the browser process. // // Chromium is setup to speak in terms of old-style private blob urls or // new-style uuid identifiers. Once blink has been migrated support for // the old-style will be deleted. Search for the term deprecated. void WebBlobRegistryImpl::registerBlobURL( const WebURL& url, WebBlobData& data) { std::string uuid = base::GenerateGUID(); registerBlobData(WebKit::WebString::fromUTF8(uuid), data); sender_->Send(new BlobHostMsg_DeprecatedRegisterBlobURL(url, uuid)); sender_->Send(new BlobHostMsg_DecrementRefCount(uuid)); } void WebBlobRegistryImpl::registerBlobURL( const WebURL& url, const WebURL& src_url) { sender_->Send(new BlobHostMsg_DeprecatedCloneBlobURL(url, src_url)); } void WebBlobRegistryImpl::unregisterBlobURL(const WebURL& url) { sender_->Send(new BlobHostMsg_DeprecatedRevokeBlobURL(url)); } // ------ streams stuff ----- 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 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::abortStream(const WebURL& url) { DCHECK(ChildThread::current()); sender_->Send(new StreamHostMsg_AbortBuilding(url)); } void WebBlobRegistryImpl::unregisterStreamURL(const WebURL& url) { DCHECK(ChildThread::current()); sender_->Send(new StreamHostMsg_Remove(url)); } } // namespace content