Move PageTransition from //content/public/common to //ui/base

chrome/browser/history/history_backend_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.
 
 #include "chrome/browser/history/history_backend.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 214 matching lines @@
 }
 
 class HistoryBackendTest : public HistoryBackendTestBase {
  public:
   HistoryBackendTest() {}
   virtual ~HistoryBackendTest() {}
 
  protected:
   void AddRedirectChain(const char* sequence[], int page_id) {
     AddRedirectChainWithTransitionAndTime(sequence, page_id,
-                                          content::PAGE_TRANSITION_LINK,
+                                          ui::PAGE_TRANSITION_LINK,
                                           Time::Now());
   }
 
   void AddRedirectChainWithTransitionAndTime(
       const char* sequence[],
       int page_id,
-      content::PageTransition transition,
+      ui::PageTransition transition,
       base::Time time) {
     history::RedirectList redirects;
     for (int i = 0; sequence[i] != NULL; ++i)
       redirects.push_back(GURL(sequence[i]));
 
     ContextID context_id = reinterpret_cast<ContextID>(1);
     history::HistoryAddPageArgs request(
         redirects.back(), time, context_id, page_id, GURL(),
         redirects, transition, history::SOURCE_BROWSED,
         true);
@@ skipping 11 matching lines @@
                          base::Time time,
                          int* transition1, int* transition2) {
     ContextID dummy_context_id = reinterpret_cast<ContextID>(0x87654321);
     history::RedirectList redirects;
     if (url1.is_valid())
       redirects.push_back(url1);
     if (url2.is_valid())
       redirects.push_back(url2);
     HistoryAddPageArgs request(
         url2, time, dummy_context_id, 0, url1,
-        redirects, content::PAGE_TRANSITION_CLIENT_REDIRECT,
+        redirects, ui::PAGE_TRANSITION_CLIENT_REDIRECT,
         history::SOURCE_BROWSED, did_replace);
     backend_->AddPage(request);
 
     *transition1 = GetTransition(url1);
     *transition2 = GetTransition(url2);
   }
 
   int GetTransition(const GURL& url) {
     if (!url.is_valid())
       return 0;
@@ skipping 336 matching lines @@
 // Checks that adding a visit, then calling DeleteAll, and then trying to add
 // data for the visited page works.  This can happen when clearing the history
 // immediately after visiting a page.
 TEST_F(HistoryBackendTest, DeleteAllThenAddData) {
   ASSERT_TRUE(backend_.get());
 
   Time visit_time = Time::Now();
   GURL url("http://www.google.com/");
   HistoryAddPageArgs request(url, visit_time, NULL, 0, GURL(),
                              history::RedirectList(),
-                             content::PAGE_TRANSITION_KEYWORD_GENERATED,
+                             ui::PAGE_TRANSITION_KEYWORD_GENERATED,
                              history::SOURCE_BROWSED, false);
   backend_->AddPage(request);
 
   // Check that a row was added.
   URLRow outrow;
   EXPECT_TRUE(backend_->db_->GetRowForURL(url, &outrow));
 
   // Check that the visit was added.
   VisitVector all_visits;
   backend_->db_->GetAllVisitsInRange(Time(), Time(), 0, &all_visits);
@@ skipping 122 matching lines @@
 // Tests a handful of assertions for a navigation with a type of
 // KEYWORD_GENERATED.
 TEST_F(HistoryBackendTest, KeywordGenerated) {
   ASSERT_TRUE(backend_.get());
 
   GURL url("http://google.com");
 
   Time visit_time = Time::Now() - base::TimeDelta::FromDays(1);
   HistoryAddPageArgs request(url, visit_time, NULL, 0, GURL(),
                              history::RedirectList(),
-                             content::PAGE_TRANSITION_KEYWORD_GENERATED,
+                             ui::PAGE_TRANSITION_KEYWORD_GENERATED,
                              history::SOURCE_BROWSED, false);
   backend_->AddPage(request);
 
   // A row should have been added for the url.
   URLRow row;
   URLID url_id = backend_->db()->GetRowForURL(url, &row);
   ASSERT_NE(0, url_id);
 
   // The typed count should be 1.
   ASSERT_EQ(1, row.typed_count());
@@ skipping 31 matching lines @@
 TEST_F(HistoryBackendTest, ClientRedirect) {
   ASSERT_TRUE(backend_.get());
 
   int transition1;
   int transition2;
 
   // Initial transition to page A.
   GURL url_a("http://google.com/a");
   AddClientRedirect(GURL(), url_a, false, base::Time(),
                     &transition1, &transition2);
-  EXPECT_TRUE(transition2 & content::PAGE_TRANSITION_CHAIN_END);
+  EXPECT_TRUE(transition2 & ui::PAGE_TRANSITION_CHAIN_END);
 
   // User initiated redirect to page B.
   GURL url_b("http://google.com/b");
   AddClientRedirect(url_a, url_b, false, base::Time(),
                     &transition1, &transition2);
-  EXPECT_TRUE(transition1 & content::PAGE_TRANSITION_CHAIN_END);
-  EXPECT_TRUE(transition2 & content::PAGE_TRANSITION_CHAIN_END);
+  EXPECT_TRUE(transition1 & ui::PAGE_TRANSITION_CHAIN_END);
+  EXPECT_TRUE(transition2 & ui::PAGE_TRANSITION_CHAIN_END);
 
   // Non-user initiated redirect to page C.
   GURL url_c("http://google.com/c");
   AddClientRedirect(url_b, url_c, true, base::Time(),
                     &transition1, &transition2);
-  EXPECT_FALSE(transition1 & content::PAGE_TRANSITION_CHAIN_END);
-  EXPECT_TRUE(transition2 & content::PAGE_TRANSITION_CHAIN_END);
+  EXPECT_FALSE(transition1 & ui::PAGE_TRANSITION_CHAIN_END);
+  EXPECT_TRUE(transition2 & ui::PAGE_TRANSITION_CHAIN_END);
 }
 
 TEST_F(HistoryBackendTest, AddPagesWithDetails) {
   ASSERT_TRUE(backend_.get());
 
   // Import one non-typed URL, and two recent and one expired typed URLs.
   URLRow row1(GURL("https://news.google.com/"));
   row1.set_visit_count(1);
   row1.set_last_visit(Time::Now());
   URLRow row2(GURL("https://www.google.com/"));
@@ skipping 248 matching lines @@
   ASSERT_TRUE(backend_.get());
 
   GURL url("http://anyuser:anypass@www.google.com");
   GURL stripped_url("http://www.google.com");
 
   // Clear all history.
   backend_->DeleteAllHistory();
 
   // Visit the url with username, password.
   backend_->AddPageVisit(url, base::Time::Now(), 0,
-      content::PageTransitionFromInt(
-          content::PageTransitionGetQualifier(content::PAGE_TRANSITION_TYPED)),
+      ui::PageTransitionFromInt(
+          ui::PageTransitionGetQualifier(ui::PAGE_TRANSITION_TYPED)),
       history::SOURCE_BROWSED);
 
   // Fetch the row information about stripped url from history db.
   VisitVector visits;
   URLID row_id = backend_->db_->GetRowForURL(stripped_url, NULL);
   backend_->db_->GetVisitsForURL(row_id, &visits);
 
   // Check if stripped url is stored in database.
   ASSERT_EQ(1U, visits.size());
 }
 
 TEST_F(HistoryBackendTest, AddPageVisitSource) {
   ASSERT_TRUE(backend_.get());
 
   GURL url("http://www.google.com");
 
   // Clear all history.
   backend_->DeleteAllHistory();
 
   // Assume visiting the url from an externsion.
   backend_->AddPageVisit(
-      url, base::Time::Now(), 0, content::PAGE_TRANSITION_TYPED,
+      url, base::Time::Now(), 0, ui::PAGE_TRANSITION_TYPED,
       history::SOURCE_EXTENSION);
   // Assume the url is imported from Firefox.
   backend_->AddPageVisit(url, base::Time::Now(), 0,
-                         content::PAGE_TRANSITION_TYPED,
+                         ui::PAGE_TRANSITION_TYPED,
                          history::SOURCE_FIREFOX_IMPORTED);
   // Assume this url is also synced.
   backend_->AddPageVisit(url, base::Time::Now(), 0,
-                         content::PAGE_TRANSITION_TYPED,
+                         ui::PAGE_TRANSITION_TYPED,
                          history::SOURCE_SYNCED);
 
   // Fetch the row information about the url from history db.
   VisitVector visits;
   URLID row_id = backend_->db_->GetRowForURL(url, NULL);
   backend_->db_->GetVisitsForURL(row_id, &visits);
 
   // Check if all the visits to the url are stored in database.
   ASSERT_EQ(3U, visits.size());
   VisitSourceMap visit_sources;
@@ skipping 25 matching lines @@
   // Clear all history.
   backend_->DeleteAllHistory();
 
   // Create visit times
   base::Time recent_time = base::Time::Now();
   base::TimeDelta visit_age = base::TimeDelta::FromDays(3);
   base::Time older_time = recent_time - visit_age;
 
   // Visit the url with recent time.
   backend_->AddPageVisit(url, recent_time, 0,
-      content::PageTransitionFromInt(
-          content::PageTransitionGetQualifier(content::PAGE_TRANSITION_TYPED)),
+      ui::PageTransitionFromInt(
+          ui::PageTransitionGetQualifier(ui::PAGE_TRANSITION_TYPED)),
       history::SOURCE_BROWSED);
 
   // Add to the url a visit with older time (could be syncing from another
   // client, etc.).
   backend_->AddPageVisit(url, older_time, 0,
-      content::PageTransitionFromInt(
-          content::PageTransitionGetQualifier(content::PAGE_TRANSITION_TYPED)),
+      ui::PageTransitionFromInt(
+          ui::PageTransitionGetQualifier(ui::PAGE_TRANSITION_TYPED)),
       history::SOURCE_SYNCED);
 
   // Fetch the row information about url from history db.
   VisitVector visits;
   URLRow row;
   URLID row_id = backend_->db_->GetRowForURL(url, &row);
   backend_->db_->GetVisitsForURL(row_id, &visits);
 
   // Last visit time should be the most recent time, not the most recently added
   // visit.
   ASSERT_EQ(2U, visits.size());
   ASSERT_EQ(recent_time, row.last_visit());
 }
 
 TEST_F(HistoryBackendTest, AddPageVisitFiresNotificationWithCorrectDetails) {
   ASSERT_TRUE(backend_.get());
 
   GURL url1("http://www.google.com");
   GURL url2("http://maps.google.com");
 
   // Clear all history.
   backend_->DeleteAllHistory();
   ClearBroadcastedNotifications();
 
   // Visit two distinct URLs, the second one twice.
   backend_->AddPageVisit(url1, base::Time::Now(), 0,
-                         content::PAGE_TRANSITION_LINK,
+                         ui::PAGE_TRANSITION_LINK,
                          history::SOURCE_BROWSED);
   for (int i = 0; i < 2; ++i) {
     backend_->AddPageVisit(url2, base::Time::Now(), 0,
-                           content::PAGE_TRANSITION_TYPED,
+                           ui::PAGE_TRANSITION_TYPED,
                            history::SOURCE_BROWSED);
   }
 
   URLRow stored_row1, stored_row2;
   EXPECT_NE(0, backend_->db_->GetRowForURL(url1, &stored_row1));
   EXPECT_NE(0, backend_->db_->GetRowForURL(url2, &stored_row2));
 
   // Expect that NOTIFICATION_HISTORY_URLS_VISITED has been fired 3x, and that
   // each time, the URLRows have the correct URLs and IDs set.
   ASSERT_EQ(3, num_broadcasted_notifications());
   ASSERT_EQ(chrome::NOTIFICATION_HISTORY_URL_VISITED,
             broadcasted_notifications()[0].first);
   const URLVisitedDetails* details = static_cast<const URLVisitedDetails*>(
       broadcasted_notifications()[0].second);
-  EXPECT_EQ(content::PAGE_TRANSITION_LINK,
-            content::PageTransitionStripQualifier(details->transition));
+  EXPECT_EQ(ui::PAGE_TRANSITION_LINK,
+            ui::PageTransitionStripQualifier(details->transition));
   EXPECT_EQ(stored_row1.id(), details->row.id());
   EXPECT_EQ(stored_row1.url(), details->row.url());
 
   // No further checking, this case analogous to the first one.
   ASSERT_EQ(chrome::NOTIFICATION_HISTORY_URL_VISITED,
             broadcasted_notifications()[1].first);
 
   ASSERT_EQ(chrome::NOTIFICATION_HISTORY_URL_VISITED,
             broadcasted_notifications()[2].first);
   details = static_cast<const URLVisitedDetails*>(
       broadcasted_notifications()[2].second);
-  EXPECT_EQ(content::PAGE_TRANSITION_TYPED,
-            content::PageTransitionStripQualifier(details->transition));
+  EXPECT_EQ(ui::PAGE_TRANSITION_TYPED,
+            ui::PageTransitionStripQualifier(details->transition));
   EXPECT_EQ(stored_row2.id(), details->row.id());
   EXPECT_EQ(stored_row2.url(), details->row.url());
 }
 
 TEST_F(HistoryBackendTest, AddPageArgsSource) {
   ASSERT_TRUE(backend_.get());
 
   GURL url("http://testpageargs.com");
 
   // Assume this page is browsed by user.
   HistoryAddPageArgs request1(url, base::Time::Now(), NULL, 0, GURL(),
                              history::RedirectList(),
-                             content::PAGE_TRANSITION_KEYWORD_GENERATED,
+                             ui::PAGE_TRANSITION_KEYWORD_GENERATED,
                              history::SOURCE_BROWSED, false);
   backend_->AddPage(request1);
   // Assume this page is synced.
   HistoryAddPageArgs request2(url, base::Time::Now(), NULL, 0, GURL(),
                              history::RedirectList(),
-                             content::PAGE_TRANSITION_LINK,
+                             ui::PAGE_TRANSITION_LINK,
                              history::SOURCE_SYNCED, false);
   backend_->AddPage(request2);
   // Assume this page is browsed again.
   HistoryAddPageArgs request3(url, base::Time::Now(), NULL, 0, GURL(),
                              history::RedirectList(),
-                             content::PAGE_TRANSITION_TYPED,
+                             ui::PAGE_TRANSITION_TYPED,
                              history::SOURCE_BROWSED, false);
   backend_->AddPage(request3);
 
   // Three visits should be added with proper sources.
   VisitVector visits;
   URLRow row;
   URLID id = backend_->db()->GetRowForURL(url, &row);
   ASSERT_TRUE(backend_->db()->GetVisitsForURL(id, &visits));
   ASSERT_EQ(3U, visits.size());
   VisitSourceMap visit_sources;
   ASSERT_TRUE(backend_->GetVisitsSource(visits, &visit_sources));
   ASSERT_EQ(1U, visit_sources.size());
   EXPECT_EQ(history::SOURCE_SYNCED, visit_sources.begin()->second);
 }
 
 TEST_F(HistoryBackendTest, AddVisitsSource) {
   ASSERT_TRUE(backend_.get());
 
   GURL url1("http://www.cnn.com");
   std::vector<VisitInfo> visits1, visits2;
   visits1.push_back(VisitInfo(
       Time::Now() - base::TimeDelta::FromDays(5),
-      content::PAGE_TRANSITION_LINK));
+      ui::PAGE_TRANSITION_LINK));
   visits1.push_back(VisitInfo(
       Time::Now() - base::TimeDelta::FromDays(1),
-      content::PAGE_TRANSITION_LINK));
+      ui::PAGE_TRANSITION_LINK));
   visits1.push_back(VisitInfo(
-      Time::Now(), content::PAGE_TRANSITION_LINK));
+      Time::Now(), ui::PAGE_TRANSITION_LINK));
 
   GURL url2("http://www.example.com");
   visits2.push_back(VisitInfo(
       Time::Now() - base::TimeDelta::FromDays(10),
-      content::PAGE_TRANSITION_LINK));
-  visits2.push_back(VisitInfo(Time::Now(), content::PAGE_TRANSITION_LINK));
+      ui::PAGE_TRANSITION_LINK));
+  visits2.push_back(VisitInfo(Time::Now(), ui::PAGE_TRANSITION_LINK));
 
   // Clear all history.
   backend_->DeleteAllHistory();
 
   // Add the visits.
   backend_->AddVisits(url1, visits1, history::SOURCE_IE_IMPORTED);
   backend_->AddVisits(url2, visits2, history::SOURCE_SYNCED);
 
   // Verify the visits were added with their sources.
   VisitVector visits;
