Move constants used by history component to history namespace

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 32 matching lines @@
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "chrome/browser/history/download_row.h"
 #include "chrome/browser/history/history_backend.h"
 #include "chrome/browser/history/history_database.h"
 #include "chrome/browser/history/history_db_task.h"
 #include "chrome/browser/history/history_notifications.h"
 #include "chrome/browser/history/history_service.h"
 #include "chrome/browser/history/history_unittest_base.h"
 #include "chrome/browser/history/in_memory_history_backend.h"
-#include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/tools/profiles/thumbnail-inl.h"
+#include "components/history/core/browser/history_constants.h"
 #include "components/history/core/browser/in_memory_database.h"
 #include "components/history/core/browser/page_usage_data.h"
 #include "components/history/core/common/thumbnail_score.h"
 #include "content/public/browser/download_item.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "sql/connection.h"
 #include "sql/statement.h"
 #include "sync/api/attachments/attachment_id.h"
 #include "sync/api/fake_sync_change_processor.h"
@@ skipping 67 matching lines @@
         "HistoryBackend::Init";
   }
 
   void CreateDBVersion(int version) {
     base::FilePath data_path;
     ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &data_path));
     data_path = data_path.AppendASCII("History");
     data_path =
           data_path.AppendASCII(base::StringPrintf("history.%d.sql", version));
     ASSERT_NO_FATAL_FAILURE(
-        ExecuteSQLScript(data_path, history_dir_.Append(
-            chrome::kHistoryFilename)));
+        ExecuteSQLScript(data_path, history_dir_.Append(kHistoryFilename)));
   }
 
   void CreateArchivedDB() {
     base::FilePath data_path;
     ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &data_path));
     data_path = data_path.AppendASCII("History");
     data_path = data_path.AppendASCII("archived_history.4.sql");
