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

components/omnibox/browser/in_memory_url_index.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 "components/omnibox/browser/in_memory_url_index.h"
 
 #include "base/files/file_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "components/history/core/browser/history_service.h"
@@ skipping 27 matching lines @@
 }
 
 InMemoryURLIndex::SaveCacheObserver::~SaveCacheObserver() {
 }
 
 // RebuildPrivateDataFromHistoryDBTask -----------------------------------------
 
 InMemoryURLIndex::RebuildPrivateDataFromHistoryDBTask::
     RebuildPrivateDataFromHistoryDBTask(
         InMemoryURLIndex* index,
-        const std::string& languages,
         const SchemeSet& scheme_whitelist)
     : index_(index),
-      languages_(languages),
       scheme_whitelist_(scheme_whitelist),
       succeeded_(false) {
 }
 
 bool InMemoryURLIndex::RebuildPrivateDataFromHistoryDBTask::RunOnDBThread(
     history::HistoryBackend* backend,
     history::HistoryDatabase* db) {
-  data_ = URLIndexPrivateData::RebuildFromHistory(db, languages_,
-                                                  scheme_whitelist_);
+  data_ = URLIndexPrivateData::RebuildFromHistory(db, scheme_whitelist_);
   succeeded_ = data_.get() && !data_->Empty();
   if (!succeeded_ && data_.get())
     data_->Clear();
   return true;
 }
 
 void InMemoryURLIndex::RebuildPrivateDataFromHistoryDBTask::
     DoneRunOnMainThread() {
   index_->DoneRebuidingPrivateDataFromHistoryDB(succeeded_, data_);
 }
 
 InMemoryURLIndex::RebuildPrivateDataFromHistoryDBTask::
     ~RebuildPrivateDataFromHistoryDBTask() {
 }
 
 // InMemoryURLIndex ------------------------------------------------------------
 
 InMemoryURLIndex::InMemoryURLIndex(
     bookmarks::BookmarkModel* bookmark_model,
     history::HistoryService* history_service,
     TemplateURLService* template_url_service,
     base::SequencedWorkerPool* worker_pool,
     const base::FilePath& history_dir,
-    const std::string& languages,
     const SchemeSet& client_schemes_to_whitelist)
     : bookmark_model_(bookmark_model),
       history_service_(history_service),
       template_url_service_(template_url_service),
       history_dir_(history_dir),
