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

net/disk_cache/eviction.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.
 
 // The eviction policy is a very simple pure LRU, so the elements at the end of
 // the list are evicted until kCleanUpMargin free space is available. There is
 // only one list in use (Rankings::NO_USE), and elements are sent to the front
 // of the list whenever they are accessed.
 
 // The new (in-development) eviction policy ads re-use as a factor to evict
@@ skipping 20 matching lines @@
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "net/disk_cache/backend_impl.h"
 #include "net/disk_cache/entry_impl.h"
 #include "net/disk_cache/histogram_macros.h"
 #include "net/disk_cache/trace.h"
 
 using base::Time;
+using base::TimeTicks;
 
 namespace {
 
 const int kCleanUpMargin = 1024 * 1024;
 const int kHighUse = 10;  // Reuse count to be on the HIGH_USE list.
 const int kTargetTime = 24 * 7;  // Time to be evicted (hours since last use).
 const int kMaxDelayedTrims = 60;
 
 int LowWaterAdjust(int high_water) {
   if (high_water < kCleanUpMargin)
@@ skipping 25 matching lines @@
     return;
 
   if (!empty && !ShouldTrim())
     return PostDelayedTrim();
 
   if (new_eviction_)
     return TrimCacheV2(empty);
 
   Trace("*** Trim Cache ***");
   trimming_ = true;
-  Time start = Time::Now();
+  TimeTicks start = TimeTicks::Now();
   Rankings::ScopedRankingsBlock node(rankings_);
   Rankings::ScopedRankingsBlock next(rankings_,
       rankings_->GetPrev(node.get(), Rankings::NO_USE));
   int target_size = empty ? 0 : max_size_;
   while (header_->num_bytes > target_size && next.get()) {
     // The iterator could be invalidated within EvictEntry().
     if (!next->HasData())
       break;
     node.reset(next.release());
     next.reset(rankings_->GetPrev(node.get(), Rankings::NO_USE));
     if (node->Data()->dirty != backend_->GetCurrentEntryId() || empty) {
       // This entry is not being used by anybody.
       // Do NOT use node as an iterator after this point.
       rankings_->TrackRankingsBlock(node.get(), false);
       if (!EvictEntry(node.get(), empty))
         continue;
 
       if (!empty) {
         backend_->OnEvent(Stats::TRIM_ENTRY);
 
-        if ((Time::Now() - start).InMilliseconds() > 20) {
+        if ((TimeTicks::Now() - start).InMilliseconds() > 20) {
           MessageLoop::current()->PostTask(FROM_HERE,
               factory_.NewRunnableMethod(&Eviction::TrimCache, false));
           break;
         }
       }
     }
   }
 
   if (empty) {
     CACHE_UMA(AGE_MS, "TotalClearTimeV1", 0, start);
@@ skipping 120 matching lines @@
   entry->Release();
 
   return true;
 }
 
 // -----------------------------------------------------------------------
 
 void Eviction::TrimCacheV2(bool empty) {
   Trace("*** Trim Cache ***");
   trimming_ = true;
-  Time start = Time::Now();
+  TimeTicks start = TimeTicks::Now();
 
   const int kListsToSearch = 3;
   Rankings::ScopedRankingsBlock next[kListsToSearch];
   int list = Rankings::LAST_ELEMENT;
 
   // Get a node from each list.
   for (int i = 0; i < kListsToSearch; i++) {
     bool done = false;
     next[i].set_rankings(rankings_);
     if (done)
@@ skipping 30 matching lines @@
       node.reset(next[list].release());
       next[list].reset(rankings_->GetPrev(node.get(),
                                           static_cast<Rankings::List>(list)));
       if (node->Data()->dirty != backend_->GetCurrentEntryId() || empty) {
         // This entry is not being used by anybody.
         // Do NOT use node as an iterator after this point.
         rankings_->TrackRankingsBlock(node.get(), false);
         if (!EvictEntry(node.get(), empty))
           continue;
 
-        if (!empty && (Time::Now() - start).InMilliseconds() > 20) {
+        if (!empty && (TimeTicks::Now() - start).InMilliseconds() > 20) {
           MessageLoop::current()->PostTask(FROM_HERE,
               factory_.NewRunnableMethod(&Eviction::TrimCache, false));
           break;
         }
       }
     }
     if (!empty)
       list = kListsToSearch;
   }
 
@@ skipping 98 matching lines @@
   return Rankings::HIGH_USE;
 }
 
 // This is a minimal implementation that just discards the oldest nodes.
 // TODO(rvargas): Do something better here.
 void Eviction::TrimDeleted(bool empty) {
   Trace("*** Trim Deleted ***");
   if (backend_->disabled_)
     return;
 
-  Time start = Time::Now();
+  TimeTicks start = TimeTicks::Now();
   Rankings::ScopedRankingsBlock node(rankings_);
   Rankings::ScopedRankingsBlock next(rankings_,
     rankings_->GetPrev(node.get(), Rankings::DELETED));
   for (int i = 0; (i < 4 || empty) && next.get(); i++) {
     node.reset(next.release());
     next.reset(rankings_->GetPrev(node.get(), Rankings::DELETED));
     RemoveDeletedNode(node.get());
   }
 
   if (header_->lru.sizes[Rankings::DELETED] > header_->num_entries / 4)
@@ skipping 69 matching lines @@
               Time::FromInternalValue(last2.get()->Data()->last_used));
   if (last3.get())
     CACHE_UMA(AGE, "HighUseAge", 0,
               Time::FromInternalValue(last3.get()->Data()->last_used));
   if (last4.get())
     CACHE_UMA(AGE, "DeletedAge", 0,
               Time::FromInternalValue(last4.get()->Data()->last_used));
 }
 
 }  // namespace disk_cache