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

chrome/browser/ui/passwords/password_manager_presenter.cc

 // Copyright 2013 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 "chrome/browser/ui/passwords/password_manager_presenter.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 59 matching lines @@
   return "2";
 }
 
 // Creates key for sorting password or password exception entries.
 // The key is eTLD+1 followed by subdomains
 // (e.g. secure.accounts.example.com => example.com.accounts.secure).
 // If |username_and_password_in_key == true|, username and password is appended
 // to the key. The entry type code (non-Android, Android w/ or w/o affiliated
 // web realm) is also appended to the key.
 std::string CreateSortKey(const autofill::PasswordForm& form,
-                          const std::string& languages,
                           bool username_and_password_in_key) {
   bool is_android_uri = false;
   bool is_clickable = false;
   GURL link_url;
   std::string origin = password_manager::GetShownOriginAndLinkUrl(
-      form, languages, &is_android_uri, &link_url, &is_clickable);
+      form, &is_android_uri, &link_url, &is_clickable);
 
   if (!is_clickable) {  // e.g. android://com.example.r => r.example.com.
     origin = SplitByDotAndReverse(
         StringPiece(&origin[kAndroidAppSchemeAndDelimiterLength],
                     origin.length() - kAndroidAppSchemeAndDelimiterLength));
   }
 
   std::string site_name =
       net::registry_controlled_domains::GetDomainAndRegistry(
           origin, net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
@@ skipping 12 matching lines @@
   // Since Android and non-Android entries shouldn't be merged into one entry,
   // add the entry type code to the sort key.
   key +=
       kSortKeyPartsSeparator + GetEntryTypeCode(is_android_uri, is_clickable);
   return key;
 }
 
 // Finds duplicates of |form| in |duplicates|, removes them from |store| and
 // from |duplicates|.
 void RemoveDuplicates(const autofill::PasswordForm& form,
-                      const std::string& languages,
                       DuplicatesMap* duplicates,
                       PasswordStore* store,
                       bool username_and_password_in_key) {
   std::string key =
-      CreateSortKey(form, languages, username_and_password_in_key);
+      CreateSortKey(form, username_and_password_in_key);
   std::pair<DuplicatesMap::iterator, DuplicatesMap::iterator> dups =
       duplicates->equal_range(key);
   for (DuplicatesMap::iterator it = dups.first; it != dups.second; ++it)
     store->RemoveLogin(*it->second);
   duplicates->erase(key);
 }
 
 }  // namespace
 
 PasswordManagerPresenter::PasswordManagerPresenter(
     PasswordUIView* password_view)
     : populater_(this),
       exception_populater_(this),
       password_view_(password_view) {
   DCHECK(password_view_);
 }
 
 PasswordManagerPresenter::~PasswordManagerPresenter() {
   PasswordStore* store = GetPasswordStore();
   if (store)
     store->RemoveObserver(this);
 }
 
 void PasswordManagerPresenter::Initialize() {
   PasswordStore* store = GetPasswordStore();
   if (store)
     store->AddObserver(this);
-
-  languages_ = password_view_->GetProfile()->GetPrefs()->
-      GetString(prefs::kAcceptLanguages);
 }
 
 void PasswordManagerPresenter::OnLoginsChanged(
     const password_manager::PasswordStoreChangeList& changes) {
   // Entire list is updated for convenience.
   UpdatePasswordLists();
 }
 
 PasswordStore* PasswordManagerPresenter::GetPasswordStore() {
   return PasswordStoreFactory::GetForProfile(password_view_->GetProfile(),
@@ skipping 19 matching lines @@
   if (index >= password_list_.size()) {
     // |index| out of bounds might come from a compromised renderer, don't let
     // it crash the browser. http://crbug.com/362054
     NOTREACHED();
     return;
   }
   PasswordStore* store = GetPasswordStore();
   if (!store)
     return;
 
-  RemoveDuplicates(*password_list_[index], languages_, &password_duplicates_,
+  RemoveDuplicates(*password_list_[index], &password_duplicates_,
                    store, true);
   store->RemoveLogin(*password_list_[index]);
   content::RecordAction(
       base::UserMetricsAction("PasswordManager_RemoveSavedPassword"));
 }
 
 void PasswordManagerPresenter::RemovePasswordException(size_t index) {
   if (index >= password_exception_list_.size()) {
     // |index| out of bounds might come from a compromised renderer, don't let
     // it crash the browser. http://crbug.com/362054
     NOTREACHED();
     return;
   }
   PasswordStore* store = GetPasswordStore();
   if (!store)
     return;
-  RemoveDuplicates(*password_exception_list_[index], languages_,
+  RemoveDuplicates(*password_exception_list_[index],
                    &password_exception_duplicates_, store, false);
   store->RemoveLogin(*password_exception_list_[index]);
   content::RecordAction(
       base::UserMetricsAction("PasswordManager_RemovePasswordException"));
 }
 
 void PasswordManagerPresenter::RequestShowPassword(size_t index) {
 #if !defined(OS_ANDROID)  // This is never called on Android.
   if (index >= password_list_.size()) {
     // |index| out of bounds might come from a compromised renderer, don't let
@@ skipping 24 matching lines @@
   }
   if (password_manager::sync_util::IsSyncAccountCredential(
           *password_list_[index], sync_service,
           SigninManagerFactory::GetForProfile(password_view_->GetProfile()))) {
     content::RecordAction(
         base::UserMetricsAction("PasswordManager_SyncCredentialShown"));
   }
 
   // Call back the front end to reveal the password.
   std::string origin_url = password_manager::GetHumanReadableOrigin(
-      *password_list_[index], languages_);
+      *password_list_[index]);
   password_view_->ShowPassword(
       index,
       origin_url,
       base::UTF16ToUTF8(password_list_[index]->username_value),
       password_list_[index]->password_value);
 #endif
 }
 
 const autofill::PasswordForm* PasswordManagerPresenter::GetPassword(
     size_t index) {
@@ skipping 19 matching lines @@
 
 void PasswordManagerPresenter::SetPasswordList() {
   password_view_->SetPasswordList(password_list_);
 }
 
 void PasswordManagerPresenter::SetPasswordExceptionList() {
   password_view_->SetPasswordExceptionList(password_exception_list_);
 }
 
 void PasswordManagerPresenter::SortEntriesAndHideDuplicates(
-    const std::string& languages,
     std::vector<scoped_ptr<autofill::PasswordForm>>* list,
     DuplicatesMap* duplicates,
     bool username_and_password_in_key) {
   std::vector<std::pair<std::string, scoped_ptr<autofill::PasswordForm>>> pairs;
   pairs.reserve(list->size());
   for (auto& form : *list) {
     pairs.push_back(std::make_pair(
-        CreateSortKey(*form, languages, username_and_password_in_key),
-        std::move(form)));
+        CreateSortKey(*form, username_and_password_in_key), std::move(form)));
   }
 
   std::sort(
       pairs.begin(), pairs.end(),
       [](const std::pair<std::string, scoped_ptr<autofill::PasswordForm>>& left,
          const std::pair<std::string, scoped_ptr<autofill::PasswordForm>>&
              right) { return left.first < right.first; });
 
   list->clear();
   duplicates->clear();
@@ skipping 26 matching lines @@
     store->GetAutofillableLoginsWithAffiliatedRealms(this);
   } else {
     LOG(ERROR) << "No password store! Cannot display passwords.";
   }
 }
 
 void PasswordManagerPresenter::PasswordListPopulater::OnGetPasswordStoreResults(
     ScopedVector<autofill::PasswordForm> results) {
   page_->password_list_ =
       password_manager_util::ConvertScopedVector(std::move(results));
-  page_->SortEntriesAndHideDuplicates(page_->languages_, &page_->password_list_,
+  page_->SortEntriesAndHideDuplicates(&page_->password_list_,
                                       &page_->password_duplicates_,
                                       true /* use username and password */);
   page_->SetPasswordList();
 }
 
 PasswordManagerPresenter::PasswordExceptionListPopulater::
     PasswordExceptionListPopulater(PasswordManagerPresenter* page)
         : ListPopulater(page) {
 }
 
 void PasswordManagerPresenter::PasswordExceptionListPopulater::Populate() {
   PasswordStore* store = page_->GetPasswordStore();
   if (store != NULL) {
     cancelable_task_tracker()->TryCancelAll();
     store->GetBlacklistLoginsWithAffiliatedRealms(this);
   } else {
     LOG(ERROR) << "No password store! Cannot display exceptions.";
   }
 }
 
 void PasswordManagerPresenter::PasswordExceptionListPopulater::
     OnGetPasswordStoreResults(ScopedVector<autofill::PasswordForm> results) {
   page_->password_exception_list_ =
       password_manager_util::ConvertScopedVector(std::move(results));
-  page_->SortEntriesAndHideDuplicates(
-      page_->languages_, &page_->password_exception_list_,
+  page_->SortEntriesAndHideDuplicates(&page_->password_exception_list_,
       &page_->password_exception_duplicates_,
       false /* don't use username and password*/);
   page_->SetPasswordExceptionList();
 }