[BlobAsync] Faster shortcuttin, make renderer controller leaky & alive.

content/browser/blob_storage/blob_dispatcher_host.cc

 // Copyright 2016 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/blob_storage/blob_dispatcher_host.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
 #include "content/common/fileapi/webblob_messages.h"
 #include "ipc/ipc_platform_file.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/blob/blob_transport_result.h"
 #include "storage/common/blob_storage/blob_item_bytes_request.h"
 #include "storage/common/blob_storage/blob_item_bytes_response.h"
 #include "storage/common/data_element.h"
 #include "url/gurl.h"
 
 using storage::BlobStorageContext;
 using storage::BlobStorageRegistry;
 using storage::BlobTransportResult;
 using storage::IPCBlobCreationCancelCode;
 
 namespace content {
 
 BlobDispatcherHost::BlobDispatcherHost(
-    ChromeBlobStorageContext* blob_storage_context)
+    ChromeBlobStorageContext* blob_storage_context,
+    SetSuddenTerminationAllowedCallback set_sudden_termination_allowed)
     : BrowserMessageFilter(BlobMsgStart),
+      set_sudden_termination_allowed_(set_sudden_termination_allowed),
       blob_storage_context_(blob_storage_context) {}
 
 BlobDispatcherHost::~BlobDispatcherHost() {
   ClearHostFromBlobStorageContext();
 }
 
 void BlobDispatcherHost::OnChannelClosing() {
   ClearHostFromBlobStorageContext();
   public_blob_urls_.clear();
   blobs_inuse_map_.clear();
@@ skipping 27 matching lines @@
     return;
   }
   blobs_inuse_map_[uuid] = 1;
   BlobTransportResult result = async_builder_.RegisterBlobUUID(
       uuid, content_type, content_disposition, referenced_blob_uuids, context);
   switch (result) {
     case BlobTransportResult::BAD_IPC:
       blobs_inuse_map_.erase(uuid);
       bad_message::ReceivedBadMessage(this, bad_message::BDH_INVALID_OPERATION);
       break;
-      ;
     case BlobTransportResult::CANCEL_REFERENCED_BLOB_BROKEN:
       // The async builder builds the blob as broken, and we just need to send
       // the cancel message back to the renderer.
       Send(new BlobStorageMsg_CancelBuildingBlob(
           uuid, IPCBlobCreationCancelCode::REFERENCED_BLOB_BROKEN));
       break;
     case BlobTransportResult::DONE:
+      // This means the builder used to be empty, and we're successfully
+      // building
+      // the blob.
+      if (async_builder_.blob_building_count() == 1) {
+        set_sudden_termination_allowed_.Run(false);
+      }
       break;
     case BlobTransportResult::CANCEL_MEMORY_FULL:
     case BlobTransportResult::CANCEL_FILE_ERROR:
     case BlobTransportResult::CANCEL_UNKNOWN:
     case BlobTransportResult::PENDING_RESPONSES:
       NOTREACHED();
       break;
   }
 }
 
@@ skipping 14 matching lines @@
     // we decided to break a blob after RegisterBlobUUID is called.
     // Second, if the last dereference of the blob happened on a different host,
     // then we still haven't gotten rid of the 'building' state in the original
     // host. So we call cancel, and send the message just in case that happens.
     if (async_builder_.IsBeingBuilt(uuid)) {
       async_builder_.CancelBuildingBlob(
           uuid, IPCBlobCreationCancelCode::BLOB_DEREFERENCED_WHILE_BUILDING,
           context);
       Send(new BlobStorageMsg_CancelBuildingBlob(
           uuid, IPCBlobCreationCancelCode::BLOB_DEREFERENCED_WHILE_BUILDING));
+      AllowSuddenTerminationIfBuilderEmpty();
     }
     return;
   }
   if (!async_builder_.IsBeingBuilt(uuid)) {
     SendIPCResponse(uuid, BlobTransportResult::BAD_IPC);
     return;
   }
   // |this| owns async_builder_ so using base::Unretained(this) is safe.
   BlobTransportResult result = async_builder_.StartBuildingBlob(
       uuid, descriptions, context->memory_available(), context,
       base::Bind(&BlobDispatcherHost::SendMemoryRequest, base::Unretained(this),
                  uuid));
   SendIPCResponse(uuid, result);
+  if (result != BlobTransportResult::PENDING_RESPONSES) {
+    AllowSuddenTerminationIfBuilderEmpty();
+  }
 }
 
 void BlobDispatcherHost::OnMemoryItemResponse(
     const std::string& uuid,
     const std::vector<storage::BlobItemBytesResponse>& responses) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (uuid.empty()) {
     SendIPCResponse(uuid, BlobTransportResult::BAD_IPC);
     return;
   }
   BlobStorageContext* context = this->context();
   const BlobStorageRegistry::Entry* entry = context->registry().GetEntry(uuid);
   if (!entry || entry->state == BlobStorageRegistry::BlobState::BROKEN) {
     // We ignore messages for blobs that don't exist to handle the case where
     // the renderer de-refs a blob that we're still constructing, and there are
     // no references to that blob. We ignore broken as well, in the case where
     // we decided to break a blob after sending the memory request.
-    // Note: if a blob is broken, then it can't be in the async_builder.
     // Second, if the last dereference of the blob happened on a different host,
     // then we still haven't gotten rid of the 'building' state in the original
     // host. So we call cancel, and send the message just in case that happens.
     if (async_builder_.IsBeingBuilt(uuid)) {
       async_builder_.CancelBuildingBlob(
           uuid, IPCBlobCreationCancelCode::BLOB_DEREFERENCED_WHILE_BUILDING,
           context);
       Send(new BlobStorageMsg_CancelBuildingBlob(
           uuid, IPCBlobCreationCancelCode::BLOB_DEREFERENCED_WHILE_BUILDING));
+      AllowSuddenTerminationIfBuilderEmpty();
     }
     return;
   }
   if (!async_builder_.IsBeingBuilt(uuid)) {
     SendIPCResponse(uuid, BlobTransportResult::BAD_IPC);
     return;
   }
   BlobTransportResult result =
       async_builder_.OnMemoryResponses(uuid, responses, context);
   SendIPCResponse(uuid, result);
