Added last_modified field to TemplateURL and database. Updated unit tests, including refactoring ...

chrome/browser/search_engines/template_url_service_unittest.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 "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
+#include "base/mock_time_provider.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/threading/thread.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/history/history_notifications.h"
 #include "chrome/browser/search_engines/search_host_to_urls_map.h"
 #include "chrome/browser/search_engines/search_terms_data.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_test_util.h"
 #include "chrome/browser/search_engines/template_url_prepopulate_data.h"
 #include "chrome/browser/webdata/web_database.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/testing_pref_service.h"
 #include "chrome/test/testing_profile.h"
 #include "content/browser/browser_thread.h"
 #include "content/common/notification_details.h"
 #include "content/common/notification_source.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
 using base::TimeDelta;
+using ::testing::Return;
+using ::testing::StrictMock;
 
 // Test the GenerateSearchURL on a thread or the main thread.
 class TestGenerateSearchURL
     : public base::RefCountedThreadSafe<TestGenerateSearchURL> {
  public:
   explicit TestGenerateSearchURL(SearchTermsData* search_terms_data)
       : search_terms_data_(search_terms_data),
         passed_(false) {
   }
 
@@ skipping 45 matching lines @@
 // current data. The caller owns the returned TemplateURL*.
 static TemplateURL* CreatePreloadedTemplateURL() {
   TemplateURL* t_url = new TemplateURL();
   t_url->SetURL("http://www.unittest.com/", 0, 0);
   t_url->set_keyword(ASCIIToUTF16("unittest"));
   t_url->set_short_name(ASCIIToUTF16("unittest"));
   t_url->set_safe_for_autoreplace(true);
   GURL favicon_url("http://favicon.url");
   t_url->SetFaviconURL(favicon_url);
   t_url->set_date_created(Time::FromTimeT(100));
+  t_url->set_last_modified(Time::FromTimeT(100));
   t_url->set_prepopulate_id(999999);
   return t_url;
 }
 
 class TemplateURLServiceTest : public testing::Test {
  public:
   TemplateURLServiceTest() {}
 
   virtual void SetUp() {
     test_util_.SetUp();
   }
 
   virtual void TearDown() {
     test_util_.TearDown();
   }
 
   TemplateURL* AddKeywordWithDate(const std::string& keyword,
                                   bool autogenerate_keyword,
                                   const std::string& url,
                                   const std::string& suggest_url,
                                   const std::string& favicon_url,
                                   const std::string& encodings,
                                   const std::string& short_name,
                                   bool safe_for_autoreplace,
-                                  Time created_date) {
+                                  Time created_date,
+                                  Time last_modified) {
     TemplateURL* template_url = new TemplateURL();
     template_url->SetURL(url, 0, 0);
     template_url->SetSuggestionsURL(suggest_url, 0, 0);
     template_url->SetFaviconURL(GURL(favicon_url));
     template_url->set_keyword(UTF8ToUTF16(keyword));
     template_url->set_autogenerate_keyword(autogenerate_keyword);
     template_url->set_short_name(UTF8ToUTF16(short_name));
     std::vector<std::string> encodings_vector;
     base::SplitString(encodings, ';', &encodings_vector);
     template_url->set_input_encodings(encodings_vector);
     template_url->set_date_created(created_date);
+    template_url->set_last_modified(last_modified);
     template_url->set_safe_for_autoreplace(safe_for_autoreplace);
     model()->Add(template_url);
     EXPECT_NE(0, template_url->id());
     return template_url;
   }
 
   // Simulate firing by the prefs service specifying that the managed
   // preferences have changed.
   void NotifyManagedPrefsHaveChanged() {
     model()->Observe(
         NotificationType::PREF_CHANGED,
         Source<PrefService>(profile()->GetTestingPrefService()),
         Details<std::string>(NULL));
   }
 
   // Verifies the two TemplateURLs are equal.
   void AssertEquals(const TemplateURL& expected, const TemplateURL& actual) {
     ASSERT_TRUE(TemplateURLRef::SameUrlRefs(expected.url(), actual.url()));
     ASSERT_TRUE(TemplateURLRef::SameUrlRefs(expected.suggestions_url(),
                                             actual.suggestions_url()));
     ASSERT_EQ(expected.keyword(), actual.keyword());
     ASSERT_EQ(expected.short_name(), actual.short_name());
     ASSERT_EQ(JoinString(expected.input_encodings(), ';'),
               JoinString(actual.input_encodings(), ';'));
     ASSERT_TRUE(expected.GetFaviconURL() == actual.GetFaviconURL());
     ASSERT_EQ(expected.id(), actual.id());
     ASSERT_EQ(expected.safe_for_autoreplace(), actual.safe_for_autoreplace());
     ASSERT_EQ(expected.show_in_default_list(), actual.show_in_default_list());
     ASSERT_TRUE(expected.date_created() == actual.date_created());
+    ASSERT_TRUE(expected.last_modified() == actual.last_modified());
   }
 
-  // Checks that the two TemplateURLs are similar. It does not check the id
-  // and the date_created.  Neither pointer should be NULL.
+  // Checks that the two TemplateURLs are similar. It does not check the id, the
+  // date_created or the last_modified time.  Neither pointer should be NULL.
   void ExpectSimilar(const TemplateURL* expected, const TemplateURL* actual) {
     ASSERT_TRUE(expected != NULL);
     ASSERT_TRUE(actual != NULL);
     EXPECT_TRUE(TemplateURLRef::SameUrlRefs(expected->url(), actual->url()));
     EXPECT_TRUE(TemplateURLRef::SameUrlRefs(expected->suggestions_url(),
                                             actual->suggestions_url()));
     EXPECT_EQ(expected->keyword(), actual->keyword());
     EXPECT_EQ(expected->short_name(), actual->short_name());
     EXPECT_EQ(JoinString(expected->input_encodings(), ';'),
               JoinString(actual->input_encodings(), ';'));
@@ skipping 205 matching lines @@
   VerifyLoad();
   const size_t initial_count = model()->GetTemplateURLs().size();
 
   TemplateURL* t_url = new TemplateURL();
   t_url->SetURL("http://www.google.com/foo/bar", 0, 0);
   t_url->set_keyword(ASCIIToUTF16("keyword"));
   t_url->set_short_name(ASCIIToUTF16("google"));
   GURL favicon_url("http://favicon.url");
   t_url->SetFaviconURL(favicon_url);
   t_url->set_date_created(Time::FromTimeT(100));
+  t_url->set_last_modified(Time::FromTimeT(100));
   t_url->set_safe_for_autoreplace(true);
   model()->Add(t_url);
   ASSERT_TRUE(model()->CanReplaceKeyword(ASCIIToUTF16("keyword"),
                                          GURL(), NULL));
   VerifyObserverCount(1);
   BlockTillServiceProcessesRequests();
   // We need to clone as model takes ownership of TemplateURL and will
   // delete it.
   TemplateURL cloned_url(*t_url);
   ASSERT_EQ(1 + initial_count, model()->GetTemplateURLs().size());
   ASSERT_TRUE(model()->GetTemplateURLForKeyword(t_url->keyword()) == t_url);
   ASSERT_TRUE(t_url->date_created() == cloned_url.date_created());
 
   // Reload the model to verify it was actually saved to the database.
   ResetModel(true);
   ASSERT_EQ(1 + initial_count, model()->GetTemplateURLs().size());
   const TemplateURL* loaded_url =
       model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword"));
   ASSERT_TRUE(loaded_url != NULL);
   AssertEquals(cloned_url, *loaded_url);
   ASSERT_TRUE(model()->CanReplaceKeyword(ASCIIToUTF16("keyword"),
                                          GURL(), NULL));
 
+  // We expect the last_modified time to be updated to the present time on an
+  // explicit reset. We have to set up the expectation here because ResetModel
+  // resets the TimeProvider in the TemplateURLService.
+  StrictMock<base::MockTimeProvider> mock_time;
+  model()->InstallTimeProvider(&base::MockTimeProvider::StaticNow);
+  EXPECT_CALL(mock_time, Now())
+      .WillOnce(Return(base::Time::FromDoubleT(1337)));
+
   // Mutate an element and verify it succeeded.
   model()->ResetTemplateURL(loaded_url, ASCIIToUTF16("a"),
                             ASCIIToUTF16("b"), "c");
   ASSERT_EQ(ASCIIToUTF16("a"), loaded_url->short_name());
   ASSERT_EQ(ASCIIToUTF16("b"), loaded_url->keyword());
   ASSERT_EQ("c", loaded_url->url()->url());
   ASSERT_FALSE(loaded_url->safe_for_autoreplace());
   ASSERT_TRUE(model()->CanReplaceKeyword(ASCIIToUTF16("keyword"),
                                          GURL(), NULL));
   ASSERT_FALSE(model()->CanReplaceKeyword(ASCIIToUTF16("b"), GURL(), NULL));
   cloned_url = *loaded_url;
   BlockTillServiceProcessesRequests();
   ResetModel(true);
   ASSERT_EQ(1 + initial_count, model()->GetTemplateURLs().size());
   loaded_url = model()->GetTemplateURLForKeyword(ASCIIToUTF16("b"));
   ASSERT_TRUE(loaded_url != NULL);
   AssertEquals(cloned_url, *loaded_url);
+  // We changed a TemplateURL in the service, so ensure that the time was
+  // updated.
+  ASSERT_EQ(loaded_url->last_modified(), base::Time::FromDoubleT(1337));
 
   // Remove an element and verify it succeeded.
   model()->Remove(loaded_url);
   VerifyObserverCount(1);
   ResetModel(true);
   ASSERT_EQ(initial_count, model()->GetTemplateURLs().size());
   EXPECT_TRUE(model()->GetTemplateURLForKeyword(ASCIIToUTF16("b")) == NULL);
+
+  model()->UninstallTimeProvider();
 }
 
 TEST_F(TemplateURLServiceTest, GenerateKeyword) {
   ASSERT_EQ(string16(), TemplateURLService::GenerateKeyword(GURL(), true));
   // Shouldn't generate keywords for https.
   ASSERT_EQ(string16(),
             TemplateURLService::GenerateKeyword(GURL("https://blah"), true));
   ASSERT_EQ(ASCIIToUTF16("foo"),
             TemplateURLService::GenerateKeyword(GURL("http://foo"), true));
   // www. should be stripped.
@@ skipping 38 matching lines @@
 TEST_F(TemplateURLServiceTest, ClearBrowsingData_Keywords) {
   Time now = Time::Now();
   TimeDelta one_day = TimeDelta::FromDays(1);
   Time month_ago = now - TimeDelta::FromDays(30);
 
   // Nothing has been added.
   EXPECT_EQ(0U, model()->GetTemplateURLs().size());
 
   // Create one with a 0 time.
   AddKeywordWithDate("key1", false, "http://foo1", "http://suggest1",
-                     "http://icon1", "UTF-8;UTF-16", "name1", true, Time());
+                     "http://icon1", "UTF-8;UTF-16", "name1", true, Time(),
+                     Time());
   // Create one for now and +/- 1 day.
   AddKeywordWithDate("key2", false, "http://foo2", "http://suggest2",
                      "http://icon2", "UTF-8;UTF-16", "name2", true,
-                     now - one_day);
+                     now - one_day, Time());
   AddKeywordWithDate("key3", false, "http://foo3", "", "", "", "name3",
-                     true, now);
+                     true, now, Time());
   AddKeywordWithDate("key4", false, "http://foo4", "", "", "", "name4",
-                     true, now + one_day);
+                     true, now + one_day, Time());
   // Try the other three states.
   AddKeywordWithDate("key5", false, "http://foo5", "http://suggest5",
-                     "http://icon5", "UTF-8;UTF-16", "name5", false, now);
+                     "http://icon5", "UTF-8;UTF-16", "name5", false, now,
+                     Time());
   AddKeywordWithDate("key6", false, "http://foo6", "http://suggest6",
                      "http://icon6", "UTF-8;UTF-16", "name6", false,
-                     month_ago);
+                     month_ago, Time());
 
   // We just added a few items, validate them.
   EXPECT_EQ(6U, model()->GetTemplateURLs().size());
 
   // Try removing from current timestamp. This should delete the one in the
   // future and one very recent one.
   model()->RemoveAutoGeneratedSince(now);
   EXPECT_EQ(4U, model()->GetTemplateURLs().size());
 
   // Try removing from two months ago. This should only delete items that are
