[Storage] Added histograms for blob storage

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 "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
+#include "base/metrics/histogram.h"
 #include "storage/browser/blob/blob_data_handle.h"
 #include "storage/common/blob/blob_data.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
@@ skipping 115 matching lines @@
   // 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.
 
-  DCHECK(item.length() > 0);
+  uint64 length = item.length();
+  DCHECK_GT(length, 0u);
+  UMA_HISTOGRAM_COUNTS("Storage.Blob.StorageSizeBeforeAppend",
+                       memory_usage_ / 1024);
   switch (item.type()) {
     case BlobData::Item::TYPE_BYTES:
+      UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.Bytes", length);
       DCHECK(!item.offset());
-      exceeded_memory = !AppendBytesItem(target_blob_data,
-                                         item.bytes(),
-                                         static_cast<int64>(item.length()));
+      exceeded_memory = !AppendBytesItem(target_blob_data, item.bytes(),
+                                         static_cast<int64>(length));
       break;
     case BlobData::Item::TYPE_FILE:
-      AppendFileItem(target_blob_data,
-                     item.path(),
-                     item.offset(),
-                     item.length(),
+      UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.File", length);
+      AppendFileItem(target_blob_data, item.path(), item.offset(), length,
                      item.expected_modification_time());
       break;
     case BlobData::Item::TYPE_FILE_FILESYSTEM:
-      AppendFileSystemFileItem(target_blob_data,
-                               item.filesystem_url(),
-                               item.offset(),
-                               item.length(),
+      UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.FileSystem", length);
+      AppendFileSystemFileItem(target_blob_data, item.filesystem_url(),
+                               item.offset(), length,
                                item.expected_modification_time());
       break;
     case BlobData::Item::TYPE_BLOB: {
+      UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.Blob", length);
       scoped_ptr<BlobDataHandle> src = GetBlobDataFromUUID(item.blob_uuid());
       if (src)
         exceeded_memory = !ExpandStorageItems(target_blob_data,
                                               src->data(),
                                               item.offset(),
                                               item.length());
       break;
     }
     default:
       NOTREACHED();
       break;
   }
+  UMA_HISTOGRAM_COUNTS("Storage.Blob.StorageSizeAfterAppend",

[michaeln, 2015/01/07 21:30:53]

Would it make sense to use either UMA_HISTOGRAM_MEMORY_MB or
UMA_HISTOGRAM_MEMORY_KB here?

+                       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();
     found->second.flags |= EXCEEDED_MEMORY;
     found->second.data = new BlobData(uuid);
     return;
   }
 }
 
 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;
   found->second.data->set_content_type(content_type);
   found->second.flags &= ~BEING_BUILT;
+  UMA_HISTOGRAM_BOOLEAN(
+      "Storage.Blob.ExceededMemory",
+      (found->second.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()) {
@@ skipping 105 matching lines @@
   if (found == blob_map_.end())
     return false;
   return found->second.flags & BEING_BUILT;
 }
 
 bool BlobStorageContext::IsUrlRegistered(const GURL& blob_url) {
   return public_blob_urls_.find(blob_url) != public_blob_urls_.end();
 }
 
 }  // namespace storage