Roll forward 8722,8721

chrome/browser/visitedlink_perftest.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 <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 63 matching lines @@
 } // namespace
 
 // This test tests adding many things to a database, and how long it takes
 // 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(NULL, DummyBroadcastNewTableEvent, NULL, true,
-                           db_name_, 0);
+                           FilePath(db_name_), 0);
   ASSERT_TRUE(master.Init());
 
   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);
@@ skipping 10 matching lines @@
   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");
 
     VisitedLinkMaster master(NULL, DummyBroadcastNewTableEvent, NULL, true,
-                             db_name_, 0);
+                             FilePath(db_name_), 0);
 
     // time init with empty table
     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
@@ skipping 19 matching lines @@
   {
     // make sure the file has to be re-loaded
     file_util::EvictFileFromSystemCache(
         FilePath::FromWStringHack(std::wstring(db_name_)));
 
     // cold load (no OS cache, hopefully)
     {
       PerfTimer cold_timer;
 
       VisitedLinkMaster master(NULL, DummyBroadcastNewTableEvent, NULL, true,
-                               db_name_, 0);
+                               FilePath(db_name_), 0);
       bool success = master.Init();
       TimeDelta elapsed = cold_timer.Elapsed();
       ASSERT_TRUE(success);
 
       cold_load_times.push_back(elapsed.InMillisecondsF());
     }
 
     // hot load (with OS caching the file in memory)
     {
       PerfTimer hot_timer;
 
       VisitedLinkMaster master(NULL, DummyBroadcastNewTableEvent, NULL, true,
-                               db_name_, 0);
+                               FilePath(db_name_), 0);
       bool success = master.Init();
       TimeDelta elapsed = hot_timer.Elapsed();
       ASSERT_TRUE(success);
 
       hot_load_times.push_back(elapsed.InMillisecondsF());
     }
   }
 
   // We discard the max and return the average time.
   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");
 }