[BlobAsync] Patch 4: Browser Classes & Logic.

storage/browser/blob/blob_async_builder_host.h

+// 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_ASYNC_BUILDER_HOST_H_
+#define STORAGE_BROWSER_BLOB_BLOB_ASYNC_BUILDER_HOST_H_
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "base/callback.h"
+#include "base/containers/scoped_ptr_map.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/shared_memory_handle.h"
+#include "storage/browser/blob/blob_async_transport_strategy.h"
+#include "storage/browser/blob/blob_data_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 {
+
+// This class holds all blobs that are currently being built asynchronously for
+// a child process. It sends memory request, cancel, and done messages through
+// the given callbacks.
+// This also includes handling 'shortcut' logic, where the host will use the
+// initial data in the description instead of requesting for data if we have
+// enough immediate space.
+class STORAGE_EXPORT BlobAsyncBuilderHost {
+ public:
+  BlobAsyncBuilderHost();
+  virtual ~BlobAsyncBuilderHost();
+
+  // This method begins the construction of the blob given the descriptions.
+  // After this method is called, the following can happen:
+  // * The |done| callback is triggered immediately because we can shortcut the
+  //   construction.
+  // * The |request_memory| callback is called to request memory from the
+  //   renderer. This class waits for calls to OnMemoryResponses to continue.
+  //   The last argument in the callback corresponds to file handle sizes.
+  // * The cancel callback is triggered if there is an error.
+  // Note: The builder given to the 'done' callback is destructed immediately

[michaeln, 2015/11/21 00:59:45]

would passing the builder to the completion callback as const ref work? probably
it needs to be mutable, but just checking

[dmurph, 2015/11/23 20:07:02]

Yeah, I can switch this to const ref everywhere.

+  //       after the callback is run.
+  void StartBuildingBlob(
+      const std::string& uuid,
+      const std::string& type,
+      const std::vector<DataElement>& descriptions,
+      size_t memory_available,
+      base::Callback<void(const std::vector<storage::BlobItemBytesRequest>&,
+                          const std::vector<base::SharedMemoryHandle>&,
+                          const std::vector<uint64_t>&)> request_memory,
+      base::Callback<void(BlobDataBuilder*)> done,
+      base::Callback<void(IPCBlobCreationCancelCode)> cancel);
+
+  bool IsBuildingBlob(const std::string& uuid) const {
+    return async_blob_map_.find(uuid) != async_blob_map_.end();
+  }
+
+  // This is called when we have responses from the Renderer to our calls to
+  // the request_memory callback above.
+  void OnMemoryResponses(const std::string& uuid,
+                         const std::vector<BlobItemBytesResponse>& responses);
+
+  // This erases the blob building state.
+  void StopBuildingBlob(const std::string& uuid);
+
+  size_t blob_building_count() const { return async_blob_map_.size(); }
+
+  // For testing use only.  Must be called before BuildBlobAsync.

[kinuko, 2015/11/20 15:19:42]

nit: BuildBlobAsync -> StartBuildingBlob?

[dmurph, 2015/11/20 22:10:05]

Done.

+  void SetMemoryConstantsForTesting(size_t max_ipc_memory_size,
+                                    size_t max_shared_memory_size,
+                                    uint64_t max_file_size) {
+    max_ipc_memory_size_ = max_ipc_memory_size;
+    max_shared_memory_size_ = max_shared_memory_size;
+    max_file_size_ = max_file_size;
+  }
+
+ private:
+  struct BlobBuildingState {
+    BlobBuildingState();
+    ~BlobBuildingState();
+
+    std::string type;
+    BlobAsyncTransportStrategy transport_strategy;
+    size_t next_request;
+    size_t num_fulfilled_requests;
+    scoped_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;
+    // Only relevant if num_shared_memory_requests is > 0
+    size_t current_shared_memory_handle_index;
+
+    base::Callback<void(const std::vector<storage::BlobItemBytesRequest>&,
+                        const std::vector<base::SharedMemoryHandle>&,
+                        const std::vector<uint64_t>&)> request_memory_callback;
+    base::Callback<void(BlobDataBuilder*)> done_callback;
+    base::Callback<void(IPCBlobCreationCancelCode)> cancel_callback;
+  };
+
+  typedef base::ScopedPtrMap<std::string, scoped_ptr<BlobBuildingState>>
+      AsyncBlobMap;
+
+  // This is the 'main loop' of our memory requests to the renderer.
+  void ContinueBlobMemoryRequests(const std::string& uuid);
+
+  void CancelAndCleanup(const std::string& uuid,
+                        IPCBlobCreationCancelCode code);
+  void DoneAndCleanup(const std::string& uuid);
+
+  AsyncBlobMap async_blob_map_;
+
+  // Here for testing.
+  size_t max_ipc_memory_size_ = kBlobStorageIPCThresholdBytes;
+  size_t max_shared_memory_size_ = kBlobStorageMaxSharedMemoryBytes;
+  uint64_t max_file_size_ = kBlobStorageMaxFileSizeBytes;
+
+  DISALLOW_COPY_AND_ASSIGN(BlobAsyncBuilderHost);
+};
+
+}  // namespace storage
+#endif  // STORAGE_BROWSER_BLOB_BLOB_ASYNC_BUILDER_HOST_H_