[BlobAsync] Patch 4: Browser Classes & Logic.

storage/browser/blob/blob_async_transport_strategy.h

Index: storage/browser/blob/blob_async_transport_strategy.h
diff --git a/storage/browser/blob/blob_async_transport_strategy.h b/storage/browser/blob/blob_async_transport_strategy.h
new file mode 100644
index 0000000000000000000000000000000000000000..eaa83b1c9c3308099b4e00798ef9b5bb5e2de552
--- /dev/null
+++ b/storage/browser/blob/blob_async_transport_strategy.h
@@ -0,0 +1,154 @@
+// 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_TRANSPORT_STRATEGY_H_
+#define STORAGE_BROWSER_BLOB_BLOB_ASYNC_TRANSPORT_STRATEGY_H_
+
+#include <map>
+#include <vector>
+
+#include "base/macros.h"
+#include "base/memory/scoped_ptr.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/data_element.h"
+
+namespace storage {
+class FileStorageStrategy;
+class SharedMemoryStorageStrategy;
+
+// This class computes and stores the strategy for asynchronously transporting
+// memory from the renderer to the browser. We take memory constraints of our
+// system and the description of a blob, and figure out:
+// 1) How to store the blob data in the browser process: in memory or on disk.
+// 2) How to transport the data from the renderer: ipc payload, shared memory,
+//    or file handles.
+// We then generate data requests for that blob's memory and seed a
+// BlobDataBuilder for storing that data.
+//
+// Note: This class does not compute requests by using the 'shortcut' method,
+//       where the data is already present in the blob description, and will
+//       always give the caller the full strategy for requesting all data from
+//       the renderer.

[michaeln, 2015/11/24 23:19:40]

short-n-sweet... thnx!

[dmurph, 2015/11/25 21:16:30]

np

+class STORAGE_EXPORT BlobAsyncTransportStrategy {
+ public:
+  enum Error {
+    ERROR_NONE = 0,
+    ERROR_TOO_LARGE,  // This item can't fit in disk or memory
+    ERROR_INVALID_PARAMS
+  };
+
+  struct RendererMemoryItemRequest {
+    RendererMemoryItemRequest();
+    // This is the index of the item in the builder on the browser side.
+    size_t browser_item_index;
+    // Note: For files this offset should always be 0, as the file offset in
+    //       segmentation is handled by the handle_offset in the message.  This
+    //       offset is used for populating a chunk when the data comes back to
+    //       the browser.
+    size_t browser_item_offset;
+    BlobItemBytesRequest message;
+    bool received;
+  };
+
+  BlobAsyncTransportStrategy();
+  virtual ~BlobAsyncTransportStrategy();
+
+  // This call does the computation to create the requests and builder for the
+  // blob given the memory constraints and blob description.
+  // 'memory_available' is the total amount of memory we can offer for storing
+  // blobs.

[kinuko, 2015/11/25 16:08:17]

nit: maybe also note that it is not valid to call this twice

[dmurph, 2015/11/25 21:16:30]

Done.

+  void Initialize(size_t max_ipc_memory_size,
+                  size_t max_shared_memory_size,
+                  uint64_t max_file_size,
+                  uint64_t disk_space_left,
+                  size_t memory_available,
+                  const std::string& uuid,
+                  const std::vector<DataElement>& blob_item_infos);
+
+  // The sizes of the file handles being used (by handle index) in the async
+  // operation.
+  std::vector<uint64_t>& file_handle_sizes() { return file_handle_sizes_; }

[kinuko, 2015/11/25 16:08:17]

nit: do we really want/need to return non-const version here and below?

[dmurph, 2015/11/25 21:16:30]

Good catch.  We don't need to anymore because we are just describing the sizes.

[michaeln, 2015/11/25 21:23:59]

This gets back to an earlier comment about how he packaging of this class feels
a little awkward. Mutable copies of internal data members are needed because
this is more struct than encapsulated object. The consumer needs to mutate the
internals directly, I'm not sure if the handle sizes need to be mutable, but the
builder certainly does.

To me, this class is more of a function that computes sizes and preps a builder,
the logic is an impl detail of the asyncbuilderhost start method and the results
are a part of the asyncbuilding state. The function/logic can be easily tested
either way, as a separate class or as an integral part of the builderhost.

+
+  // The sizes of the shared memory handles being used (by handle index) in the
+  // async operation.
+  std::vector<size_t>& shared_memory_handle_sizes() {
+    return shared_memory_handle_sizes_;
+  }
+
+  // The requests for memory, segmented as described above, along with their
+  // destination browser indexes and offsets.
+  const std::vector<RendererMemoryItemRequest>& requests() const {
+    return requests_;
+  }
+
+  // A BlobDataBuilder which can be used to construct the Blob in the
+  // BlobStorageContext object after:
+  // * The bytes items from AppendFutureData are populated by
+  //   PopulateFutureData.
+  // * The temporary files from AppendFutureFile are populated by
+  //   PopulateFutureFile.
+  BlobDataBuilder* blob_builder() { return builder_.get(); }
+
+  // The total bytes size of memory items in the blob.
+  uint64_t total_bytes_size() const { return total_bytes_size_; }
+
+  Error error() const { return error_; }

[michaeln, 2015/11/25 21:23:59]

Given how this data member is used, maybe have Initialize() return this value
instead of having it as a data member.

+
+  static bool ShouldBeShortcut(const std::vector<DataElement>& items,
+                               size_t memory_available);
+
+ protected:
+  friend class FileStorageStrategy;
+  friend class SharedMemoryStorageStrategy;
+
+  template <typename SizeType>
+  class BlobSegmentVisitor {
+   public:
+    virtual ~BlobSegmentVisitor(){};
+    virtual void VisitBytesSegment(size_t element_index,
+                                   SizeType element_offset,
+                                   size_t segment_index,
+                                   SizeType segment_offset,
+                                   SizeType size) = 0;
+    virtual void VisitNonBytesSegment(const DataElement& element,
+                                      size_t element_index) = 0;
+    virtual void Done() = 0;
+  };
+
+  // This iterates of the data elements and segments the 'bytes' data into
+  // the smallest number of segments given the max_segment_size.
+  // The callback describes either:
+  // * A non-memory item
+  // * A partition of a bytes element which will be populated into a given
+  //   segment and segment offset.
+  // Assumptions: All memory items are consolidated.  As in, there are no two
+  //              'bytes' items next to eachother.
+  template <typename SizeType>
+  static void ForEachWithSegment(const std::vector<DataElement>& items,
+                                 SizeType max_segment_size,
+                                 BlobSegmentVisitor<SizeType>* visitor);
+
+ private:
+  template <typename SizeType>
+  static void ComputeHandleSizes(SizeType total_memory_size,
+                                 SizeType max_segment_size,
+                                 std::vector<SizeType>* segment_sizes);
+
+  Error error_;
+
+  std::vector<uint64_t> file_handle_sizes_;
+  std::vector<size_t> shared_memory_handle_sizes_;
+
+  uint64_t total_bytes_size_;
+  std::vector<RendererMemoryItemRequest> requests_;
+  scoped_ptr<BlobDataBuilder> builder_;
+
+  DISALLOW_COPY_AND_ASSIGN(BlobAsyncTransportStrategy);
+};
+
+}  // namespace storage
+
+#endif  // STORAGE_BROWSER_BLOB_BLOB_ASYNC_TRANSPORT_STRATEGY_H_