Rework arguments of HistoryService::AddPage()

chrome/browser/history/history_unittest.cc

 // Copyright (c) 2012 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.
 
 // History unit tests come in two flavors:
 //
 // 1. The more complicated style is that the unit test creates a full history
 //    service. This spawns a background thread for the history backend, and
 //    all communication is asynchronous. This is useful for testing more
 //    complicated things or end-to-end behavior.
@@ skipping 16 matching lines @@
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/scoped_temp_dir.h"
 #include "base/string_util.h"
+#include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/history/history_backend.h"
 #include "chrome/browser/history/history_database.h"
 #include "chrome/browser/history/history_notifications.h"
 #include "chrome/browser/history/in_memory_database.h"
 #include "chrome/browser/history/in_memory_history_backend.h"
 #include "chrome/browser/history/page_usage_data.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
@@ skipping 422 matching lines @@
   }
 }
 
 TEST_F(HistoryTest, AddPage) {
   scoped_refptr<HistoryService> history(new HistoryService);
   history_service_ = history;
   ASSERT_TRUE(history->Init(history_dir_, NULL));
 
   // Add the page once from a child frame.
   const GURL test_url("http://www.google.com/");
-  history->AddPage(test_url, NULL, 0, GURL(),
+  history->AddPage(test_url, base::Time::Now(), NULL, 0, GURL(),
+                   history::RedirectList(),
                    content::PAGE_TRANSITION_MANUAL_SUBFRAME,
-                   history::RedirectList(),
                    history::SOURCE_BROWSED, false);
   EXPECT_TRUE(QueryURL(history, test_url));
   EXPECT_EQ(1, query_url_row_.visit_count());
   EXPECT_EQ(0, query_url_row_.typed_count());
   EXPECT_TRUE(query_url_row_.hidden());  // Hidden because of child frame.
 
   // Add the page once from the main frame (should unhide it).
-  history->AddPage(test_url, NULL, 0, GURL(), content::PAGE_TRANSITION_LINK,
-                   history::RedirectList(),
+  history->AddPage(test_url, base::Time::Now(), NULL, 0, GURL(),
+                   history::RedirectList(), content::PAGE_TRANSITION_LINK,
                    history::SOURCE_BROWSED, false);
   EXPECT_TRUE(QueryURL(history, test_url));
   EXPECT_EQ(2, query_url_row_.visit_count());  // Added twice.
   EXPECT_EQ(0, query_url_row_.typed_count());  // Never typed.
   EXPECT_FALSE(query_url_row_.hidden());  // Because loaded in main frame.
 }
 
 TEST_F(HistoryTest, AddPageSameTimes) {
   scoped_refptr<HistoryService> history(new HistoryService);
   history_service_ = history;
   ASSERT_TRUE(history->Init(history_dir_, NULL));
 
   Time now = Time::Now();
   const GURL test_urls[] = {
     GURL("http://timer.first.page/"),
     GURL("http://timer.second.page/"),
     GURL("http://timer.third.page/"),
   };
 
   // Make sure that two pages added at the same time with no intervening
   // additions have different timestamps.
   history->AddPage(test_urls[0], now, NULL, 0, GURL(),
-                   content::PAGE_TRANSITION_LINK,
-                   history::RedirectList(),
+                   history::RedirectList(), content::PAGE_TRANSITION_LINK,
                    history::SOURCE_BROWSED, false);
   EXPECT_TRUE(QueryURL(history, test_urls[0]));
   EXPECT_EQ(1, query_url_row_.visit_count());
   EXPECT_TRUE(now == query_url_row_.last_visit());  // gtest doesn't like Time
 
   history->AddPage(test_urls[1], now, NULL, 0, GURL(),
-                   content::PAGE_TRANSITION_LINK,
-                   history::RedirectList(),
+                   history::RedirectList(), content::PAGE_TRANSITION_LINK,
                    history::SOURCE_BROWSED, false);
   EXPECT_TRUE(QueryURL(history, test_urls[1]));
   EXPECT_EQ(1, query_url_row_.visit_count());
   EXPECT_TRUE(now + TimeDelta::FromMicroseconds(1) ==
       query_url_row_.last_visit());
 
   // Make sure the next page, at a different time, is also correct.
   history->AddPage(test_urls[2], now + TimeDelta::FromMinutes(1),
-                   NULL, 0, GURL(),
-                   content::PAGE_TRANSITION_LINK,
-                   history::RedirectList(),
-                   history::SOURCE_BROWSED, false);
+                   NULL, 0, GURL(), history::RedirectList(),
+                   content::PAGE_TRANSITION_LINK, history::SOURCE_BROWSED,
+                   false);
   EXPECT_TRUE(QueryURL(history, test_urls[2]));
   EXPECT_EQ(1, query_url_row_.visit_count());
   EXPECT_TRUE(now + TimeDelta::FromMinutes(1) ==
       query_url_row_.last_visit());
 }
 
 TEST_F(HistoryTest, AddRedirect) {
   scoped_refptr<HistoryService> history(new HistoryService);
   history_service_ = history;
   ASSERT_TRUE(history->Init(history_dir_, NULL));
 
   const char* first_sequence[] = {
     "http://first.page.com/",
     "http://second.page.com/"};
   int first_count = arraysize(first_sequence);
   history::RedirectList first_redirects;
   for (int i = 0; i < first_count; i++)
     first_redirects.push_back(GURL(first_sequence[i]));
 
   // Add the sequence of pages as a server with no referrer. Note that we need
   // to have a non-NULL page ID scope.
-  history->AddPage(first_redirects.back(), MakeFakeHost(1), 0, GURL(),
-                   content::PAGE_TRANSITION_LINK, first_redirects,
-                   history::SOURCE_BROWSED,  true);
+  history->AddPage(first_redirects.back(), base::Time::Now(), MakeFakeHost(1),
+                   0, GURL(), first_redirects, content::PAGE_TRANSITION_LINK,
+                   history::SOURCE_BROWSED, true);
 
   // The first page should be added once with a link visit type (because we set
   // LINK when we added the original URL, and a referrer of nowhere (0).
   EXPECT_TRUE(QueryURL(history, first_redirects[0]));
   EXPECT_EQ(1, query_url_row_.visit_count());
   ASSERT_EQ(1U, query_url_visits_.size());
   int64 first_visit = query_url_visits_[0].visit_id;
   EXPECT_EQ(content::PAGE_TRANSITION_LINK |
             content::PAGE_TRANSITION_CHAIN_START,
             query_url_visits_[0].transition);
@@ skipping 15 matching lines @@
   QueryRedirectsFrom(history, first_redirects[0]);
   ASSERT_EQ(1U, saved_redirects_.size());
   EXPECT_EQ(first_redirects[1], saved_redirects_[0]);
 
   // Now add a client redirect from that second visit to a third, client
   // redirects are tracked by the RenderView prior to updating history,
   // so we pass in a CLIENT_REDIRECT qualifier to mock that behavior.
   history::RedirectList second_redirects;
   second_redirects.push_back(first_redirects[1]);
   second_redirects.push_back(GURL("http://last.page.com/"));
-  history->AddPage(second_redirects[1], MakeFakeHost(1), 1,
-                   second_redirects[0],
+  history->AddPage(second_redirects[1], base::Time::Now(),
+                   MakeFakeHost(1), 1, second_redirects[0], second_redirects,
                    static_cast<content::PageTransition>(
                        content::PAGE_TRANSITION_LINK |
                        content::PAGE_TRANSITION_CLIENT_REDIRECT),
-                   second_redirects, history::SOURCE_BROWSED, true);
+                   history::SOURCE_BROWSED, true);
 
   // The last page (source of the client redirect) should NOT have an
   // additional visit added, because it was a client redirect (normally it
   // would). We should only have 1 left over from the first sequence.
   EXPECT_TRUE(QueryURL(history, second_redirects[0]));
   EXPECT_EQ(1, query_url_row_.visit_count());
 
   // The final page should be set as a client redirect from the previous visit.
   EXPECT_TRUE(QueryURL(history, second_redirects[1]));
   EXPECT_EQ(1, query_url_row_.visit_count());
   ASSERT_EQ(1U, query_url_visits_.size());
   EXPECT_EQ(content::PAGE_TRANSITION_CLIENT_REDIRECT |
             content::PAGE_TRANSITION_CHAIN_END,
             query_url_visits_[0].transition);
   EXPECT_EQ(second_visit, query_url_visits_[0].referring_visit);
 }
 
 TEST_F(HistoryTest, MakeIntranetURLsTyped) {
   scoped_refptr<HistoryService> history(new HistoryService);
   history_service_ = history;
   ASSERT_TRUE(history->Init(history_dir_, NULL));
 
   // Add a non-typed visit to an intranet URL on an unvisited host.  This should
   // get promoted to a typed visit.
   const GURL test_url("http://intranet_host/path");
-  history->AddPage(test_url, NULL, 0, GURL(), content::PAGE_TRANSITION_LINK,
-                   history::RedirectList(), history::SOURCE_BROWSED, false);
+  history->AddPage(test_url, base::Time::Now(), NULL, 0, GURL(),
+                   history::RedirectList(), content::PAGE_TRANSITION_LINK,
+                   history::SOURCE_BROWSED, false);
   EXPECT_TRUE(QueryURL(history, test_url));
   EXPECT_EQ(1, query_url_row_.visit_count());
   EXPECT_EQ(1, query_url_row_.typed_count());
   ASSERT_EQ(1U, query_url_visits_.size());
   EXPECT_EQ(content::PAGE_TRANSITION_TYPED,
       content::PageTransitionStripQualifier(query_url_visits_[0].transition));
 
   // Add more visits on the same host.  None of these should be promoted since
   // there is already a typed visit.
 
   // Different path.
   const GURL test_url2("http://intranet_host/different_path");
-  history->AddPage(test_url2, NULL, 0, GURL(), content::PAGE_TRANSITION_LINK,
-                   history::RedirectList(), history::SOURCE_BROWSED, false);
+  history->AddPage(test_url2, base::Time::Now(), NULL, 0, GURL(),
+                   history::RedirectList(), content::PAGE_TRANSITION_LINK,
+                   history::SOURCE_BROWSED, false);
   EXPECT_TRUE(QueryURL(history, test_url2));
   EXPECT_EQ(1, query_url_row_.visit_count());
   EXPECT_EQ(0, query_url_row_.typed_count());
   ASSERT_EQ(1U, query_url_visits_.size());
   EXPECT_EQ(content::PAGE_TRANSITION_LINK,
       content::PageTransitionStripQualifier(query_url_visits_[0].transition));
 
   // No path.
   const GURL test_url3("http://intranet_host/");
-  history->AddPage(test_url3, NULL, 0, GURL(), content::PAGE_TRANSITION_LINK,
-                   history::RedirectList(), history::SOURCE_BROWSED, false);
+  history->AddPage(test_url3, base::Time::Now(), NULL, 0, GURL(),
+                   history::RedirectList(), content::PAGE_TRANSITION_LINK,
+                   history::SOURCE_BROWSED, false);
   EXPECT_TRUE(QueryURL(history, test_url3));
   EXPECT_EQ(1, query_url_row_.visit_count());
   EXPECT_EQ(0, query_url_row_.typed_count());
   ASSERT_EQ(1U, query_url_visits_.size());
   EXPECT_EQ(content::PAGE_TRANSITION_LINK,
       content::PageTransitionStripQualifier(query_url_visits_[0].transition));
 
   // Different scheme.
   const GURL test_url4("https://intranet_host/");
-  history->AddPage(test_url4, NULL, 0, GURL(), content::PAGE_TRANSITION_LINK,
-                   history::RedirectList(), history::SOURCE_BROWSED, false);
+  history->AddPage(test_url4, base::Time::Now(), NULL, 0, GURL(),
+                   history::RedirectList(), content::PAGE_TRANSITION_LINK,
+                   history::SOURCE_BROWSED, false);
   EXPECT_TRUE(QueryURL(history, test_url4));
   EXPECT_EQ(1, query_url_row_.visit_count());
   EXPECT_EQ(0, query_url_row_.typed_count());
   ASSERT_EQ(1U, query_url_visits_.size());
   EXPECT_EQ(content::PAGE_TRANSITION_LINK,
       content::PageTransitionStripQualifier(query_url_visits_[0].transition));
 
   // Different transition.
   const GURL test_url5("http://intranet_host/another_path");
-  history->AddPage(test_url5, NULL, 0, GURL(),
+  history->AddPage(test_url5, base::Time::Now(), NULL, 0, GURL(),
+                   history::RedirectList(),
                    content::PAGE_TRANSITION_AUTO_BOOKMARK,
-                   history::RedirectList(), history::SOURCE_BROWSED, false);
+                   history::SOURCE_BROWSED, false);
   EXPECT_TRUE(QueryURL(history, test_url5));
   EXPECT_EQ(1, query_url_row_.visit_count());
   EXPECT_EQ(0, query_url_row_.typed_count());
   ASSERT_EQ(1U, query_url_visits_.size());
   EXPECT_EQ(content::PAGE_TRANSITION_AUTO_BOOKMARK,
       content::PageTransitionStripQualifier(query_url_visits_[0].transition));
 
   // Original URL.
-  history->AddPage(test_url, NULL, 0, GURL(), content::PAGE_TRANSITION_LINK,
-                   history::RedirectList(), history::SOURCE_BROWSED, false);
+  history->AddPage(test_url, base::Time::Now(), NULL, 0, GURL(),
+                   history::RedirectList(), content::PAGE_TRANSITION_LINK,
+                   history::SOURCE_BROWSED, false);
   EXPECT_TRUE(QueryURL(history, test_url));
   EXPECT_EQ(2, query_url_row_.visit_count());
   EXPECT_EQ(1, query_url_row_.typed_count());
   ASSERT_EQ(2U, query_url_visits_.size());
   EXPECT_EQ(content::PAGE_TRANSITION_LINK,
       content::PageTransitionStripQualifier(query_url_visits_[1].transition));
 }
 
 TEST_F(HistoryTest, Typed) {
   scoped_refptr<HistoryService> history(new HistoryService);
   history_service_ = history;
   ASSERT_TRUE(history->Init(history_dir_, NULL));
 
   // Add the page once as typed.
   const GURL test_url("http://www.google.com/");
-  history->AddPage(test_url, NULL, 0, GURL(), content::PAGE_TRANSITION_TYPED,
-                   history::RedirectList(),
+  history->AddPage(test_url, base::Time::Now(), NULL, 0, GURL(),
+                   history::RedirectList(), content::PAGE_TRANSITION_TYPED,
                    history::SOURCE_BROWSED, false);
   EXPECT_TRUE(QueryURL(history, test_url));
 
   // We should have the same typed & visit count.
   EXPECT_EQ(1, query_url_row_.visit_count());
   EXPECT_EQ(1, query_url_row_.typed_count());
 
   // Add the page again not typed.
-  history->AddPage(test_url, NULL, 0, GURL(), content::PAGE_TRANSITION_LINK,
-                   history::RedirectList(),
+  history->AddPage(test_url, base::Time::Now(), NULL, 0, GURL(),
+                   history::RedirectList(), content::PAGE_TRANSITION_LINK,
                    history::SOURCE_BROWSED, false);
   EXPECT_TRUE(QueryURL(history, test_url));
 
   // The second time should not have updated the typed count.
   EXPECT_EQ(2, query_url_row_.visit_count());
   EXPECT_EQ(1, query_url_row_.typed_count());
 
   // Add the page again as a generated URL.
-  history->AddPage(test_url, NULL, 0, GURL(),
-                   content::PAGE_TRANSITION_GENERATED, history::RedirectList(),
+  history->AddPage(test_url, base::Time::Now(), NULL, 0, GURL(),
+                   history::RedirectList(), content::PAGE_TRANSITION_GENERATED,
                    history::SOURCE_BROWSED, false);
   EXPECT_TRUE(QueryURL(history, test_url));
 
   // This should have worked like a link click.
   EXPECT_EQ(3, query_url_row_.visit_count());
   EXPECT_EQ(1, query_url_row_.typed_count());
 
   // Add the page again as a reload.
-  history->AddPage(test_url, NULL, 0, GURL(),
-                   content::PAGE_TRANSITION_RELOAD, history::RedirectList(),
+  history->AddPage(test_url, base::Time::Now(), NULL, 0, GURL(),
+                   history::RedirectList(), content::PAGE_TRANSITION_RELOAD,
                    history::SOURCE_BROWSED, false);
   EXPECT_TRUE(QueryURL(history, test_url));
 
   // This should not have incremented any visit counts.
   EXPECT_EQ(3, query_url_row_.visit_count());
   EXPECT_EQ(1, query_url_row_.typed_count());
 }
 
 TEST_F(HistoryTest, SetTitle) {
   scoped_refptr<HistoryService> history(new HistoryService);
   history_service_ = history;
   ASSERT_TRUE(history->Init(history_dir_, NULL));
 
   // Add a URL.
   const GURL existing_url("http://www.google.com/");
-  history->AddPage(existing_url, history::SOURCE_BROWSED);
+  history->AddPage(existing_url, base::Time::Now(), history::SOURCE_BROWSED);
 
   // Set some title.
   const string16 existing_title = UTF8ToUTF16("Google");
   history->SetPageTitle(existing_url, existing_title);
 
   // Make sure the title got set.
   EXPECT_TRUE(QueryURL(history, existing_url));
   EXPECT_EQ(existing_title, query_url_row_.title());
 
   // set a title on a nonexistent page
@@ skipping 12 matching lines @@
 TEST_F(HistoryTest, Segments) {
   scoped_refptr<HistoryService> history(new HistoryService);
   history_service_ = history;
 
   ASSERT_TRUE(history->Init(history_dir_, NULL));
 
   static const void* scope = static_cast<void*>(this);
 
   // Add a URL.
   const GURL existing_url("http://www.google.com/");
-  history->AddPage(existing_url, scope, 0, GURL(),
-                   content::PAGE_TRANSITION_TYPED, history::RedirectList(),
+  history->AddPage(existing_url, base::Time::Now(), scope, 0, GURL(),
+                   history::RedirectList(), content::PAGE_TRANSITION_TYPED,
                    history::SOURCE_BROWSED, false);
 
   // Make sure a segment was created.
   history->QuerySegmentUsageSince(
       &consumer_, Time::Now() - TimeDelta::FromDays(1), 10,
       base::Bind(&HistoryTest::OnSegmentUsageAvailable,
                  base::Unretained(this)));
 
   // Wait for processing.
   MessageLoop::current()->Run();
 
   ASSERT_EQ(1U, page_usage_data_.size());
   EXPECT_TRUE(page_usage_data_[0]->GetURL() == existing_url);
   EXPECT_DOUBLE_EQ(3.0, page_usage_data_[0]->GetScore());
 
   // Add a URL which doesn't create a segment.
   const GURL link_url("http://yahoo.com/");
-  history->AddPage(link_url, scope, 0, GURL(),
-                   content::PAGE_TRANSITION_LINK, history::RedirectList(),
+  history->AddPage(link_url, base::Time::Now(), scope, 0, GURL(),
+                   history::RedirectList(), content::PAGE_TRANSITION_LINK,
                    history::SOURCE_BROWSED, false);
 
   // Query again
   history->QuerySegmentUsageSince(
       &consumer_, Time::Now() - TimeDelta::FromDays(1), 10,
       base::Bind(&HistoryTest::OnSegmentUsageAvailable,
                  base::Unretained(this)));
 
   // Wait for processing.
   MessageLoop::current()->Run();
 
   // Make sure we still have one segment.
   ASSERT_EQ(1U, page_usage_data_.size());
   EXPECT_TRUE(page_usage_data_[0]->GetURL() == existing_url);
 
   // Add a page linked from existing_url.
-  history->AddPage(GURL("http://www.google.com/foo"), scope, 3, existing_url,
-                   content::PAGE_TRANSITION_LINK, history::RedirectList(),
-                   history::SOURCE_BROWSED, false);
+  history->AddPage(GURL("http://www.google.com/foo"), base::Time::Now(),
+                   scope, 3, existing_url, history::RedirectList(),
+                   content::PAGE_TRANSITION_LINK, history::SOURCE_BROWSED,
+                   false);
 
   // Query again
   history->QuerySegmentUsageSince(
       &consumer_, Time::Now() - TimeDelta::FromDays(1), 10,
       base::Bind(&HistoryTest::OnSegmentUsageAvailable,
                  base::Unretained(this)));
 
   // Wait for processing.
   MessageLoop::current()->Run();
 
@@ skipping 12 matching lines @@
 
   const GURL url0("http://www.google.com/url0/");
   const GURL url1("http://www.google.com/url1/");
   const GURL url2("http://www.google.com/url2/");
   const GURL url3("http://www.google.com/url3/");
   const GURL url4("http://www.google.com/url4/");
 
   static const void* scope = static_cast<void*>(this);
 
   // Add two pages.
-  history->AddPage(url0, scope, 0, GURL(),
-                   content::PAGE_TRANSITION_TYPED, history::RedirectList(),
+  history->AddPage(url0, base::Time::Now(), scope, 0, GURL(),
+                   history::RedirectList(), content::PAGE_TRANSITION_TYPED,
                    history::SOURCE_BROWSED, false);
-  history->AddPage(url1, scope, 0, GURL(),
-                   content::PAGE_TRANSITION_TYPED, history::RedirectList(),
+  history->AddPage(url1, base::Time::Now(), scope, 0, GURL(),
+                   history::RedirectList(), content::PAGE_TRANSITION_TYPED,
                    history::SOURCE_BROWSED, false);
   history->QueryMostVisitedURLs(20, 90, &consumer_,
                                 base::Bind(
                                     &HistoryTest::OnMostVisitedURLsAvailable,
                                     base::Unretained(this)));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(2U, most_visited_urls_.size());
   EXPECT_EQ(url0, most_visited_urls_[0].url);
   EXPECT_EQ(url1, most_visited_urls_[1].url);
 
   // Add another page.
-  history->AddPage(url2, scope, 0, GURL(),
-                   content::PAGE_TRANSITION_TYPED, history::RedirectList(),
+  history->AddPage(url2, base::Time::Now(), scope, 0, GURL(),
+                   history::RedirectList(), content::PAGE_TRANSITION_TYPED,
                    history::SOURCE_BROWSED, false);
   history->QueryMostVisitedURLs(20, 90, &consumer_,
                                 base::Bind(
                                     &HistoryTest::OnMostVisitedURLsAvailable,
                                     base::Unretained(this)));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(3U, most_visited_urls_.size());
   EXPECT_EQ(url0, most_visited_urls_[0].url);
   EXPECT_EQ(url1, most_visited_urls_[1].url);
   EXPECT_EQ(url2, most_visited_urls_[2].url);
 
   // Revisit url2, making it the top URL.
-  history->AddPage(url2, scope, 0, GURL(),
-                   content::PAGE_TRANSITION_TYPED, history::RedirectList(),
+  history->AddPage(url2, base::Time::Now(), scope, 0, GURL(),
+                   history::RedirectList(), content::PAGE_TRANSITION_TYPED,
                    history::SOURCE_BROWSED, false);
   history->QueryMostVisitedURLs(20, 90, &consumer_,
                                 base::Bind(
                                     &HistoryTest::OnMostVisitedURLsAvailable,
                                     base::Unretained(this)));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(3U, most_visited_urls_.size());
   EXPECT_EQ(url2, most_visited_urls_[0].url);
   EXPECT_EQ(url0, most_visited_urls_[1].url);
   EXPECT_EQ(url1, most_visited_urls_[2].url);
 
   // Revisit url1, making it the top URL.
-  history->AddPage(url1, scope, 0, GURL(),
-                   content::PAGE_TRANSITION_TYPED, history::RedirectList(),
+  history->AddPage(url1, base::Time::Now(), scope, 0, GURL(),
+                   history::RedirectList(), content::PAGE_TRANSITION_TYPED,
                    history::SOURCE_BROWSED, false);
   history->QueryMostVisitedURLs(20, 90, &consumer_,
                                 base::Bind(
                                     &HistoryTest::OnMostVisitedURLsAvailable,
                                     base::Unretained(this)));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(3U, most_visited_urls_.size());
   EXPECT_EQ(url1, most_visited_urls_[0].url);
   EXPECT_EQ(url2, most_visited_urls_[1].url);
   EXPECT_EQ(url0, most_visited_urls_[2].url);
 
   // Redirects
   history::RedirectList redirects;
   redirects.push_back(url3);
   redirects.push_back(url4);
 
   // Visit url4 using redirects.
-  history->AddPage(url4, scope, 0, GURL(),
-                   content::PAGE_TRANSITION_TYPED, redirects,
+  history->AddPage(url4, base::Time::Now(), scope, 0, GURL(),
+                   redirects, content::PAGE_TRANSITION_TYPED,
                    history::SOURCE_BROWSED, false);
   history->QueryMostVisitedURLs(20, 90, &consumer_,
                                 base::Bind(
                                     &HistoryTest::OnMostVisitedURLsAvailable,
                                     base::Unretained(this)));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(4U, most_visited_urls_.size());
   EXPECT_EQ(url1, most_visited_urls_[0].url);
   EXPECT_EQ(url2, most_visited_urls_[1].url);
@@ skipping 92 matching lines @@
   history_service_ = history;
   history->ScheduleDBTask(task.get(), &request_consumer);
   request_consumer.CancelAllRequests();
   CleanupHistoryService();
   // WARNING: history has now been deleted.
   history = NULL;
   ASSERT_FALSE(task->done_invoked);
 }
 
 }  // namespace history