@@ skipping 26 matching lines @@
   // Add a new TemplateURL.
   VerifyLoad();
   const size_t initial_count = model()->GetTemplateURLs().size();
   TemplateURL* t_url = new TemplateURL();
   t_url->SetURL("http://www.google.com/foo/bar", 0, 0);
   t_url->set_keyword(ASCIIToUTF16("keyword"));
   t_url->set_short_name(ASCIIToUTF16("google"));
   GURL favicon_url("http://favicon.url");
   t_url->SetFaviconURL(favicon_url);
   t_url->set_date_created(Time::FromTimeT(100));
+  t_url->set_last_modified(Time::FromTimeT(100));
   model()->Add(t_url);
 
   VerifyObserverCount(1);
   BlockTillServiceProcessesRequests();
 
+  StrictMock<base::MockTimeProvider> mock_time;
+  model()->InstallTimeProvider(&base::MockTimeProvider::StaticNow);
+  EXPECT_CALL(mock_time, Now())
+      .WillOnce(Return(base::Time::FromDoubleT(1337)));
+
   // Reset the short name, keyword, url and make sure it takes.
   const string16 new_short_name(ASCIIToUTF16("a"));
   const string16 new_keyword(ASCIIToUTF16("b"));
   const std::string new_url("c");
   model()->ResetTemplateURL(t_url, new_short_name, new_keyword, new_url);
   ASSERT_EQ(new_short_name, t_url->short_name());
   ASSERT_EQ(new_keyword, t_url->keyword());
   ASSERT_EQ(new_url, t_url->url()->url());
 
   // Make sure the mappings in the model were updated.
   ASSERT_TRUE(model()->GetTemplateURLForKeyword(new_keyword) == t_url);
   ASSERT_TRUE(
       model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword")) == NULL);
 
   TemplateURL last_url = *t_url;
 
   // Reload the model from the database and make sure the change took.
   ResetModel(true);
   t_url = NULL;
   EXPECT_EQ(initial_count + 1, model()->GetTemplateURLs().size());
   const TemplateURL* read_url = model()->GetTemplateURLForKeyword(new_keyword);
   ASSERT_TRUE(read_url);
   AssertEquals(last_url, *read_url);
+  ASSERT_EQ(read_url->last_modified(), base::Time::FromDoubleT(1337));
+
+  model()->UninstallTimeProvider();
 }
 
 TEST_F(TemplateURLServiceTest, DefaultSearchProvider) {
   // Add a new TemplateURL.
   VerifyLoad();
   const size_t initial_count = model()->GetTemplateURLs().size();
   TemplateURL* t_url = AddKeywordWithDate("key1", false, "http://foo1",
-      "http://sugg1", "http://icon1", "UTF-8;UTF-16", "name1", true, Time());
+      "http://sugg1", "http://icon1", "UTF-8;UTF-16", "name1", true, Time(),
+      Time());
 
   test_util_.ResetObserverCount();
   model()->SetDefaultSearchProvider(t_url);
 
   ASSERT_EQ(t_url, model()->GetDefaultSearchProvider());
 
   ASSERT_TRUE(t_url->safe_for_autoreplace());
   ASSERT_TRUE(t_url->show_in_default_list());
 
   // Setting the default search provider should have caused notification.
