[BlobAsync] Moving async handling into BlobStorageContext & quota out.

storage/browser/blob/blob_transport_host.h

Index: storage/browser/blob/blob_transport_host.h
diff --git a/storage/browser/blob/blob_transport_host.h b/storage/browser/blob/blob_transport_host.h
new file mode 100644
index 0000000000000000000000000000000000000000..f8e952a787a408aafa1eddb4621c9d4f225b3bca
--- /dev/null
+++ b/storage/browser/blob/blob_transport_host.h
@@ -0,0 +1,186 @@
+// 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.
+
+#ifndef STORAGE_BROWSER_BLOB_BLOB_TRANSPORT_HOST_H_
+#define STORAGE_BROWSER_BLOB_BLOB_TRANSPORT_HOST_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "base/callback.h"
+#include "base/files/file.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/shared_memory_handle.h"
+#include "base/memory/weak_ptr.h"
+#include "storage/browser/blob/blob_data_builder.h"
+#include "storage/browser/blob/blob_memory_controller.h"
+#include "storage/browser/blob/blob_transport_request_builder.h"
+#include "storage/browser/storage_browser_export.h"
+#include "storage/common/blob_storage/blob_item_bytes_request.h"
+#include "storage/common/blob_storage/blob_item_bytes_response.h"
+#include "storage/common/blob_storage/blob_storage_constants.h"
+#include "storage/common/data_element.h"
+
+namespace base {
+class SharedMemory;
+}
+
+namespace storage {
+class BlobDataHandle;
+class BlobStorageContext;
+
+// This class facilitates moving memory from the renderer to the browser.
+class STORAGE_EXPORT BlobTransportHost {
+ public:
+  // One is expected to use std::move when calling this callback.
+  using RequestMemoryCallback =
+      base::Callback<void(std::vector<storage::BlobItemBytesRequest>,
+                          std::vector<base::SharedMemoryHandle>,
+                          std::vector<base::File>)>;
+
+  BlobTransportHost();
+  ~BlobTransportHost();
+
+  // This registers the given blob internally and adds it to the storage with a
+  // refcount of 1. |completion_callback| is called synchronously or
+  // asynchronously with:
+  // * INVALID_CONSTRUCTION_ARGUMENTS if we have invalid input arguments/data.
+  // * REFERENCED_BLOB_BROKEN if one of the referenced blobs is broken or
+  //   doesn't exist.
+  // * DONE if we don't need any more data transported and we can clean up.
+  // Returns a blob handle that is never null.
+  std::unique_ptr<BlobDataHandle> StartBuildingBlob(
+      const std::string& uuid,
+      const std::string& content_type,
+      const std::string& content_disposition,
+      const std::vector<DataElement>& elements,
+      BlobStorageContext* context,
+      const RequestMemoryCallback& request_memory,
+      const BlobStatusCallback& completion_callback);
+
+  // This is called when we have responses from the Renderer to our calls to
+  // the request_memory callback above. The callbacks given in StartBuildingBlob
+  // will be used to request for more memory or signal completion.
+  // Note: The uuid must be being built in this host (IsBeingBuilt).
+  void OnMemoryResponses(const std::string& uuid,
+                         const std::vector<BlobItemBytesResponse>& responses,
+                         BlobStorageContext* context);
+
+  // This removes the TransportState from our map and flags the blob as broken
+  // in the context. This can be called both from our own logic to cancel the
+  // blob, or from the DispatcherHost (Renderer). The blob MUST be being built
+  // in this builder. This also calls the |completion_callback|.
+  // Note: if the blob isn't in the context (renderer dereferenced it before we
+  // finished constructing), then we don't bother touching the context.
+  void CancelBuildingBlob(const std::string& uuid,
+                          BlobStatus code,
+                          BlobStorageContext* context);
+
+  // This clears this object of pending construction and does NOT call transport
+  // complete callbacks.
+  void CancelAll(BlobStorageContext* context);
+
+  bool IsEmpty() const { return async_blob_map_.empty(); }
+
+  size_t blob_building_count() const { return async_blob_map_.size(); }
+
+  bool IsBeingBuilt(const std::string& key) const {
+    return async_blob_map_.find(key) != async_blob_map_.end();
+  }
+
+ private:
+  struct TransportState {
+    TransportState(const std::string& uuid,
+                   const std::string& content_type,
+                   const std::string& content_disposition,
+                   RequestMemoryCallback request_memory_callback,
+                   BlobStatusCallback completion_callback);
+    TransportState(TransportState&&);
+    TransportState& operator=(TransportState&&);
+    DISALLOW_COPY_AND_ASSIGN(TransportState);
+    ~TransportState();
+
+    IPCBlobItemRequestStrategy strategy = IPCBlobItemRequestStrategy::UNKNOWN;
+    BlobTransportRequestBuilder request_builder;
+    BlobDataBuilder data_builder;
+    std::vector<bool> request_received;
+    size_t num_fulfilled_requests = 0;
+
+    RequestMemoryCallback request_memory_callback;
+    BlobStatusCallback completion_callback;
+
+    // Used by shared memory strategy.
+    size_t next_request = 0;
+    std::unique_ptr<base::SharedMemory> shared_memory_block;
+    // This is the number of requests that have been sent to populate the above
+    // shared data. We won't ask for more data in shared memory until all
+    // requests have been responded to.
+    size_t num_shared_memory_requests = 0;
+    // Only relevant if num_shared_memory_requests is > 0
+    size_t current_shared_memory_handle_index = 0;
+
+    // Used by file strategy.
+    std::vector<scoped_refptr<ShareableFileReference>> files;
+  };
+
+  typedef std::unordered_map<std::string, TransportState> AsyncBlobMap;
+
+  void StartRequests(
+      const std::string& uuid,
+      TransportState* state,
+      BlobStorageContext* context,
+      std::vector<BlobMemoryController::FileCreationInfo> file_infos);
+
+  void OnReadyForTransport(
+      const std::string& uuid,
+      base::WeakPtr<BlobStorageContext> context,
+      BlobStatus status,
+      std::vector<BlobMemoryController::FileCreationInfo> file_infos);
+
+  void SendIPCRequests(TransportState* state, BlobStorageContext* context);
+  void OnIPCResponses(const std::string& uuid,
+                      TransportState* state,
+                      const std::vector<BlobItemBytesResponse>& responses,
+                      BlobStorageContext* context);
+
+  // This is the 'main loop' of our memory requests to the renderer.
+  void ContinueSharedMemoryRequests(const std::string& uuid,
+                                    TransportState* state,
+                                    BlobStorageContext* context);
+
+  void OnSharedMemoryResponses(
+      const std::string& uuid,
+      TransportState* state,
+      const std::vector<BlobItemBytesResponse>& responses,
+      BlobStorageContext* context);
+
+  void SendFileRequests(
+      TransportState* state,
+      BlobStorageContext* context,
+      std::vector<BlobMemoryController::FileCreationInfo> files);
+
+  void OnFileResponses(const std::string& uuid,
+                       TransportState* state,
+                       const std::vector<BlobItemBytesResponse>& responses,
+                       BlobStorageContext* context);
+
+  // This finishes creating the blob in the context, decrements blob references
+  // that we were holding during construction, and erases our state.
+  void CompleteTransport(TransportState* state, BlobStorageContext* context);
+
+  AsyncBlobMap async_blob_map_;
+  base::WeakPtrFactory<BlobTransportHost> ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(BlobTransportHost);
+};
+
+}  // namespace storage
+#endif  // STORAGE_BROWSER_BLOB_BLOB_TRANSPORT_HOST_H_