@@ skipping 15 matching lines @@
     EXPECT_EQ(history::SOURCE_SYNCED, visit_sources[visits[i].visit_id]);
 }
 
 TEST_F(HistoryBackendTest, GetMostRecentVisits) {
   ASSERT_TRUE(backend_.get());
 
   GURL url1("http://www.cnn.com");
   std::vector<VisitInfo> visits1;
   visits1.push_back(VisitInfo(
       Time::Now() - base::TimeDelta::FromDays(5),
-      content::PAGE_TRANSITION_LINK));
+      ui::PAGE_TRANSITION_LINK));
   visits1.push_back(VisitInfo(
       Time::Now() - base::TimeDelta::FromDays(1),
-      content::PAGE_TRANSITION_LINK));
+      ui::PAGE_TRANSITION_LINK));
   visits1.push_back(VisitInfo(
-      Time::Now(), content::PAGE_TRANSITION_LINK));
+      Time::Now(), ui::PAGE_TRANSITION_LINK));
 
   // Clear all history.
   backend_->DeleteAllHistory();
 
   // Add the visits.
   backend_->AddVisits(url1, visits1, history::SOURCE_IE_IMPORTED);
 
   // Verify the visits were added with their sources.
   VisitVector visits;
   URLRow row;
   URLID id = backend_->db()->GetRowForURL(url1, &row);
   ASSERT_TRUE(backend_->db()->GetMostRecentVisitsForURL(id, 1, &visits));
   ASSERT_EQ(1U, visits.size());
   EXPECT_EQ(visits1[2].first, visits[0].visit_time);
 }
 
 TEST_F(HistoryBackendTest, RemoveVisitsTransitions) {
   ASSERT_TRUE(backend_.get());
 
   // Clear all history.
   backend_->DeleteAllHistory();
 
   GURL url1("http://www.cnn.com");
   VisitInfo typed_visit(
       Time::Now() - base::TimeDelta::FromDays(6),
-      content::PAGE_TRANSITION_TYPED);
+      ui::PAGE_TRANSITION_TYPED);
   VisitInfo reload_visit(
       Time::Now() - base::TimeDelta::FromDays(5),
-      content::PAGE_TRANSITION_RELOAD);
+      ui::PAGE_TRANSITION_RELOAD);
   VisitInfo link_visit(
       Time::Now() - base::TimeDelta::FromDays(4),
-      content::PAGE_TRANSITION_LINK);
+      ui::PAGE_TRANSITION_LINK);
   std::vector<VisitInfo> visits_to_add;
   visits_to_add.push_back(typed_visit);
   visits_to_add.push_back(reload_visit);
   visits_to_add.push_back(link_visit);
 
   // Add the visits.
   backend_->AddVisits(url1, visits_to_add, history::SOURCE_SYNCED);
 
   // Verify that the various counts are what we expect.
   VisitVector visits;
