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

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 "storage/browser/blob/blob_data_builder.h"
+
 #include "base/time/time.h"
+#include "storage/browser/blob/blob_storage_context.h"
 
 namespace storage {
 
+BlobDataBuilder* BlobDataBuilder::Create(const std::string& uuid) {
+  return new BlobDataBuilder(uuid);
+}
 BlobDataBuilder::BlobDataBuilder(const std::string& uuid) : uuid_(uuid) {
 }
 BlobDataBuilder::~BlobDataBuilder() {
 }
 
-void BlobDataBuilder::AppendData(const char* data, size_t length) {
+BlobDataBuilder* BlobDataBuilder::AppendData(const char* data, size_t length) {
   DCHECK(length > 0);
   scoped_ptr<DataElement> element(new DataElement());
   element->SetToBytes(data, length);
   items_.push_back(new BlobDataItem(element.Pass()));
+  return this;
 }
 
-void BlobDataBuilder::AppendFile(const base::FilePath& file_path,
-                                 uint64 offset,
-                                 uint64 length,
-                                 const base::Time& expected_modification_time) {
+BlobDataBuilder* BlobDataBuilder::AppendFile(
+    const base::FilePath& file_path,
+    uint64 offset,
+    uint64 length,
+    const base::Time& expected_modification_time) {
   DCHECK(length > 0);
   scoped_ptr<DataElement> element(new DataElement());
   element->SetToFilePathRange(file_path, offset, length,
                               expected_modification_time);
   items_.push_back(new BlobDataItem(element.Pass()));
+  return this;
 }
 
-void BlobDataBuilder::AppendFile(
+BlobDataBuilder* BlobDataBuilder::AppendFile(
     const base::FilePath& file_path,
     uint64 offset,
     uint64 length,
     const base::Time& expected_modification_time,
     scoped_refptr<ShareableFileReference> shareable_file) {
   DCHECK(length > 0);
   scoped_ptr<DataElement> element(new DataElement());
   element->SetToFilePathRange(file_path, offset, length,
                               expected_modification_time);
   items_.push_back(new BlobDataItem(element.Pass(), shareable_file));
+  return this;
 }
 
-void BlobDataBuilder::AppendBlob(const std::string& uuid,
-                                 uint64 offset,
-                                 uint64 length) {
+BlobDataBuilder* BlobDataBuilder::AppendBlob(const std::string& uuid,
+                                             uint64 offset,
+                                             uint64 length) {
   DCHECK_GT(length, 0ul);
   scoped_ptr<DataElement> element(new DataElement());
   element->SetToBlobRange(uuid, offset, length);
   items_.push_back(new BlobDataItem(element.Pass()));
+  return this;
 }
 
-void BlobDataBuilder::AppendFileSystemFile(
+BlobDataBuilder* BlobDataBuilder::AppendBlob(const std::string& uuid) {
+  scoped_ptr<DataElement> element(new DataElement());
+  element->SetToBlob(uuid);
+  items_.push_back(new BlobDataItem(element.Pass()));
+  return this;
+}
+
+BlobDataBuilder* BlobDataBuilder::AppendFileSystemFile(
     const GURL& url,
     uint64 offset,
     uint64 length,
     const base::Time& expected_modification_time) {
   DCHECK(length > 0);
   scoped_ptr<DataElement> element(new DataElement());
   element->SetToFileSystemUrlRange(url, offset, length,
                                    expected_modification_time);
   items_.push_back(new BlobDataItem(element.Pass()));
+  return this;
+}
+
+scoped_ptr<BlobDataBuilder> BlobDataBuilder::Clone() {

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

Is there a use case for Clone()?

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

Nope, removed.  Left over from having the context consume the builder.

+  scoped_ptr<BlobDataBuilder> other(new BlobDataBuilder(this->uuid_));
+  other->content_type_ = this->content_type_;
+  other->content_disposition_ = this->content_disposition_;
+  other->items_.reserve(this->items_.size());
+  for (const auto& data_item : items_) {
+    scoped_ptr<DataElement> element(new DataElement());
+    *element = data_item->data_element();
+    other->items_.push_back(
+        new BlobDataItem(element.Pass(), data_item->file_handle_));

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

Why make a new item instead of letting the new builder reference the same
collection of refcounted items? other->items_ = this->items_ ?

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

this was for a deep clone method, we don't need it anymore though.

+  }
+  return other.Pass();
 }
 
 size_t BlobDataBuilder::GetMemoryUsage() const {
   int64 memory = 0;
   for (const auto& data_item : items_) {
     if (data_item->type() == DataElement::TYPE_BYTES)
       memory += data_item->length();
   }
   return memory;
 }
 
 scoped_ptr<BlobDataSnapshot> BlobDataBuilder::BuildSnapshot() {
   return scoped_ptr<BlobDataSnapshot>(new BlobDataSnapshot(uuid_, content_type_,
                                                            content_disposition_,
                                                            items_)).Pass();
 }
 
 }  // namespace storage