[BlobAsync] Patch 4: Browser Classes & Logic.

storage/browser/blob/blob_data_builder.cc

 // Copyright (c) 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 "storage/browser/blob/blob_data_builder.h"
 
 #include "base/numerics/safe_conversions.h"
 #include "base/numerics/safe_math.h"
 #include "base/time/time.h"
 #include "net/disk_cache/disk_cache.h"
 #include "storage/browser/blob/shareable_file_reference.h"
 
 namespace storage {
+namespace {
+const char* kFuturePopulatingFilePath = "kFakeFilenameToBeChanged";
+}
 
 BlobDataBuilder::BlobDataBuilder(const std::string& uuid) : uuid_(uuid) {
 }
 BlobDataBuilder::~BlobDataBuilder() {
 }
 
 void BlobDataBuilder::AppendIPCDataElement(const DataElement& ipc_data) {
   uint64 length = ipc_data.length();
   switch (ipc_data.type()) {
     case DataElement::TYPE_BYTES:
@@ skipping 34 matching lines @@
   scoped_ptr<DataElement> element(new DataElement());
   element->SetToBytesDescription(length);
   items_.push_back(new BlobDataItem(element.Pass()));
   return items_.size() - 1;
 }
 
 bool BlobDataBuilder::PopulateFutureData(size_t index,
                                          const char* data,
                                          size_t offset,
                                          size_t length) {
+  DCHECK_LT(index, items_.size());
   DCHECK(data);
   DataElement* element = items_.at(index)->data_element_ptr();
 
   // We lazily allocate our data buffer by waiting until the first
   // PopulateFutureData call.
   // Why? The reason we have the AppendFutureData  method is to create our Blob
   // record when the Renderer tells us about the blob without actually
   // allocating the memory yet, as we might not have the quota yet. So we don't
   // want to allocate the memory until we're actually receiving the data (which
   // the browser process only does when it has quota).
   if (element->type() == DataElement::TYPE_BYTES_DESCRIPTION) {
     element->SetToAllocatedBytes(element->length());
     // The type of the element is now TYPE_BYTES.
   }
   if (element->type() != DataElement::TYPE_BYTES) {
     DVLOG(1) << "Invalid item type.";
     return false;
   }
   base::CheckedNumeric<size_t> checked_end = offset;
   checked_end += length;
   if (!checked_end.IsValid() || checked_end.ValueOrDie() > element->length()) {
     DVLOG(1) << "Invalid offset or length.";
     return false;
   }
   std::memcpy(element->mutable_bytes() + offset, data, length);
   return true;
 }
 
+size_t BlobDataBuilder::AppendFutureFile(uint64_t offset, uint64_t length) {
+  CHECK_NE(length, 0ull);
+  scoped_ptr<DataElement> element(new DataElement());
+  element->SetToFilePathRange(
+      base::FilePath::FromUTF8Unsafe(std::string(kFuturePopulatingFilePath)),
+      offset, length, base::Time());
+  items_.push_back(new BlobDataItem(element.Pass()));
+  return items_.size() - 1;
+}
+
+bool BlobDataBuilder::PopulateFutureFile(
+    size_t index,
+    const scoped_refptr<ShareableFileReference>& file_reference,
+    const base::Time& expected_modification_time) {
+  DCHECK_LT(index, items_.size());
+  DataElement* old_element = items_.at(index)->data_element_ptr();
+
+  if (old_element->type() != DataElement::TYPE_FILE) {
+    DVLOG(1) << "Invalid item type.";
+    return false;
+  } else if (old_element->path().AsUTF8Unsafe() !=
+             std::string(kFuturePopulatingFilePath)) {
+    DVLOG(1) << "Item not created by AppendFutureFile";
+    return false;
+  }
+  uint64_t length = old_element->length();
+  uint64_t offset = old_element->offset();
+  // We null this out as it is about to be invalid after we set the vector item
+  // to a different BlobDataItem
+  old_element = nullptr;

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

Not sure you need to do this or comment about it, the ptr is valid right up till
the return statement on line 134.

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

Done.

+  scoped_ptr<DataElement> element(new DataElement());
+  element->SetToFilePathRange(file_reference->path(), offset, length,
+                              expected_modification_time);
+  items_[index] = new BlobDataItem(element.Pass(), file_reference);
+  return true;
+}
+
 void BlobDataBuilder::AppendFile(const base::FilePath& file_path,
                                  uint64_t offset,
                                  uint64_t length,
                                  const base::Time& expected_modification_time) {
   scoped_ptr<DataElement> element(new DataElement());
   element->SetToFilePathRange(file_path, offset, length,
                               expected_modification_time);
   items_.push_back(
       new BlobDataItem(element.Pass(), ShareableFileReference::Get(file_path)));
 }
@@ skipping 50 matching lines @@
       << ", content_type: " << x.content_type_
       << ", content_disposition: " << x.content_disposition_ << ", items: [";
   for (const auto& item : x.items_) {
     PrintTo(*item, os);
     *os << ", ";
   }
   *os << "]}";
 }
 
 }  // namespace storage