[BlobStorage] BlobMemoryController & tests

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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/numerics/safe_conversions.h"
 #include "base/numerics/safe_math.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_util.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 static int kInvalidDiskCacheSideStreamIndex = -1;
 
 }  // namespace
 
-const char BlobDataBuilder::kAppendFutureFileTemporaryFileName[] =
-    "kFakeFilenameToBeChangedByPopulateFutureFile";
+const char kFutureFileName[] = "_future_name_";
 
-BlobDataBuilder::BlobDataBuilder(const std::string& uuid) : uuid_(uuid) {
+/* static */
+base::FilePath BlobDataBuilder::GetFutureFileItemPath(uint64_t file_id) {
+  return base::FilePath::FromUTF8Unsafe(kFutureFileName)
+      .AddExtension(base::Uint64ToString(file_id));
 }
-BlobDataBuilder::~BlobDataBuilder() {
+
+/* static */
+bool BlobDataBuilder::IsFutureFileItem(const DataElement& element) {
+  const std::string prefix(kFutureFileName);
+  const std::string path = element.path().MaybeAsASCII();
+  // The prefix shouldn't occur unless the user used "AppendFutureFile". We
+  // DCHECK on AppendFile to make sure no one appends a future file.
+  return base::StartsWith(path, prefix, base::CompareCase::SENSITIVE);
 }
 
+/* static */
+uint64_t BlobDataBuilder::GetFutureFileID(const DataElement& element) {
+  DCHECK(IsFutureFileItem(element));
+  uint64_t id = 0;
+  bool success =
+      base::StringToUint64(element.path().Extension().substr(1), &id);
+  DCHECK(success) << element.path().Extension();
+  return id;
+}
+
+BlobDataBuilder::BlobDataBuilder(const std::string& uuid) : uuid_(uuid) {}
+BlobDataBuilder::~BlobDataBuilder() {}
+
 void BlobDataBuilder::AppendIPCDataElement(const DataElement& ipc_data) {
   uint64_t length = ipc_data.length();
   switch (ipc_data.type()) {
     case DataElement::TYPE_BYTES:
       DCHECK(!ipc_data.offset());
       AppendData(ipc_data.bytes(),
                  base::checked_cast<size_t, uint64_t>(length));
       break;
     case DataElement::TYPE_FILE:
       AppendFile(ipc_data.path(), ipc_data.offset(), length,
@@ skipping 31 matching lines @@
   items_.push_back(new BlobDataItem(std::move(element)));
   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();
+  DataElement* element = items_[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) {
+size_t BlobDataBuilder::AppendFutureFile(uint64_t offset,
+                                         uint64_t length,
+                                         uint64_t file_id) {
   CHECK_NE(length, 0ull);
   std::unique_ptr<DataElement> element(new DataElement());
-  element->SetToFilePathRange(base::FilePath::FromUTF8Unsafe(std::string(
-                                  kAppendFutureFileTemporaryFileName)),
-                              offset, length, base::Time());
+  element->SetToFilePathRange(GetFutureFileItemPath(file_id), offset, length,
+                              base::Time());
   items_.push_back(new BlobDataItem(std::move(element)));
   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();
+  DataElement* element = items_[index]->data_element_ptr();
 
-  if (old_element->type() != DataElement::TYPE_FILE) {
+  if (element->type() != DataElement::TYPE_FILE) {
     DVLOG(1) << "Invalid item type.";
     return false;
-  } else if (old_element->path().AsUTF8Unsafe() !=
-             std::string(kAppendFutureFileTemporaryFileName)) {
+  } else if (!IsFutureFileItem(*element)) {
     DVLOG(1) << "Item not created by AppendFutureFile";
     return false;
   }
-  uint64_t length = old_element->length();
-  uint64_t offset = old_element->offset();
-  std::unique_ptr<DataElement> element(new DataElement());
+  uint64_t length = element->length();
+  uint64_t offset = element->offset();
+  items_[index]->data_handle_ = std::move(file_reference);
   element->SetToFilePathRange(file_reference->path(), offset, length,
                               expected_modification_time);
-  items_[index] = new BlobDataItem(std::move(element), file_reference);
   return true;
 }
 
 void BlobDataBuilder::AppendFile(const base::FilePath& file_path,
                                  uint64_t offset,
                                  uint64_t length,
                                  const base::Time& expected_modification_time) {
   std::unique_ptr<DataElement> element(new DataElement());
   element->SetToFilePathRange(file_path, offset, length,
                               expected_modification_time);
+  DCHECK(!IsFutureFileItem(*element));
   items_.push_back(new BlobDataItem(std::move(element),
                                     ShareableFileReference::Get(file_path)));
 }
 
 void BlobDataBuilder::AppendBlob(const std::string& uuid,
                                  uint64_t offset,
                                  uint64_t length) {
   DCHECK_GT(length, 0ul);
   std::unique_ptr<DataElement> element(new DataElement());
   element->SetToBlobRange(uuid, offset, length);
@@ skipping 56 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