Disk cache: Use TimeTicks instead of Time for some of the...

net/disk_cache/entry_impl.cc

 // Copyright (c) 2006-2009 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/bitmap.h"
 #include "net/disk_cache/cache_util.h"
 #include "net/disk_cache/histogram_macros.h"
 #include "net/disk_cache/sparse_control.h"
 
 using base::Time;
 using base::TimeDelta;
+using base::TimeTicks;
 
 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
 // operation from the actual net class.
 class SyncCallback: public disk_cache::FileIOCallback {
  public:
   SyncCallback(disk_cache::EntryImpl* entry, net::IOBuffer* buffer,
                net::CompletionCallback* callback )
-      : entry_(entry), callback_(callback), buf_(buffer), start_(Time::Now()) {
+      : entry_(entry), callback_(callback), buf_(buffer),
+        start_(TimeTicks::Now()) {
     entry->AddRef();
     entry->IncrementIoCount();
   }
   ~SyncCallback() {}
 
   virtual void OnFileIOComplete(int bytes_copied);
   void Discard();
  private:
   disk_cache::EntryImpl* entry_;
   net::CompletionCallback* callback_;
   scoped_refptr<net::IOBuffer> buf_;
-  Time start_;
+  TimeTicks start_;
 
   DISALLOW_EVIL_CONSTRUCTORS(SyncCallback);
 };
 
 void SyncCallback::OnFileIOComplete(int bytes_copied) {
   entry_->DecrementIoCount();
   if (callback_) {
     entry_->ReportIOTime(disk_cache::EntryImpl::kAsyncIO, start_);
     callback_->Run(bytes_copied);
   }
@@ skipping 137 matching lines @@
   if (index < 0 || index >= kNumStreams)
     return net::ERR_INVALID_ARGUMENT;
 
   int entry_size = entry_.Data()->data_size[index];
   if (offset >= entry_size || offset < 0 || !buf_len)
     return 0;
 
   if (buf_len < 0)
     return net::ERR_INVALID_ARGUMENT;
 
-  Time start = Time::Now();
+  TimeTicks start = TimeTicks::Now();
 
   if (offset + buf_len > entry_size)
     buf_len = entry_size - offset;
 
   UpdateRank(false);
 
   backend_->OnEvent(Stats::READ_DATA);
 
   if (user_buffers_[index].get()) {
     // Complete the operation locally.
@@ skipping 50 matching lines @@
   // offset of buf_len could be negative numbers.
   if (offset > max_file_size || buf_len > max_file_size ||
       offset + buf_len > max_file_size) {
     int size = offset + buf_len;
     if (size <= max_file_size)
       size = kint32max;
     backend_->TooMuchStorageRequested(size);
     return net::ERR_FAILED;
   }
 
-  Time start = Time::Now();
+  TimeTicks start = TimeTicks::Now();
 
   // Read the size at this point (it may change inside prepare).
   int entry_size = entry_.Data()->data_size[index];
   if (!PrepareTarget(index, offset, buf_len, truncate))
     return net::ERR_FAILED;
 
   if (entry_size < offset + buf_len) {
     unreported_size_[index] += offset + buf_len - entry_size;
     entry_.Data()->data_size[index] = offset + buf_len;
     entry_.set_modified();
@@ skipping 64 matching lines @@
   return (completed || !completion_callback) ? buf_len : net::ERR_IO_PENDING;
 }
 
 int EntryImpl::ReadSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
                               net::CompletionCallback* completion_callback) {
   DCHECK(node_.Data()->dirty);
   int result = InitSparseData();
   if (net::OK != result)
     return result;
 
-  Time start = Time::Now();
+  TimeTicks start = TimeTicks::Now();
   result = sparse_->StartIO(SparseControl::kReadOperation, offset, buf, buf_len,
                             completion_callback);
   ReportIOTime(kSparseRead, start);
   return result;
 }
 
 int EntryImpl::WriteSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
                                net::CompletionCallback* completion_callback) {
   DCHECK(node_.Data()->dirty);
   int result = InitSparseData();
   if (net::OK != result)
     return result;
 
-  Time start = Time::Now();
+  TimeTicks start = TimeTicks::Now();
   result = sparse_->StartIO(SparseControl::kWriteOperation, offset, buf,
                             buf_len, completion_callback);
   ReportIOTime(kSparseWrite, start);
   return result;
 }
 
 int EntryImpl::GetAvailableRange(int64 offset, int len, int64* start) {
   int result = InitSparseData();
   if (net::OK != result)
     return result;
@@ skipping 206 matching lines @@
 void EntryImpl::DecrementIoCount() {
   backend_->DecrementIoCount();
 }
 
 void EntryImpl::SetTimes(base::Time last_used, base::Time last_modified) {
   node_.Data()->last_used = last_used.ToInternalValue();
   node_.Data()->last_modified = last_modified.ToInternalValue();
   node_.set_modified();
 }
 
-void EntryImpl::ReportIOTime(Operation op, const base::Time& start) {
+void EntryImpl::ReportIOTime(Operation op, const base::TimeTicks& start) {
   int group = backend_->GetSizeGroup();
   switch (op) {
     case kRead:
       CACHE_UMA(AGE_MS, "ReadTime", group, start);
       break;
     case kWrite:
       CACHE_UMA(AGE_MS, "WriteTime", group, start);
       break;
     case kSparseRead:
       CACHE_UMA(AGE_MS, "SparseReadTime", 0, start);
@@ skipping 313 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%x", doomed_, dirty);
 }
 
 }  // namespace disk_cache