[Storage] Blob items are now shared between blobs. Ready for disk swap.

storage/browser/blob/blob_storage_context.cc

 // Copyright (c) 2013 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_storage_context.h"
 
+#include <algorithm>
+
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "storage/browser/blob/blob_data_builder.h"
+#include "storage/browser/blob/blob_data_handle.h"
 #include "url/gurl.h"
 
 namespace storage {
 
 namespace {
 
 // We can't use GURL directly for these hash fragment manipulations
 // since it doesn't have specific knowlege of the BlobURL format. GURL
 // treats BlobURLs as if they were PathURLs which don't support hash
 // fragments.
 
 bool BlobUrlHasRef(const GURL& url) {
   return url.spec().find('#') != std::string::npos;
 }
 
 GURL ClearBlobUrlRef(const GURL& url) {
   size_t hash_pos = url.spec().find('#');
   if (hash_pos == std::string::npos)
     return url;
   return GURL(url.spec().substr(0, hash_pos));
 }
 
 // TODO(michaeln): use base::SysInfo::AmountOfPhysicalMemoryMB() in some
 // way to come up with a better limit.
 static const int64 kMaxMemoryUsage = 500 * 1024 * 1024;  // Half a gig.
 
 }  // namespace
 
-BlobStorageContext::BlobMapEntry::BlobMapEntry()
-    : refcount(0), flags(0) {
+BlobStorageContext::BlobMapEntry::BlobMapEntry() : refcount(0), flags(0) {
 }
 
 BlobStorageContext::BlobMapEntry::BlobMapEntry(int refcount,
-                                               BlobDataBuilder* data)
+                                               InternalBlobData::Builder* data)
     : refcount(refcount), flags(0), data_builder(data) {
 }
 
 BlobStorageContext::BlobMapEntry::~BlobMapEntry() {
 }
 
 bool BlobStorageContext::BlobMapEntry::IsBeingBuilt() {
   return data_builder;
 }
 
-BlobStorageContext::BlobStorageContext()
-    : memory_usage_(0) {
+BlobStorageContext::BlobStorageContext() : memory_usage_(0) {
 }
 
 BlobStorageContext::~BlobStorageContext() {
   STLDeleteContainerPairSecondPointers(blob_map_.begin(), blob_map_.end());
 }
 
 scoped_ptr<BlobDataHandle> BlobStorageContext::GetBlobDataFromUUID(
     const std::string& uuid) {
   scoped_ptr<BlobDataHandle> result;
   BlobMap::iterator found = blob_map_.find(uuid);
   if (found == blob_map_.end())
     return result.Pass();
   auto* entry = found->second;
   if (entry->flags & EXCEEDED_MEMORY)
     return result.Pass();
   DCHECK(!entry->IsBeingBuilt());
   result.reset(
       new BlobDataHandle(uuid, this, base::MessageLoopProxy::current().get()));
   return result.Pass();
 }
 
 scoped_ptr<BlobDataHandle> BlobStorageContext::GetBlobDataFromPublicURL(
     const GURL& url) {
-  BlobURLMap::iterator found = public_blob_urls_.find(
-      BlobUrlHasRef(url) ? ClearBlobUrlRef(url) : url);
+  BlobURLMap::iterator found =
+      public_blob_urls_.find(BlobUrlHasRef(url) ? ClearBlobUrlRef(url) : url);
   if (found == public_blob_urls_.end())
     return scoped_ptr<BlobDataHandle>();
   return GetBlobDataFromUUID(found->second);
 }
 
 scoped_ptr<BlobDataHandle> BlobStorageContext::AddFinishedBlob(
-    const BlobDataBuilder& data) {
-  StartBuildingBlob(data.uuid_);
-  for (const auto& blob_item : data.items_)
-    AppendBlobDataItem(data.uuid_, *(blob_item->item_));
-  FinishBuildingBlob(data.uuid_, data.content_type_);
-  scoped_ptr<BlobDataHandle> handle = GetBlobDataFromUUID(data.uuid_);
-  DecrementBlobRefCount(data.uuid_);
+    BlobDataBuilder* builder) {
+  StartBuildingBlob(builder->uuid_);
+  BlobMap::iterator found = blob_map_.find(builder->uuid_);
+  DCHECK(found != blob_map_.end());
+  BlobMapEntry* entry = found->second;
+  InternalBlobData::Builder* target_blob_builder = entry->data_builder.get();
+  DCHECK(target_blob_builder);
+
+  for (const auto& blob_item : builder->items_) {
+    if (entry->flags & EXCEEDED_MEMORY)

[michaeln, 2015/02/05 22:58:47]

not sure this test is needed since StartBuildingBlob can't result in an entry
with this flag set?

[dmurph, 2015/02/06 01:32:30]

True, removed.

+      break;
+    if (!AppendAllocatedBlobItem(builder->uuid_, target_blob_builder,
+                                 blob_item)) {
+      BlobEntryExceededMemory(entry);
+      break;
+    }
+  }
+
+  FinishBuildingBlob(builder->uuid_, builder->content_type_);
+  scoped_ptr<BlobDataHandle> handle = GetBlobDataFromUUID(builder->uuid_);
+  DecrementBlobRefCount(builder->uuid_);
   return handle.Pass();
 }
 
-bool BlobStorageContext::RegisterPublicBlobURL(
-    const GURL& blob_url, const std::string& uuid) {
+bool BlobStorageContext::RegisterPublicBlobURL(const GURL& blob_url,
+                                               const std::string& uuid) {
   DCHECK(!BlobUrlHasRef(blob_url));
   DCHECK(IsInUse(uuid));
   DCHECK(!IsUrlRegistered(blob_url));
   if (!IsInUse(uuid) || IsUrlRegistered(blob_url))
     return false;
   IncrementBlobRefCount(uuid);
   public_blob_urls_[blob_url] = uuid;
   return true;
 }
 
 void BlobStorageContext::RevokePublicBlobURL(const GURL& blob_url) {
   DCHECK(!BlobUrlHasRef(blob_url));
   if (!IsUrlRegistered(blob_url))
     return;
   DecrementBlobRefCount(public_blob_urls_[blob_url]);
   public_blob_urls_.erase(blob_url);
 }
 
 scoped_ptr<BlobDataSnapshot> BlobStorageContext::CreateSnapshot(
     const std::string& uuid) {
   scoped_ptr<BlobDataSnapshot> result;
   auto found = blob_map_.find(uuid);
   DCHECK(found != blob_map_.end())
-      << "Blob should be in map, as the handle is still around";
+      << "Blob " << uuid << " should be in map, as the handle is still around";
   BlobMapEntry* entry = found->second;
   DCHECK(!entry->IsBeingBuilt());
-  result.reset(new BlobDataSnapshot(*entry->data));
-  return result.Pass();
+  const InternalBlobData& data = *entry->data;
+  return CreateSnapshot(uuid, data);
 }
 
 void BlobStorageContext::StartBuildingBlob(const std::string& uuid) {
   DCHECK(!IsInUse(uuid) && !uuid.empty());
-  blob_map_[uuid] = new BlobMapEntry(1, new BlobDataBuilder(uuid));
+  blob_map_[uuid] = new BlobMapEntry(1, new InternalBlobData::Builder());
 }
 
-void BlobStorageContext::AppendBlobDataItem(const std::string& uuid,
-                                            const DataElement& item) {
+void BlobStorageContext::AppendBlobDataItem(
+    const std::string& uuid,
+    const storage::DataElement& data_element) {
   DCHECK(IsBeingBuilt(uuid));
   BlobMap::iterator found = blob_map_.find(uuid);
   if (found == blob_map_.end())
     return;
   BlobMapEntry* entry = found->second;
   if (entry->flags & EXCEEDED_MEMORY)
     return;
-  BlobDataBuilder* target_blob_data = entry->data_builder.get();
-  DCHECK(target_blob_data);
+  InternalBlobData::Builder* target_blob_builder = entry->data_builder.get();
+  DCHECK(target_blob_builder);
 
-  bool exceeded_memory = false;
-
-  // The blob data is stored in the canonical way which only contains a
-  // list of Data, File, and FileSystem items. Aggregated TYPE_BLOB items
-  // are expanded into the primitive constituent types.
-  // 1) The Data item is denoted by the raw data and length.
-  // 2) The File item is denoted by the file path, the range and the expected
-  //    modification time.
-  // 3) The FileSystem File item is denoted by the FileSystem URL, the range
-  //    and the expected modification time.
-  // 4) The Blob items are expanded.
-  // TODO(michaeln): Would be nice to avoid copying Data items when expanding.
-
-  uint64 length = item.length();
-  DCHECK_GT(length, 0u);
-  UMA_HISTOGRAM_COUNTS("Storage.Blob.StorageSizeBeforeAppend",
-                       memory_usage_ / 1024);
-  switch (item.type()) {
-    case DataElement::TYPE_BYTES:
-      UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.Bytes", length / 1024);
-      DCHECK(!item.offset());
-      exceeded_memory = !AppendBytesItem(target_blob_data, item.bytes(),
-                                         static_cast<int64>(length));
-      break;
-    case DataElement::TYPE_FILE:
-      UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.File", length / 1024);
-      AppendFileItem(target_blob_data, item.path(), item.offset(),
-                     item.length(), item.expected_modification_time());
-      break;
-    case DataElement::TYPE_FILE_FILESYSTEM:
-      UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.FileSystem", length / 1024);
-      AppendFileSystemFileItem(target_blob_data, item.filesystem_url(),
-                               item.offset(), item.length(),
-                               item.expected_modification_time());
-      break;
-    case DataElement::TYPE_BLOB: {
-      UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.Blob", length / 1024);
-      // We grab the handle to ensure it stays around while we copy it.
-      scoped_ptr<BlobDataHandle> src = GetBlobDataFromUUID(item.blob_uuid());
-      if (src) {
-        BlobMapEntry* entry = blob_map_.find(item.blob_uuid())->second;
-        DCHECK(entry->data);
-        exceeded_memory = !ExpandStorageItems(target_blob_data, *entry->data,
-                                              item.offset(), item.length());
-      }
-      break;
-    }
-    default:
-      NOTREACHED();
-      break;
+  if (!CanFitDataElement(data_element)) {

[michaeln, 2015/02/05 22:58:47]

it might make sense to hoist the one line body of the CanFit method inline into
the AppendBlobDataItem method body, its not used elsewhere and then it'd be real
easy to see just what it does

[dmurph, 2015/02/06 01:32:30]

Done.

+    BlobEntryExceededMemory(entry);
+    return;
   }
-  UMA_HISTOGRAM_COUNTS("Storage.Blob.StorageSizeAfterAppend",
-                       memory_usage_ / 1024);
-
-  // If we're using too much memory, drop this blob's data.
-  // TODO(michaeln): Blob memory storage does not yet spill over to disk,
-  // as a stop gap, we'll prevent memory usage over a max amount.
-  if (exceeded_memory) {
-    memory_usage_ -= target_blob_data->GetMemoryUsage();
-    entry->flags |= EXCEEDED_MEMORY;
-    entry->data_builder.reset(new BlobDataBuilder(uuid));
-    return;
+  scoped_refptr<BlobDataItem> data_item =
+      TransformDataElement(uuid, data_element);

[michaeln, 2015/02/05 22:58:47]

maybe rename this method to AllocateBlobItem(id, element), you could use it in
the arg list in the line below

if (!AppendAllocatedBlobItem(uuid, target_blob_builder,
                             AllocateBlobItem(id, elem));

[dmurph, 2015/02/06 01:32:30]

Done.

+  if (!AppendAllocatedBlobItem(uuid, target_blob_builder, data_item)) {
+    BlobEntryExceededMemory(entry);
   }
 }
 
-void BlobStorageContext::FinishBuildingBlob(
-    const std::string& uuid, const std::string& content_type) {
+void BlobStorageContext::FinishBuildingBlob(const std::string& uuid,
+                                            const std::string& content_type) {
   DCHECK(IsBeingBuilt(uuid));
   BlobMap::iterator found = blob_map_.find(uuid);
   if (found == blob_map_.end())
     return;
   BlobMapEntry* entry = found->second;
   entry->data_builder->set_content_type(content_type);
-  entry->data = entry->data_builder->BuildSnapshot().Pass();
-  entry->data_builder.reset();
+  scoped_ptr<InternalBlobData::Builder> builder(entry->data_builder.release());
+  entry->data.reset(new InternalBlobData(builder.Pass()));
   UMA_HISTOGRAM_COUNTS("Storage.Blob.ItemCount", entry->data->items().size());
   UMA_HISTOGRAM_BOOLEAN("Storage.Blob.ExceededMemory",
                         (entry->flags & EXCEEDED_MEMORY) == EXCEEDED_MEMORY);
 }
 
 void BlobStorageContext::CancelBuildingBlob(const std::string& uuid) {
   DCHECK(IsBeingBuilt(uuid));
   DecrementBlobRefCount(uuid);
 }
 
 void BlobStorageContext::IncrementBlobRefCount(const std::string& uuid) {
   BlobMap::iterator found = blob_map_.find(uuid);
   if (found == blob_map_.end()) {
     DCHECK(false);
     return;
   }
   ++(found->second->refcount);
 }
 
 void BlobStorageContext::DecrementBlobRefCount(const std::string& uuid) {
   BlobMap::iterator found = blob_map_.find(uuid);
   if (found == blob_map_.end())
     return;
   auto* entry = found->second;
   if (--(entry->refcount) == 0) {
+    size_t memory_freeing = 0;
     if (entry->IsBeingBuilt()) {
-      memory_usage_ -= entry->data_builder->GetMemoryUsage();
+      memory_freeing = entry->data_builder->GetNonsharedMemoryUsage();
+      entry->data_builder->RemoveBlobFromShareableItems(uuid);
     } else {
-      memory_usage_ -= entry->data->GetMemoryUsage();
+      memory_freeing = entry->data->GetNonsharedMemoryUsage();
+      entry->data->RemoveBlobFromShareableItems(uuid);
     }
+    DCHECK_LE(memory_freeing, memory_usage_);
+    memory_usage_ -= memory_freeing;
     delete entry;
     blob_map_.erase(found);
   }
 }
 
-bool BlobStorageContext::ExpandStorageItems(
-    BlobDataBuilder* target_blob_data,
-    const BlobDataSnapshot& src_blob_data,
-    uint64 offset,
-    uint64 length) {
-  DCHECK(target_blob_data && length != static_cast<uint64>(-1));
+bool BlobStorageContext::CanFitDataElement(const DataElement& item) {
+  return item.type() == DataElement::TYPE_BYTES &&
+         memory_usage_ + item.length() <= kMaxMemoryUsage;
+}
 
-  const std::vector<scoped_refptr<BlobDataItem>>& items = src_blob_data.items();
+void BlobStorageContext::BlobEntryExceededMemory(BlobMapEntry* entry) {
+  // If we're using too much memory, drop this blob's data.
+  // TODO(michaeln): Blob memory storage does not yet spill over to disk,
+  // as a stop gap, we'll prevent memory usage over a max amount.
+  memory_usage_ -= entry->data_builder->GetNonsharedMemoryUsage();
+  entry->flags |= EXCEEDED_MEMORY;
+  entry->data_builder.reset(new InternalBlobData::Builder());
+}
+
+scoped_refptr<BlobDataItem> BlobStorageContext::TransformDataElement(
+    const std::string& uuid,
+    const DataElement& item) {
+  scoped_refptr<BlobDataItem> blob_item;
+
+  size_t length = item.length();
+  DCHECK_GT(length, 0u);
+  scoped_ptr<DataElement> element(new DataElement());
+  switch (item.type()) {
+    case DataElement::TYPE_BYTES:
+      DCHECK(!item.offset());
+      element->SetToBytes(item.bytes(), length);
+      blob_item = new BlobDataItem(element.Pass());
+      break;
+    case DataElement::TYPE_FILE:
+      element->SetToFilePathRange(item.path(), item.offset(), length,
+                                  item.expected_modification_time());
+      blob_item = new BlobDataItem(element.Pass(),
+                                   ShareableFileReference::Get(item.path()));
+      break;
+    case DataElement::TYPE_FILE_FILESYSTEM:
+      element->SetToFileSystemUrlRange(item.filesystem_url(), item.offset(),
+                                       length,
+                                       item.expected_modification_time());
+      blob_item = new BlobDataItem(element.Pass());
+      break;
+    case DataElement::TYPE_BLOB:
+      // This is a temporary item that will be deconstructed later.
+      element->SetToBlobRange(item.blob_uuid(), item.offset(), item.length());
+      blob_item = new BlobDataItem(element.Pass());
+      break;
+    default:
+      NOTREACHED();
+      break;
+  }
+
+  return blob_item;
+}
+
+bool BlobStorageContext::AppendAllocatedBlobItem(
+    const std::string& target_blob_uuid,
+    InternalBlobData::Builder* target_blob_builder,
+    scoped_refptr<BlobDataItem> blob_item) {
+  bool exceeded_memory = false;
+
+  // The blob data is stored in the canonical way which only contains a
+  // list of Data, File, and FileSystem items. Aggregated TYPE_BLOB items
+  // are expanded into the primitive constituent types.
+  // 1) The Data item is denoted by the raw data and length.
+  // 2) The File item is denoted by the file path, the range and the expected
+  //    modification time.
+  // 3) The FileSystem File item is denoted by the FileSystem URL, the range
+  //    and the expected modification time.
+  // 4) The Blob items are expanded.
+
+  const DataElement& data_element = blob_item->data_element();
+  size_t length = data_element.length();
+  size_t offset = data_element.offset();

[michaeln, 2015/02/05 22:58:47]

these can be len/offsets into files so int64 as the data type?

[dmurph, 2015/02/06 01:32:30]

Done

+  DCHECK_GT(length, 0u);
+  UMA_HISTOGRAM_COUNTS("Storage.Blob.StorageSizeBeforeAppend",
+                       memory_usage_ / 1024);
+  switch (data_element.type()) {
+    case DataElement::TYPE_BYTES:
+      UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.Bytes", length / 1024);
+      DCHECK(!offset);
+      if (memory_usage_ + length > kMaxMemoryUsage) {
+        exceeded_memory = true;
+        break;
+      }
+      memory_usage_ += length;
+      target_blob_builder->AppendSharedBlobItem(
+          new ShareableBlobDataItem(target_blob_uuid, blob_item));
+      break;
+    case DataElement::TYPE_FILE:
+      UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.File",
+                           (length - offset) / 1024);
+      target_blob_builder->AppendSharedBlobItem(
+          new ShareableBlobDataItem(target_blob_uuid, blob_item));
+      break;
+    case DataElement::TYPE_FILE_FILESYSTEM:
+      UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.FileSystem",
+                           (length - offset) / 1024);
+      target_blob_builder->AppendSharedBlobItem(
+          new ShareableBlobDataItem(target_blob_uuid, blob_item));
+      break;
+    case DataElement::TYPE_BLOB: {
+      UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.Blob",
+                           (length - offset) / 1024);
+      // We grab the handle to ensure it stays around while we copy it.
+      scoped_ptr<BlobDataHandle> src =
+          GetBlobDataFromUUID(data_element.blob_uuid());
+      if (src) {
+        BlobMapEntry* other_entry =
+            blob_map_.find(data_element.blob_uuid())->second;
+        DCHECK(other_entry->data);
+        exceeded_memory = !AppendBlob(target_blob_uuid, target_blob_builder,
+                                      *other_entry->data, offset, length);
+      }
+      break;
+    }
+    default:
+      NOTREACHED();
+      break;
+  }
+  UMA_HISTOGRAM_COUNTS("Storage.Blob.StorageSizeAfterAppend",
+                       memory_usage_ / 1024);
+
+  return !exceeded_memory;
+}
+
+bool BlobStorageContext::AppendBlob(
+    const std::string& target_blob_uuid,
+    InternalBlobData::Builder* target_blob_builder,
+    const InternalBlobData& blob,
+    size_t offset,
+    size_t length) {
+  DCHECK(length > 0);
+
+  const std::vector<scoped_refptr<ShareableBlobDataItem>>& items = blob.items();
   auto iter = items.begin();
   if (offset) {
     for (; iter != items.end(); ++iter) {
-      const BlobDataItem& item = *(iter->get());
+      const BlobDataItem& item = *(iter->get()->item());
       if (offset >= item.length())
         offset -= item.length();
       else
         break;
     }
   }
 
   for (; iter != items.end() && length > 0; ++iter) {
-    const BlobDataItem& item = *(iter->get());
-    uint64 current_length = item.length() - offset;
-    uint64 new_length = current_length > length ? length : current_length;
-    if (iter->get()->type() == DataElement::TYPE_BYTES) {
-      if (!AppendBytesItem(
-              target_blob_data,
-              item.bytes() + static_cast<size_t>(item.offset() + offset),
-              static_cast<int64>(new_length))) {
-        return false;  // exceeded memory
-      }
-    } else if (item.type() == DataElement::TYPE_FILE) {
-      AppendFileItem(target_blob_data, item.path(), item.offset() + offset,
-                     new_length, item.expected_modification_time());
-    } else {
-      DCHECK(item.type() == DataElement::TYPE_FILE_FILESYSTEM);
-      AppendFileSystemFileItem(target_blob_data, item.filesystem_url(),
-                               item.offset() + offset, new_length,
-                               item.expected_modification_time());
+    scoped_refptr<ShareableBlobDataItem> shareable_item = iter->get();
+    const BlobDataItem& item = *(shareable_item->item());
+    size_t item_length = item.length();
+    DCHECK_GT(item_length, offset);
+    size_t current_length = item.length() - offset;
+    size_t new_length = current_length > length ? length : current_length;
+
+    bool reusing_blob_item = offset == 0 && new_length == item.length();
+    UMA_HISTOGRAM_BOOLEAN("Storage.Blob.ReusedItem", reusing_blob_item);
+    if (reusing_blob_item) {

[michaeln, 2015/02/05 20:02:09]

woohooo!

[dmurph, 2015/02/06 01:32:30]

:)

+      shareable_item->referencing_blobs().insert(target_blob_uuid);
+      target_blob_builder->AppendSharedBlobItem(shareable_item);
+      length -= new_length;
+      continue;
+    }
+
+    // We need to do copying of the items when we have a different offset or
+    // length
+    switch (item.type()) {
+      case DataElement::TYPE_BYTES: {
+        UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.Blob.Bytes",
+                             new_length / 1024);
+        if (memory_usage_ + new_length > kMaxMemoryUsage) {
+          return false;
+        }
+        DCHECK(!item.offset());
+        scoped_ptr<DataElement> element(new DataElement());
+        element->SetToBytes(item.bytes() + offset,
+                            static_cast<int64>(new_length));
+        memory_usage_ += new_length;
+        target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem(
+            target_blob_uuid, new BlobDataItem(element.Pass())));
+      } break;
+      case DataElement::TYPE_FILE: {
+        UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.Blob.File",
+                             new_length / 1024);
+        scoped_ptr<DataElement> element(new DataElement());
+        element->SetToFilePathRange(item.path(), item.offset() + offset,
+                                    new_length,
+                                    item.expected_modification_time());
+        target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem(
+            target_blob_uuid,
+            new BlobDataItem(element.Pass(), item.file_handle_)));
+      } break;
+      case DataElement::TYPE_FILE_FILESYSTEM: {
+        UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.Blob.FileSystem",
+                             new_length / 1024);
+        scoped_ptr<DataElement> element(new DataElement());
+        element->SetToFileSystemUrlRange(item.filesystem_url(),
+                                         item.offset() + offset, new_length,
+                                         item.expected_modification_time());
+        target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem(
+            target_blob_uuid, new BlobDataItem(element.Pass())));
+      } break;
+      default:
+        CHECK(false) << "Illegal blob item type: " << item.type();
     }
     length -= new_length;
     offset = 0;
   }
   return true;
 }
 