@@ skipping 26 matching lines @@
   ASSERT_EQ(0, backend_->db()->GetRowForURL(url1, &row));
 }
 
 TEST_F(HistoryBackendTest, RemoveVisitsSource) {
   ASSERT_TRUE(backend_.get());
 
   GURL url1("http://www.cnn.com");
   std::vector<VisitInfo> visits1, visits2;
   visits1.push_back(VisitInfo(
       Time::Now() - base::TimeDelta::FromDays(5),
-      content::PAGE_TRANSITION_LINK));
+      ui::PAGE_TRANSITION_LINK));
   visits1.push_back(VisitInfo(Time::Now(),
-    content::PAGE_TRANSITION_LINK));
+    ui::PAGE_TRANSITION_LINK));
 
   GURL url2("http://www.example.com");
   visits2.push_back(VisitInfo(
       Time::Now() - base::TimeDelta::FromDays(10),
-      content::PAGE_TRANSITION_LINK));
-  visits2.push_back(VisitInfo(Time::Now(), content::PAGE_TRANSITION_LINK));
+      ui::PAGE_TRANSITION_LINK));
+  visits2.push_back(VisitInfo(Time::Now(), ui::PAGE_TRANSITION_LINK));
 
   // Clear all history.
   backend_->DeleteAllHistory();
 
   // Add the visits.
   backend_->AddVisits(url1, visits1, history::SOURCE_IE_IMPORTED);
   backend_->AddVisits(url2, visits2, history::SOURCE_SYNCED);
 
   // Verify the visits of url1 were added.
   VisitVector visits;
