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

components/bookmarks/browser/bookmark_model.cc

 // Copyright 2014 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/bookmarks/browser/bookmark_model.h"
 
 #include <algorithm>
 #include <functional>
 #include <utility>
 
@@ skipping 129 matching lines @@
   if (loaded_)
     return;
 
   // See comment in HistoryService::ShutdownOnUIThread where this is invoked for
   // details. It is also called when the BookmarkModel is deleted.
   loaded_signal_.Signal();
 }
 
 void BookmarkModel::Load(
     PrefService* pref_service,
-    const std::string& accept_languages,
     const base::FilePath& profile_path,
     const scoped_refptr<base::SequencedTaskRunner>& io_task_runner,
     const scoped_refptr<base::SequencedTaskRunner>& ui_task_runner) {
   if (store_.get()) {
     // If the store is non-null, it means Load was already invoked. Load should
     // only be invoked once.
     NOTREACHED();
     return;
   }
 
   expanded_state_tracker_.reset(
       new BookmarkExpandedStateTracker(this, pref_service));
 
   // Load the bookmarks. BookmarkStorage notifies us when done.
   store_.reset(new BookmarkStorage(this, profile_path, io_task_runner.get()));
-  store_->LoadBookmarks(CreateLoadDetails(accept_languages), ui_task_runner);
+  store_->LoadBookmarks(CreateLoadDetails(), ui_task_runner);
 }
 
 const BookmarkNode* BookmarkModel::GetParentForNewNodes() {
   std::vector<const BookmarkNode*> nodes =
       GetMostRecentlyModifiedUserFolders(this, 1);
   DCHECK(!nodes.empty());  // This list is always padded with default folders.
   return nodes[0];
 }
 
 void BookmarkModel::AddObserver(BookmarkModelObserver* observer) {
@@ skipping 906 matching lines @@
   if (node->is_url())
     nodes_ordered_by_url_set_.insert(node);
   for (int i = 0; i < node->child_count(); ++i)
     PopulateNodesByURL(node->GetChild(i));
 }
 
 int64_t BookmarkModel::generate_next_node_id() {
   return next_node_id_++;
 }
 
-scoped_ptr<BookmarkLoadDetails> BookmarkModel::CreateLoadDetails(
-    const std::string& accept_languages) {
+scoped_ptr<BookmarkLoadDetails> BookmarkModel::CreateLoadDetails() {
   BookmarkPermanentNode* bb_node =
       CreatePermanentNode(BookmarkNode::BOOKMARK_BAR);
   BookmarkPermanentNode* other_node =
       CreatePermanentNode(BookmarkNode::OTHER_NODE);
   BookmarkPermanentNode* mobile_node =
       CreatePermanentNode(BookmarkNode::MOBILE);
   return scoped_ptr<BookmarkLoadDetails>(new BookmarkLoadDetails(
       bb_node,
       other_node,
       mobile_node,
       client_->GetLoadExtraNodesCallback(),
-      new BookmarkIndex(client_.get(), accept_languages),
+      new BookmarkIndex(client_.get()),
       next_node_id_));
 }
 
 void BookmarkModel::SetUndoDelegate(BookmarkUndoDelegate* undo_delegate) {
   undo_delegate_ = undo_delegate;
   if (undo_delegate_)
     undo_delegate_->SetUndoProvider(this);
 }
 
 BookmarkUndoDelegate* BookmarkModel::undo_delegate() const {
   return undo_delegate_ ? undo_delegate_ : empty_undo_delegate_.get();
 }
 
 }  // namespace bookmarks