Disk Cache: Second pass (and final) to allow multiple instances...

net/disk_cache/entry_impl.cc

 // Copyright (c) 2006-2008 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 "net/disk_cache/entry_impl.h"
 
 #include "base/histogram.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/backend_impl.h"
 #include "net/disk_cache/cache_util.h"
+#include "net/disk_cache/histogram_macros.h"
 
 using base::Time;
 using base::TimeDelta;
 
 namespace {
 
 // Index for the file used to store the key, if any (files_[kKeyFileIndex]).
 const int kKeyFileIndex = 3;
 
 // This class implements FileIOCallback to buffer the callback from a file IO
@@ skipping 177 matching lines @@
     buf_len = entry_size - offset;
 
   UpdateRank(false);
 
   backend_->OnEvent(Stats::READ_DATA);
 
   if (user_buffers_[index].get()) {
     // Complete the operation locally.
     DCHECK(kMaxBlockSize >= offset + buf_len);
     memcpy(buf->data() , user_buffers_[index].get() + offset, buf_len);
-    stats.AddTime(Time::Now() - start);
+    if (backend_->cache_type() == net::DISK_CACHE)
+      stats.AddTime(Time::Now() - start);
     return buf_len;
   }
 
   Addr address(entry_.Data()->data_addr[index]);
   DCHECK(address.is_initialized());
   if (!address.is_initialized())
     return net::ERR_FAILED;
 
   File* file = GetBackingFile(address, index);
   if (!file)
@@ skipping 11 matching lines @@
   bool completed;
   if (!file->Read(buf->data(), buf_len, file_offset, io_callback, &completed)) {
     if (io_callback)
       io_callback->Discard();
     return net::ERR_FAILED;
   }
 
   if (io_callback && completed)
     io_callback->Discard();
 
-  stats.AddTime(Time::Now() - start);
+  if (backend_->cache_type() == net::DISK_CACHE)
+    stats.AddTime(Time::Now() - start);
   return (completed || !completion_callback) ? buf_len : net::ERR_IO_PENDING;
 }
 
 int EntryImpl::WriteData(int index, int offset, net::IOBuffer* buf, int buf_len,
                          net::CompletionCallback* completion_callback,
                          bool truncate) {
   DCHECK(node_.Data()->dirty);
   if (index < 0 || index >= NUM_STREAMS)
     return net::ERR_INVALID_ARGUMENT;
 
@@ skipping 48 matching lines @@
 
   // If we have prepared the cache as an external file, we should never use
   // user_buffers_ and always write to file directly.
   if (!need_file_[index] && user_buffers_[index].get()) {
     // Complete the operation locally.
     if (!buf_len)
       return 0;
 
     DCHECK(kMaxBlockSize >= offset + buf_len);
     memcpy(user_buffers_[index].get() + offset, buf->data(), buf_len);
-    stats.AddTime(Time::Now() - start);
+    if (backend_->cache_type() == net::DISK_CACHE)
+      stats.AddTime(Time::Now() - start);
     return buf_len;
   }
 
   Addr address(entry_.Data()->data_addr[index]);
   File* file = GetBackingFile(address, index);
   if (!file)
     return net::ERR_FAILED;
 
   size_t file_offset = offset;
   if (address.is_block_file()) {
@@ skipping 15 matching lines @@
   if (!file->Write(buf->data(), buf_len, file_offset, io_callback,
                    &completed)) {
     if (io_callback)
       io_callback->Discard();
     return net::ERR_FAILED;
   }
 
   if (io_callback && completed)
     io_callback->Discard();
 
-  stats.AddTime(Time::Now() - start);
+  if (backend_->cache_type() == net::DISK_CACHE)
+    stats.AddTime(Time::Now() - start);
   return (completed || !completion_callback) ? buf_len : net::ERR_IO_PENDING;
 }
 
 base::PlatformFile EntryImpl::UseExternalFile(int index) {
   DCHECK(index >= 0 && index < NUM_STREAMS);
 
   Addr address(entry_.Data()->data_addr[index]);
 
   // We will not prepare the cache file since the entry is already initialized,
   // just return the platform file backing the cache.
@@ skipping 92 matching lines @@
     node_.Data()->dirty = backend_->GetCurrentEntryId();
     node_.Store();
   }
   doomed_ = true;
 }
 
 void EntryImpl::DeleteEntryData(bool everything) {
   DCHECK(doomed_ || !everything);
 
   if (GetDataSize(0))
-    UMA_HISTOGRAM_COUNTS("DiskCache.DeleteHeader", GetDataSize(0));
+    CACHE_UMA(COUNTS, "DeleteHeader", 0, GetDataSize(0));
   if (GetDataSize(1))
-    UMA_HISTOGRAM_COUNTS("DiskCache.DeleteData", GetDataSize(1));
+    CACHE_UMA(COUNTS, "DeleteData", 0, GetDataSize(1));
   for (int index = 0; index < NUM_STREAMS; index++) {
     Addr address(entry_.Data()->data_addr[index]);
     if (address.is_initialized()) {
       DeleteData(address, index);
       backend_->ModifyStorageSize(entry_.Data()->data_size[index] -
                                       unreported_size_[index], 0);
       entry_.Data()->data_addr[index] = 0;
       entry_.Data()->data_size[index] = 0;
     }
   }
@@ skipping 136 matching lines @@
 }
 
 void EntryImpl::DeleteData(Addr address, int index) {
   if (!address.is_initialized())
     return;
   if (address.is_separate_file()) {
     if (files_[index])
       files_[index] = NULL;  // Releases the object.
 
     if (!DeleteCacheFile(backend_->GetFileName(address))) {
-      UMA_HISTOGRAM_COUNTS("DiskCache.DeleteFailed", 1);
+      CACHE_UMA(COUNTS, "DeleteFailed", 0, 1);
       LOG(ERROR) << "Failed to delete " << backend_->GetFileName(address) <<
                     " from the cache.";
     }
   } else {
     backend_->DeleteBlock(address, true);
   }
 }
 
 void EntryImpl::UpdateRank(bool modified) {
   if (!doomed_) {
@@ skipping 217 matching lines @@
   Trace("%s 0x%p 0x%x 0x%x", msg, reinterpret_cast<void*>(this),
         entry_.address().value(), node_.address().value());
 
   Trace("  data: 0x%x 0x%x 0x%x", entry_.Data()->data_addr[0],
         entry_.Data()->data_addr[1], entry_.Data()->long_key);
 
   Trace("  doomed: %d 0x%p 0x%x", doomed_, pointer, dirty);
 }
 
 }  // namespace disk_cache