Preparing components_perftests

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/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/strings/stringprintf.h"
-#include "base/test/perf_log.h"
-#include "base/test/perf_time_logger.h"
 #include "base/test/test_file_util.h"
 #include "base/timer/elapsed_timer.h"
 #include "components/visitedlink/browser/visitedlink_master.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "testing/perf/perf_test.h"
 #include "url/gurl.h"
 
 using base::TimeDelta;
 
 namespace visitedlink {
 
 namespace {
 
+// Designed like base/test/perf_time_logger but uses testing/perf instead of
+// base/test/perf* to report timings.
+class TimeLogger {
+ public:
+  explicit TimeLogger(std::string test_name);

[Alexei Svitkine (slow), 2016/10/21 19:01:46]

Nit: const&

[Peter Kasting, 2016/10/21 19:45:21]

Can't, he's doing std::move() below to move into the member.

+  ~TimeLogger();
+  void Done();
+
+ private:
+  bool logged_;
+  std::string test_name_;
+  base::ElapsedTimer timer_;
+
+  DISALLOW_COPY_AND_ASSIGN(TimeLogger);
+};
+
+TimeLogger::TimeLogger(std::string test_name)
+    : logged_(false), test_name_(std::move(test_name)) {}
+
+TimeLogger::~TimeLogger() {
+  if (!logged_)
+    Done();
+}
+
+void TimeLogger::Done() {
+  // We use a floating-point millisecond value because it is more
+  // intuitive than microseconds and we want more precision than
+  // integer milliseconds.
+  perf_test::PrintResult(test_name_, std::string(), std::string(),
+                         timer_.Elapsed().InMillisecondsF(), "ms", true);
+  logged_ = true;
+}
+
 // how we generate URLs, note that the two strings should be the same length
 const int add_count = 10000;
 const int load_test_add_count = 250000;
 const char added_prefix[] = "http://www.google.com/stuff/something/foo?session=85025602345625&id=1345142319023&seq=";
 const char unadded_prefix[] = "http://www.google.org/stuff/something/foo?session=39586739476365&id=2347624314402&seq=";
 
 // Returns a URL with the given prefix and index
 GURL TestURL(const char* prefix, int i) {
   return GURL(base::StringPrintf("%s%d", prefix, i));
 }
@@ skipping 41 matching lines @@
 // 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());
   content::RunAllBlockingPoolTasksUntilIdle();
 
-  base::PerfTimeLogger timer("Visited_link_add_and_query");
+  TimeLogger 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
   {
-    base::PerfTimeLogger table_initialization_timer("Table_initialization");
+    TimeLogger table_initialization_timer("Table_initialization");
 
     VisitedLinkMaster master(new DummyVisitedLinkEventListener(),
                              NULL, true, true, db_path_, 0);
 
     // time init with empty table
-    base::PerfTimeLogger initTimer("Empty_visited_link_init");
+    TimeLogger initTimer("Empty_visited_link_init");
     bool success = master.Init();
     content::RunAllBlockingPoolTasksUntilIdle();
     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
-    base::PerfTimeLogger flushTimer("Visited_link_database_flush");
+    TimeLogger 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 45 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];
   }
-  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");
+
+  perf_test::PrintResult("Visited_link_cold_load_time", std::string(),
+                         std::string(), cold_sum / cold_load_times.size(), "ms",
+                         true);
+  perf_test::PrintResult("Visited_link_hot_load_time", std::string(),
+                         std::string(), hot_sum / hot_load_times.size(), "ms",
+                         true);
 }
 
 }  // namespace visitedlink