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

components/visitedlink/test/visitedlink_perftest.cc

 // Copyright (c) 2010 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 <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/memory/shared_memory.h"
 #include "base/strings/stringprintf.h"
+#include "base/test/perf_log.h"
+#include "base/test/perf_time_logger.h"
 #include "base/test/perftimer.h"
 #include "base/test/test_file_util.h"
 #include "components/visitedlink/browser/visitedlink_master.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 using base::TimeDelta;
 
 namespace visitedlink {
 
@@ skipping 53 matching lines @@
 // to query the database with different numbers of things in it. The time
 // is the total time to do all the operations, and as such, it is only
 // useful for a regression test. If there is a regression, it might be
 // useful to make another set of tests to test these things in isolation.
 TEST_F(VisitedLink, TestAddAndQuery) {
   // init
   VisitedLinkMaster master(new DummyVisitedLinkEventListener(),
                            NULL, true, true, db_path_, 0);
   ASSERT_TRUE(master.Init());
 
-  PerfTimeLogger timer("Visited_link_add_and_query");
+  base::PerfTimeLogger timer("Visited_link_add_and_query");
 
   // first check without anything in the table
   CheckVisited(master, added_prefix, 0, add_count);
 
   // now fill half the table
   const int half_size = add_count / 2;
   FillTable(master, added_prefix, 0, half_size);
 
   // check the table again, half of these URLs will be visited, the other half
   // will not
   CheckVisited(master, added_prefix, 0, add_count);
 
   // fill the rest of the table
   FillTable(master, added_prefix, half_size, add_count);
 
   // check URLs, doing half visited, half unvisited
   CheckVisited(master, added_prefix, 0, add_count);
   CheckVisited(master, unadded_prefix, 0, add_count);
 }
 
 // Tests how long it takes to write and read a large database to and from disk.
 TEST_F(VisitedLink, TestLoad) {
   // create a big DB
   {
-    PerfTimeLogger table_initialization_timer("Table_initialization");
+    base::PerfTimeLogger table_initialization_timer("Table_initialization");
 
     VisitedLinkMaster master(new DummyVisitedLinkEventListener(),
                              NULL, true, true, db_path_, 0);
 
     // time init with empty table
-    PerfTimeLogger initTimer("Empty_visited_link_init");
+    base::PerfTimeLogger initTimer("Empty_visited_link_init");
     bool success = master.Init();
     initTimer.Done();
     ASSERT_TRUE(success);
 
     // add a bunch of stuff
     // TODO(maruel): This is very inefficient because the file gets rewritten
     // many time and this is the actual bottleneck of this test. The file should
     // only get written that the end of the FillTable call, not 4169(!) times.
     FillTable(master, added_prefix, 0, load_test_add_count);
 
     // time writing the file out out
-    PerfTimeLogger flushTimer("Visited_link_database_flush");
+    base::PerfTimeLogger flushTimer("Visited_link_database_flush");
     master.RewriteFile();
     // TODO(maruel): Without calling FlushFileBuffers(master.file_); you don't
     // know really how much time it took to write the file.
     flushTimer.Done();
 
     table_initialization_timer.Done();
   }
 
   // test loading the DB back, we do this several times since the flushing is
   // not very reliable.
@@ skipping 43 matching lines @@
   cold_load_times.erase(std::max_element(cold_load_times.begin(),
                                          cold_load_times.end()));
   hot_load_times.erase(std::max_element(hot_load_times.begin(),
                                         hot_load_times.end()));
 
   double cold_sum = 0, hot_sum = 0;
   for (int i = 0; i < static_cast<int>(cold_load_times.size()); i++) {
     cold_sum += cold_load_times[i];
     hot_sum += hot_load_times[i];
   }
-  LogPerfResult("Visited_link_cold_load_time",
-                cold_sum / cold_load_times.size(), "ms");
-  LogPerfResult("Visited_link_hot_load_time",
-                hot_sum / hot_load_times.size(), "ms");
+  base::LogPerfResult(
+      "Visited_link_cold_load_time", cold_sum / cold_load_times.size(), "ms");
+  base::LogPerfResult(
+      "Visited_link_hot_load_time", hot_sum / hot_load_times.size(), "ms");
 }
 
 }  // namespace visitedlink