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

net/disk_cache/block_files.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/block_files.h"
 
 #include "base/file_util.h"
 #include "base/histogram.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "net/disk_cache/cache_util.h"
 #include "net/disk_cache/file_lock.h"
 
 using base::Time;
+using base::TimeTicks;
 
 namespace {
 
 const char* kBlockName = "data_";
 
 // This array is used to perform a fast lookup of the nibble bit pattern to the
 // type of entry that can be stored there (number of consecutive blocks).
 const char s_types[16] = {4, 3, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0};
 
 // Returns the type of block (number of consecutive blocks that can be stored)
 // for a given nibble of the bitmap.
 inline int GetMapBlockType(uint8 value) {
   value &= 0xf;
   return s_types[value];
 }
 
 void FixAllocationCounters(disk_cache::BlockFileHeader* header);
 
 // Creates a new entry on the allocation map, updating the apropriate counters.
 // target is the type of block to use (number of empty blocks), and size is the
 // actual number of blocks to use.
 bool CreateMapBlock(int target, int size, disk_cache::BlockFileHeader* header,
                     int* index) {
   if (target <= 0 || target > disk_cache::kMaxNumBlocks ||
       size <= 0 || size > disk_cache::kMaxNumBlocks) {
     NOTREACHED();
     return false;
   }
 
-  Time start = Time::Now();
+  TimeTicks start = TimeTicks::Now();
   // We are going to process the map on 32-block chunks (32 bits), and on every
   // chunk, iterate through the 8 nibbles where the new block can be located.
   int current = header->hints[target - 1];
   for (int i = 0; i < header->max_entries / 32; i++, current++) {
     if (current == header->max_entries / 32)
       current = 0;
     uint32 map_block = header->allocation_map[current];
 
     for (int j = 0; j < 8; j++, map_block >>= 4) {
       if (GetMapBlockType(map_block) != target)
         continue;
 
       disk_cache::FileLock lock(header);
       int index_offset = j * 4 + 4 - target;
       *index = current * 32 + index_offset;
       uint32 to_add = ((1 << size) - 1) << index_offset;
       header->allocation_map[current] |= to_add;
 
       header->hints[target - 1] = current;
       header->empty[target - 1]--;
       DCHECK(header->empty[target - 1] >= 0);
       header->num_entries++;
       if (target != size) {
         header->empty[target - size - 1]++;
       }
-      HISTOGRAM_TIMES("DiskCache.CreateBlock", Time::Now() - start);
+      HISTOGRAM_TIMES("DiskCache.CreateBlock", TimeTicks::Now() - start);
       return true;
     }
   }
 
   // It is possible to have an undetected corruption (for example when the OS
   // crashes), fix it here.
   LOG(ERROR) << "Failing CreateMapBlock";
   FixAllocationCounters(header);
   return false;
 }
 
 // Deletes the block pointed by index from allocation_map, and updates the
 // relevant counters on the header.
 void DeleteMapBlock(int index, int size, disk_cache::BlockFileHeader* header) {
   if (size < 0 || size > disk_cache::kMaxNumBlocks) {
     NOTREACHED();
     return;
   }
-  Time start = Time::Now();
+  TimeTicks start = TimeTicks::Now();
   int byte_index = index / 8;
   uint8* byte_map = reinterpret_cast<uint8*>(header->allocation_map);
   uint8 map_block = byte_map[byte_index];
 
   if (index % 8 >= 4)
     map_block >>= 4;
 
   // See what type of block will be availabe after we delete this one.
   int bits_at_end = 4 - size - index % 4;
   uint8 end_mask = (0xf << (4 - bits_at_end)) & 0xf;
   bool update_counters = (map_block & end_mask) == 0;
   uint8 new_value = map_block & ~(((1 << size) - 1) << (index % 4));
   int new_type = GetMapBlockType(new_value);
 
   disk_cache::FileLock lock(header);
   DCHECK((((1 << size) - 1) << (index % 8)) < 0x100);
   uint8  to_clear = ((1 << size) - 1) << (index % 8);
   DCHECK((byte_map[byte_index] & to_clear) == to_clear);
   byte_map[byte_index] &= ~to_clear;
 
   if (update_counters) {
     if (bits_at_end)
       header->empty[bits_at_end - 1]--;
     header->empty[new_type - 1]++;
     DCHECK(header->empty[bits_at_end - 1] >= 0);
   }
   header->num_entries--;
   DCHECK(header->num_entries >= 0);
-  HISTOGRAM_TIMES("DiskCache.DeleteBlock", Time::Now() - start);
+  HISTOGRAM_TIMES("DiskCache.DeleteBlock", TimeTicks::Now() - start);
 }
 
 // Restores the "empty counters" and allocation hints.
 void FixAllocationCounters(disk_cache::BlockFileHeader* header) {
   for (int i = 0; i < disk_cache::kMaxNumBlocks; i++) {
     header->hints[i] = 0;
     header->empty[i] = 0;
   }
 
   for (int i = 0; i < header->max_entries / 32; i++) {
@@ skipping 178 matching lines @@
   header->max_entries = new_size;
 
   return true;
 }
 
 MappedFile* BlockFiles::FileForNewBlock(FileType block_type, int block_count) {
   COMPILE_ASSERT(RANKINGS == 1, invalid_fily_type);
   MappedFile* file = block_files_[block_type - 1];
   BlockFileHeader* header = reinterpret_cast<BlockFileHeader*>(file->buffer());
 
-  Time start = Time::Now();
+  TimeTicks start = TimeTicks::Now();
   while (NeedToGrowBlockFile(header, block_count)) {
     if (kMaxBlocks == header->max_entries) {
       file = NextFile(file);
       if (!file)
         return NULL;
       header = reinterpret_cast<BlockFileHeader*>(file->buffer());
       continue;
     }
 
     if (!GrowBlockFile(file, header))
       return NULL;
     break;
   }
-  HISTOGRAM_TIMES("DiskCache.GetFileForNewBlock", Time::Now() - start);
+  HISTOGRAM_TIMES("DiskCache.GetFileForNewBlock", TimeTicks::Now() - start);
   return file;
 }
 
 MappedFile* BlockFiles::NextFile(const MappedFile* file) {
   BlockFileHeader* header = reinterpret_cast<BlockFileHeader*>(file->buffer());
   int new_file = header->next_file;
   if (!new_file) {
     // RANKINGS is not reported as a type for small entries, but we may be
     // extending the rankings block file.
     FileType type = Addr::RequiredFileType(header->entry_size);
@@ skipping 137 matching lines @@
     int num_entries = (file_size - sizeof(*header)) / header->entry_size;
     header->max_entries = num_entries;
   }
 
   FixAllocationCounters(header);
   header->updating = 0;
   return true;
 }
 
 }  // namespace disk_cache