Abstract //content-level dependencies out of InMemoryURLIndex

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"
 #include "base/files/scoped_temp_dir.h"
 #include "base/i18n/case_conversion.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
+#include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/in_memory_url_index.h"
 #include "chrome/browser/autocomplete/url_index_private_data.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/test/base/history_index_restore_observer.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/bookmarks/test/bookmark_test_helpers.h"
 #include "components/history/core/browser/history_backend.h"
 #include "components/history/core/browser/history_database.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/omnibox/in_memory_url_index_types.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "sql/transaction.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::ASCIIToUTF16;
 
 // The test version of the history url database table ('url') is contained in
 // 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 {
 const size_t kInvalid = base::string16::npos;
 const size_t kMaxMatches = 3;
 const char kTestLanguages[] = "en,ja,hi,zh";
+const char kClientWhitelistedScheme[] = "xyz";
 
 // Helper function to set lower case |lower_string| and |lower_terms| (words
 // list) based on supplied |search_string| and |cursor_position|. If
 // |cursor_position| is set and useful (not at either end of the string), allow
 // the |search_string| to be broken at |cursor_position|. We do this by
 // pretending there's a space where the cursor is. |lower_terms| are obtained by
 // splitting the |lower_string| on whitespace into tokens.
 void StringToTerms(const char* search_string,
                    size_t cursor_position,
                    base::string16* lower_string,
@@ skipping 68 matching lines @@
   sql::Connection& GetDB();
 
   // Pass-through functions to simplify our friendship with InMemoryURLIndex.
   URLIndexPrivateData* GetPrivateData() const;
   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();
+  const SchemeSet& scheme_whitelist();
 
 
   // Pass-through functions to simplify our friendship with URLIndexPrivateData.
   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,
@@ skipping 39 matching lines @@
 }
 
 void InMemoryURLIndexTest::PostRestoreFromCacheFileTask() {
   url_index_->PostRestoreFromCacheFileTask();
 }
 
 void InMemoryURLIndexTest::PostSaveToCacheFileTask() {
   url_index_->PostSaveToCacheFileTask();
 }
 
-const std::set<std::string>& InMemoryURLIndexTest::scheme_whitelist() {
+const SchemeSet& InMemoryURLIndexTest::scheme_whitelist() {
   return url_index_->scheme_whitelist();
 }
 
 bool InMemoryURLIndexTest::UpdateURL(const history::URLRow& row) {
   return GetPrivateData()->UpdateURL(history_service_,
                                      row,
                                      url_index_->languages_,
                                      url_index_->scheme_whitelist_,
                                      GetPrivateDataTracker());
 }
@@ skipping 104 matching lines @@
 base::FilePath::StringType InMemoryURLIndexTest::TestDBName() const {
     return FILE_PATH_LITERAL("url_history_provider_test.db.txt");
 }
 
 bool InMemoryURLIndexTest::InitializeInMemoryURLIndexInSetUp() const {
   return true;
 }
 
 void InMemoryURLIndexTest::InitializeInMemoryURLIndex() {
   DCHECK(!url_index_);
-  url_index_.reset(new InMemoryURLIndex(nullptr, history_service_,
-                                        base::FilePath(), kTestLanguages));
+
+  SchemeSet client_schemes_to_whitelist;
+  client_schemes_to_whitelist.insert(kClientWhitelistedScheme);
+  url_index_.reset(new InMemoryURLIndex(
+      nullptr, history_service_, content::BrowserThread::GetBlockingPool(),
+      base::FilePath(), kTestLanguages, client_schemes_to_whitelist));
   url_index_->Init();
   url_index_->RebuildFromHistory(history_database_);
 }
 
 void InMemoryURLIndexTest::CheckTerm(
     const URLIndexPrivateData::SearchTermCacheMap& cache,
     base::string16 term) const {
   URLIndexPrivateData::SearchTermCacheMap::const_iterator cache_iter(
       cache.find(term));
   ASSERT_TRUE(cache.end() != cache_iter)
@@ skipping 599 matching lines @@
   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).empty());
 }
 
 TEST_F(InMemoryURLIndexTest, WhitelistedURLs) {
+  std::string client_whitelisted_url =
+      base::StringPrintf("%s://foo", kClientWhitelistedScheme);
   struct TestData {
     const std::string url_spec;
     const bool expected_is_whitelisted;
   } data[] = {
     // URLs with whitelisted schemes.
     { "about:histograms", true },
-    { "chrome://settings", true },
     { "file://localhost/Users/joeschmoe/sekrets", true },
     { "ftp://public.mycompany.com/myfile.txt", true },
     { "http://www.google.com/translate", true },
     { "https://www.gmail.com/", true },
     { "mailto:support@google.com", true },
+    { client_whitelisted_url, true },
     // URLs with unacceptable schemes.
     { "aaa://www.dummyhost.com;frammy", false },
     { "aaas://www.dummyhost.com;frammy", false },
     { "acap://suzie@somebody.com", false },
     { "cap://cal.example.com/Company/Holidays", false },
     { "cid:foo4*foo1@bar.net", false },
     { "crid://example.com/foobar", false },
     { "data:image/png;base64,iVBORw0KGgoAAAANSUhE=", false },
     { "dict://dict.org/d:shortcake:", false },
     { "dns://192.168.1.1/ftp.example.org?type=A", false },
@@ skipping 41 matching lines @@
     { "tftp://example.com/mystartupfile", false },
     { "tip://123.123.123.123/?urn:xopen:xid", false },
     { "tv:nbc.com", false },
     { "urn:foo:A123,456", false },
     { "vemmi://zeus.mctel.fr/demo", false },
     { "wais://www.mydomain.net:8765/mydatabase", false },
     { "xmpp:node@example.com", false },
     { "xmpp://guest@example.com", false },
   };
 
-  const std::set<std::string>& whitelist(scheme_whitelist());
+  const SchemeSet& whitelist(scheme_whitelist());
   for (size_t i = 0; i < arraysize(data); ++i) {
     GURL url(data[i].url_spec);
     EXPECT_EQ(data[i].expected_is_whitelisted,
               URLIndexPrivateData::URLSchemeIsWhitelisted(url, whitelist));
   }
 }
 
 TEST_F(InMemoryURLIndexTest, ReadVisitsFromHistory) {
   const HistoryInfoMap& history_info_map = GetPrivateData()->history_info_map_;
 
@@ skipping 278 matching lines @@
   bool GetCacheFilePath(base::FilePath* file_path) const;
 
   content::TestBrowserThreadBundle thread_bundle_;
   base::ScopedTempDir temp_dir_;
   scoped_ptr<InMemoryURLIndex> url_index_;
 };
 
 void InMemoryURLIndexCacheTest::SetUp() {
   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   base::FilePath path(temp_dir_.path());
-  url_index_.reset(
-      new InMemoryURLIndex(nullptr, nullptr, path, kTestLanguages));
+  url_index_.reset(new InMemoryURLIndex(
+      nullptr, nullptr, content::BrowserThread::GetBlockingPool(), path,
+      kTestLanguages, SchemeSet()));
 }
 
 void InMemoryURLIndexCacheTest::TearDown() {
   if (url_index_)
     url_index_->Shutdown();
 }
 
 void InMemoryURLIndexCacheTest::set_history_dir(
     const base::FilePath& dir_path) {
   return url_index_->set_history_dir(dir_path);
@@ skipping 14 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());
 }