@@ skipping 1084 matching lines @@
 
   // Clear all history.
   backend_->DeleteAllHistory();
 
   Time tested_time = Time::Now().LocalMidnight() +
                      base::TimeDelta::FromHours(4);
   base::TimeDelta half_an_hour = base::TimeDelta::FromMinutes(30);
   base::TimeDelta one_hour = base::TimeDelta::FromHours(1);
   base::TimeDelta one_day = base::TimeDelta::FromDays(1);
 
-  const content::PageTransition kTypedTransition =
-      content::PAGE_TRANSITION_TYPED;
-  const content::PageTransition kKeywordGeneratedTransition =
-      content::PAGE_TRANSITION_KEYWORD_GENERATED;
+  const ui::PageTransition kTypedTransition =
+      ui::PAGE_TRANSITION_TYPED;
+  const ui::PageTransition kKeywordGeneratedTransition =
+      ui::PAGE_TRANSITION_KEYWORD_GENERATED;
 
   const char* redirect_sequence[2];
   redirect_sequence[1] = NULL;
 
   redirect_sequence[0] = google;
   AddRedirectChainWithTransitionAndTime(
       redirect_sequence, 0, kTypedTransition,
       tested_time - one_day - half_an_hour * 2);
   AddRedirectChainWithTransitionAndTime(
       redirect_sequence, 0,
@@ skipping 115 matching lines @@
 }
 
 TEST_F(HistoryBackendTest, UpdateVisitDuration) {
   // This unit test will test adding and deleting visit details information.
   ASSERT_TRUE(backend_.get());
 
   GURL url1("http://www.cnn.com");
   std::vector<VisitInfo> visit_info1, visit_info2;
   Time start_ts = Time::Now() - base::TimeDelta::FromDays(5);
   Time end_ts = start_ts + base::TimeDelta::FromDays(2);
-  visit_info1.push_back(VisitInfo(start_ts, content::PAGE_TRANSITION_LINK));
+  visit_info1.push_back(VisitInfo(start_ts, ui::PAGE_TRANSITION_LINK));
 
   GURL url2("http://www.example.com");
   visit_info2.push_back(VisitInfo(Time::Now() - base::TimeDelta::FromDays(10),
-                                  content::PAGE_TRANSITION_LINK));
+                                  ui::PAGE_TRANSITION_LINK));
 
   // Clear all history.
   backend_->DeleteAllHistory();
 
   // Add the visits.
   backend_->AddVisits(url1, visit_info1, history::SOURCE_BROWSED);
   backend_->AddVisits(url2, visit_info2, history::SOURCE_BROWSED);
 
   // Verify the entries for both visits were added in visit_details.
   VisitVector visits1, visits2;
