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

content/browser/blob_storage/blob_dispatcher_host.h

 // 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.
 
 #ifndef CONTENT_BROWSER_BLOB_STORAGE_BLOB_DISPATCHER_HOST_H_
 #define CONTENT_BROWSER_BLOB_STORAGE_BLOB_DISPATCHER_HOST_H_
 
 #include <set>
 #include <string>
 #include <vector>
 
+#include "base/callback_forward.h"
 #include "base/files/file.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/shared_memory_handle.h"
 #include "content/common/content_export.h"
 #include "content/public/browser/browser_message_filter.h"
 #include "storage/browser/blob/blob_async_builder_host.h"
 #include "storage/browser/blob/blob_transport_result.h"
 #include "storage/common/blob_storage/blob_storage_constants.h"
@@ skipping 10 matching lines @@
 struct BlobItemBytesRequest;
 struct BlobItemBytesResponse;
 class BlobStorageContext;
 }
 
 namespace content {
 class ChromeBlobStorageContext;
 
 // This class's responsibility is to listen for and dispatch blob storage
 // messages and handle logistics of blob storage for a single child process.
+// It also makes sure the renderer process sticks around while we transfer
+// blobs.
 // When the child process terminates all blob references attributable to
 // that process go away upon destruction of the instance.
 // This lives in the browser process, is single threaded (IO thread), and there
 // is one per child process.
 class CONTENT_EXPORT BlobDispatcherHost : public BrowserMessageFilter {
  public:
-  explicit BlobDispatcherHost(ChromeBlobStorageContext* blob_storage_context);
+  using SetSuddenTerminationAllowedCallback = base::Callback<void(bool)>;
+
+  explicit BlobDispatcherHost(
+      ChromeBlobStorageContext* blob_storage_context,
+      SetSuddenTerminationAllowedCallback set_sudden_termination_allowed);
 
   // BrowserMessageFilter implementation.
   void OnChannelClosing() override;
   bool OnMessageReceived(const IPC::Message& message) override;
 
  protected:
   ~BlobDispatcherHost() override;
 
   // For testing use only.
   void SetMemoryConstantsForTesting(size_t max_ipc_memory_size,
                                     size_t max_shared_memory_size,
                                     uint64_t max_file_size) {
     async_builder_.SetMemoryConstantsForTesting(
         max_ipc_memory_size, max_shared_memory_size, max_file_size);
   }
 
  private:
   friend class base::RefCountedThreadSafe<BlobDispatcherHost>;
   friend class BlobDispatcherHostTest;
   FRIEND_TEST_ALL_PREFIXES(BlobDispatcherHostTest, EmptyUUIDs);
+  FRIEND_TEST_ALL_PREFIXES(BlobDispatcherHostTest, MultipleTransfers);
   FRIEND_TEST_ALL_PREFIXES(BlobDispatcherHostTest, SharedMemoryTransfer);
   FRIEND_TEST_ALL_PREFIXES(BlobDispatcherHostTest, OnCancelBuildingBlob);
   FRIEND_TEST_ALL_PREFIXES(BlobDispatcherHostTest,
                            BlobReferenceWhileConstructing);
   FRIEND_TEST_ALL_PREFIXES(BlobDispatcherHostTest,
                            BlobReferenceWhileShortcutConstructing);
   FRIEND_TEST_ALL_PREFIXES(BlobDispatcherHostTest,
                            BlobReferenceWhileConstructingCancelled);
   FRIEND_TEST_ALL_PREFIXES(BlobDispatcherHostTest, DecrementRefAfterRegister);
   FRIEND_TEST_ALL_PREFIXES(BlobDispatcherHostTest, DecrementRefAfterOnStart);
@@ skipping 40 matching lines @@
   // Send the appropriate IPC response to the renderer for the given result.
   void SendIPCResponse(const std::string& uuid,
                        storage::BlobTransportResult result);
 
   bool IsInUseInHost(const std::string& uuid);
   bool IsUrlRegisteredInHost(const GURL& blob_url);
 
   // Unregisters all blobs and urls that were registered in this host.
   void ClearHostFromBlobStorageContext();
 
+  void AllowSuddenTerminationIfBuilderEmpty();
+
+  // Calling this should disable or enable sudden renderer termination. We use
+  // this to keep the renderer alive while blobs are being transferred.
+  SetSuddenTerminationAllowedCallback set_sudden_termination_allowed_;
+
   // Collection of blob ids and a count of how many usages
   // of that id are attributable to this consumer.
   BlobReferenceMap blobs_inuse_map_;
 
   // The set of public blob urls coined by this consumer.
   std::set<GURL> public_blob_urls_;
 
   scoped_refptr<ChromeBlobStorageContext> blob_storage_context_;
   storage::BlobAsyncBuilderHost async_builder_;
 
   DISALLOW_COPY_AND_ASSIGN(BlobDispatcherHost);
 };
 }  // namespace content
 #endif  // CONTENT_BROWSER_BLOB_STORAGE_BLOB_DISPATCHER_HOST_H_