[BlobStorage] BlobMemoryController & tests

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 272 matching lines @@
   switch (data_element.type()) {
     case DataElement::TYPE_BYTES:
       UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.Bytes", length / 1024);
       DCHECK(!offset);
       if (memory_usage_ + length > kBlobStorageMaxMemoryUsage) {
         error = true;
         *error_code = IPCBlobCreationCancelCode::OUT_OF_MEMORY;
         break;
       }
       memory_usage_ += length;
-      target_blob_builder->AppendSharedBlobItem(
-          new ShareableBlobDataItem(target_blob_uuid, blob_item));
+      target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem(
+          target_blob_uuid, blob_item,
+          ShareableBlobDataItem::POPULATED_WITH_QUOTA));
       break;
     case DataElement::TYPE_FILE: {
       bool full_file = (length == std::numeric_limits<uint64_t>::max());
       UMA_HISTOGRAM_BOOLEAN("Storage.BlobItemSize.File.Unknown", full_file);
       if (!full_file) {
         UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.File",
                              (length - offset) / 1024);
       }
-      target_blob_builder->AppendSharedBlobItem(
-          new ShareableBlobDataItem(target_blob_uuid, blob_item));
+      target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem(
+          target_blob_uuid, blob_item,
+          ShareableBlobDataItem::POPULATED_WITHOUT_QUOTA));
       break;
     }
     case DataElement::TYPE_FILE_FILESYSTEM: {
       bool full_file = (length == std::numeric_limits<uint64_t>::max());
       UMA_HISTOGRAM_BOOLEAN("Storage.BlobItemSize.FileSystem.Unknown",
                             full_file);
       if (!full_file) {
         UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.FileSystem",
                              (length - offset) / 1024);
       }
-      target_blob_builder->AppendSharedBlobItem(
-          new ShareableBlobDataItem(target_blob_uuid, blob_item));
+      target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem(
+          target_blob_uuid, blob_item,
+          ShareableBlobDataItem::POPULATED_WITHOUT_QUOTA));
       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.
       std::unique_ptr<BlobDataHandle> src =
           GetBlobDataFromUUID(data_element.blob_uuid());
       if (!src || src->IsBroken() || src->IsBeingBuilt()) {
         error = true;
         *error_code = IPCBlobCreationCancelCode::REFERENCED_BLOB_BROKEN;
         break;
       }
       BlobRegistryEntry* other_entry =
           registry_.GetEntry(data_element.blob_uuid());
       DCHECK(other_entry->data);
       if (!AppendBlob(target_blob_uuid, *other_entry->data, offset, length,
                       target_blob_builder)) {
         error = true;
         *error_code = IPCBlobCreationCancelCode::OUT_OF_MEMORY;
       }
       break;
     }
     case DataElement::TYPE_DISK_CACHE_ENTRY: {
       UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.CacheEntry",
                            (length - offset) / 1024);
-      target_blob_builder->AppendSharedBlobItem(
-          new ShareableBlobDataItem(target_blob_uuid, blob_item));
+      target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem(
+          target_blob_uuid, blob_item,
+          ShareableBlobDataItem::POPULATED_WITHOUT_QUOTA));
       break;
     }
     case DataElement::TYPE_BYTES_DESCRIPTION:
     case DataElement::TYPE_UNKNOWN:
       NOTREACHED();
       break;
   }
   UMA_HISTOGRAM_COUNTS("Storage.Blob.StorageSizeAfterAppend",
                        memory_usage_ / 1024);
   return !error;
@@ skipping 23 matching lines @@
     scoped_refptr<ShareableBlobDataItem> shareable_item = iter->get();
     const BlobDataItem& item = *(shareable_item->item());
     uint64_t item_length = item.length();
     DCHECK_GT(item_length, offset);
     uint64_t current_length = item_length - offset;
     uint64_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) {
-      shareable_item->referencing_blobs().insert(target_blob_uuid);
+      shareable_item->referencing_blobs_mutable()->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.BlobSlice.Bytes",
                              new_length / 1024);
         if (memory_usage_ + new_length > kBlobStorageMaxMemoryUsage) {
           return false;
         }
         DCHECK(!item.offset());
         std::unique_ptr<DataElement> element(new DataElement());
         element->SetToBytes(item.bytes() + offset,
                             static_cast<int64_t>(new_length));
         memory_usage_ += new_length;
         target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem(
-            target_blob_uuid, new BlobDataItem(std::move(element))));
+            target_blob_uuid, new BlobDataItem(std::move(element)),
+            ShareableBlobDataItem::POPULATED_WITH_QUOTA));
       } break;
       case DataElement::TYPE_FILE: {
         DCHECK_NE(item.length(), std::numeric_limits<uint64_t>::max())
             << "We cannot use a section of a file with an unknown length";
         UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.BlobSlice.File",
                              new_length / 1024);
         std::unique_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(std::move(element), item.data_handle_)));
+            new BlobDataItem(std::move(element), item.data_handle_),
+            ShareableBlobDataItem::POPULATED_WITHOUT_QUOTA));
       } break;
       case DataElement::TYPE_FILE_FILESYSTEM: {
         UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.BlobSlice.FileSystem",
                              new_length / 1024);
         std::unique_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(std::move(element))));
+            target_blob_uuid, new BlobDataItem(std::move(element)),
+            ShareableBlobDataItem::POPULATED_WITHOUT_QUOTA));
       } break;
       case DataElement::TYPE_DISK_CACHE_ENTRY: {
         std::unique_ptr<DataElement> element(new DataElement());
         element->SetToDiskCacheEntryRange(item.offset() + offset,
                                           new_length);
         target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem(
             target_blob_uuid,
             new BlobDataItem(std::move(element), item.data_handle_,
                              item.disk_cache_entry(),
                              item.disk_cache_stream_index(),
-                             item.disk_cache_side_stream_index())));
+                             item.disk_cache_side_stream_index()),
+            ShareableBlobDataItem::POPULATED_WITHOUT_QUOTA));
       } break;
       case DataElement::TYPE_BYTES_DESCRIPTION:
       case DataElement::TYPE_BLOB:
       case DataElement::TYPE_UNKNOWN:
         CHECK(false) << "Illegal blob item type: " << item.type();
     }
     length -= new_length;
     offset = 0;
   }
   return true;
 }
 
 }  // namespace storage