Add uma stats to help evaluate the impact of changes to the quota allocation logic.

content/browser/cache_storage/cache_storage_cache.cc

 // Copyright 2014 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 "content/browser/cache_storage/cache_storage_cache.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <limits>
 #include <memory>
@@ skipping 20 matching lines @@
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "storage/browser/blob/blob_data_builder.h"
 #include "storage/browser/blob/blob_data_handle.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/blob/blob_url_request_job_factory.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
+#include "storage/common/storage_histograms.h"
 #include "third_party/WebKit/public/platform/modules/serviceworker/WebServiceWorkerResponseType.h"
 
 namespace content {
 
 namespace {
 
 const size_t kMaxQueryCacheResultBytes =
     1024 * 1024 * 10;  // 10MB query cache limit
 
+const char kRecordBytesLabel[] = "DiskCache.CacheStorage";
+
 // This class ensures that the cache and the entry have a lifetime as long as
 // the blob that is created to contain them.
 class CacheStorageCacheDataHandle
     : public storage::BlobDataBuilder::DataHandle {
  public:
   CacheStorageCacheDataHandle(
       std::unique_ptr<CacheStorageCacheHandle> cache_handle,
       disk_cache::ScopedEntryPtr entry)
       : cache_handle_(std::move(cache_handle)), entry_(std::move(entry)) {}
 
@@ skipping 118 matching lines @@
 
 void ReadMetadataDidReadMetadata(disk_cache::Entry* entry,
                                  const MetadataCallback& callback,
                                  scoped_refptr<net::IOBufferWithSize> buffer,
                                  int rv) {
   if (rv != buffer->size()) {
     callback.Run(std::unique_ptr<proto::CacheMetadata>());
     return;
   }
 
+  if (rv > 0)
+    storage::RecordBytesRead(kRecordBytesLabel, rv);
+
   std::unique_ptr<proto::CacheMetadata> metadata(new proto::CacheMetadata());
 
   if (!metadata->ParseFromArray(buffer->data(), buffer->size())) {
     callback.Run(std::unique_ptr<proto::CacheMetadata>());
     return;
   }
 
   callback.Run(std::move(metadata));
 }
 
@@ skipping 797 matching lines @@
 void CacheStorageCache::WriteSideDataDidWrite(const ErrorCallback& callback,
                                               disk_cache::ScopedEntryPtr entry,
                                               int expected_bytes,
                                               int rv) {
   if (rv != expected_bytes) {
     entry->Doom();
     UpdateCacheSize(base::Bind(callback, CACHE_STORAGE_ERROR_NOT_FOUND));
     return;
   }
 
+  if (rv > 0)
+    storage::RecordBytesWritten(kRecordBytesLabel, rv);
+
   UpdateCacheSize(base::Bind(callback, CACHE_STORAGE_OK));
 }
 
 void CacheStorageCache::Put(const CacheStorageBatchOperation& operation,
                             const ErrorCallback& callback) {
   DCHECK(BACKEND_OPEN == backend_state_ || initializing_);
   DCHECK_EQ(CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT, operation.operation_type);
 
   std::unique_ptr<ServiceWorkerFetchRequest> request(
       new ServiceWorkerFetchRequest(
@@ skipping 151 matching lines @@
 void CacheStorageCache::PutDidWriteHeaders(
     std::unique_ptr<PutContext> put_context,
     int expected_bytes,
     int rv) {
   if (rv != expected_bytes) {
     put_context->cache_entry->Doom();
     put_context->callback.Run(CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
+  if (rv > 0)
+    storage::RecordBytesWritten(kRecordBytesLabel, rv);
+
   // The metadata is written, now for the response content. The data is streamed
   // from the blob into the cache entry.
 
   if (put_context->response->blob_uuid.empty()) {
     UpdateCacheSize(base::Bind(put_context->callback, CACHE_STORAGE_OK));
     return;
   }
 
   DCHECK(put_context->blob_data_handle);
 
@@ skipping 297 matching lines @@
       temp_entry, INDEX_RESPONSE_BODY, INDEX_SIDE_DATA);
   return blob_storage_context_->AddFinishedBlob(&blob_data);
 }
 
 std::unique_ptr<CacheStorageCacheHandle>
 CacheStorageCache::CreateCacheHandle() {
   return cache_storage_->CreateCacheHandle(this);
 }
 
 }  // namespace content