-      languages_(languages),
       private_data_(new URLIndexPrivateData),
       restore_cache_observer_(NULL),
       save_cache_observer_(NULL),
       task_runner_(
           worker_pool->GetSequencedTaskRunner(worker_pool->GetSequenceToken())),
       shutdown_(false),
       restored_(false),
       needs_to_be_cached_(false),
       listen_to_history_service_loaded_(false) {
   InitializeSchemeWhitelist(&scheme_whitelist_, client_schemes_to_whitelist);
@@ skipping 25 matching lines @@
   return true;
 }
 
 // Querying --------------------------------------------------------------------
 
 ScoredHistoryMatches InMemoryURLIndex::HistoryItemsForTerms(
     const base::string16& term_string,
     size_t cursor_position,
     size_t max_matches) {
   return private_data_->HistoryItemsForTerms(
-      term_string, cursor_position, max_matches, languages_, bookmark_model_,
+      term_string, cursor_position, max_matches, bookmark_model_,
       template_url_service_);
 }
 
 // Updating --------------------------------------------------------------------
 
 void InMemoryURLIndex::DeleteURL(const GURL& url) {
   private_data_->DeleteURL(url);
 }
 
 void InMemoryURLIndex::OnURLVisited(history::HistoryService* history_service,
                                     ui::PageTransition transition,
                                     const history::URLRow& row,
                                     const history::RedirectList& redirects,
                                     base::Time visit_time) {
   DCHECK_EQ(history_service_, history_service);
   needs_to_be_cached_ |= private_data_->UpdateURL(history_service_,
                                                   row,
-                                                  languages_,
                                                   scheme_whitelist_,
                                                   &private_data_tracker_);
 }
 
 void InMemoryURLIndex::OnURLsModified(history::HistoryService* history_service,
                                       const history::URLRows& changed_urls) {
   DCHECK_EQ(history_service_, history_service);
   for (const auto& row : changed_urls) {
     needs_to_be_cached_ |= private_data_->UpdateURL(history_service_,
                                                     row,
-                                                    languages_,
                                                     scheme_whitelist_,
                                                     &private_data_tracker_);
   }
 }
 
 void InMemoryURLIndex::OnURLsDeleted(history::HistoryService* history_service,
                                      bool all_history,
                                      bool expired,
                                      const history::URLRows& deleted_rows,
                                      const std::set<GURL>& favicon_urls) {
@@ skipping 42 matching lines @@
   if (!GetCacheFilePath(&path) || shutdown_) {
     restored_ = true;
     if (restore_cache_observer_)
       restore_cache_observer_->OnCacheRestoreFinished(false);
     return;
   }
 
   base::PostTaskAndReplyWithResult(
       task_runner_.get(),
       FROM_HERE,
-      base::Bind(&URLIndexPrivateData::RestoreFromFile, path, languages_),
+      base::Bind(&URLIndexPrivateData::RestoreFromFile, path),
       base::Bind(&InMemoryURLIndex::OnCacheLoadDone, AsWeakPtr()));
 }
 
 void InMemoryURLIndex::OnCacheLoadDone(
     scoped_refptr<URLIndexPrivateData> private_data) {
   if (private_data.get() && !private_data->Empty()) {
     private_data_tracker_.TryCancelAll();
     private_data_ = private_data;
     restored_ = true;
     if (restore_cache_observer_)
@@ skipping 38 matching lines @@
   needs_to_be_cached_ = false;
 }
 
 // Restoring from the History DB -----------------------------------------------
 
 void InMemoryURLIndex::ScheduleRebuildFromHistory() {
   DCHECK(history_service_);
   history_service_->ScheduleDBTask(
       scoped_ptr<history::HistoryDBTask>(
           new InMemoryURLIndex::RebuildPrivateDataFromHistoryDBTask(
-              this, languages_, scheme_whitelist_)),
+              this, scheme_whitelist_)),
       &cache_reader_tracker_);
 }
 
 void InMemoryURLIndex::DoneRebuidingPrivateDataFromHistoryDB(
     bool succeeded,
     scoped_refptr<URLIndexPrivateData> private_data) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (succeeded) {
     private_data_tracker_.TryCancelAll();
     private_data_ = private_data;
     PostSaveToCacheFileTask();  // Cache the newly rebuilt index.
   } else {
     private_data_->Clear();  // Dump the old private data.
     // There is no need to do anything with the cache file as it was deleted
     // when the rebuild from the history operation was kicked off.
   }
   restored_ = true;
   if (restore_cache_observer_)
     restore_cache_observer_->OnCacheRestoreFinished(succeeded);
 }
 
 void InMemoryURLIndex::RebuildFromHistory(
     history::HistoryDatabase* history_db) {
   private_data_tracker_.TryCancelAll();
   private_data_ = URLIndexPrivateData::RebuildFromHistory(history_db,
-                                                          languages_,
                                                           scheme_whitelist_);
 }
 
 // Saving to Cache -------------------------------------------------------------
 
 void InMemoryURLIndex::PostSaveToCacheFileTask() {
   base::FilePath path;
   if (!GetCacheFilePath(&path))
     return;
   // If there is anything in our private data then make a copy of it and tell
@@ skipping 14 matching lines @@
     task_runner_->PostTask(
         FROM_HERE,
         base::Bind(base::IgnoreResult(base::DeleteFile), path, false));
   }
 }
 
 void InMemoryURLIndex::OnCacheSaveDone(bool succeeded) {
   if (save_cache_observer_)
     save_cache_observer_->OnCacheSaveFinished(succeeded);
 }