[BlobAsync] Renderer support for blob file writing.

content/child/blob_storage/blob_consolidation.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 "content/child/blob_storage/blob_consolidation.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
+#include "base/bind.h"
+#include "base/callback.h"
+
 using storage::DataElement;
 using blink::WebThreadSafeData;
 
 namespace content {
+namespace {
+bool WriteMemory(void* memory_out,
+                 size_t total_read,
+                 const char* memory,
+                 size_t size) {
+  memcpy(static_cast<char*>(memory_out) + total_read, memory, size);
+  return true;
+}
+}  // namespace
 
 using ReadStatus = BlobConsolidation::ReadStatus;
 
 BlobConsolidation::ConsolidatedItem::ConsolidatedItem()
     : type(DataElement::TYPE_UNKNOWN),
       offset(0),
       length(std::numeric_limits<uint64_t>::max()),
       expected_modification_time(0) {}
 
 BlobConsolidation::ConsolidatedItem::~ConsolidatedItem() {
@@ skipping 65 matching lines @@
                                           double expected_modification_time) {
   if (length == 0)
     return;
   consolidated_items_.push_back(
       ConsolidatedItem(DataElement::TYPE_FILE_FILESYSTEM, offset, length));
   ConsolidatedItem& item = consolidated_items_.back();
   item.filesystem_url = url;
   item.expected_modification_time = expected_modification_time;
 }
 
-ReadStatus BlobConsolidation::ReadMemory(size_t consolidated_item_index,
-                                         size_t consolidated_offset,
-                                         size_t consolidated_size,
-                                         void* memory_out) {
-  CHECK(memory_out);
+ReadStatus BlobConsolidation::VisitMemory(
+    size_t consolidated_item_index,
+    size_t consolidated_offset,
+    size_t consolidated_size,
+    base::Callback<bool(size_t /* total_memory_read */,
+                        const char* /* memory */,
+                        size_t /* memory_size */)> visitor) const {
   if (consolidated_item_index >= consolidated_items_.size())
     return ReadStatus::ERROR_OUT_OF_BOUNDS;
 
   const ConsolidatedItem& item = consolidated_items_[consolidated_item_index];
   if (item.type != DataElement::TYPE_BYTES)
     return ReadStatus::ERROR_WRONG_TYPE;
 
   if (consolidated_size + consolidated_offset > item.length) {
     LOG(ERROR) << "Invalid consolidated size " << consolidated_size

[michaeln, 2016/04/26 22:50:08]

is this worth logging? search content/child for other LOG(ERROR) and you'll
notice how very little there is

                << " and offset " << consolidated_offset << " vs item length of "
                << item.length;
     return ReadStatus::ERROR_OUT_OF_BOUNDS;
   }
 
   // We do a binary search to find the correct data to start with in the data
   // elements.  This is slightly customized due to our unique storage and
   // constraints.
   size_t mid = 0;
   size_t offset_from_mid = consolidated_offset;
@@ skipping 22 matching lines @@
       }
     }
   }
 
   DCHECK_LT(offset_from_mid, item.data[mid].size());
   // Read starting from 'mid' and 'offset_from_mid'.
   for (size_t memory_read = 0;
        mid < num_items && memory_read < consolidated_size; mid++) {
     size_t read_size = std::min(item.data[mid].size() - offset_from_mid,
                                 consolidated_size - memory_read);
-    memcpy(static_cast<char*>(memory_out) + memory_read,
-           item.data[mid].data() + offset_from_mid, read_size);
+    bool continu = visitor.Run(

[kinuko, 2016/04/25 14:10:30]

nit: continu -> continue ?

[dmurph, 2016/04/26 22:33:28]

It's a keyword :(

[michaeln, 2016/04/26 22:50:08]

i said the same thing, but continue already means something in c/c++ :)

+        memory_read, item.data[mid].data() + offset_from_mid, read_size);
+    // If the visitor doesn't want to continue then we return early.
+    if (!continu)
+      return ReadStatus::CANCELLED_BY_VISITOR;
     offset_from_mid = 0;
     memory_read += read_size;
   }
   return ReadStatus::OK;
 }
 
+ReadStatus BlobConsolidation::ReadMemory(size_t consolidated_item_index,
+                                         size_t consolidated_offset,
+                                         size_t consolidated_size,
+                                         void* memory_out) const {
+  CHECK(memory_out);

[michaeln, 2016/04/26 22:50:08]

check isn't needed becuase VisitMemory/WriteMemory will crash in an obvious way

[dmurph, 2016/04/27 19:14:04]

ok

+  return VisitMemory(consolidated_item_index, consolidated_offset,
+                     consolidated_size, base::Bind(&WriteMemory, memory_out));
+}
+
 }  // namespace content