| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "chrome/browser/ui/webui/options/search_engine_manager_handler.h" | |
| 6 | |
| 7 #include "base/bind.h" | |
| 8 #include "base/string_number_conversions.h" | |
| 9 #include "base/utf_string_conversions.h" | |
| 10 #include "base/values.h" | |
| 11 #include "chrome/browser/extensions/extension_service.h" | |
| 12 #include "chrome/browser/profiles/profile.h" | |
| 13 #include "chrome/browser/search_engines/template_url.h" | |
| 14 #include "chrome/browser/search_engines/template_url_service.h" | |
| 15 #include "chrome/browser/ui/search_engines/keyword_editor_controller.h" | |
| 16 #include "chrome/browser/ui/search_engines/template_url_table_model.h" | |
| 17 #include "chrome/common/extensions/extension.h" | |
| 18 #include "chrome/common/url_constants.h" | |
| 19 #include "content/public/browser/web_ui.h" | |
| 20 #include "grit/generated_resources.h" | |
| 21 #include "grit/locale_settings.h" | |
| 22 #include "ui/base/l10n/l10n_util.h" | |
| 23 | |
| 24 namespace { | |
| 25 | |
| 26 enum EngineInfoIndexes { | |
| 27 ENGINE_NAME, | |
| 28 ENGINE_KEYWORD, | |
| 29 ENGINE_URL, | |
| 30 }; | |
| 31 | |
| 32 }; // namespace | |
| 33 | |
| 34 SearchEngineManagerHandler::SearchEngineManagerHandler() { | |
| 35 } | |
| 36 | |
| 37 SearchEngineManagerHandler::~SearchEngineManagerHandler() { | |
| 38 if (list_controller_.get() && list_controller_->table_model()) | |
| 39 list_controller_->table_model()->SetObserver(NULL); | |
| 40 } | |
| 41 | |
| 42 void SearchEngineManagerHandler::InitializeHandler() { | |
| 43 list_controller_.reset( | |
| 44 new KeywordEditorController(Profile::FromWebUI(web_ui()))); | |
| 45 if (list_controller_.get()) { | |
| 46 list_controller_->table_model()->SetObserver(this); | |
| 47 OnModelChanged(); | |
| 48 } | |
| 49 } | |
| 50 | |
| 51 void SearchEngineManagerHandler::GetLocalizedValues( | |
| 52 base::DictionaryValue* localized_strings) { | |
| 53 DCHECK(localized_strings); | |
| 54 | |
| 55 RegisterTitle(localized_strings, "searchEngineManagerPage", | |
| 56 IDS_SEARCH_ENGINES_EDITOR_WINDOW_TITLE); | |
| 57 localized_strings->SetString("defaultSearchEngineListTitle", | |
| 58 l10n_util::GetStringUTF16(IDS_SEARCH_ENGINES_EDITOR_MAIN_SEPARATOR)); | |
| 59 localized_strings->SetString("otherSearchEngineListTitle", | |
| 60 l10n_util::GetStringUTF16(IDS_SEARCH_ENGINES_EDITOR_OTHER_SEPARATOR)); | |
| 61 localized_strings->SetString("extensionKeywordsListTitle", | |
| 62 l10n_util::GetStringUTF16( | |
| 63 IDS_SEARCH_ENGINES_EDITOR_EXTENSIONS_SEPARATOR)); | |
| 64 localized_strings->SetString("manageExtensionsLinkText", | |
| 65 l10n_util::GetStringUTF16(IDS_MANAGE_EXTENSIONS)); | |
| 66 localized_strings->SetString("searchEngineTableNameHeader", | |
| 67 l10n_util::GetStringUTF16(IDS_SEARCH_ENGINES_EDITOR_DESCRIPTION_COLUMN)); | |
| 68 localized_strings->SetString("searchEngineTableKeywordHeader", | |
| 69 l10n_util::GetStringUTF16(IDS_SEARCH_ENGINES_EDITOR_KEYWORD_COLUMN)); | |
| 70 localized_strings->SetString("searchEngineTableURLHeader", | |
| 71 l10n_util::GetStringUTF16(IDS_SEARCH_ENGINES_EDITOR_EDIT_BUTTON)); | |
| 72 localized_strings->SetString("makeDefaultSearchEngineButton", | |
| 73 l10n_util::GetStringUTF16(IDS_SEARCH_ENGINES_EDITOR_MAKE_DEFAULT_BUTTON)); | |
| 74 localized_strings->SetString("searchEngineTableNamePlaceholder", | |
| 75 l10n_util::GetStringUTF16(IDS_SEARCH_ENGINE_ADD_NEW_NAME_PLACEHOLDER)); | |
| 76 localized_strings->SetString("searchEngineTableKeywordPlaceholder", | |
| 77 l10n_util::GetStringUTF16(IDS_SEARCH_ENGINE_ADD_NEW_KEYWORD_PLACEHOLDER)); | |
| 78 localized_strings->SetString("searchEngineTableURLPlaceholder", | |
| 79 l10n_util::GetStringUTF16(IDS_SEARCH_ENGINE_ADD_NEW_URL_PLACEHOLDER)); | |
| 80 localized_strings->SetString("editSearchEngineInvalidTitleToolTip", | |
| 81 l10n_util::GetStringUTF16(IDS_SEARCH_ENGINES_INVALID_TITLE_TT)); | |
| 82 localized_strings->SetString("editSearchEngineInvalidKeywordToolTip", | |
| 83 l10n_util::GetStringUTF16(IDS_SEARCH_ENGINES_INVALID_KEYWORD_TT)); | |
| 84 localized_strings->SetString("editSearchEngineInvalidURLToolTip", | |
| 85 l10n_util::GetStringUTF16(IDS_SEARCH_ENGINES_INVALID_URL_TT)); | |
| 86 } | |
| 87 | |
| 88 void SearchEngineManagerHandler::RegisterMessages() { | |
| 89 web_ui()->RegisterMessageCallback( | |
| 90 "managerSetDefaultSearchEngine", | |
| 91 base::Bind(&SearchEngineManagerHandler::SetDefaultSearchEngine, | |
| 92 base::Unretained(this))); | |
| 93 web_ui()->RegisterMessageCallback( | |
| 94 "removeSearchEngine", | |
| 95 base::Bind(&SearchEngineManagerHandler::RemoveSearchEngine, | |
| 96 base::Unretained(this))); | |
| 97 web_ui()->RegisterMessageCallback( | |
| 98 "editSearchEngine", | |
| 99 base::Bind(&SearchEngineManagerHandler::EditSearchEngine, | |
| 100 base::Unretained(this))); | |
| 101 web_ui()->RegisterMessageCallback( | |
| 102 "checkSearchEngineInfoValidity", | |
| 103 base::Bind(&SearchEngineManagerHandler::CheckSearchEngineInfoValidity, | |
| 104 base::Unretained(this))); | |
| 105 web_ui()->RegisterMessageCallback( | |
| 106 "searchEngineEditCancelled", | |
| 107 base::Bind(&SearchEngineManagerHandler::EditCancelled, | |
| 108 base::Unretained(this))); | |
| 109 web_ui()->RegisterMessageCallback( | |
| 110 "searchEngineEditCompleted", | |
| 111 base::Bind(&SearchEngineManagerHandler::EditCompleted, | |
| 112 base::Unretained(this))); | |
| 113 } | |
| 114 | |
| 115 void SearchEngineManagerHandler::OnModelChanged() { | |
| 116 if (!list_controller_->loaded()) | |
| 117 return; | |
| 118 | |
| 119 // Find the default engine. | |
| 120 const TemplateURL* default_engine = | |
| 121 list_controller_->url_model()->GetDefaultSearchProvider(); | |
| 122 int default_index = list_controller_->table_model()->IndexOfTemplateURL( | |
| 123 default_engine); | |
| 124 | |
| 125 // Build the first list (default search engine options). | |
| 126 ListValue defaults_list; | |
| 127 int last_default_engine_index = | |
| 128 list_controller_->table_model()->last_search_engine_index(); | |
| 129 for (int i = 0; i < last_default_engine_index; ++i) { | |
| 130 defaults_list.Append(CreateDictionaryForEngine(i, i == default_index)); | |
| 131 } | |
| 132 | |
| 133 // Build the second list (other search templates). | |
| 134 ListValue others_list; | |
| 135 if (last_default_engine_index < 0) | |
| 136 last_default_engine_index = 0; | |
| 137 int engine_count = list_controller_->table_model()->RowCount(); | |
| 138 for (int i = last_default_engine_index; i < engine_count; ++i) { | |
| 139 others_list.Append(CreateDictionaryForEngine(i, i == default_index)); | |
| 140 } | |
| 141 | |
| 142 // Build the extension keywords list. | |
| 143 ListValue keyword_list; | |
| 144 ExtensionService* extension_service = | |
| 145 Profile::FromWebUI(web_ui())->GetExtensionService(); | |
| 146 if (extension_service) { | |
| 147 const ExtensionSet* extensions = extension_service->extensions(); | |
| 148 for (ExtensionSet::const_iterator it = extensions->begin(); | |
| 149 it != extensions->end(); ++it) { | |
| 150 if ((*it)->omnibox_keyword().size() > 0) | |
| 151 keyword_list.Append(CreateDictionaryForExtension(*(*it))); | |
| 152 } | |
| 153 } | |
| 154 | |
| 155 web_ui()->CallJavascriptFunction("SearchEngineManager.updateSearchEngineList", | |
| 156 defaults_list, others_list, keyword_list); | |
| 157 } | |
| 158 | |
| 159 void SearchEngineManagerHandler::OnItemsChanged(int start, int length) { | |
| 160 OnModelChanged(); | |
| 161 } | |
| 162 | |
| 163 void SearchEngineManagerHandler::OnItemsAdded(int start, int length) { | |
| 164 OnModelChanged(); | |
| 165 } | |
| 166 | |
| 167 void SearchEngineManagerHandler::OnItemsRemoved(int start, int length) { | |
| 168 OnModelChanged(); | |
| 169 } | |
| 170 | |
| 171 base::DictionaryValue* SearchEngineManagerHandler::CreateDictionaryForExtension( | |
| 172 const Extension& extension) { | |
| 173 base::DictionaryValue* dict = new base::DictionaryValue(); | |
| 174 dict->SetString("name", extension.name()); | |
| 175 dict->SetString("displayName", extension.name()); | |
| 176 dict->SetString("keyword", extension.omnibox_keyword()); | |
| 177 GURL icon = extension.GetIconURL(16, ExtensionIconSet::MATCH_BIGGER); | |
| 178 dict->SetString("iconURL", icon.spec()); | |
| 179 dict->SetString("url", string16()); | |
| 180 return dict; | |
| 181 } | |
| 182 | |
| 183 base::DictionaryValue* SearchEngineManagerHandler::CreateDictionaryForEngine( | |
| 184 int index, bool is_default) { | |
| 185 TemplateURLTableModel* table_model = list_controller_->table_model(); | |
| 186 const TemplateURL* template_url = list_controller_->GetTemplateURL(index); | |
| 187 | |
| 188 base::DictionaryValue* dict = new base::DictionaryValue(); | |
| 189 dict->SetString("name", template_url->short_name()); | |
| 190 dict->SetString("displayName", table_model->GetText( | |
| 191 index, IDS_SEARCH_ENGINES_EDITOR_DESCRIPTION_COLUMN)); | |
| 192 dict->SetString("keyword", table_model->GetText( | |
| 193 index, IDS_SEARCH_ENGINES_EDITOR_KEYWORD_COLUMN)); | |
| 194 dict->SetString("url", template_url->url()->DisplayURL()); | |
| 195 dict->SetBoolean("urlLocked", template_url->prepopulate_id() > 0); | |
| 196 GURL icon_url = template_url->GetFaviconURL(); | |
| 197 if (icon_url.is_valid()) | |
| 198 dict->SetString("iconURL", icon_url.spec()); | |
| 199 dict->SetString("modelIndex", base::IntToString(index)); | |
| 200 | |
| 201 if (list_controller_->CanRemove(template_url)) | |
| 202 dict->SetString("canBeRemoved", "1"); | |
| 203 if (list_controller_->CanMakeDefault(template_url)) | |
| 204 dict->SetString("canBeDefault", "1"); | |
| 205 if (is_default) | |
| 206 dict->SetString("default", "1"); | |
| 207 if (list_controller_->CanEdit(template_url)) | |
| 208 dict->SetString("canBeEdited", "1"); | |
| 209 | |
| 210 return dict; | |
| 211 } | |
| 212 | |
| 213 void SearchEngineManagerHandler::SetDefaultSearchEngine(const ListValue* args) { | |
| 214 int index; | |
| 215 if (!ExtractIntegerValue(args, &index)) { | |
| 216 NOTREACHED(); | |
| 217 return; | |
| 218 } | |
| 219 if (index < 0 || index >= list_controller_->table_model()->RowCount()) | |
| 220 return; | |
| 221 | |
| 222 list_controller_->MakeDefaultTemplateURL(index); | |
| 223 } | |
| 224 | |
| 225 void SearchEngineManagerHandler::RemoveSearchEngine(const ListValue* args) { | |
| 226 int index; | |
| 227 if (!ExtractIntegerValue(args, &index)) { | |
| 228 NOTREACHED(); | |
| 229 return; | |
| 230 } | |
| 231 if (index < 0 || index >= list_controller_->table_model()->RowCount()) | |
| 232 return; | |
| 233 | |
| 234 if (list_controller_->CanRemove(list_controller_->GetTemplateURL(index))) | |
| 235 list_controller_->RemoveTemplateURL(index); | |
| 236 } | |
| 237 | |
| 238 void SearchEngineManagerHandler::EditSearchEngine(const ListValue* args) { | |
| 239 int index; | |
| 240 if (!ExtractIntegerValue(args, &index)) { | |
| 241 NOTREACHED(); | |
| 242 return; | |
| 243 } | |
| 244 // Allow -1, which means we are adding a new engine. | |
| 245 if (index < -1 || index >= list_controller_->table_model()->RowCount()) | |
| 246 return; | |
| 247 | |
| 248 edit_controller_.reset(new EditSearchEngineController( | |
| 249 (index == -1) ? NULL : list_controller_->GetTemplateURL(index), this, | |
| 250 Profile::FromWebUI(web_ui()))); | |
| 251 } | |
| 252 | |
| 253 void SearchEngineManagerHandler::OnEditedKeyword( | |
| 254 const TemplateURL* template_url, | |
| 255 const string16& title, | |
| 256 const string16& keyword, | |
| 257 const std::string& url) { | |
| 258 if (template_url) | |
| 259 list_controller_->ModifyTemplateURL(template_url, title, keyword, url); | |
| 260 else | |
| 261 list_controller_->AddTemplateURL(title, keyword, url); | |
| 262 edit_controller_.reset(); | |
| 263 } | |
| 264 | |
| 265 void SearchEngineManagerHandler::CheckSearchEngineInfoValidity( | |
| 266 const ListValue* args) | |
| 267 { | |
| 268 if (!edit_controller_.get()) | |
| 269 return; | |
| 270 string16 name; | |
| 271 string16 keyword; | |
| 272 std::string url; | |
| 273 std::string modelIndex; | |
| 274 if (!args->GetString(ENGINE_NAME, &name) || | |
| 275 !args->GetString(ENGINE_KEYWORD, &keyword) || | |
| 276 !args->GetString(ENGINE_URL, &url) || | |
| 277 !args->GetString(3, &modelIndex)) { | |
| 278 NOTREACHED(); | |
| 279 return; | |
| 280 } | |
| 281 | |
| 282 base::DictionaryValue validity; | |
| 283 validity.SetBoolean("name", edit_controller_->IsTitleValid(name)); | |
| 284 validity.SetBoolean("keyword", edit_controller_->IsKeywordValid(keyword)); | |
| 285 validity.SetBoolean("url", edit_controller_->IsURLValid(url)); | |
| 286 StringValue indexValue(modelIndex); | |
| 287 web_ui()->CallJavascriptFunction("SearchEngineManager.validityCheckCallback", | |
| 288 validity, indexValue); | |
| 289 } | |
| 290 | |
| 291 void SearchEngineManagerHandler::EditCancelled(const ListValue* args) { | |
| 292 if (!edit_controller_.get()) | |
| 293 return; | |
| 294 edit_controller_->CleanUpCancelledAdd(); | |
| 295 edit_controller_.reset(); | |
| 296 } | |
| 297 | |
| 298 void SearchEngineManagerHandler::EditCompleted(const ListValue* args) { | |
| 299 if (!edit_controller_.get()) | |
| 300 return; | |
| 301 string16 name; | |
| 302 string16 keyword; | |
| 303 std::string url; | |
| 304 if (!args->GetString(ENGINE_NAME, &name) || | |
| 305 !args->GetString(ENGINE_KEYWORD, &keyword) || | |
| 306 !args->GetString(ENGINE_URL, &url)) { | |
| 307 NOTREACHED(); | |
| 308 return; | |
| 309 } | |
| 310 edit_controller_->AcceptAddOrEdit(name, keyword, url); | |
| 311 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 9814030:
get rid of old options pages (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src