[BlobAsync] Renderer support for blob file writing.

content/child/blob_storage/blob_message_filter.cc

 // Copyright 2015 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/blob_storage/blob_message_filter.h"
 
+#include "base/bind.h"
+#include "base/task_runner.h"
 #include "content/child/blob_storage/blob_transport_controller.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/common/fileapi/webblob_messages.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_sender.h"
 #include "storage/common/blob_storage/blob_item_bytes_request.h"
+#include "storage/common/blob_storage/blob_item_bytes_response.h"
 
 namespace content {
 
-BlobMessageFilter::BlobMessageFilter()
-    : IPC::MessageFilter(), sender_(nullptr) {}
+BlobMessageFilter::BlobMessageFilter(
+    scoped_refptr<base::TaskRunner> io_runner,
+    scoped_refptr<base::TaskRunner> file_runner)
+    : IPC::MessageFilter(),

[kinuko, 2016/04/15 15:02:32]

nit: this line is probably not necessary

[dmurph, 2016/04/20 21:15:34]

Done.

+      sender_(nullptr),
+      io_runner_(std::move(io_runner)),
+      file_runner_(std::move(file_runner)) {}
 
 BlobMessageFilter::~BlobMessageFilter() {}
 
 void BlobMessageFilter::OnFilterAdded(IPC::Sender* sender) {
   sender_ = sender;
 }
 
+void BlobMessageFilter::OnChannelClosing() {
+  sender_ = nullptr;
+}
+
 bool BlobMessageFilter::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(BlobMessageFilter, message)
     IPC_MESSAGE_HANDLER(BlobStorageMsg_RequestMemoryItem, OnRequestMemoryItem)
     IPC_MESSAGE_HANDLER(BlobStorageMsg_CancelBuildingBlob, OnCancelBuildingBlob)
     IPC_MESSAGE_HANDLER(BlobStorageMsg_DoneBuildingBlob, OnDoneBuildingBlob)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 bool BlobMessageFilter::GetSupportedMessageClasses(
     std::vector<uint32_t>* supported_message_classes) const {
   supported_message_classes->push_back(BlobMsgStart);
   return true;
 }
 
 void BlobMessageFilter::OnRequestMemoryItem(
     const std::string& uuid,
     const std::vector<storage::BlobItemBytesRequest>& requests,
     std::vector<base::SharedMemoryHandle> memory_handles,
     const std::vector<IPC::PlatformFileForTransit>& file_handles) {
   BlobTransportController::GetInstance()->OnMemoryRequest(
-      uuid, requests, &memory_handles, file_handles, sender_);
+      uuid, requests, &memory_handles, file_handles, sender_, io_runner_,
+      file_runner_.get(),
+      base::Bind(&BlobMessageFilter::SendResponses, this, uuid),
+      base::Bind(&BlobMessageFilter::SendCancel, this, uuid));

[kinuko, 2016/04/15 15:02:32]

BlobTransportController already knows the concept of IPC and knows how to send
messages, and this seems to be the only callsite of OnMemoryRequest... I feel we
could possibly just let the TransportController/callee to directly call Send
method and it might be simpler?

[dmurph, 2016/04/20 21:15:34]

So you're saying we just give them a Send method callback?

 }
 
 void BlobMessageFilter::OnCancelBuildingBlob(
     const std::string& uuid,
     storage::IPCBlobCreationCancelCode code) {
   BlobTransportController::GetInstance()->OnCancel(uuid, code);
 }
 
+void BlobMessageFilter::SendResponses(
+    const std::string& uuid,
+    const std::vector<storage::BlobItemBytesResponse>& responses) {
+  if (sender_)
+    sender_->Send(new BlobStorageMsg_MemoryItemResponse(uuid, responses));
+}
+void BlobMessageFilter::SendCancel(const std::string& uuid,
+                                   storage::IPCBlobCreationCancelCode code) {
+  if (sender_)
+    sender_->Send(new BlobStorageMsg_CancelBuildingBlob(uuid, code));

[kinuko, 2016/04/15 15:02:32]

Common pattern is that we have Send method that checks sender_ and sends or
deletes the given message depending on if it's null or not

[dmurph, 2016/04/20 21:15:34]

Done.

+}
+
 void BlobMessageFilter::OnDoneBuildingBlob(const std::string& uuid) {
   BlobTransportController::GetInstance()->OnDone(uuid);
 }
 
 }  // namespace content