Move InMemoryURLIndex outside of history namespace

chrome/browser/autocomplete/in_memory_url_index_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 <algorithm>
 #include <fstream>
 
 #include "base/auto_reset.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 26 matching lines @@
 // a database file created from a text file('url_history_provider_test.db.txt').
 // The only difference between this table and a live 'urls' table from a
 // profile is that the last_visit_time column in the test table contains a
 // number specifying the number of days relative to 'today' to which the
 // absolute time should be set during the test setup stage.
 //
 // The format of the test database text file is of a SQLite .dump file.
 // Note that only lines whose first character is an upper-case letter are
 // processed when creating the test database.
 
-namespace history {
 namespace {
 const size_t kMaxMatches = 3;
 const char kTestLanguages[] = "en,ja,hi,zh";
 }  // namespace
 
 // -----------------------------------------------------------------------------
 
 // Observer class so the unit tests can wait while the cache is being saved.
 class CacheFileSaverObserver : public InMemoryURLIndex::SaveCacheObserver {
  public:
@@ skipping 55 matching lines @@
   base::CancelableTaskTracker* GetPrivateDataTracker() const;
   void ClearPrivateData();
   void set_history_dir(const base::FilePath& dir_path);
   bool GetCacheFilePath(base::FilePath* file_path) const;
   void PostRestoreFromCacheFileTask();
   void PostSaveToCacheFileTask();
   const std::set<std::string>& scheme_whitelist();
 
 
   // Pass-through functions to simplify our friendship with URLIndexPrivateData.
-  bool UpdateURL(const URLRow& row);
+  bool UpdateURL(const history::URLRow& row);
   bool DeleteURL(const GURL& url);
 
   // Data verification helper functions.
   void ExpectPrivateDataNotEmpty(const URLIndexPrivateData& data);
   void ExpectPrivateDataEmpty(const URLIndexPrivateData& data);
   void ExpectPrivateDataEqual(const URLIndexPrivateData& expected,
                               const URLIndexPrivateData& actual);
 
   ScoredHistoryMatchBuilderImpl builder_;
   content::TestBrowserThreadBundle thread_bundle_;
   scoped_ptr<InMemoryURLIndex> url_index_;
   TestingProfile profile_;
   HistoryService* history_service_;
-  HistoryDatabase* history_database_;
+  history::HistoryDatabase* history_database_;
 };
 
 InMemoryURLIndexTest::InMemoryURLIndexTest()
     : builder_(ScoredHistoryMatchBuilderImpl::IsBookmarkedCallback()),
       history_service_(nullptr),
       history_database_(nullptr) {
 }
 
 sql::Connection& InMemoryURLIndexTest::GetDB() {
   return history_database_->GetDB();
@@ skipping 28 matching lines @@
 }
 
 void InMemoryURLIndexTest::PostSaveToCacheFileTask() {
   url_index_->PostSaveToCacheFileTask();
 }
 
 const std::set<std::string>& InMemoryURLIndexTest::scheme_whitelist() {
   return url_index_->scheme_whitelist();
 }
 
-bool InMemoryURLIndexTest::UpdateURL(const URLRow& row) {
+bool InMemoryURLIndexTest::UpdateURL(const history::URLRow& row) {
   return GetPrivateData()->UpdateURL(history_service_,
                                      row,
                                      url_index_->languages_,
                                      url_index_->scheme_whitelist_,
                                      GetPrivateDataTracker());
 }
 
 bool InMemoryURLIndexTest::DeleteURL(const GURL& url) {
   return GetPrivateData()->DeleteURL(url);
 }
 
 void InMemoryURLIndexTest::SetUp() {
   // We cannot access the database until the backend has been loaded.
   ASSERT_TRUE(profile_.CreateHistoryService(true, false));
   profile_.CreateBookmarkModel(true);
   bookmarks::test::WaitForBookmarkModelToLoad(
       BookmarkModelFactory::GetForProfile(&profile_));
   profile_.BlockUntilHistoryProcessesPendingRequests();
   profile_.BlockUntilHistoryIndexIsRefreshed();
   history_service_ = HistoryServiceFactory::GetForProfile(
       &profile_, ServiceAccessType::EXPLICIT_ACCESS);
   ASSERT_TRUE(history_service_);
-  HistoryBackend* backend = history_service_->history_backend_.get();
+  history::HistoryBackend* backend = history_service_->history_backend_.get();
   history_database_ = backend->db();
 
   // Create and populate a working copy of the URL history database.
   base::FilePath history_proto_path;
   PathService::Get(chrome::DIR_TEST_DATA, &history_proto_path);
   history_proto_path = history_proto_path.Append(
       FILE_PATH_LITERAL("History"));
   history_proto_path = history_proto_path.Append(TestDBName());
   EXPECT_TRUE(base::PathExists(history_proto_path));
 
@@ skipping 25 matching lines @@
   // such that it represents a time relative to 'now'.
   sql::Statement statement(db.GetUniqueStatement(
       "SELECT" HISTORY_URL_ROW_FIELDS "FROM urls;"));
   ASSERT_TRUE(statement.is_valid());
   base::Time time_right_now = base::Time::NowFromSystemTime();
   base::TimeDelta day_delta = base::TimeDelta::FromDays(1);
   {
     sql::Transaction transaction(&db);
     transaction.Begin();
     while (statement.Step()) {
-      URLRow row;
+      history::URLRow row;
       history_database_->FillURLRow(statement, &row);
       base::Time last_visit = time_right_now;
       for (int64 i = row.last_visit().ToInternalValue(); i > 0; --i)
         last_visit -= day_delta;
       row.set_last_visit(last_visit);
       history_database_->UpdateURLRow(row.id(), row);
     }
     transaction.Commit();
   }
 
   // Update the visit_time table column in the "visits" table
   // such that it represents a time relative to 'now'.
   statement.Assign(db.GetUniqueStatement(
       "SELECT" HISTORY_VISIT_ROW_FIELDS "FROM visits;"));
   ASSERT_TRUE(statement.is_valid());
   {
     sql::Transaction transaction(&db);
     transaction.Begin();
     while (statement.Step()) {
-      VisitRow row;
+      history::VisitRow row;
       history_database_->FillVisitRow(statement, &row);
       base::Time last_visit = time_right_now;
       for (int64 i = row.visit_time.ToInternalValue(); i > 0; --i)
         last_visit -= day_delta;
       row.visit_time = last_visit;
       history_database_->UpdateVisitRow(row);
     }
     transaction.Commit();
   }
 
@@ skipping 105 matching lines @@
 
   for (HistoryInfoMap::const_iterator expected_info =
       expected.history_info_map_.begin();
       expected_info != expected.history_info_map_.end(); ++expected_info) {
     HistoryInfoMap::const_iterator actual_info =
         actual.history_info_map_.find(expected_info->first);
     // NOTE(yfriedman): ASSERT_NE can't be used due to incompatibility between
     // gtest and STLPort in the Android build. See
     // http://code.google.com/p/googletest/issues/detail?id=359
     ASSERT_TRUE(actual_info != actual.history_info_map_.end());
-    const URLRow& expected_row(expected_info->second.url_row);
-    const URLRow& actual_row(actual_info->second.url_row);
+    const history::URLRow& expected_row(expected_info->second.url_row);
+    const history::URLRow& actual_row(actual_info->second.url_row);
     EXPECT_EQ(expected_row.visit_count(), actual_row.visit_count());
     EXPECT_EQ(expected_row.typed_count(), actual_row.typed_count());
     EXPECT_EQ(expected_row.last_visit(), actual_row.last_visit());
     EXPECT_EQ(expected_row.url(), actual_row.url());
     const VisitInfoVector& expected_visits(expected_info->second.visits);
     const VisitInfoVector& actual_visits(actual_info->second.visits);
     EXPECT_EQ(expected_visits.size(), actual_visits.size());
     for (size_t i = 0;
          i < std::min(expected_visits.size(), actual_visits.size()); ++i) {
       EXPECT_EQ(expected_visits[i].first, actual_visits[i].first);
@@ skipping 274 matching lines @@
   matches = url_index_->HistoryItemsForTerms(
       ASCIIToUTF16("atdmt.view"), base::string16::npos, kMaxMatches, builder_);
   ASSERT_EQ(0U, matches.size());
   matches = url_index_->HistoryItemsForTerms(
       ASCIIToUTF16("view.atdmt"), base::string16::npos, kMaxMatches, builder_);
   ASSERT_EQ(1U, matches.size());
 }
 
 TEST_F(InMemoryURLIndexTest, HugeResultSet) {
   // Create a huge set of qualifying history items.
-  for (URLID row_id = 5000; row_id < 6000; ++row_id) {
-    URLRow new_row(GURL("http://www.brokeandaloneinmanitoba.com/"), row_id);
+  for (history::URLID row_id = 5000; row_id < 6000; ++row_id) {
+    history::URLRow new_row(GURL("http://www.brokeandaloneinmanitoba.com/"),
+                            row_id);
     new_row.set_last_visit(base::Time::Now());
     EXPECT_TRUE(UpdateURL(new_row));
   }
 
   ScoredHistoryMatches matches = url_index_->HistoryItemsForTerms(
       ASCIIToUTF16("b"), base::string16::npos, kMaxMatches, builder_);
   URLIndexPrivateData& private_data(*GetPrivateData());
   ASSERT_EQ(kMaxMatches, matches.size());
   // There are 7 matches already in the database.
   ASSERT_EQ(1008U, private_data.pre_filter_item_count_);
@@ skipping 28 matching lines @@
 
 TEST_F(InMemoryURLIndexTest, TitleChange) {
   // Verify current title terms retrieves desired item.
   base::string16 original_terms =
       ASCIIToUTF16("lebronomics could high taxes influence");
   ScoredHistoryMatches matches = url_index_->HistoryItemsForTerms(
       original_terms, base::string16::npos, kMaxMatches, builder_);
   ASSERT_EQ(1U, matches.size());
 
   // Verify that we got back the result we expected.
-  const URLID expected_id = 3;
+  const history::URLID expected_id = 3;
   EXPECT_EQ(expected_id, matches[0].url_info.id());
   EXPECT_EQ("http://www.businessandmedia.org/articles/2010/20100708120415.aspx",
             matches[0].url_info.url().spec());
   EXPECT_EQ(ASCIIToUTF16(
       "LeBronomics: Could High Taxes Influence James' Team Decision?"),
       matches[0].url_info.title());
-  URLRow old_row(matches[0].url_info);
+  history::URLRow old_row(matches[0].url_info);
 
   // Verify new title terms retrieves nothing.
   base::string16 new_terms = ASCIIToUTF16("does eat oats little lambs ivy");
   matches = url_index_->HistoryItemsForTerms(new_terms, base::string16::npos,
                                              kMaxMatches, builder_);
   ASSERT_EQ(0U, matches.size());
 
   // Update the row.
   old_row.set_title(ASCIIToUTF16("Does eat oats and little lambs eat ivy"));
   EXPECT_TRUE(UpdateURL(old_row));
@@ skipping 94 matching lines @@
   // Simulate a <DELETE> by removing the 'reco' and adding back the 'rec'.
   url_index_->HistoryItemsForTerms(ASCIIToUTF16("mort rec"),
                                    base::string16::npos, kMaxMatches, builder_);
   ASSERT_EQ(2U, cache.size());
   CheckTerm(cache, ASCIIToUTF16("mort"));
   CheckTerm(cache, ASCIIToUTF16("rec"));
 }
 
 TEST_F(InMemoryURLIndexTest, AddNewRows) {
   // Verify that the row we're going to add does not already exist.
-  URLID new_row_id = 87654321;
-  // Newly created URLRows get a last_visit time of 'right now' so it should
+  history::URLID new_row_id = 87654321;
+  // Newly created history::URLRows get a last_visit time of 'right now' so it
+  // should
   // qualify as a quick result candidate.
   EXPECT_TRUE(url_index_->HistoryItemsForTerms(ASCIIToUTF16("brokeandalone"),
                                                base::string16::npos,
                                                kMaxMatches, builder_).empty());
 
   // Add a new row.
-  URLRow new_row(GURL("http://www.brokeandaloneinmanitoba.com/"), new_row_id++);
+  history::URLRow new_row(GURL("http://www.brokeandaloneinmanitoba.com/"),
+                          new_row_id++);
   new_row.set_last_visit(base::Time::Now());
   EXPECT_TRUE(UpdateURL(new_row));
 
   // Verify that we can retrieve it.
   EXPECT_EQ(1U, url_index_->HistoryItemsForTerms(ASCIIToUTF16("brokeandalone"),
                                                  base::string16::npos,
                                                  kMaxMatches, builder_).size());
 
   // Add it again just to be sure that is harmless and that it does not update
   // the index.
   EXPECT_FALSE(UpdateURL(new_row));
   EXPECT_EQ(1U, url_index_->HistoryItemsForTerms(ASCIIToUTF16("brokeandalone"),
                                                  base::string16::npos,
                                                  kMaxMatches, builder_).size());
 
   // Make up an URL that does not qualify and try to add it.
-  URLRow unqualified_row(GURL("http://www.brokeandaloneinmanitoba.com/"),
-                         new_row_id++);
+  history::URLRow unqualified_row(
+      GURL("http://www.brokeandaloneinmanitoba.com/"), new_row_id++);
   EXPECT_FALSE(UpdateURL(new_row));
 }
 
 TEST_F(InMemoryURLIndexTest, DeleteRows) {
   ScoredHistoryMatches matches = url_index_->HistoryItemsForTerms(
       ASCIIToUTF16("DrudgeReport"), base::string16::npos, kMaxMatches,
       builder_);
   ASSERT_EQ(1U, matches.size());
 
   // Delete the URL then search again.
   EXPECT_TRUE(DeleteURL(matches[0].url_info.url()));
   EXPECT_TRUE(url_index_->HistoryItemsForTerms(ASCIIToUTF16("DrudgeReport"),
                                                base::string16::npos,
                                                kMaxMatches, builder_).empty());
 
   // Make up an URL that does not exist in the database and delete it.
   GURL url("http://www.hokeypokey.com/putyourrightfootin.html");
   EXPECT_FALSE(DeleteURL(url));
 }
 
 TEST_F(InMemoryURLIndexTest, ExpireRow) {
   ScoredHistoryMatches matches = url_index_->HistoryItemsForTerms(
       ASCIIToUTF16("DrudgeReport"), base::string16::npos, kMaxMatches,
       builder_);
   ASSERT_EQ(1U, matches.size());
 
   // Determine the row id for the result, remember that id, broadcast a
   // delete notification, then ensure that the row has been deleted.
-  URLRows deleted_rows;
+  history::URLRows deleted_rows;
   deleted_rows.push_back(matches[0].url_info);
   url_index_->OnURLsDeleted(nullptr, false, false, deleted_rows,
                             std::set<GURL>());
   EXPECT_TRUE(url_index_->HistoryItemsForTerms(ASCIIToUTF16("DrudgeReport"),
                                                base::string16::npos,
                                                kMaxMatches, builder_).empty());
 }
 
 TEST_F(InMemoryURLIndexTest, WhitelistedURLs) {
   struct TestData {
@@ skipping 316 matching lines @@
   ASSERT_TRUE(GetCacheFilePath(&full_file_path));
   std::vector<base::FilePath::StringType> actual_parts;
   full_file_path.GetComponents(&actual_parts);
   ASSERT_EQ(expected_parts.size(), actual_parts.size());
   size_t count = expected_parts.size();
   for (size_t i = 0; i < count; ++i)
     EXPECT_EQ(expected_parts[i], actual_parts[i]);
   // Must clear the history_dir_ to satisfy the dtor's DCHECK.
   set_history_dir(base::FilePath());
 }
-
-}  // namespace history