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

storage/browser/blob/blob_reader.cc

 // Copyright 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_reader.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/debug/stack_trace.h"
 #include "base/sequenced_task_runner.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/disk_cache.h"
 #include "storage/browser/blob/blob_data_handle.h"
 #include "storage/browser/blob/blob_data_snapshot.h"
 #include "storage/browser/fileapi/file_stream_reader.h"
 #include "storage/browser/fileapi/file_system_context.h"
 #include "storage/browser/fileapi/file_system_url.h"
 #include "storage/common/data_element.h"
+#include "storage/common/storage_histograms.h"
 
 namespace storage {
 namespace {
+const char kCacheStorageRecordBytesLabel[] = "DiskCache.CacheStorage";
+
 bool IsFileType(DataElement::Type type) {
   switch (type) {
     case DataElement::TYPE_FILE:
     case DataElement::TYPE_FILE_FILESYSTEM:
       return true;
     default:
       return false;
   }
 }
 
@@ skipping 95 matching lines @@
   if (result == net::ERR_IO_PENDING)
     return Status::IO_PENDING;
   return ReportError(result);
 }
 
 void BlobReader::DidReadDiskCacheEntrySideData(const StatusCallback& done,
                                                int expected_size,
                                                int result) {
   if (result >= 0) {
     DCHECK_EQ(expected_size, result);
+    if (result > 0)
+      storage::RecordBytesRead(kCacheStorageRecordBytesLabel, result);
     done.Run(Status::DONE);
     return;
   }
   side_data_ = nullptr;
   done.Run(ReportError(result));
 }
 
 BlobReader::Status BlobReader::SetReadRange(uint64_t offset, uint64_t length) {
   if (!blob_handle_.get() || blob_handle_->IsBroken()) {
     return ReportError(net::ERR_FILE_NOT_FOUND);
@@ skipping 419 matching lines @@
   if (result == net::ERR_IO_PENDING) {
     io_pending_ = true;
     return Status::IO_PENDING;
   }
   return ReportError(result);
 }
 
 void BlobReader::DidReadDiskCacheEntry(int result) {
   TRACE_EVENT_ASYNC_END1("Blob", "BlobRequest::ReadDiskCacheItem", this, "uuid",
                          blob_data_->uuid());
+  if (result > 0)
+    storage::RecordBytesRead(kCacheStorageRecordBytesLabel, result);
   DidReadItem(result);
 }
 
 void BlobReader::DidReadItem(int result) {
   DCHECK(io_pending_) << "Asynchronous IO completed while IO wasn't pending?";
   io_pending_ = false;
   if (result <= 0) {
     InvalidateCallbacksAndDone(result, read_callback_);
     return;
   }
@@ skipping 72 matching lines @@
 void BlobReader::SetFileReaderAtIndex(
     size_t index,
     std::unique_ptr<FileStreamReader> reader) {
   if (reader)
     index_to_reader_[index] = std::move(reader);
   else
     index_to_reader_.erase(index);
 }
 
 }  // namespace storage