[BlobAsync] Patch 4: Browser Classes & Logic.

storage/browser/blob/blob_async_transport_strategy.cc

+// 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.
+
+#include <algorithm>
+
+#include "storage/browser/blob/blob_async_transport_strategy.h"
+#include "storage/common/blob_storage/blob_storage_constants.h"
+
+namespace storage {
+namespace {
+bool IsBytes(DataElement::Type type) {
+  return type == DataElement::TYPE_BYTES ||
+         type == DataElement::TYPE_BYTES_DESCRIPTION;
+}
+}  // namespace
+
+// This class handles the logic of how transported memory is going to be
+// represented as storage in the browser.  The main idea is that all the memory
+// is now packed into file chunks, and the browser items will just reference
+// the file with offsets and sizes.
+class FileStorageStrategy
+    : public BlobAsyncTransportStrategy::BlobSegmentVisitor<uint64_t> {
+ public:
+  typedef uint64_t SizeType;
+
+  FileStorageStrategy(
+      std::vector<BlobAsyncTransportStrategy::RendererMemoryItemRequest>*
+          requests,
+      BlobDataBuilder* builder)
+      : requests(requests), builder(builder), current_item_index(0) {}
+
+  ~FileStorageStrategy() override {}
+
+  void VisitBytesSegment(size_t element_index,
+                         SizeType element_offset,
+                         size_t segment_index,
+                         SizeType segment_offset,
+                         SizeType size) override {
+    BlobAsyncTransportStrategy::RendererMemoryItemRequest request;
+    request.browser_item_index = current_item_index;
+    request.browser_item_offset = 0;
+    request.message.request_number = requests->size();
+    request.message.transport_strategy = IPCBlobItemRequestStrategy::FILE;
+    request.message.renderer_item_index = element_index;
+    request.message.renderer_item_offset = element_offset;
+    request.message.size = size;
+    request.message.handle_index = segment_index;
+    request.message.handle_offset = segment_offset;
+
+    requests->push_back(request);
+    builder->AppendFutureFile(segment_offset, size);
+    current_item_index++;
+  }
+
+  void VisitNonBytesSegment(const DataElement& element,
+                            size_t element_index) override {
+    builder->AppendIPCDataElement(element);
+    current_item_index++;
+  }
+
+  void Done() override {}
+
+  std::vector<BlobAsyncTransportStrategy::RendererMemoryItemRequest>* requests;
+  BlobDataBuilder* builder;
+
+  size_t current_item_index;
+};
+
+// This class handles the logic of storing memory that is transported as
+// consolidated shared memory.
+class SharedMemoryStorageStrategy
+    : public BlobAsyncTransportStrategy::BlobSegmentVisitor<size_t> {
+ public:
+  typedef size_t SizeType;
+
+  SharedMemoryStorageStrategy(
+      SizeType max_segment_size,
+      std::vector<BlobAsyncTransportStrategy::RendererMemoryItemRequest>*
+          requests,
+      BlobDataBuilder* builder)
+      : requests(requests),
+        max_segment_size(max_segment_size),
+        builder(builder),
+        current_item_size(0),
+        current_item_index(0) {}
+  ~SharedMemoryStorageStrategy() override {}
+
+  void VisitBytesSegment(size_t element_index,
+                         SizeType element_offset,
+                         size_t segment_index,
+                         SizeType segment_offset,
+                         SizeType size) override {
+    if (current_item_size + size > max_segment_size) {
+      builder->AppendFutureData(current_item_size);
+      current_item_index++;
+      current_item_size = 0;
+    }
+    BlobAsyncTransportStrategy::RendererMemoryItemRequest request;
+    request.browser_item_index = current_item_index;
+    request.browser_item_offset = current_item_size;
+    request.message.request_number = requests->size();
+    request.message.transport_strategy =
+        IPCBlobItemRequestStrategy::SHARED_MEMORY;
+    request.message.renderer_item_index = element_index;
+    request.message.renderer_item_offset = element_offset;
+    request.message.size = size;
+    request.message.handle_index = segment_index;
+    request.message.handle_offset = segment_offset;
+
+    requests->push_back(request);
+    current_item_size += size;
+  };
+
+  void VisitNonBytesSegment(const DataElement& element,
+                            size_t element_index) override {
+    if (current_item_size != 0) {
+      builder->AppendFutureData(current_item_size);
+      current_item_index++;
+    }
+    builder->AppendIPCDataElement(element);
+    current_item_index++;
+    current_item_size = 0;
+  }
+
+  void Done() override {
+    if (current_item_size != 0) {
+      builder->AppendFutureData(current_item_size);
+    }
+  }
+
+  std::vector<BlobAsyncTransportStrategy::RendererMemoryItemRequest>* requests;
+
+  SizeType max_segment_size;
+  BlobDataBuilder* builder;
+  SizeType current_item_size;
+  size_t current_item_index;
+};
+
+BlobAsyncTransportStrategy::RendererMemoryItemRequest::
+    RendererMemoryItemRequest()
+    : browser_item_index(0), browser_item_offset(0), received(false) {}
+
+BlobAsyncTransportStrategy::BlobAsyncTransportStrategy()
+    : error_(BlobAsyncTransportStrategy::ERROR_NONE), total_bytes_size_(0) {}
+
+BlobAsyncTransportStrategy::~BlobAsyncTransportStrategy() {}
+
+// if total_blob_size > kMaxBlobSize (say 400MB)
+//   Request all data in files
+//   (Segment all of the existing data into
+//   file blocks, of <= kMaxFileSize)
+// else if total_blob_size > kMaxIPCSize (this is 150KB)
+//   Request all data in shared memory
+//   (Segment all of the existing data into
+//   shared memory blocks, of <= kMaxSharedMemorySize)
+// else
+//   Request all data to be sent over IPC
+void BlobAsyncTransportStrategy::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) {
+  DCHECK(file_handle_sizes_.empty());
+  DCHECK(shared_memory_handle_sizes_.empty());
+  DCHECK(requests_.empty());
+  DCHECK(!builder_.get());
+  builder_.reset(new BlobDataBuilder(uuid));
+  error_ = BlobAsyncTransportStrategy::ERROR_NONE;
+
+  size_t memory_items = 0;
+  total_bytes_size_ = 0;
+  for (const auto& info : blob_item_infos) {
+    if (!IsBytes(info.type())) {
+      continue;
+    }
+    total_bytes_size_ += info.length();
+    ++memory_items;
+  }
+
+  // See if we have enough memory

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

nit: finish comment with period

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

Done.

+  if (total_bytes_size_ >
+      disk_space_left + static_cast<uint64_t>(memory_available)) {
+    error_ = BlobAsyncTransportStrategy::ERROR_TOO_LARGE;
+    return;
+  }
+
+  // If we're more than the available memory, then we're going straight to disk.
+  if (total_bytes_size_ > memory_available) {
+    if (total_bytes_size_ > disk_space_left) {
+      error_ = BlobAsyncTransportStrategy::ERROR_TOO_LARGE;
+      return;
+    }
+    ComputeHandleSizes(total_bytes_size_, max_file_size, &file_handle_sizes_);
+    FileStorageStrategy strategy(&requests_, builder_.get());
+    ForEachWithSegment(blob_item_infos, max_file_size, &strategy);
+    return;
+  }
+
+  if (total_bytes_size_ > max_ipc_memory_size) {
+    CHECK_LE(total_bytes_size_, std::numeric_limits<size_t>::max());
+    ComputeHandleSizes(static_cast<size_t>(total_bytes_size_),
+                       max_shared_memory_size, &shared_memory_handle_sizes_);
+    SharedMemoryStorageStrategy strategy(max_shared_memory_size, &requests_,
+                                         builder_.get());
+    ForEachWithSegment(blob_item_infos, max_shared_memory_size, &strategy);
+    return;
+  }
+
+  // Since they can all fit in IPC memory, we don't need to segment anything,
+  // and just request them straight in IPC.
+  size_t items_length = blob_item_infos.size();
+  for (size_t i = 0; i < items_length; i++) {
+    const auto& info = blob_item_infos.at(i);
+    if (!IsBytes(info.type())) {
+      builder_->AppendIPCDataElement(info);
+      continue;
+    }
+    BlobAsyncTransportStrategy::RendererMemoryItemRequest request;
+    request.browser_item_index = i;
+    request.browser_item_offset = 0;
+    request.message.request_number = requests_.size();
+    request.message.transport_strategy = IPCBlobItemRequestStrategy::IPC;
+    request.message.renderer_item_index = i;
+    request.message.renderer_item_offset = 0;
+    request.message.size = info.length();
+    requests_.push_back(request);
+    builder_->AppendFutureData(info.length());
+  }
+}
+
+// Splits each |element| into one or more |segments| of a max_size, invokes the
+// strategy to determine the request to make for each |segment| produced. A
+// |segment| can also span multiple |elements|.
+/* static */
+template <typename SizeType>
+void BlobAsyncTransportStrategy::ForEachWithSegment(
+    const std::vector<DataElement>& elements,
+    SizeType max_segment_size,
+    BlobSegmentVisitor<SizeType>* visitor) {
+  DCHECK_GT(max_segment_size, 0ull);
+  size_t segment_index = 0;
+  SizeType segment_offset = 0;
+  size_t elements_length = elements.size();
+  for (size_t element_index = 0; element_index < elements_length;
+       ++element_index) {
+    const auto& element = elements.at(element_index);
+    DataElement::Type type = element.type();
+    if (!IsBytes(type)) {
+      visitor->VisitNonBytesSegment(element, element_index);
+      continue;
+    }
+    SizeType element_memory_left = element.length();
+    SizeType element_offset = 0;
+    while (element_memory_left > 0) {
+      if (segment_offset == max_segment_size) {
+        ++segment_index;
+        segment_offset = 0;
+      }
+      SizeType memory_writing =
+          std::min(max_segment_size - segment_offset, element_memory_left);
+      visitor->VisitBytesSegment(element_index, element_offset, segment_index,
+                                 segment_offset, memory_writing);
+      element_memory_left -= memory_writing;
+      segment_offset += memory_writing;
+      element_offset += memory_writing;
+    }
+  }
+  visitor->Done();
+}
+
+/* static */
+bool BlobAsyncTransportStrategy::ShouldBeShortcut(
+    const std::vector<DataElement>& elements,
+    size_t memory_available) {
+  size_t shortcut_bytes = 0;
+  for (const auto& element : elements) {
+    DataElement::Type type = element.type();
+    if (type == DataElement::TYPE_BYTES_DESCRIPTION) {
+      return false;
+    }
+    if (type == DataElement::TYPE_BYTES) {
+      shortcut_bytes += element.length();
+    }
+  }
+  return shortcut_bytes <= memory_available;
+}
+
+/* static */
+template <typename SizeType>
+void BlobAsyncTransportStrategy::ComputeHandleSizes(
+    SizeType total_memory_size,
+    SizeType max_segment_size,
+    std::vector<SizeType>* segment_sizes) {
+  size_t total_max_segments =
+      static_cast<size_t>(total_memory_size / max_segment_size);
+  bool hasExtraSegment = (total_memory_size % max_segment_size) > 0;
+  segment_sizes->reserve(total_max_segments + (hasExtraSegment ? 1 : 0));
+  segment_sizes->insert(segment_sizes->begin(), total_max_segments,
+                        max_segment_size);
+  if (hasExtraSegment) {
+    segment_sizes->push_back(total_memory_size % max_segment_size);
+  }
+}
+
+}  // namespace storage