@@ skipping 11 matching lines @@
   ASSERT_TRUE(model()->GetDefaultSearchProvider());
   AssertEquals(cloned_url, *model()->GetDefaultSearchProvider());
 }
 
 TEST_F(TemplateURLServiceTest, TemplateURLWithNoKeyword) {
   VerifyLoad();
 
   const size_t initial_count = model()->GetTemplateURLs().size();
 
   AddKeywordWithDate("", false, "http://foo1", "http://sugg1",
-      "http://icon1", "UTF-8;UTF-16", "name1", true, Time());
+      "http://icon1", "UTF-8;UTF-16", "name1", true, Time(), Time());
 
   // We just added a few items, validate them.
   ASSERT_EQ(initial_count + 1, model()->GetTemplateURLs().size());
 
   // Reload the model from the database and make sure we get the url back.
   ResetModel(true);
 
   ASSERT_EQ(1 + initial_count, model()->GetTemplateURLs().size());
 
   bool found_keyword = false;
   for (size_t i = 0; i < initial_count + 1; ++i) {
     if (model()->GetTemplateURLs()[i]->keyword().empty()) {
       found_keyword = true;
       break;
     }
   }
   ASSERT_TRUE(found_keyword);
 }
 
 TEST_F(TemplateURLServiceTest, CantReplaceWithSameKeyword) {
   ChangeModelToLoadState();
   ASSERT_TRUE(model()->CanReplaceKeyword(ASCIIToUTF16("foo"), GURL(), NULL));
   TemplateURL* t_url = AddKeywordWithDate("foo", false, "http://foo1",
-      "http://sugg1", "http://icon1", "UTF-8;UTF-16",  "name1", true, Time());
+      "http://sugg1", "http://icon1", "UTF-8;UTF-16",  "name1", true, Time(),
+      Time());
 
   // Can still replace, newly added template url is marked safe to replace.
   ASSERT_TRUE(model()->CanReplaceKeyword(ASCIIToUTF16("foo"),
                                          GURL("http://foo2"), NULL));
 
   // ResetTemplateURL marks the TemplateURL as unsafe to replace, so it should
   // no longer be replaceable.
   model()->ResetTemplateURL(t_url, t_url->short_name(), t_url->keyword(),
-                           t_url->url()->url());
+                            t_url->url()->url());
 
   ASSERT_FALSE(model()->CanReplaceKeyword(ASCIIToUTF16("foo"),
                                           GURL("http://foo2"), NULL));
 }
 
 TEST_F(TemplateURLServiceTest, CantReplaceWithSameHosts) {
   ChangeModelToLoadState();
   ASSERT_TRUE(model()->CanReplaceKeyword(ASCIIToUTF16("foo"),
                                          GURL("http://foo.com"), NULL));
   TemplateURL* t_url = AddKeywordWithDate("foo", false, "http://foo.com",
-      "http://sugg1", "http://icon1", "UTF-8;UTF-16",  "name1", true, Time());
+      "http://sugg1", "http://icon1", "UTF-8;UTF-16",  "name1", true, Time(),
+      Time());
 
   // Can still replace, newly added template url is marked safe to replace.
   ASSERT_TRUE(model()->CanReplaceKeyword(ASCIIToUTF16("bar"),
                                          GURL("http://foo.com"), NULL));
 
   // ResetTemplateURL marks the TemplateURL as unsafe to replace, so it should
   // no longer be replaceable.
   model()->ResetTemplateURL(t_url, t_url->short_name(), t_url->keyword(),
-                           t_url->url()->url());
+                            t_url->url()->url());
 
   ASSERT_FALSE(model()->CanReplaceKeyword(ASCIIToUTF16("bar"),
                                           GURL("http://foo.com"), NULL));
 }
 
 TEST_F(TemplateURLServiceTest, HasDefaultSearchProvider) {
   // We should have a default search provider even if we haven't loaded.
   ASSERT_TRUE(model()->GetDefaultSearchProvider());
 
   // Now force the model to load and make sure we still have a default.
   VerifyLoad();
 
   ASSERT_TRUE(model()->GetDefaultSearchProvider());
 }
 
 TEST_F(TemplateURLServiceTest, DefaultSearchProviderLoadedFromPrefs) {
   VerifyLoad();
 
   TemplateURL* template_url = new TemplateURL();
   template_url->SetURL("http://url", 0, 0);
   template_url->SetSuggestionsURL("http://url2", 0, 0);
   template_url->SetInstantURL("http://instant", 0, 0);
   template_url->set_short_name(ASCIIToUTF16("a"));
   template_url->set_safe_for_autoreplace(true);
   template_url->set_date_created(Time::FromTimeT(100));
+  template_url->set_last_modified(Time::FromTimeT(100));
 
   model()->Add(template_url);
 
   const TemplateURLID id = template_url->id();
 
   model()->SetDefaultSearchProvider(template_url);
 
   BlockTillServiceProcessesRequests();
 
   TemplateURL first_default_search_provider = *template_url;
@@ skipping 80 matching lines @@
     { "http://foo/foo?q=xx", string16() },
     { "http://x/bar?q=xx", string16() },
     { "http://x/foo?y=xx", string16() },
     { "http://x/foo?q=xx", ASCIIToUTF16("xx") },
     { "http://x/foo?a=b&q=xx", ASCIIToUTF16("xx") },
     { "http://x/foo?q=b&q=xx", string16() },
   };
 
   ChangeModelToLoadState();
   AddKeywordWithDate("x", false, "http://x/foo?q={searchTerms}",
-      "http://sugg1", "http://icon1", "UTF-8;UTF-16", "name", false, Time());
+      "http://sugg1", "http://icon1", "UTF-8;UTF-16", "name", false, Time(),
+      Time());
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) {
     history::URLVisitedDetails details;
     details.row = history::URLRow(GURL(data[i].url));
     details.transition = 0;
     model()->UpdateKeywordSearchTermsForURL(details);
     EXPECT_EQ(data[i].term, GetAndClearSearchTerm());
   }
 }
 
 TEST_F(TemplateURLServiceTest, DontUpdateKeywordSearchForNonReplaceable) {
   struct TestData {
     const std::string url;
   } data[] = {
     { "http://foo/" },
     { "http://x/bar?q=xx" },
     { "http://x/foo?y=xx" },
   };
 
   ChangeModelToLoadState();
   AddKeywordWithDate("x", false, "http://x/foo", "http://sugg1",
-      "http://icon1", "UTF-8;UTF-16", "name", false, Time());
+      "http://icon1", "UTF-8;UTF-16", "name", false, Time(), Time());
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) {
     history::URLVisitedDetails details;
     details.row = history::URLRow(GURL(data[i].url));
     details.transition = 0;
     model()->UpdateKeywordSearchTermsForURL(details);
     ASSERT_EQ(string16(), GetAndClearSearchTerm());
   }
 }
 
 TEST_F(TemplateURLServiceTest, ChangeGoogleBaseValue) {
   // NOTE: Do not do a VerifyLoad() here as it will load the prepopulate data,
   // which also has a {google:baseURL} keyword in it, which will confuse this
   // test.
   ChangeModelToLoadState();
   SetGoogleBaseURL("http://google.com/");
   const TemplateURL* t_url = AddKeywordWithDate("", true,
       "{google:baseURL}?q={searchTerms}", "http://sugg1", "http://icon1",
-      "UTF-8;UTF-16", "name", false, Time());
+      "UTF-8;UTF-16", "name", false, Time(), Time());
   ASSERT_EQ(t_url, model()->GetTemplateURLForHost("google.com"));
   EXPECT_EQ("google.com", t_url->url()->GetHost());
   EXPECT_EQ(ASCIIToUTF16("google.com"), t_url->keyword());
 
   // Change the Google base url.
   test_util_.ResetObserverCount();
   SetGoogleBaseURL("http://foo.com/");
   VerifyObserverCount(1);
 
   // Make sure the host->TemplateURL map was updated appropriately.