@@ skipping 265 matching lines @@
   // Add a URL.
   GURL url("http://www.google.com");
   HistoryClientMock history_client;
   history_client.AddBookmark(url);
   scoped_ptr<HistoryService> service(
       new HistoryService(&history_client, profile.get()));
   EXPECT_TRUE(service->Init(profile->GetPath()));
 
   service->AddPage(
       url, base::Time::Now(), NULL, 1, GURL(), RedirectList(),
-      content::PAGE_TRANSITION_TYPED, SOURCE_BROWSED, false);
+      ui::PAGE_TRANSITION_TYPED, SOURCE_BROWSED, false);
 
   // This won't actually delete the URL, rather it'll empty out the visits.
   // This triggers blocking on the BookmarkModel.
   EXPECT_CALL(history_client, BlockUntilBookmarksLoaded());
   service->DeleteURL(url);
 }
 
 // Test DeleteFTSIndexDatabases deletes expected files.
 TEST_F(HistoryBackendTest, DeleteFTSIndexDatabases) {
   ASSERT_TRUE(backend_.get());
@@ skipping 229 matching lines @@
   // Verify that the second term is no longer returned as result, and also check
   // at the low level that it is gone for good. The term corresponding to the
   // first URLRow should not be affected.
   EXPECT_EQ(1u, GetNumberOfMatchingSearchTerms(kTestKeywordId, term1));
   EXPECT_EQ(0u, GetNumberOfMatchingSearchTerms(kTestKeywordId, term2));
   EXPECT_TRUE(mem_backend_->db()->GetKeywordSearchTermRow(row1.id(), NULL));
   EXPECT_FALSE(mem_backend_->db()->GetKeywordSearchTermRow(row2.id(), NULL));
 }
 
 }  // namespace history