-    ASSERT_NO_FATAL_FAILURE(
-        ExecuteSQLScript(data_path, history_dir_.Append(
-            chrome::kArchivedHistoryFilename)));
+    ASSERT_NO_FATAL_FAILURE(ExecuteSQLScript(
+        data_path, history_dir_.Append(kArchivedHistoryFilename)));
   }
 
   // testing::Test
   void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     history_dir_ = temp_dir_.path().AppendASCII("HistoryBackendDBTest");
     ASSERT_TRUE(base::CreateDirectory(history_dir_));
   }
 
   void DeleteBackend() {
@@ skipping 116 matching lines @@
   db_->QueryDownloads(&downloads);
   EXPECT_EQ(0U, downloads.size());
 }
 
 TEST_F(HistoryBackendDBTest, MigrateDownloadsState) {
   // Create the db we want.
   ASSERT_NO_FATAL_FAILURE(CreateDBVersion(22));
   {
     // Open the db for manual manipulation.
     sql::Connection db;
-    ASSERT_TRUE(db.Open(history_dir_.Append(chrome::kHistoryFilename)));
+    ASSERT_TRUE(db.Open(history_dir_.Append(kHistoryFilename)));
 
     // Manually insert corrupted rows; there's infrastructure in place now to
     // make this impossible, at least according to the test above.
     for (int state = 0; state < 5; ++state) {
       sql::Statement s(db.GetUniqueStatement(
             "INSERT INTO downloads (id, full_path, url, start_time, "
             "received_bytes, total_bytes, state, end_time, opened) VALUES "
             "(?, ?, ?, ?, ?, ?, ?, ?, ?)"));
       s.BindInt64(0, 1 + state);
       s.BindString(1, "path");
       s.BindString(2, "url");
       s.BindInt64(3, base::Time::Now().ToTimeT());
       s.BindInt64(4, 100);
       s.BindInt64(5, 100);
       s.BindInt(6, state);
       s.BindInt64(7, base::Time::Now().ToTimeT());
       s.BindInt(8, state % 2);
       ASSERT_TRUE(s.Run());
     }
   }
 
   // Re-open the db using the HistoryDatabase, which should migrate from version
   // 22 to the current version, fixing just the row whose state was 3.
   // Then close the db so that we can re-open it directly.
   CreateBackendAndDatabase();
   DeleteBackend();
   {
     // Re-open the db for manual manipulation.
     sql::Connection db;
-    ASSERT_TRUE(db.Open(history_dir_.Append(chrome::kHistoryFilename)));
+    ASSERT_TRUE(db.Open(history_dir_.Append(kHistoryFilename)));
     {
       // The version should have been updated.
       int cur_version = HistoryDatabase::GetCurrentVersion();
       ASSERT_LT(22, cur_version);
       sql::Statement s(db.GetUniqueStatement(
           "SELECT value FROM meta WHERE key = 'version'"));
       EXPECT_TRUE(s.Step());
       EXPECT_EQ(cur_version, s.ColumnInt(0));
     }
     {
@@ skipping 17 matching lines @@
 
 TEST_F(HistoryBackendDBTest, MigrateDownloadsReasonPathsAndDangerType) {
   Time now(base::Time::Now());
 
   // Create the db we want.  The schema didn't change from 22->23, so just
   // re-use the v22 file.
   ASSERT_NO_FATAL_FAILURE(CreateDBVersion(22));
   {
     // Re-open the db for manual manipulation.
     sql::Connection db;
-    ASSERT_TRUE(db.Open(history_dir_.Append(chrome::kHistoryFilename)));
+    ASSERT_TRUE(db.Open(history_dir_.Append(kHistoryFilename)));
 
     // Manually insert some rows.
     sql::Statement s(db.GetUniqueStatement(
         "INSERT INTO downloads (id, full_path, url, start_time, "
         "received_bytes, total_bytes, state, end_time, opened) VALUES "
         "(?, ?, ?, ?, ?, ?, ?, ?, ?)"));
 
     int64 id = 0;
     // Null path.
     s.BindInt64(0, ++id);
@@ skipping 22 matching lines @@
   }
 
   // Re-open the db using the HistoryDatabase, which should migrate from version
   // 23 to 24, creating the new tables and creating the new path, reason,
   // and danger columns.
   CreateBackendAndDatabase();
   DeleteBackend();
   {
     // Re-open the db for manual manipulation.
     sql::Connection db;
-    ASSERT_TRUE(db.Open(history_dir_.Append(chrome::kHistoryFilename)));
+    ASSERT_TRUE(db.Open(history_dir_.Append(kHistoryFilename)));
     {
       // The version should have been updated.
       int cur_version = HistoryDatabase::GetCurrentVersion();
       ASSERT_LT(23, cur_version);
       sql::Statement s(db.GetUniqueStatement(
           "SELECT value FROM meta WHERE key = 'version'"));
       EXPECT_TRUE(s.Step());
       EXPECT_EQ(cur_version, s.ColumnInt(0));
     }
     {
@@ skipping 46 matching lines @@
       EXPECT_FALSE(statement.Step());
     }
   }
 }
 
 TEST_F(HistoryBackendDBTest, MigrateReferrer) {
   Time now(base::Time::Now());
   ASSERT_NO_FATAL_FAILURE(CreateDBVersion(22));
   {
     sql::Connection db;
-    ASSERT_TRUE(db.Open(history_dir_.Append(chrome::kHistoryFilename)));
+    ASSERT_TRUE(db.Open(history_dir_.Append(kHistoryFilename)));
     sql::Statement s(db.GetUniqueStatement(
         "INSERT INTO downloads (id, full_path, url, start_time, "
         "received_bytes, total_bytes, state, end_time, opened) VALUES "
         "(?, ?, ?, ?, ?, ?, ?, ?, ?)"));
     int64 db_handle = 0;
     s.BindInt64(0, ++db_handle);
     s.BindString(1, "full_path");
     s.BindString(2, "http://whatever.com/index.html");
     s.BindInt64(3, now.ToTimeT());
     s.BindInt64(4, 100);
     s.BindInt64(5, 100);
     s.BindInt(6, 1);
     s.BindInt64(7, now.ToTimeT());
     s.BindInt(8, 1);
     ASSERT_TRUE(s.Run());
   }
   // Re-open the db using the HistoryDatabase, which should migrate to version
   // 26, creating the referrer column.
   CreateBackendAndDatabase();
   DeleteBackend();
   {
     // Re-open the db for manual manipulation.
     sql::Connection db;
-    ASSERT_TRUE(db.Open(history_dir_.Append(chrome::kHistoryFilename)));
+    ASSERT_TRUE(db.Open(history_dir_.Append(kHistoryFilename)));
     // The version should have been updated.
     int cur_version = HistoryDatabase::GetCurrentVersion();
     ASSERT_LE(26, cur_version);
     {
       sql::Statement s(db.GetUniqueStatement(
           "SELECT value FROM meta WHERE key = 'version'"));
       EXPECT_TRUE(s.Step());
       EXPECT_EQ(cur_version, s.ColumnInt(0));
     }
     {
       sql::Statement s(db.GetUniqueStatement(
           "SELECT referrer from downloads"));
       EXPECT_TRUE(s.Step());
       EXPECT_EQ(std::string(), s.ColumnString(0));
     }
   }
 }
 
 TEST_F(HistoryBackendDBTest, MigrateDownloadedByExtension) {
   Time now(base::Time::Now());
   ASSERT_NO_FATAL_FAILURE(CreateDBVersion(26));
   {
     sql::Connection db;
-    ASSERT_TRUE(db.Open(history_dir_.Append(chrome::kHistoryFilename)));
+    ASSERT_TRUE(db.Open(history_dir_.Append(kHistoryFilename)));
     {
       sql::Statement s(db.GetUniqueStatement(
           "INSERT INTO downloads (id, current_path, target_path, start_time, "
           "received_bytes, total_bytes, state, danger_type, interrupt_reason, "
           "end_time, opened, referrer) VALUES "
           "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"));
       s.BindInt64(0, 1);
       s.BindString(1, "current_path");
       s.BindString(2, "target_path");
       s.BindInt64(3, now.ToTimeT());
@@ skipping 17 matching lines @@
       ASSERT_TRUE(s.Run());
     }
   }
   // Re-open the db using the HistoryDatabase, which should migrate to version
   // 27, creating the by_ext_id and by_ext_name columns.
   CreateBackendAndDatabase();
   DeleteBackend();
   {
     // Re-open the db for manual manipulation.
     sql::Connection db;
-    ASSERT_TRUE(db.Open(history_dir_.Append(chrome::kHistoryFilename)));
+    ASSERT_TRUE(db.Open(history_dir_.Append(kHistoryFilename)));
     // The version should have been updated.
     int cur_version = HistoryDatabase::GetCurrentVersion();
     ASSERT_LE(27, cur_version);
     {
       sql::Statement s(db.GetUniqueStatement(
           "SELECT value FROM meta WHERE key = 'version'"));
       EXPECT_TRUE(s.Step());
       EXPECT_EQ(cur_version, s.ColumnInt(0));
     }
     {
       sql::Statement s(db.GetUniqueStatement(
           "SELECT by_ext_id, by_ext_name from downloads"));
       EXPECT_TRUE(s.Step());
       EXPECT_EQ(std::string(), s.ColumnString(0));
       EXPECT_EQ(std::string(), s.ColumnString(1));
     }
   }
 }
 
 TEST_F(HistoryBackendDBTest, MigrateDownloadValidators) {
   Time now(base::Time::Now());
   ASSERT_NO_FATAL_FAILURE(CreateDBVersion(27));
   {
     sql::Connection db;
-    ASSERT_TRUE(db.Open(history_dir_.Append(chrome::kHistoryFilename)));
+    ASSERT_TRUE(db.Open(history_dir_.Append(kHistoryFilename)));
     {
       sql::Statement s(db.GetUniqueStatement(
           "INSERT INTO downloads (id, current_path, target_path, start_time, "
           "received_bytes, total_bytes, state, danger_type, interrupt_reason, "
           "end_time, opened, referrer, by_ext_id, by_ext_name) VALUES "
           "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"));
       s.BindInt64(0, 1);
       s.BindString(1, "current_path");
       s.BindString(2, "target_path");
       s.BindInt64(3, now.ToTimeT());
@@ skipping 19 matching lines @@
       ASSERT_TRUE(s.Run());
     }
   }
   // Re-open the db using the HistoryDatabase, which should migrate to the
   // current version, creating the etag and last_modified columns.
   CreateBackendAndDatabase();
   DeleteBackend();
   {
     // Re-open the db for manual manipulation.
     sql::Connection db;
-    ASSERT_TRUE(db.Open(history_dir_.Append(chrome::kHistoryFilename)));
+    ASSERT_TRUE(db.Open(history_dir_.Append(kHistoryFilename)));
     // The version should have been updated.
     int cur_version = HistoryDatabase::GetCurrentVersion();
     ASSERT_LE(28, cur_version);
     {
       sql::Statement s(db.GetUniqueStatement(
           "SELECT value FROM meta WHERE key = 'version'"));
       EXPECT_TRUE(s.Step());
       EXPECT_EQ(cur_version, s.ColumnInt(0));
     }
     {
       sql::Statement s(db.GetUniqueStatement(
           "SELECT etag, last_modified from downloads"));
       EXPECT_TRUE(s.Step());
       EXPECT_EQ(std::string(), s.ColumnString(0));
       EXPECT_EQ(std::string(), s.ColumnString(1));
     }
   }
 }
 
 TEST_F(HistoryBackendDBTest, PurgeArchivedDatabase) {
   ASSERT_NO_FATAL_FAILURE(CreateDBVersion(27));
   ASSERT_NO_FATAL_FAILURE(CreateArchivedDB());
 
-  ASSERT_TRUE(base::PathExists(
-      history_dir_.Append(chrome::kArchivedHistoryFilename)));
+  ASSERT_TRUE(base::PathExists(history_dir_.Append(kArchivedHistoryFilename)));
 
   CreateBackendAndDatabase();
   DeleteBackend();
 
   // We do not retain expired history entries in an archived database as of M37.
   // Verify that any legacy archived database is deleted on start-up.
-  ASSERT_FALSE(base::PathExists(
-      history_dir_.Append(chrome::kArchivedHistoryFilename)));
+  ASSERT_FALSE(base::PathExists(history_dir_.Append(kArchivedHistoryFilename)));
 }
 
 TEST_F(HistoryBackendDBTest, MigrateDownloadMimeType) {
   Time now(base::Time::Now());
   ASSERT_NO_FATAL_FAILURE(CreateDBVersion(28));
   {
     sql::Connection db;
-    ASSERT_TRUE(db.Open(history_dir_.Append(chrome::kHistoryFilename)));
+    ASSERT_TRUE(db.Open(history_dir_.Append(kHistoryFilename)));
     {
       sql::Statement s(db.GetUniqueStatement(
           "INSERT INTO downloads (id, current_path, target_path, start_time, "
           "received_bytes, total_bytes, state, danger_type, interrupt_reason, "
           "end_time, opened, referrer, by_ext_id, by_ext_name, etag, "
           "last_modified) VALUES "
           "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"));
       s.BindInt64(0, 1);
       s.BindString(1, "current_path");
       s.BindString(2, "target_path");
@@ skipping 22 matching lines @@
       ASSERT_TRUE(s.Run());
     }
   }
   // Re-open the db using the HistoryDatabase, which should migrate to the
   // current version, creating themime_type abd original_mime_type columns.
   CreateBackendAndDatabase();
   DeleteBackend();
   {
     // Re-open the db for manual manipulation.
     sql::Connection db;
-    ASSERT_TRUE(db.Open(history_dir_.Append(chrome::kHistoryFilename)));
+    ASSERT_TRUE(db.Open(history_dir_.Append(kHistoryFilename)));
     // The version should have been updated.
     int cur_version = HistoryDatabase::GetCurrentVersion();
     ASSERT_LE(29, cur_version);
     {
       sql::Statement s(db.GetUniqueStatement(
           "SELECT value FROM meta WHERE key = 'version'"));
       EXPECT_TRUE(s.Step());
       EXPECT_EQ(cur_version, s.ColumnInt(0));
     }
     {
@@ skipping 15 matching lines @@
   // Add some downloads.
   uint32 id1 = 1, id2 = 2, id3 = 3;
   AddDownload(id1, DownloadItem::COMPLETE, now);
   AddDownload(id2, DownloadItem::COMPLETE, now + base::TimeDelta::FromDays(2));
   AddDownload(id3, DownloadItem::COMPLETE, now - base::TimeDelta::FromDays(2));
 
   // Confirm that resulted in the correct number of rows in the DB.
   DeleteBackend();
   {
     sql::Connection db;
-    ASSERT_TRUE(db.Open(history_dir_.Append(chrome::kHistoryFilename)));
+    ASSERT_TRUE(db.Open(history_dir_.Append(kHistoryFilename)));
     sql::Statement statement(db.GetUniqueStatement(
         "Select Count(*) from downloads"));
     EXPECT_TRUE(statement.Step());
     EXPECT_EQ(3, statement.ColumnInt(0));
 
     sql::Statement statement1(db.GetUniqueStatement(
         "Select Count(*) from downloads_url_chains"));
     EXPECT_TRUE(statement1.Step());
     EXPECT_EQ(3, statement1.ColumnInt(0));
   }
 
   // Delete some rows and make sure the results are still correct.
   CreateBackendAndDatabase();
   db_->RemoveDownload(id2);
   db_->RemoveDownload(id3);
   DeleteBackend();
   {
     sql::Connection db;
-    ASSERT_TRUE(db.Open(history_dir_.Append(chrome::kHistoryFilename)));
+    ASSERT_TRUE(db.Open(history_dir_.Append(kHistoryFilename)));
     sql::Statement statement(db.GetUniqueStatement(
         "Select Count(*) from downloads"));
     EXPECT_TRUE(statement.Step());
     EXPECT_EQ(1, statement.ColumnInt(0));
 
     sql::Statement statement1(db.GetUniqueStatement(
         "Select Count(*) from downloads_url_chains"));
     EXPECT_TRUE(statement1.Step());
     EXPECT_EQ(1, statement1.ColumnInt(0));
   }
@@ skipping 26 matching lines @@
   // Creating records without any urls should fail.
   EXPECT_FALSE(db_->CreateDownload(download));
 
   download.url_chain.push_back(GURL("foo-url"));
   EXPECT_TRUE(db_->CreateDownload(download));
 
   // Pretend that the URLs were dropped.
   DeleteBackend();
   {
     sql::Connection db;
-    ASSERT_TRUE(db.Open(history_dir_.Append(chrome::kHistoryFilename)));
+    ASSERT_TRUE(db.Open(history_dir_.Append(kHistoryFilename)));
     sql::Statement statement(db.GetUniqueStatement(
         "DELETE FROM downloads_url_chains WHERE id=1"));
     ASSERT_TRUE(statement.Run());
   }
   CreateBackendAndDatabase();
   std::vector<DownloadRow> downloads;
   db_->QueryDownloads(&downloads);
   EXPECT_EQ(0U, downloads.size());
 
   // QueryDownloads should have nuked the corrupt record.
   DeleteBackend();
   {
     sql::Connection db;
-    ASSERT_TRUE(db.Open(history_dir_.Append(chrome::kHistoryFilename)));
+    ASSERT_TRUE(db.Open(history_dir_.Append(kHistoryFilename)));
     {
       sql::Statement statement(db.GetUniqueStatement(
             "SELECT count(*) from downloads"));
       ASSERT_TRUE(statement.Step());
       EXPECT_EQ(0, statement.ColumnInt(0));
     }
   }
 }
 
 TEST_F(HistoryBackendDBTest, ConfirmDownloadInProgressCleanup) {
   // Create the DB.
   CreateBackendAndDatabase();
 
   base::Time now(base::Time::Now());
 
   // Put an IN_PROGRESS download in the DB.
   AddDownload(1, DownloadItem::IN_PROGRESS, now);
 
   // Confirm that they made it into the DB unchanged.
   DeleteBackend();
   {
     sql::Connection db;
-    ASSERT_TRUE(db.Open(history_dir_.Append(chrome::kHistoryFilename)));
+    ASSERT_TRUE(db.Open(history_dir_.Append(kHistoryFilename)));
     sql::Statement statement(db.GetUniqueStatement(
         "Select Count(*) from downloads"));
     EXPECT_TRUE(statement.Step());
     EXPECT_EQ(1, statement.ColumnInt(0));
 
     sql::Statement statement1(db.GetUniqueStatement(
         "Select state, interrupt_reason from downloads"));
     EXPECT_TRUE(statement1.Step());
     EXPECT_EQ(DownloadDatabase::kStateInProgress, statement1.ColumnInt(0));
     EXPECT_EQ(content::DOWNLOAD_INTERRUPT_REASON_NONE, statement1.ColumnInt(1));
     EXPECT_FALSE(statement1.Step());
   }
 
   // Read in the DB through query downloads, then test that the
   // right transformation was returned.
   CreateBackendAndDatabase();
   std::vector<DownloadRow> results;
   db_->QueryDownloads(&results);
   ASSERT_EQ(1u, results.size());
   EXPECT_EQ(content::DownloadItem::INTERRUPTED, results[0].state);
   EXPECT_EQ(content::DOWNLOAD_INTERRUPT_REASON_CRASH,
             results[0].interrupt_reason);
 
   // Allow the update to propagate, shut down the DB, and confirm that
   // the query updated the on disk database as well.
   base::MessageLoop::current()->RunUntilIdle();
   DeleteBackend();
   {
     sql::Connection db;
-    ASSERT_TRUE(db.Open(history_dir_.Append(chrome::kHistoryFilename)));
+    ASSERT_TRUE(db.Open(history_dir_.Append(kHistoryFilename)));
     sql::Statement statement(db.GetUniqueStatement(
         "Select Count(*) from downloads"));
     EXPECT_TRUE(statement.Step());
     EXPECT_EQ(1, statement.ColumnInt(0));
 
     sql::Statement statement1(db.GetUniqueStatement(
         "Select state, interrupt_reason from downloads"));
     EXPECT_TRUE(statement1.Step());
     EXPECT_EQ(DownloadDatabase::kStateInterrupted, statement1.ColumnInt(0));
     EXPECT_EQ(content::DOWNLOAD_INTERRUPT_REASON_CRASH,
@@ skipping 927 matching lines @@
   const SegmentID segment_id = 2;
   const URLID url_id = 3;
   const GURL url("http://www.foo.com");
   const std::string url_name(VisitSegmentDatabase::ComputeSegmentName(url));
   const base::string16 title(base::ASCIIToUTF16("Title1"));
   const Time segment_time(Time::Now());
 
   {
     // Re-open the db for manual manipulation.
     sql::Connection db;
-    ASSERT_TRUE(db.Open(history_dir_.Append(chrome::kHistoryFilename)));
+    ASSERT_TRUE(db.Open(history_dir_.Append(kHistoryFilename)));
 
     // Add an entry to urls.
     {
       sql::Statement s(db.GetUniqueStatement(
                            "INSERT INTO urls "
                            "(id, url, title, last_visit_time) VALUES "
                            "(?, ?, ?, ?)"));
       s.BindInt64(0, url_id);
       s.BindString(1, url.spec());
       s.BindString16(2, title);
@@ skipping 34 matching lines @@
   std::vector<PageUsageData*> results;
   db_->QuerySegmentUsage(segment_time, 10, &results);
   ASSERT_EQ(1u, results.size());
   EXPECT_EQ(url, results[0]->GetURL());
   EXPECT_EQ(segment_id, results[0]->GetID());
   EXPECT_EQ(title, results[0]->GetTitle());
   STLDeleteElements(&results);
 }
 
 }  // namespace history