[BlobAsync] Moving async handling into BlobStorageContext & quota out.

storage/browser/blob/blob_memory_controller.cc

 // Copyright 2016 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_memory_controller.h"
 
 #include <algorithm>
 
 #include "base/callback.h"
 #include "base/callback_helpers.h"
@@ skipping 474 matching lines @@
     std::vector<scoped_refptr<ShareableBlobDataItem>> unreserved_file_items,
     const FileQuotaRequestCallback& done_callback) {
   pending_file_quota_tasks_.push_back(base::MakeUnique<FileQuotaAllocationTask>(
       this, std::move(unreserved_file_items), done_callback));
   pending_file_quota_tasks_.back()->set_my_list_position(
       --pending_file_quota_tasks_.end());
   return pending_file_quota_tasks_.back()->GetWeakPtr();
 }
 
 void BlobMemoryController::NotifyMemoryItemsUsed(
-    std::vector<scoped_refptr<ShareableBlobDataItem>>& items) {
+    const std::vector<scoped_refptr<ShareableBlobDataItem>>& items) {
   for (const auto& item : items) {
-    DCHECK_EQ(DataElement::TYPE_BYTES, item->item()->type());
-    DCHECK_EQ(ShareableBlobDataItem::POPULATED_WITH_QUOTA, item->state());
+    if (item->item()->type() != DataElement::TYPE_BYTES ||
+        item->state() != ShareableBlobDataItem::POPULATED_WITH_QUOTA) {
+      continue;
+    }
     // We don't want to re-add the item if we're currently paging it to disk.
     if (items_paging_to_file_.find(item->item_id()) !=
         items_paging_to_file_.end()) {
       return;
     }
     auto iterator = populated_memory_items_.Get(item->item_id());
     if (iterator == populated_memory_items_.end()) {
       populated_memory_items_bytes_ +=
           static_cast<size_t>(item->item()->length());
       populated_memory_items_.Put(item->item_id(), item.get());
@@ skipping 183 matching lines @@
         pending_memory_quota_total_size_ - in_flight_memory_used_;
   }
   if (limits_.max_blob_disk_space < total_disk_used)
     return 0;
   return limits_.max_blob_disk_space - total_disk_used;
 }
 
 void BlobMemoryController::GrantMemoryAllocations(
     std::vector<scoped_refptr<ShareableBlobDataItem>>* items,
     size_t total_bytes) {
+  // These metrics let us calculate the global distribution of blob storage by
+  // subtracting the histograms.
+  UMA_HISTOGRAM_COUNTS("Storage.Blob.StorageSizeBeforeAppend",
+                       blob_memory_used_ / 1024);
   blob_memory_used_ += total_bytes;
+  UMA_HISTOGRAM_COUNTS("Storage.Blob.StorageSizeAfterAppend",
+                       blob_memory_used_ / 1024);
+
   for (auto& item : *items) {
     item->set_state(ShareableBlobDataItem::QUOTA_GRANTED);
     item->set_memory_allocation(base::MakeUnique<MemoryAllocation>(
         weak_factory_.GetWeakPtr(), item->item_id(),
         base::checked_cast<size_t>(item->item()->length())));
   }
 }
 
 void BlobMemoryController::RevokeMemoryAllocation(uint64_t item_id,
                                                   size_t length) {
   DCHECK_LE(length, blob_memory_used_);
+
+  // These metrics let us calculate the global distribution of blob storage by
+  // subtracting the histograms.
+  UMA_HISTOGRAM_COUNTS("Storage.Blob.StorageSizeBeforeAppend",
+                       blob_memory_used_ / 1024);
   blob_memory_used_ -= length;
+  UMA_HISTOGRAM_COUNTS("Storage.Blob.StorageSizeAfterAppend",
+                       blob_memory_used_ / 1024);
+
   auto iterator = populated_memory_items_.Get(item_id);
   if (iterator != populated_memory_items_.end()) {
     DCHECK_GE(populated_memory_items_bytes_, length);
     populated_memory_items_bytes_ -= length;
     populated_memory_items_.Erase(iterator);
   }
   MaybeGrantPendingMemoryRequests();
 }
 
 void BlobMemoryController::OnBlobFileDelete(uint64_t size,
                                             const FilePath& path) {
   DCHECK_LE(size, disk_used_);
   disk_used_ -= size;
 }
 
 }  // namespace storage