src/chrome/browser/ui/webui/options/core_options_handler.cc

   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/core_options_handler.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/json/json_reader.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/strings/string16.h"
  12 #include "base/strings/string_number_conversions.h"
  13 #include "base/strings/utf_string_conversions.h"
  14 #include "base/values.h"
  15 #include "chrome/browser/browser_process.h"
  16 #include "chrome/browser/chrome_notification_types.h"
  17 #include "chrome/browser/profiles/profile.h"
  18 #include "chrome/browser/ui/options/options_util.h"
  19 #include "chrome/common/net/url_fixer_upper.h"
  20 #include "chrome/common/pref_names.h"
  21 #include "chrome/common/url_constants.h"
  22 #include "content/public/browser/notification_details.h"
  23 #include "content/public/browser/notification_types.h"
  24 #include "content/public/browser/user_metrics.h"
  25 #include "content/public/browser/web_ui.h"
  26 #include "grit/chromium_strings.h"
  27 #include "grit/generated_resources.h"
  28 #include "grit/locale_settings.h"
  29 #include "grit/theme_resources.h"
  30 #include "ui/base/l10n/l10n_util.h"
  31 #include "url/gurl.h"
  32
  33 using content::UserMetricsAction;
  34
  35 namespace options {
  36
  37 namespace {
  38
  39 // Only allow changes to the metrics reporting checkbox if we were succesfully
  40 // able to change the service.
  41 bool AllowMetricsReportingChange(const base::Value* to_value) {
  42   bool enable;
  43   if (!to_value->GetAsBoolean(&enable)) {
  44     NOTREACHED();
  45     return false;
  46   }
  47
  48   return enable == OptionsUtil::ResolveMetricsReportingEnabled(enable);
  49 }
  50
  51 }  // namespace
  52
  53 CoreOptionsHandler::CoreOptionsHandler()
  54     : handlers_host_(NULL) {
  55 }
  56
  57 CoreOptionsHandler::~CoreOptionsHandler() {}
  58
  59 void CoreOptionsHandler::InitializeHandler() {
  60   Profile* profile = Profile::FromWebUI(web_ui());
  61
  62   plugin_status_pref_setter_.Init(
  63       profile,
  64       base::Bind(&CoreOptionsHandler::OnPreferenceChanged,
  65                  base::Unretained(this),
  66                  profile->GetPrefs()));
  67
  68   pref_change_filters_[prefs::kMetricsReportingEnabled] =
  69       base::Bind(&AllowMetricsReportingChange);
  70 }
  71
  72 void CoreOptionsHandler::InitializePage() {
  73   UpdateClearPluginLSOData();
  74   UpdatePepperFlashSettingsEnabled();
  75 }
  76
  77 void CoreOptionsHandler::GetLocalizedValues(
  78     DictionaryValue* localized_strings) {
  79   GetStaticLocalizedValues(localized_strings);
  80 }
  81
  82 void CoreOptionsHandler::GetStaticLocalizedValues(
  83     base::DictionaryValue* localized_strings) {
  84   DCHECK(localized_strings);
  85   // Main
  86   localized_strings->SetString("optionsPageTitle",
  87       l10n_util::GetStringUTF16(IDS_SETTINGS_TITLE));
  88
  89   // Controlled settings bubble.
  90   localized_strings->SetString("controlledSettingPolicy",
  91       l10n_util::GetStringUTF16(IDS_OPTIONS_CONTROLLED_SETTING_POLICY));
  92   localized_strings->SetString("controlledSettingExtension",
  93       l10n_util::GetStringUTF16(IDS_OPTIONS_CONTROLLED_SETTING_EXTENSION));
  94   localized_strings->SetString("controlledSettingRecommended",
  95       l10n_util::GetStringUTF16(IDS_OPTIONS_CONTROLLED_SETTING_RECOMMENDED));
  96   localized_strings->SetString("controlledSettingHasRecommendation",
  97       l10n_util::GetStringUTF16(
  98           IDS_OPTIONS_CONTROLLED_SETTING_HAS_RECOMMENDATION));
  99   localized_strings->SetString("controlledSettingFollowRecommendation",
 100       l10n_util::GetStringUTF16(
 101           IDS_OPTIONS_CONTROLLED_SETTING_FOLLOW_RECOMMENDATION));
 102   localized_strings->SetString("controlledSettingsPolicy",
 103       l10n_util::GetStringUTF16(IDS_OPTIONS_CONTROLLED_SETTINGS_POLICY));
 104   localized_strings->SetString("controlledSettingsExtension",
 105       l10n_util::GetStringUTF16(IDS_OPTIONS_CONTROLLED_SETTINGS_EXTENSION));
 106
 107   // Search
 108   RegisterTitle(localized_strings, "searchPage", IDS_OPTIONS_SEARCH_PAGE_TITLE);
 109   localized_strings->SetString("searchPlaceholder",
 110       l10n_util::GetStringUTF16(IDS_OPTIONS_SEARCH_PLACEHOLDER));
 111   localized_strings->SetString("searchPageNoMatches",
 112       l10n_util::GetStringUTF16(IDS_OPTIONS_SEARCH_PAGE_NO_MATCHES));
 113   localized_strings->SetString("searchPageHelpLabel",
 114       l10n_util::GetStringUTF16(IDS_OPTIONS_SEARCH_PAGE_HELP_LABEL));
 115   localized_strings->SetString("searchPageHelpTitle",
 116       l10n_util::GetStringFUTF16(IDS_OPTIONS_SEARCH_PAGE_HELP_TITLE,
 117           l10n_util::GetStringUTF16(IDS_PRODUCT_NAME)));
 118   localized_strings->SetString("searchPageHelpURL",
 119                                chrome::kSettingsSearchHelpURL);
 120
 121   // Common
 122   localized_strings->SetString("ok",
 123       l10n_util::GetStringUTF16(IDS_OK));
 124   localized_strings->SetString("cancel",
 125       l10n_util::GetStringUTF16(IDS_CANCEL));
 126   localized_strings->SetString("learnMore",
 127       l10n_util::GetStringUTF16(IDS_LEARN_MORE));
 128   localized_strings->SetString("close",
 129       l10n_util::GetStringUTF16(IDS_CLOSE));
 130   localized_strings->SetString("done",
 131       l10n_util::GetStringUTF16(IDS_DONE));
 132 }
 133
 134 void CoreOptionsHandler::Uninitialize() {
 135   std::string last_pref;
 136   for (PreferenceCallbackMap::const_iterator iter = pref_callback_map_.begin();
 137        iter != pref_callback_map_.end();
 138        ++iter) {
 139     if (last_pref != iter->first) {
 140       StopObservingPref(iter->first);
 141       last_pref = iter->first;
 142     }
 143   }
 144 }
 145
 146 void CoreOptionsHandler::OnPreferenceChanged(PrefService* service,
 147                                              const std::string& pref_name) {
 148   if (pref_name == prefs::kClearPluginLSODataEnabled) {
 149     // This preference is stored in Local State, not in the user preferences.
 150     UpdateClearPluginLSOData();
 151     return;
 152   }
 153   if (pref_name == prefs::kPepperFlashSettingsEnabled) {
 154     UpdatePepperFlashSettingsEnabled();
 155     return;
 156   }
 157   NotifyPrefChanged(pref_name, std::string());
 158 }
 159
 160 void CoreOptionsHandler::RegisterMessages() {
 161   registrar_.Init(Profile::FromWebUI(web_ui())->GetPrefs());
 162   local_state_registrar_.Init(g_browser_process->local_state());
 163
 164   web_ui()->RegisterMessageCallback("coreOptionsInitialize",
 165       base::Bind(&CoreOptionsHandler::HandleInitialize,
 166                  base::Unretained(this)));
 167   web_ui()->RegisterMessageCallback("fetchPrefs",
 168       base::Bind(&CoreOptionsHandler::HandleFetchPrefs,
 169                  base::Unretained(this)));
 170   web_ui()->RegisterMessageCallback("observePrefs",
 171       base::Bind(&CoreOptionsHandler::HandleObservePrefs,
 172                  base::Unretained(this)));
 173   web_ui()->RegisterMessageCallback("setBooleanPref",
 174       base::Bind(&CoreOptionsHandler::HandleSetBooleanPref,
 175                  base::Unretained(this)));
 176   web_ui()->RegisterMessageCallback("setIntegerPref",
 177       base::Bind(&CoreOptionsHandler::HandleSetIntegerPref,
 178                  base::Unretained(this)));
 179   web_ui()->RegisterMessageCallback("setDoublePref",
 180       base::Bind(&CoreOptionsHandler::HandleSetDoublePref,
 181                  base::Unretained(this)));
 182   web_ui()->RegisterMessageCallback("setStringPref",
 183       base::Bind(&CoreOptionsHandler::HandleSetStringPref,
 184                  base::Unretained(this)));
 185   web_ui()->RegisterMessageCallback("setURLPref",
 186       base::Bind(&CoreOptionsHandler::HandleSetURLPref,
 187                  base::Unretained(this)));
 188   web_ui()->RegisterMessageCallback("setListPref",
 189       base::Bind(&CoreOptionsHandler::HandleSetListPref,
 190                  base::Unretained(this)));
 191   web_ui()->RegisterMessageCallback("clearPref",
 192       base::Bind(&CoreOptionsHandler::HandleClearPref,
 193                  base::Unretained(this)));
 194   web_ui()->RegisterMessageCallback("coreOptionsUserMetricsAction",
 195       base::Bind(&CoreOptionsHandler::HandleUserMetricsAction,
 196                  base::Unretained(this)));
 197 }
 198
 199 void CoreOptionsHandler::HandleInitialize(const ListValue* args) {
 200   DCHECK(handlers_host_);
 201   handlers_host_->InitializeHandlers();
 202 }
 203
 204 base::Value* CoreOptionsHandler::FetchPref(const std::string& pref_name) {
 205   return CreateValueForPref(pref_name, std::string());
 206 }
 207
 208 void CoreOptionsHandler::ObservePref(const std::string& pref_name) {
 209   if (g_browser_process->local_state()->FindPreference(pref_name.c_str())) {
 210     local_state_registrar_.Add(
 211         pref_name.c_str(),
 212         base::Bind(&CoreOptionsHandler::OnPreferenceChanged,
 213                    base::Unretained(this),
 214                    local_state_registrar_.prefs()));
 215   }
 216   // TODO(pneubeck): change this to if/else once kProxy is only used as a user
 217   // pref. Currently, it is both a user and a local state pref.
 218   if (Profile::FromWebUI(web_ui())->GetPrefs()->FindPreference(
 219           pref_name.c_str())) {
 220     registrar_.Add(
 221         pref_name.c_str(),
 222         base::Bind(&CoreOptionsHandler::OnPreferenceChanged,
 223                    base::Unretained(this),
 224                    registrar_.prefs()));
 225   }
 226 }
 227
 228 void CoreOptionsHandler::StopObservingPref(const std::string& pref_name) {
 229   if (g_browser_process->local_state()->FindPreference(pref_name.c_str()))
 230     local_state_registrar_.Remove(pref_name.c_str());
 231   else
 232     registrar_.Remove(pref_name.c_str());
 233 }
 234
 235 void CoreOptionsHandler::SetPref(const std::string& pref_name,
 236                                  const base::Value* value,
 237                                  const std::string& metric) {
 238   PrefService* pref_service = FindServiceForPref(pref_name);
 239   PrefChangeFilterMap::iterator iter = pref_change_filters_.find(pref_name);
 240   if (iter != pref_change_filters_.end()) {
 241     // Also check if the pref is user modifiable (don't even try to run the
 242     // filter function if the user is not allowed to change the pref).
 243     const PrefService::Preference* pref =
 244         pref_service->FindPreference(pref_name.c_str());
 245     if ((pref && !pref->IsUserModifiable()) || !iter->second.Run(value)) {
 246       // Reject the change; remind the page of the true value.
 247       NotifyPrefChanged(pref_name, std::string());
 248       return;
 249     }
 250   }
 251
 252   switch (value->GetType()) {
 253     case base::Value::TYPE_BOOLEAN:
 254     case base::Value::TYPE_INTEGER:
 255     case base::Value::TYPE_DOUBLE:
 256     case base::Value::TYPE_STRING:
 257     case base::Value::TYPE_LIST:
 258       pref_service->Set(pref_name.c_str(), *value);
 259       break;
 260
 261     default:
 262       NOTREACHED();
 263       return;
 264   }
 265
 266   ProcessUserMetric(value, metric);
 267 }
 268
 269 void CoreOptionsHandler::ClearPref(const std::string& pref_name,
 270                                    const std::string& metric) {
 271   PrefService* pref_service = FindServiceForPref(pref_name);
 272   pref_service->ClearPref(pref_name.c_str());
 273
 274   if (!metric.empty())
 275     content::RecordComputedAction(metric);
 276 }
 277
 278 void CoreOptionsHandler::ProcessUserMetric(const base::Value* value,
 279                                            const std::string& metric) {
 280   if (metric.empty())
 281     return;
 282
 283   std::string metric_string = metric;
 284   if (value->IsType(base::Value::TYPE_BOOLEAN)) {
 285     bool bool_value;
 286     CHECK(value->GetAsBoolean(&bool_value));
 287     metric_string += bool_value ? "_Enable" : "_Disable";
 288   }
 289
 290   content::RecordComputedAction(metric_string);
 291 }
 292
 293 void CoreOptionsHandler::NotifyPrefChanged(
 294     const std::string& pref_name,
 295     const std::string& controlling_pref_name) {
 296   scoped_ptr<base::Value> value(
 297       CreateValueForPref(pref_name, controlling_pref_name));
 298   DispatchPrefChangeNotification(pref_name, value.Pass());
 299 }
 300
 301 void CoreOptionsHandler::DispatchPrefChangeNotification(
 302     const std::string& name,
 303     scoped_ptr<base::Value> value) {
 304   std::pair<PreferenceCallbackMap::const_iterator,
 305             PreferenceCallbackMap::const_iterator> range =
 306       pref_callback_map_.equal_range(name);
 307   ListValue result_value;
 308   result_value.Append(new base::StringValue(name.c_str()));
 309   result_value.Append(value.release());
 310   for (PreferenceCallbackMap::const_iterator iter = range.first;
 311        iter != range.second; ++iter) {
 312     const std::string& callback_function = iter->second;
 313     web_ui()->CallJavascriptFunction(callback_function, result_value);
 314   }
 315 }
 316
 317 base::Value* CoreOptionsHandler::CreateValueForPref(
 318     const std::string& pref_name,
 319     const std::string& controlling_pref_name) {
 320   const PrefService* pref_service = FindServiceForPref(pref_name.c_str());
 321   const PrefService::Preference* pref =
 322       pref_service->FindPreference(pref_name.c_str());
 323   if (!pref) {
 324     NOTREACHED();
 325     return base::Value::CreateNullValue();
 326   }
 327   const PrefService::Preference* controlling_pref =
 328       pref_service->FindPreference(controlling_pref_name.c_str());
 329   if (!controlling_pref)
 330     controlling_pref = pref;
 331
 332   DictionaryValue* dict = new DictionaryValue;
 333   dict->Set("value", pref->GetValue()->DeepCopy());
 334   if (controlling_pref->IsManaged())
 335     dict->SetString("controlledBy", "policy");
 336   else if (controlling_pref->IsExtensionControlled())
 337     dict->SetString("controlledBy", "extension");
 338   else if (controlling_pref->IsRecommended())
 339     dict->SetString("controlledBy", "recommended");
 340
 341   const base::Value* recommended_value =
 342       controlling_pref->GetRecommendedValue();
 343   if (recommended_value)
 344     dict->Set("recommendedValue", recommended_value->DeepCopy());
 345   dict->SetBoolean("disabled", !controlling_pref->IsUserModifiable());
 346   return dict;
 347 }
 348
 349 PrefService* CoreOptionsHandler::FindServiceForPref(
 350     const std::string& pref_name) {
 351   // Proxy is a peculiar case: on ChromeOS, settings exist in both user
 352   // prefs and local state, but chrome://settings should affect only user prefs.
 353   // Elsewhere the proxy settings are stored in local state.
 354   // See http://crbug.com/157147
 355   PrefService* user_prefs = Profile::FromWebUI(web_ui())->GetPrefs();
 356   if (pref_name == prefs::kProxy)
 357 #if defined(OS_CHROMEOS)
 358     return user_prefs;
 359 #else
 360     return g_browser_process->local_state();
 361 #endif
 362
 363   // Find which PrefService contains the given pref. Pref names should not
 364   // be duplicated across services, however if they are, prefer the user's
 365   // prefs.
 366   if (user_prefs->FindPreference(pref_name.c_str()))
 367     return user_prefs;
 368
 369   if (g_browser_process->local_state()->FindPreference(pref_name.c_str()))
 370     return g_browser_process->local_state();
 371
 372   return user_prefs;
 373 }
 374
 375 void CoreOptionsHandler::HandleFetchPrefs(const ListValue* args) {
 376   // First param is name of callback function, so, there needs to be at least
 377   // one more element for the actual preference identifier.
 378   DCHECK_GE(static_cast<int>(args->GetSize()), 2);
 379
 380   // Get callback JS function name.
 381   const base::Value* callback;
 382   if (!args->Get(0, &callback) || !callback->IsType(base::Value::TYPE_STRING))
 383     return;
 384
 385   string16 callback_function;
 386   if (!callback->GetAsString(&callback_function))
 387     return;
 388
 389   // Get the list of name for prefs to build the response dictionary.
 390   DictionaryValue result_value;
 391   const base::Value* list_member;
 392
 393   for (size_t i = 1; i < args->GetSize(); i++) {
 394     if (!args->Get(i, &list_member))
 395       break;
 396
 397     if (!list_member->IsType(base::Value::TYPE_STRING))
 398       continue;
 399
 400     std::string pref_name;
 401     if (!list_member->GetAsString(&pref_name))
 402       continue;
 403
 404     result_value.Set(pref_name.c_str(), FetchPref(pref_name));
 405   }
 406   web_ui()->CallJavascriptFunction(UTF16ToASCII(callback_function),
 407                                    result_value);
 408 }
 409
 410 void CoreOptionsHandler::HandleObservePrefs(const ListValue* args) {
 411   // First param is name is JS callback function name, the rest are pref
 412   // identifiers that we are observing.
 413   DCHECK_GE(static_cast<int>(args->GetSize()), 2);
 414
 415   // Get preference change callback function name.
 416   std::string callback_func_name;
 417   if (!args->GetString(0, &callback_func_name))
 418     return;
 419
 420   // Get all other parameters - pref identifiers.
 421   for (size_t i = 1; i < args->GetSize(); i++) {
 422     const base::Value* list_member;
 423     if (!args->Get(i, &list_member))
 424       break;
 425
 426     // Just ignore bad pref identifiers for now.
 427     std::string pref_name;
 428     if (!list_member->IsType(base::Value::TYPE_STRING) ||
 429         !list_member->GetAsString(&pref_name))
 430       continue;
 431
 432     if (pref_callback_map_.find(pref_name) == pref_callback_map_.end())
 433       ObservePref(pref_name);
 434
 435     pref_callback_map_.insert(
 436         PreferenceCallbackMap::value_type(pref_name, callback_func_name));
 437   }
 438 }
 439
 440 void CoreOptionsHandler::HandleSetBooleanPref(const ListValue* args) {
 441   HandleSetPref(args, TYPE_BOOLEAN);
 442 }
 443
 444 void CoreOptionsHandler::HandleSetIntegerPref(const ListValue* args) {
 445   HandleSetPref(args, TYPE_INTEGER);
 446 }
 447
 448 void CoreOptionsHandler::HandleSetDoublePref(const ListValue* args) {
 449   HandleSetPref(args, TYPE_DOUBLE);
 450 }
 451
 452 void CoreOptionsHandler::HandleSetStringPref(const ListValue* args) {
 453   HandleSetPref(args, TYPE_STRING);
 454 }
 455
 456 void CoreOptionsHandler::HandleSetURLPref(const ListValue* args) {
 457   HandleSetPref(args, TYPE_URL);
 458 }
 459
 460 void CoreOptionsHandler::HandleSetListPref(const ListValue* args) {
 461   HandleSetPref(args, TYPE_LIST);
 462 }
 463
 464 void CoreOptionsHandler::HandleSetPref(const ListValue* args, PrefType type) {
 465   DCHECK_GT(static_cast<int>(args->GetSize()), 1);
 466
 467   std::string pref_name;
 468   if (!args->GetString(0, &pref_name))
 469     return;
 470
 471   const base::Value* value;
 472   if (!args->Get(1, &value))
 473     return;
 474
 475   scoped_ptr<base::Value> temp_value;
 476
 477   switch (type) {
 478     case TYPE_BOOLEAN:
 479       if (!value->IsType(base::Value::TYPE_BOOLEAN)) {
 480         NOTREACHED();
 481         return;
 482       }
 483       break;
 484     case TYPE_INTEGER: {
 485       // In JS all numbers are doubles.
 486       double double_value;
 487       if (!value->GetAsDouble(&double_value)) {
 488         NOTREACHED();
 489         return;
 490       }
 491       int int_value = static_cast<int>(double_value);
 492       temp_value.reset(new base::FundamentalValue(int_value));
 493       value = temp_value.get();
 494       break;
 495     }
 496     case TYPE_DOUBLE:
 497       if (!value->IsType(base::Value::TYPE_DOUBLE)) {
 498         NOTREACHED();
 499         return;
 500       }
 501       break;
 502     case TYPE_STRING:
 503       if (!value->IsType(base::Value::TYPE_STRING)) {
 504         NOTREACHED();
 505         return;
 506       }
 507       break;
 508     case TYPE_URL: {
 509       std::string original;
 510       if (!value->GetAsString(&original)) {
 511         NOTREACHED();
 512         return;
 513       }
 514       GURL fixed = URLFixerUpper::FixupURL(original, std::string());
 515       temp_value.reset(new base::StringValue(fixed.spec()));
 516       value = temp_value.get();
 517       break;
 518     }
 519     case TYPE_LIST: {
 520       // In case we have a List pref we got a JSON string.
 521       std::string json_string;
 522       if (!value->GetAsString(&json_string)) {
 523         NOTREACHED();
 524         return;
 525       }
 526       temp_value.reset(
 527           base::JSONReader::Read(json_string));
 528       value = temp_value.get();
 529       if (!value->IsType(base::Value::TYPE_LIST)) {
 530         NOTREACHED();
 531         return;
 532       }
 533       break;
 534     }
 535     default:
 536       NOTREACHED();
 537   }
 538
 539   std::string metric;
 540   if (args->GetSize() > 2 && !args->GetString(2, &metric))
 541     LOG(WARNING) << "Invalid metric parameter: " << pref_name;
 542   SetPref(pref_name, value, metric);
 543 }
 544
 545 void CoreOptionsHandler::HandleClearPref(const ListValue* args) {
 546   DCHECK_GT(static_cast<int>(args->GetSize()), 0);
 547
 548   std::string pref_name;
 549   if (!args->GetString(0, &pref_name))
 550     return;
 551
 552   std::string metric;
 553   if (args->GetSize() > 1) {
 554     if (!args->GetString(1, &metric))
 555       NOTREACHED();
 556   }
 557
 558   ClearPref(pref_name, metric);
 559 }
 560
 561 void CoreOptionsHandler::HandleUserMetricsAction(const ListValue* args) {
 562   std::string metric = UTF16ToUTF8(ExtractStringValue(args));
 563   if (!metric.empty())
 564     content::RecordComputedAction(metric);
 565 }
 566
 567 void CoreOptionsHandler::UpdateClearPluginLSOData() {
 568   base::FundamentalValue enabled(
 569           plugin_status_pref_setter_.IsClearPluginLSODataEnabled());
 570   web_ui()->CallJavascriptFunction(
 571       "OptionsPage.setClearPluginLSODataEnabled", enabled);
 572 }
 573
 574 void CoreOptionsHandler::UpdatePepperFlashSettingsEnabled() {
 575   base::FundamentalValue enabled(
 576           plugin_status_pref_setter_.IsPepperFlashSettingsEnabled());
 577   web_ui()->CallJavascriptFunction(
 578       "OptionsPage.setPepperFlashSettingsEnabled", enabled);
 579 }
 580
 581 }  // namespace options