+  if (result != BlobTransportResult::PENDING_RESPONSES) {
+    AllowSuddenTerminationIfBuilderEmpty();
+  }
 }
 
 void BlobDispatcherHost::OnCancelBuildingBlob(
     const std::string& uuid,
     const storage::IPCBlobCreationCancelCode code) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (uuid.empty()) {
     SendIPCResponse(uuid, BlobTransportResult::BAD_IPC);
     return;
   }
   BlobStorageContext* context = this->context();
   const BlobStorageRegistry::Entry* entry = context->registry().GetEntry(uuid);
   if (!entry || entry->state == BlobStorageRegistry::BlobState::BROKEN) {
     // We ignore messages for blobs that don't exist to handle the case where
     // the renderer de-refs a blob that we're still constructing, and there are
     // no references to that blob. We ignore broken as well, in the case where
     // we decided to break a blob and the renderer also decided to cancel.
-    // Note: if a blob is broken, then it can't be in the async_builder.
     // Second, if the last dereference of the blob happened on a different host,
     // then we still haven't gotten rid of the 'building' state in the original
     // host. So we call cancel just in case this happens.
-    async_builder_.CancelBuildingBlob(
-        uuid, IPCBlobCreationCancelCode::BLOB_DEREFERENCED_WHILE_BUILDING,
-        context);
+    if (async_builder_.IsBeingBuilt(uuid)) {
+      async_builder_.CancelBuildingBlob(
+          uuid, IPCBlobCreationCancelCode::BLOB_DEREFERENCED_WHILE_BUILDING,
+          context);
+      AllowSuddenTerminationIfBuilderEmpty();
+    }
     return;
   }
   if (!async_builder_.IsBeingBuilt(uuid)) {
     SendIPCResponse(uuid, BlobTransportResult::BAD_IPC);
     return;
   }
   VLOG(1) << "Blob construction of " << uuid << " cancelled by renderer. "
           << " Reason: " << static_cast<int>(code) << ".";
   async_builder_.CancelBuildingBlob(uuid, code, context);
+  AllowSuddenTerminationIfBuilderEmpty();
 }
 
 void BlobDispatcherHost::OnIncrementBlobRefCount(const std::string& uuid) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BlobStorageContext* context = this->context();
   if (uuid.empty() || !context->registry().HasEntry(uuid)) {
     bad_message::ReceivedBadMessage(this, bad_message::BDH_INVALID_OPERATION);
     return;
   }
   context->IncrementBlobRefCount(uuid);
@@ skipping 14 matching lines @@
     // If the blob has been deleted in the context and we're still building it,
     // this means we have no references waiting to read it. Clear the building
     // state and send a cancel message to the renderer.
     if (async_builder_.IsBeingBuilt(uuid) &&
         !context->registry().HasEntry(uuid)) {
       async_builder_.CancelBuildingBlob(
           uuid, IPCBlobCreationCancelCode::BLOB_DEREFERENCED_WHILE_BUILDING,
           context);
       Send(new BlobStorageMsg_CancelBuildingBlob(
           uuid, IPCBlobCreationCancelCode::BLOB_DEREFERENCED_WHILE_BUILDING));
+      AllowSuddenTerminationIfBuilderEmpty();
     }
   }
 }
 
 void BlobDispatcherHost::OnRegisterPublicBlobURL(const GURL& public_url,
                                                  const std::string& uuid) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BlobStorageContext* context = this->context();
   if (uuid.empty() || !IsInUseInHost(uuid) ||
       context->registry().IsURLMapped(public_url)) {
@@ skipping 73 matching lines @@
 
 void BlobDispatcherHost::ClearHostFromBlobStorageContext() {
   BlobStorageContext* context = this->context();
   for (const auto& url : public_blob_urls_) {
     context->RevokePublicBlobURL(url);
   }
   for (const auto& uuid_refnum_pair : blobs_inuse_map_) {
     for (int i = 0; i < uuid_refnum_pair.second; ++i)
       context->DecrementBlobRefCount(uuid_refnum_pair.first);
   }
-  async_builder_.CancelAll(context);
+  if (!async_builder_.IsEmpty()) {
+    async_builder_.CancelAll(context);
+    set_sudden_termination_allowed_.Run(true);
+  }
+}
+
+void BlobDispatcherHost::AllowSuddenTerminationIfBuilderEmpty() {
+  if (async_builder_.IsEmpty()) {
+    set_sudden_termination_allowed_.Run(true);
+  }
 }
 
 }  // namespace content