-bool BlobStorageContext::AppendBytesItem(BlobDataBuilder* target_blob_data,
-                                         const char* bytes,
-                                         int64 length) {
-  if (length < 0) {
-    DCHECK(false);
-    return false;
-  }
-  if (memory_usage_ + length > kMaxMemoryUsage) {
-    return false;
-  }
-  target_blob_data->AppendData(bytes, static_cast<size_t>(length));
-  memory_usage_ += length;
-  return true;
-}
-
-void BlobStorageContext::AppendFileItem(
-    BlobDataBuilder* target_blob_data,
-    const base::FilePath& file_path,
-    uint64 offset,
-    uint64 length,
-    const base::Time& expected_modification_time) {
-  // It may be a temporary file that should be deleted when no longer needed.
-  scoped_refptr<ShareableFileReference> shareable_file =
-      ShareableFileReference::Get(file_path);
-
-  target_blob_data->AppendFile(file_path, offset, length,
-                               expected_modification_time, shareable_file);
-}
-
-void BlobStorageContext::AppendFileSystemFileItem(
-    BlobDataBuilder* target_blob_data,
-    const GURL& filesystem_url,
-    uint64 offset,
-    uint64 length,
-    const base::Time& expected_modification_time) {
-  target_blob_data->AppendFileSystemFile(filesystem_url, offset, length,
-                                         expected_modification_time);
-}
-
 bool BlobStorageContext::IsInUse(const std::string& uuid) {
   return blob_map_.find(uuid) != blob_map_.end();
 }
 
 bool BlobStorageContext::IsBeingBuilt(const std::string& uuid) {
   BlobMap::iterator found = blob_map_.find(uuid);
   if (found == blob_map_.end())
     return false;
   return found->second->IsBeingBuilt();
 }
 
 bool BlobStorageContext::IsUrlRegistered(const GURL& blob_url) {
   return public_blob_urls_.find(blob_url) != public_blob_urls_.end();
 }
 
+scoped_ptr<BlobDataSnapshot> BlobStorageContext::CreateSnapshot(
+    const std::string& uuid,
+    const InternalBlobData& data) {
+  scoped_ptr<BlobDataSnapshot> snapshot(new BlobDataSnapshot(
+      uuid, data.content_type(), data.content_disposition()));
+  snapshot->items_.resize(data.items_.size());
+  std::transform(data.items_.begin(), data.items_.end(),

[michaeln, 2015/02/05 20:02:09]

might be easier to read as a for (const auto& shareable_item : data.items_) 
snapshot_.items_.push_back(shareable_item->item(); loop

[dmurph, 2015/02/06 01:32:30]

Fine! :)

+                 snapshot->items_.begin(),
+                 [](const scoped_refptr<ShareableBlobDataItem>& shareableItem) {

[michaeln, 2015/02/05 20:02:09]

shareableItem s/b shareable_item

[dmurph, 2015/02/06 01:32:30]

Done.

+    return shareableItem->item();
+  });
+  return snapshot;
+}
+
 }  // namespace storage