[BlobAsync] Asynchronous Blob Construction Final Patch

content/browser/fileapi/fileapi_message_filter.cc

 // Copyright (c) 2012 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/browser/fileapi/fileapi_message_filter.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/child_process_security_policy_impl.h"
-#include "content/browser/fileapi/blob_storage_host.h"
 #include "content/browser/fileapi/browser_file_system_helper.h"
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
 #include "content/browser/streams/stream_registry.h"
 #include "content/common/fileapi/file_system_messages.h"
 #include "content/common/fileapi/webblob_messages.h"
 #include "content/public/browser/user_metrics.h"
 #include "ipc/ipc_platform_file.h"
 #include "net/base/mime_util.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
@@ skipping 15 matching lines @@
 using storage::FileSystemBackend;
 using storage::FileSystemOperation;
 using storage::FileSystemURL;
 using storage::BlobDataBuilder;
 using storage::BlobStorageContext;
 
 namespace content {
 
 namespace {
 
-const uint32 kFilteredMessageClasses[] = {
-  BlobMsgStart,
-  FileSystemMsgStart,
-};
+const uint32 kFilteredMessageClasses[] = {BlobMsgStart, FileSystemMsgStart};

[michaeln, 2015/12/15 02:40:48]

does BlobMsgStart still belong here given the new filter class?

[dmurph, 2015/12/18 03:22:50]

I don't think so.

 
 void RevokeFilePermission(int child_id, const base::FilePath& path) {
   ChildProcessSecurityPolicyImpl::GetInstance()->RevokeAllPermissionsForFile(
     child_id, path);
 }
 
 }  // namespace
 
 FileAPIMessageFilter::FileAPIMessageFilter(
     int process_id,
@@ skipping 39 matching lines @@
 void FileAPIMessageFilter::OnChannelConnected(int32 peer_pid) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (request_context_getter_.get()) {
     DCHECK(!request_context_);
     request_context_ = request_context_getter_->GetURLRequestContext();
     request_context_getter_ = NULL;
     DCHECK(request_context_);
   }
 
-  blob_storage_host_.reset(
-      new BlobStorageHost(blob_storage_context_->context()));
-
   operation_runner_ = context_->CreateFileSystemOperationRunner();
 }
 
 void FileAPIMessageFilter::OnChannelClosing() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  // Unregister all the blob and stream URLs that are previously registered in
-  // this process.
-  blob_storage_host_.reset();
+  // Unregister all stream URLs that are previously registered in this process.
   for (base::hash_set<std::string>::const_iterator iter = stream_urls_.begin();
        iter != stream_urls_.end(); ++iter) {
     stream_context_->registry()->UnregisterStream(GURL(*iter));
   }
 
   in_transit_snapshot_files_.clear();
 
   operation_runner_.reset();
   operations_.clear();
 }
@@ skipping 21 matching lines @@
     IPC_MESSAGE_HANDLER(FileSystemHostMsg_Write, OnWrite)
     IPC_MESSAGE_HANDLER(FileSystemHostMsg_Truncate, OnTruncate)
     IPC_MESSAGE_HANDLER(FileSystemHostMsg_TouchFile, OnTouchFile)
     IPC_MESSAGE_HANDLER(FileSystemHostMsg_CancelWrite, OnCancel)
     IPC_MESSAGE_HANDLER(FileSystemHostMsg_CreateSnapshotFile,
                         OnCreateSnapshotFile)
     IPC_MESSAGE_HANDLER(FileSystemHostMsg_DidReceiveSnapshotFile,
                         OnDidReceiveSnapshotFile)
     IPC_MESSAGE_HANDLER(FileSystemHostMsg_SyncGetPlatformPath,
                         OnSyncGetPlatformPath)
-    IPC_MESSAGE_HANDLER(BlobHostMsg_StartBuilding, OnStartBuildingBlob)
-    IPC_MESSAGE_HANDLER(BlobHostMsg_AppendBlobDataItem,
-                        OnAppendBlobDataItemToBlob)
-    IPC_MESSAGE_HANDLER(BlobHostMsg_SyncAppendSharedMemory,
-                        OnAppendSharedMemoryToBlob)
-    IPC_MESSAGE_HANDLER(BlobHostMsg_FinishBuilding, OnFinishBuildingBlob)
-    IPC_MESSAGE_HANDLER(BlobHostMsg_IncrementRefCount,
-                        OnIncrementBlobRefCount)
-    IPC_MESSAGE_HANDLER(BlobHostMsg_DecrementRefCount,
-                        OnDecrementBlobRefCount)
-    IPC_MESSAGE_HANDLER(BlobHostMsg_RegisterPublicURL,
-                        OnRegisterPublicBlobURL)
-    IPC_MESSAGE_HANDLER(BlobHostMsg_RevokePublicURL, OnRevokePublicBlobURL)
     IPC_MESSAGE_HANDLER(StreamHostMsg_StartBuilding, OnStartBuildingStream)
     IPC_MESSAGE_HANDLER(StreamHostMsg_AppendBlobDataItem,
                         OnAppendBlobDataItemToStream)
     IPC_MESSAGE_HANDLER(StreamHostMsg_SyncAppendSharedMemory,
                         OnAppendSharedMemoryToStream)
     IPC_MESSAGE_HANDLER(StreamHostMsg_Flush, OnFlushStream)
     IPC_MESSAGE_HANDLER(StreamHostMsg_FinishBuilding, OnFinishBuildingStream)
     IPC_MESSAGE_HANDLER(StreamHostMsg_AbortBuilding, OnAbortBuildingStream)
     IPC_MESSAGE_HANDLER(StreamHostMsg_Clone, OnCloneStream)
     IPC_MESSAGE_HANDLER(StreamHostMsg_Remove, OnRemoveStream)
