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

content/browser/appcache/appcache_response.cc

 // Copyright (c) 2012 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/appcache/appcache_response.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/numerics/safe_math.h"
 #include "base/pickle.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/appcache/appcache_storage.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
+#include "storage/common/storage_histograms.h"
 
 namespace content {
 
 namespace {
 
 // Disk cache entry data indices.
 enum { kResponseInfoIndex, kResponseContentIndex, kResponseMetadataIndex };
 
 // An IOBuffer that wraps a pickle's data. Ownership of the
 // pickle is transfered to the WrappedPickleIOBuffer object.
@@ skipping 40 matching lines @@
 HttpResponseInfoIOBuffer::HttpResponseInfoIOBuffer()
     : response_data_size(kUnkownResponseDataSize) {}
 
 HttpResponseInfoIOBuffer::HttpResponseInfoIOBuffer(net::HttpResponseInfo* info)
     : http_info(info), response_data_size(kUnkownResponseDataSize) {}
 
 HttpResponseInfoIOBuffer::~HttpResponseInfoIOBuffer() {}
 
 // AppCacheDiskCacheInterface ----------------------------------------
 
-AppCacheDiskCacheInterface::AppCacheDiskCacheInterface()
-    : weak_factory_(this) {}
+AppCacheDiskCacheInterface::AppCacheDiskCacheInterface(const char* uma_name)
+    : uma_name_(uma_name), weak_factory_(this) {}
 
 base::WeakPtr<AppCacheDiskCacheInterface>
 AppCacheDiskCacheInterface::GetWeakPtr() {
   return weak_factory_.GetWeakPtr();
 }
 
 AppCacheDiskCacheInterface::~AppCacheDiskCacheInterface() {}
 
 // AppCacheResponseIO ----------------------------------------------
 
@@ skipping 191 matching lines @@
         info_buffer_->http_info->metadata = new net::IOBufferWithSize(
             base::checked_cast<size_t>(metadata_size));
         ReadRaw(kResponseMetadataIndex, 0,
                 info_buffer_->http_info->metadata.get(), metadata_size);
         return;
       }
     } else {
       read_position_ += result;
     }
   }
+  if (result > 0 && disk_cache_)
+    storage::RecordBytesRead(disk_cache_->uma_name(), result);
   InvokeUserCompletionCallback(result);
+  // Note: |this| may have been deleted by the completion callback.
 }
 
 void AppCacheResponseReader::OnOpenEntryComplete() {
   if (!entry_)  {
     ScheduleIOCompletionCallback(net::ERR_CACHE_MISS);
     return;
   }
   if (info_buffer_.get())
     ContinueReadInfo();
   else
@@ skipping 71 matching lines @@
 }
 
 void AppCacheResponseWriter::OnIOComplete(int result) {
   if (result >= 0) {
     DCHECK(write_amount_ == result);
     if (!info_buffer_.get())
       write_position_ += result;
     else
       info_size_ = result;
   }
+  if (result > 0 && disk_cache_)
+    storage::RecordBytesWritten(disk_cache_->uma_name(), result);
   InvokeUserCompletionCallback(result);
+  // Note: |this| may have been deleted by the completion callback.
 }
 
 void AppCacheResponseWriter::CreateEntryIfNeededAndContinue() {
   int rv;
   AppCacheDiskCacheInterface::Entry** entry_ptr = NULL;
   if (entry_) {
     creation_phase_ = NO_ATTEMPT;
     rv = net::OK;
   } else if (!disk_cache_) {
     creation_phase_ = NO_ATTEMPT;
@@ skipping 83 matching lines @@
 void AppCacheResponseMetadataWriter::OnOpenEntryComplete() {
   if (!entry_) {
     ScheduleIOCompletionCallback(net::ERR_FAILED);
     return;
   }
   WriteRaw(kResponseMetadataIndex, 0, buffer_.get(), write_amount_);
 }
 
 void AppCacheResponseMetadataWriter::OnIOComplete(int result) {
   DCHECK(result < 0 || write_amount_ == result);
+  if (result > 0 && disk_cache_)
+    storage::RecordBytesWritten(disk_cache_->uma_name(), result);
   InvokeUserCompletionCallback(result);
+  // Note: |this| may have been deleted by the completion callback.
 }
 
 }  // namespace content