[BlobAsync] Disk support for blob storage

storage/browser/blob/blob_async_transport_request_builder.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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 
 #include "base/numerics/safe_math.h"
+#include "base/strings/string_number_conversions.h"
 #include "storage/browser/blob/blob_async_transport_request_builder.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;
 }
 
@@ skipping 33 matching lines @@
     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);
+    builder->AppendFutureFile(segment_offset, size,
+                              base::SizeTToString(segment_index));
     current_item_index++;
   }
 
   void VisitNonBytesSegment(const DataElement& element, size_t element_index) {
     builder->AppendIPCDataElement(element);
     current_item_index++;
   }
 
   void Done() {}
 
@@ skipping 179 matching lines @@
     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());
   }
 }
 
 /* static */
-bool BlobAsyncTransportRequestBuilder::ShouldBeShortcut(
-    const std::vector<DataElement>& elements,
-    size_t memory_available) {
-  base::CheckedNumeric<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();
-      if (!shortcut_bytes.IsValid()) {
-        return false;
-      }
-    }
-  }
-  return shortcut_bytes.ValueOrDie() <= memory_available;
-}
-
-/* static */
 void BlobAsyncTransportRequestBuilder::ComputeHandleSizes(
     uint64_t total_memory_size,
     size_t max_segment_size,
     std::vector<size_t>* segment_sizes) {
   size_t total_max_segments =
       static_cast<size_t>(total_memory_size / max_segment_size);
   bool has_extra_segment = (total_memory_size % max_segment_size) > 0;
   segment_sizes->reserve(total_max_segments + (has_extra_segment ? 1 : 0));
   segment_sizes->insert(segment_sizes->begin(), total_max_segments,
                         max_segment_size);
   if (has_extra_segment) {
     segment_sizes->push_back(total_memory_size % max_segment_size);
   }
 }
 
 }  // namespace storage