@@ skipping 312 matching lines @@
         base::Bind(&FileAPIMessageFilter::DidCreateSnapshot,
                    this, request_id, url));
   }
 }
 
 void FileAPIMessageFilter::OnDidReceiveSnapshotFile(int request_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   in_transit_snapshot_files_.erase(request_id);
 }
 
-void FileAPIMessageFilter::OnStartBuildingBlob(const std::string& uuid) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  ignore_result(blob_storage_host_->StartBuildingBlob(uuid));
-}
-
-void FileAPIMessageFilter::OnAppendBlobDataItemToBlob(
-    const std::string& uuid,
-    const storage::DataElement& item) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  if (item.type() == storage::DataElement::TYPE_FILE_FILESYSTEM) {
-    FileSystemURL filesystem_url(context_->CrackURL(item.filesystem_url()));
-    if (!FileSystemURLIsValid(context_, filesystem_url) ||
-        !security_policy_->CanReadFileSystemFile(process_id_, filesystem_url)) {
-      ignore_result(blob_storage_host_->CancelBuildingBlob(uuid));
-      return;
-    }
-  }
-  if (item.type() == storage::DataElement::TYPE_FILE &&
-      !security_policy_->CanReadFile(process_id_, item.path())) {
-    ignore_result(blob_storage_host_->CancelBuildingBlob(uuid));
-    return;
-  }
-  if (item.length() == 0) {
-    bad_message::ReceivedBadMessage(this,
-                                    bad_message::FAMF_APPEND_ITEM_TO_BLOB);
-    return;
-  }
-  ignore_result(blob_storage_host_->AppendBlobDataItem(uuid, item));
-}
-
-void FileAPIMessageFilter::OnAppendSharedMemoryToBlob(
-    const std::string& uuid,
-    base::SharedMemoryHandle handle,
-    size_t buffer_size) {
-  DCHECK(base::SharedMemory::IsHandleValid(handle));
-  if (!buffer_size) {
-    bad_message::ReceivedBadMessage(
-        this, bad_message::FAMF_APPEND_SHARED_MEMORY_TO_BLOB);
-    return;
-  }
-#if defined(OS_WIN)
-  base::SharedMemory shared_memory(handle, true, PeerHandle());
-#else
-  base::SharedMemory shared_memory(handle, true);
-#endif
-  if (!shared_memory.Map(buffer_size)) {
-    ignore_result(blob_storage_host_->CancelBuildingBlob(uuid));
-    return;
-  }
-
-  storage::DataElement item;
-  item.SetToSharedBytes(static_cast<char*>(shared_memory.memory()),
-                        buffer_size);
-  ignore_result(blob_storage_host_->AppendBlobDataItem(uuid, item));
-}
-
-void FileAPIMessageFilter::OnFinishBuildingBlob(
-    const std::string& uuid, const std::string& content_type) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  ignore_result(blob_storage_host_->FinishBuildingBlob(uuid, content_type));
-  // TODO(michaeln): check return values once blink has migrated, crbug/174200
-}
-
-void FileAPIMessageFilter::OnIncrementBlobRefCount(const std::string& uuid) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  ignore_result(blob_storage_host_->IncrementBlobRefCount(uuid));
-}
-
-void FileAPIMessageFilter::OnDecrementBlobRefCount(const std::string& uuid) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  ignore_result(blob_storage_host_->DecrementBlobRefCount(uuid));
-}
-
-void FileAPIMessageFilter::OnRegisterPublicBlobURL(
-    const GURL& public_url, const std::string& uuid) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  ignore_result(blob_storage_host_->RegisterPublicBlobURL(public_url, uuid));
-}
-
-void FileAPIMessageFilter::OnRevokePublicBlobURL(const GURL& public_url) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  ignore_result(blob_storage_host_->RevokePublicBlobURL(public_url));
-}
-
 void FileAPIMessageFilter::OnStartBuildingStream(
     const GURL& url, const std::string& content_type) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // Only an internal Blob URL is expected here. See the BlobURL of the Blink.
   if (!base::StartsWith(url.path(), "blobinternal%3A///",
                         base::CompareCase::SENSITIVE)) {
     NOTREACHED() << "Malformed Stream URL: " << url.spec();
     bad_message::ReceivedBadMessage(this,
                                     bad_message::FAMF_MALFORMED_STREAM_URL);
     return;
@@ skipping 277 matching lines @@
   }
 
   return true;
 }
 
 scoped_refptr<Stream> FileAPIMessageFilter::GetStreamForURL(const GURL& url) {
   return stream_context_->registry()->GetStream(url);
 }
 
 }  // namespace content