Drop |languages| from {Format,Elide}Url* and IDNToUnicode

components/omnibox/browser/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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <fstream>
 
@@ skipping 33 matching lines @@
 // 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,
@@ skipping 136 matching lines @@
 void InMemoryURLIndexTest::PostSaveToCacheFileTask() {
   url_index_->PostSaveToCacheFileTask();
 }
 
 const SchemeSet& InMemoryURLIndexTest::scheme_whitelist() {
   return url_index_->scheme_whitelist();
 }
 
 bool InMemoryURLIndexTest::UpdateURL(const history::URLRow& row) {
   return GetPrivateData()->UpdateURL(
-      history_service_.get(), row, url_index_->languages_,
-      url_index_->scheme_whitelist_, GetPrivateDataTracker());
+      history_service_.get(), row, 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.
-  if (history_dir_.CreateUniqueTempDir()) {
-    history_service_ = history::CreateHistoryService(
-        history_dir_.path(), std::string(), true);
-  }
+  if (history_dir_.CreateUniqueTempDir())
+    history_service_ = history::CreateHistoryService(history_dir_.path(), true);
   ASSERT_TRUE(history_service_);
   BlockUntilInMemoryURLIndexIsRefreshed(url_index_.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(base::DIR_SOURCE_ROOT, &history_proto_path);
   history_proto_path = history_proto_path.AppendASCII("components");
@@ skipping 88 matching lines @@
   return true;
 }
 
 void InMemoryURLIndexTest::InitializeInMemoryURLIndex() {
   DCHECK(!url_index_);
 
   SchemeSet client_schemes_to_whitelist;
   client_schemes_to_whitelist.insert(kClientWhitelistedScheme);
   url_index_.reset(new InMemoryURLIndex(
       nullptr, history_service_.get(), nullptr, pool_owner_.pool().get(),
-      base::FilePath(), kTestLanguages, client_schemes_to_whitelist));
+      base::FilePath(), 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 894 matching lines @@
     SCOPED_TRACE(testing::Message()
                  << "search_string = " << test_cases[i].search_string
                  << ", cursor_position = " << test_cases[i].cursor_position);
 
     base::string16 lower_string;
     String16Vector lower_terms;
     StringToTerms(test_cases[i].search_string, test_cases[i].cursor_position,
                   &lower_string, &lower_terms);
     URLIndexPrivateData::AddHistoryMatch match(nullptr, nullptr,
                                                *GetPrivateData(),
-                                               kTestLanguages, lower_string,
-                                               lower_terms, base::Time::Now());
+                                               lower_string, lower_terms,
+                                               base::Time::Now());
 
     // Verify against expectations.
     EXPECT_EQ(test_cases[i].expected_word_starts_offsets_size,
               match.lower_terms_to_word_starts_offsets_.size());
     for (size_t j = 0; j < test_cases[i].expected_word_starts_offsets_size;
          ++j) {
       EXPECT_EQ(test_cases[i].expected_word_starts_offsets[j],
                 match.lower_terms_to_word_starts_offsets_[j]);
     }
   }
@@ skipping 18 matching lines @@
 };
 
 InMemoryURLIndexCacheTest::InMemoryURLIndexCacheTest()
     : pool_owner_(3, "Background Pool") {}
 
 void InMemoryURLIndexCacheTest::SetUp() {
   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   base::FilePath path(temp_dir_.path());
   url_index_.reset(new InMemoryURLIndex(nullptr, nullptr, nullptr,
                                         pool_owner_.pool().get(), path,
-                                        kTestLanguages, SchemeSet()));
+                                        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());
 }