@@ skipping 26 matching lines @@
 // Make sure TemplateURLService generates a KEYWORD_GENERATED visit for
 // KEYWORD visits.
 TEST_F(TemplateURLServiceTest, GenerateVisitOnKeyword) {
   VerifyLoad();
   profile()->CreateHistoryService(true, false);
 
   // Create a keyword.
   TemplateURL* t_url = AddKeywordWithDate(
       "keyword", false, "http://foo.com/foo?query={searchTerms}",
       "http://sugg1", "http://icon1", "UTF-8;UTF-16", "keyword",
-      true, base::Time::Now());
+      true, base::Time::Now(), base::Time::Now());
 
   // Add a visit that matches the url of the keyword.
   HistoryService* history =
       profile()->GetHistoryService(Profile::EXPLICIT_ACCESS);
   history->AddPage(
       GURL(t_url->url()->ReplaceSearchTerms(*t_url, ASCIIToUTF16("blah"), 0,
                                             string16())),
       NULL, 0, GURL(), PageTransition::KEYWORD, history::RedirectList(),
       history::SOURCE_BROWSED, false);
 
@@ skipping 194 matching lines @@
 // the default search as managed.  Also check that we are getting the right
 // values.
 TEST_F(TemplateURLServiceTest, TestManagedDefaultSearch) {
   VerifyLoad();
   const size_t initial_count = model()->GetTemplateURLs().size();
   test_util_.ResetObserverCount();
 
   // Set a regular default search provider.
   TemplateURL* regular_default = AddKeywordWithDate("key1", false,
       "http://foo1", "http://sugg1", "http://icon1", "UTF-8;UTF-16", "name1",
-      true, Time());
+      true, Time(), Time());
   VerifyObserverCount(1);
   model()->SetDefaultSearchProvider(regular_default);
   // Adding the URL and setting the default search provider should have caused
   // notifications.
   VerifyObserverCount(1);
   EXPECT_FALSE(model()->is_default_search_managed());
   EXPECT_EQ(1 + initial_count, model()->GetTemplateURLs().size());
 
   // Set a managed preference that establishes a default search provider.
   const char kName[] = "test1";
@@ skipping 73 matching lines @@
   EXPECT_EQ(actual_managed_default->show_in_default_list(), true);
 
   // Clear the model and disable the default search provider through policy.
   // Verify that there is no default search provider after loading the model.
   // This checks against regressions of http://crbug.com/67180
 
   // First, remove the preferences, reset the model, and set a default.
   RemoveManagedDefaultSearchPreferences();
   ResetModel(true);
   TemplateURL* t_url = AddKeywordWithDate("key1", false, "http://foo1",
-      "http://sugg1", "http://icon1", "UTF-8;UTF-16", "name1", true, Time());
+      "http://sugg1", "http://icon1", "UTF-8;UTF-16", "name1", true, Time(),
+      Time());
   model()->SetDefaultSearchProvider(t_url);
   EXPECT_EQ(t_url, model()->GetDefaultSearchProvider());
 
   // Now reset the model again but load it after setting the preferences.
   ResetModel(false);
   SetManagedDefaultSearchPreferences(false, "", "", "", "", "", "");
   VerifyLoad();
   EXPECT_TRUE(model()->is_default_search_managed());
   EXPECT_TRUE(model()->GetDefaultSearchProvider() == NULL);
 }