base: Split logging functions and PerfTimeLogger out of perftimer.h

net/disk_cache/disk_cache_perftest.cc

 // Copyright (c) 2011 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 <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/hash.h"
 #include "base/strings/string_util.h"
-#include "base/test/perftimer.h"
+#include "base/test/perf_time_logger.h"
 #include "base/test/test_file_util.h"
 #include "base/threading/thread.h"
 #include "base/timer/timer.h"
 #include "net/base/cache_type.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/disk_cache/backend_impl.h"
 #include "net/disk_cache/block_files.h"
 #include "net/disk_cache/disk_cache.h"
@@ skipping 23 matching lines @@
   scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kMaxSize));
 
   CacheTestFillBuffer(buffer1->data(), kSize1, false);
   CacheTestFillBuffer(buffer2->data(), kMaxSize, false);
 
   int expected = 0;
 
   MessageLoopHelper helper;
   CallbackTest callback(&helper, true);
 
-  PerfTimeLogger timer("Write disk cache entries");
+  base::PerfTimeLogger timer("Write disk cache entries");
 
   for (int i = 0; i < num_entries; i++) {
     TestEntry entry;
     entry.key = GenerateKey(true);
     entry.data_len = rand() % kMaxSize;
     entries->push_back(entry);
 
     disk_cache::Entry* cache_entry;
     net::TestCompletionCallback cb;
     int rv = cache->CreateEntry(entry.key, &cache_entry, cb.callback());
@@ skipping 33 matching lines @@
   CacheTestFillBuffer(buffer1->data(), kSize1, false);
   CacheTestFillBuffer(buffer2->data(), kMaxSize, false);
 
   int expected = 0;
 
   MessageLoopHelper helper;
   CallbackTest callback(&helper, true);
 
   const char* message = cold ? "Read disk cache entries (cold)" :
                         "Read disk cache entries (warm)";
-  PerfTimeLogger timer(message);
+  base::PerfTimeLogger timer(message);
 
   for (int i = 0; i < num_entries; i++) {
     disk_cache::Entry* cache_entry;
     net::TestCompletionCallback cb;
     int rv = cache->OpenEntry(entries[i].key, &cache_entry, cb.callback());
     if (net::OK != cb.GetResult(rv))
       break;
     int ret = cache_entry->ReadData(
         0, 0, buffer1.get(), kSize1,
         base::Bind(&CallbackTest::Run, base::Unretained(&callback)));
@@ skipping 22 matching lines @@
   // We can use form 1 to 4 blocks.
   return (rand() & 0x3) + 1;
 }
 
 }  // namespace
 
 TEST_F(DiskCacheTest, Hash) {
   int seed = static_cast<int>(Time::Now().ToInternalValue());
   srand(seed);
 
-  PerfTimeLogger timer("Hash disk cache keys");
+  base::PerfTimeLogger timer("Hash disk cache keys");
   for (int i = 0; i < 300000; i++) {
     std::string key = GenerateKey(true);
     base::Hash(key);
   }
   timer.Done();
 }
 
 TEST_F(DiskCacheTest, CacheBackendPerformance) {
   base::Thread cache_thread("CacheThread");
   ASSERT_TRUE(cache_thread.StartWithOptions(
@@ skipping 52 matching lines @@
 
   disk_cache::BlockFiles files(cache_path_);
   ASSERT_TRUE(files.Init(true));
 
   int seed = static_cast<int>(Time::Now().ToInternalValue());
   srand(seed);
 
   const int kNumEntries = 60000;
   disk_cache::Addr* address = new disk_cache::Addr[kNumEntries];
 
-  PerfTimeLogger timer1("Fill three block-files");
+  base::PerfTimeLogger timer1("Fill three block-files");
 
   // Fill up the 32-byte block file (use three files).
   for (int i = 0; i < kNumEntries; i++) {
     EXPECT_TRUE(files.CreateBlock(disk_cache::RANKINGS, BlockSize(),
                                   &address[i]));
   }
 
   timer1.Done();
-  PerfTimeLogger timer2("Create and delete blocks");
+  base::PerfTimeLogger timer2("Create and delete blocks");
 
   for (int i = 0; i < 200000; i++) {
     int entry = rand() * (kNumEntries / RAND_MAX + 1);
     if (entry >= kNumEntries)
       entry = 0;
 
     files.DeleteBlock(address[entry], false);
     EXPECT_TRUE(files.CreateBlock(disk_cache::RANKINGS, BlockSize(),
                                   &address[entry]));
   }
 
   timer2.Done();
   base::MessageLoop::current()->RunUntilIdle();
   delete[] address;
 }