[uber page] Migrate all elements in the 'System' (cros) page to new locations.

chrome/browser/ui/webui/options2/advanced_options_handler2.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 "chrome/browser/ui/webui/options2/advanced_options_handler2.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 29 matching lines @@
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if !defined(OS_CHROMEOS)
 #include "chrome/browser/printing/cloud_print/cloud_print_setup_handler.h"
 #include "chrome/browser/ui/webui/options2/advanced_options_utils2.h"
 #endif
 
+#if defined(OS_CHROMEOS)
+#include "chrome/browser/chromeos/accessibility/accessibility_util.h"
+#include "chrome/browser/chromeos/cros_settings.h"
+#include "chrome/browser/ui/webui/options2/chromeos/system_settings_provider2.h"
+#endif
+
 using content::DownloadManager;
 using content::OpenURLParams;
 using content::Referrer;
 using content::UserMetricsAction;
 
 namespace options2 {
 
 AdvancedOptionsHandler::AdvancedOptionsHandler() {
 
 #if(!defined(GOOGLE_CHROME_BUILD) && defined(OS_WIN))
@@ skipping 125 matching lines @@
     { "passwordsAndAutofillGroupName",
       IDS_OPTIONS_PASSWORDS_AND_FORMS_GROUP_NAME },
     { "passwordManagerEnabled",
       IDS_OPTIONS_PASSWORD_MANAGER_ENABLE },
     { "managePasswords",
       IDS_OPTIONS_PASSWORDS_MANAGE_PASSWORDS_LINK },
     { "autofillEnabled",
       IDS_OPTIONS_AUTOFILL_ENABLE },
     { "manageAutofillSettings",
       IDS_OPTIONS_MANAGE_AUTOFILL_SETTINGS_LINK },
+#if defined(OS_CHROMEOS)
+    { "datetimeTitle",
+      IDS_OPTIONS_SETTINGS_SECTION_TITLE_DATETIME },
+    { "timezone",
+      IDS_OPTIONS_SETTINGS_TIMEZONE_DESCRIPTION },
+    { "use24HourClock",
+      IDS_OPTIONS_SETTINGS_USE_24HOUR_CLOCK_DESCRIPTION },
+    { "accessibilityTitle",
+      IDS_OPTIONS_SETTINGS_SECTION_TITLE_ACCESSIBILITY },
+    { "accessibilitySpokenFeedback",
+      IDS_OPTIONS_SETTINGS_ACCESSIBILITY_DESCRIPTION },
+    { "accessibilityHighContrast",
+      IDS_OPTIONS_SETTINGS_ACCESSIBILITY_HIGH_CONTRAST_DESCRIPTION },
+    { "accessibilityScreenMagnifier",
+      IDS_OPTIONS_SETTINGS_ACCESSIBILITY_SCREEN_MAGNIFIER_DESCRIPTION },
+    { "accessibilityVirtualKeyboard",
+      IDS_OPTIONS_SETTINGS_ACCESSIBILITY_VIRTUAL_KEYBOARD_DESCRIPTION },
+#endif
   };
 
   RegisterStrings(localized_strings, resources, arraysize(resources));
   RegisterCloudPrintStrings(localized_strings);
   RegisterTitle(localized_strings, "advancedPage",
                 IDS_OPTIONS_ADVANCED_TAB_LABEL);
 
   localized_strings->SetString("privacyLearnMoreURL",
       google_util::AppendGoogleLocaleParam(
           GURL(chrome::kPrivacyLearnMoreURL)).spec());
 
   localized_strings->SetString(
       "languageSectionLabel",
       l10n_util::GetStringFUTF16(
           IDS_OPTIONS_ADVANCED_LANGUAGE_LABEL,
           l10n_util::GetStringUTF16(IDS_SHORT_PRODUCT_NAME)));
 
 #if defined(OS_CHROMEOS)
   localized_strings->SetString("cloudPrintLearnMoreURL",
       google_util::AppendGoogleLocaleParam(
           GURL(chrome::kCloudPrintLearnMoreURL)).spec());
+
+  // TODO(pastarmovj): replace this with a call to the CrosSettings list
+  // handling functionality to come.
+  localized_strings->Set("timezoneList",
+      static_cast<chromeos::options2::SystemSettingsProvider*>(
+          chromeos::CrosSettings::Get()->GetProvider(
+              chromeos::kSystemTimezone))->GetTimezoneList());
 #endif
 #if defined(OS_MACOSX)
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   if (profile_manager->GetNumberOfProfiles() > 1) {
     localized_strings->SetString("macPasswordsWarning",
         l10n_util::GetStringUTF16(IDS_OPTIONS_PASSWORDS_MAC_WARNING));
   }
 #endif
 }
 
@@ skipping 34 matching lines @@
   SetupProxySettingsSection();
   SetupSSLConfigSettings();
 #if !defined(OS_CHROMEOS)
   if (cloud_print_connector_ui_enabled_) {
     SetupCloudPrintConnectorSection();
     RefreshCloudPrintStatusFromService();
   } else {
     RemoveCloudPrintConnectorSection();
   }
 #endif
+#if defined(OS_CHROMEOS)
+  SetupAccessibilityFeatures();
+#endif
 #if !defined(OS_MACOSX) && !defined(OS_CHROMEOS)
   SetupBackgroundModeSettings();
 #endif
 
 }
 
 void AdvancedOptionsHandler::RegisterMessages() {
   // Register for preferences that we need to observe manually.  These have
   // special behaviors that aren't handled by the standard prefs UI.
   PrefService* prefs = Profile::FromWebUI(web_ui())->GetPrefs();
@@ skipping 17 matching lines @@
 
   auto_open_files_.Init(prefs::kDownloadExtensionsToOpen, prefs, this);
   default_font_size_.Init(prefs::kWebKitGlobalDefaultFontSize, prefs, this);
   default_zoom_level_.Init(prefs::kDefaultZoomLevel, prefs, this);
 #if !defined(OS_CHROMEOS)
   proxy_prefs_.reset(
       PrefSetObserver::CreateProxyPrefSetObserver(prefs, this));
 #endif  // !defined(OS_CHROMEOS)
 
   // Setup handlers specific to this panel.
-  web_ui()->RegisterMessageCallback("selectDownloadLocation",
+  web_ui()->RegisterMessageCallback(
+      "selectDownloadLocation",
       base::Bind(&AdvancedOptionsHandler::HandleSelectDownloadLocation,
                  base::Unretained(this)));
-  web_ui()->RegisterMessageCallback("autoOpenFileTypesAction",
+  web_ui()->RegisterMessageCallback(
+      "autoOpenFileTypesAction",
       base::Bind(&AdvancedOptionsHandler::HandleAutoOpenButton,
                  base::Unretained(this)));
-  web_ui()->RegisterMessageCallback("defaultFontSizeAction",
+  web_ui()->RegisterMessageCallback(
+      "defaultFontSizeAction",
       base::Bind(&AdvancedOptionsHandler::HandleDefaultFontSize,
                  base::Unretained(this)));
-  web_ui()->RegisterMessageCallback("defaultZoomFactorAction",
+  web_ui()->RegisterMessageCallback(
+      "defaultZoomFactorAction",
       base::Bind(&AdvancedOptionsHandler::HandleDefaultZoomFactor,
                  base::Unretained(this)));
 #if !defined(OS_CHROMEOS)
-  web_ui()->RegisterMessageCallback("metricsReportingCheckboxAction",
+  web_ui()->RegisterMessageCallback(
+      "metricsReportingCheckboxAction",
       base::Bind(&AdvancedOptionsHandler::HandleMetricsReportingCheckbox,
                  base::Unretained(this)));
 #endif
 #if !defined(USE_NSS) && !defined(USE_OPENSSL)
-  web_ui()->RegisterMessageCallback("showManageSSLCertificates",
+  web_ui()->RegisterMessageCallback(
+      "showManageSSLCertificates",
       base::Bind(&AdvancedOptionsHandler::ShowManageSSLCertificates,
                  base::Unretained(this)));
 #endif
-  web_ui()->RegisterMessageCallback("showCloudPrintManagePage",
+  web_ui()->RegisterMessageCallback(
+      "showCloudPrintManagePage",
       base::Bind(&AdvancedOptionsHandler::ShowCloudPrintManagePage,
                  base::Unretained(this)));
 #if !defined(OS_CHROMEOS)
   if (cloud_print_connector_ui_enabled_) {
-    web_ui()->RegisterMessageCallback("showCloudPrintSetupDialog",
+    web_ui()->RegisterMessageCallback(
+        "showCloudPrintSetupDialog",
         base::Bind(&AdvancedOptionsHandler::ShowCloudPrintSetupDialog,
                    base::Unretained(this)));
-    web_ui()->RegisterMessageCallback("disableCloudPrintConnector",
+    web_ui()->RegisterMessageCallback(
+        "disableCloudPrintConnector",
         base::Bind(&AdvancedOptionsHandler::HandleDisableCloudPrintConnector,
                    base::Unretained(this)));
   }
-  web_ui()->RegisterMessageCallback("showNetworkProxySettings",
+  web_ui()->RegisterMessageCallback(
+      "showNetworkProxySettings",
       base::Bind(&AdvancedOptionsHandler::ShowNetworkProxySettings,
                  base::Unretained(this)));
 #endif
-  web_ui()->RegisterMessageCallback("checkRevocationCheckboxAction",
+  web_ui()->RegisterMessageCallback(
+      "checkRevocationCheckboxAction",
       base::Bind(&AdvancedOptionsHandler::HandleCheckRevocationCheckbox,
                  base::Unretained(this)));
 #if !defined(OS_MACOSX) && !defined(OS_CHROMEOS)
-  web_ui()->RegisterMessageCallback("backgroundModeAction",
+  web_ui()->RegisterMessageCallback(
+      "backgroundModeAction",
       base::Bind(&AdvancedOptionsHandler::HandleBackgroundModeCheckbox,
                  base::Unretained(this)));
 #endif
+#if defined(OS_CHROMEOS)
+  web_ui()->RegisterMessageCallback(
+      "spokenFeedbackChange",
+      base::Bind(&AdvancedOptionsHandler::SpokenFeedbackChangeCallback,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      "highContrastChange",
+      base::Bind(&AdvancedOptionsHandler::HighContrastChangeCallback,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      "screenMagnifierChange",
+      base::Bind(&AdvancedOptionsHandler::ScreenMagnifierChangeCallback,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      "virtualKeyboardChange",
+      base::Bind(&AdvancedOptionsHandler::VirtualKeyboardChangeCallback,
+                 base::Unretained(this)));
+#endif
 }
 
 void AdvancedOptionsHandler::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   if (type == chrome::NOTIFICATION_PREF_CHANGED) {
     std::string* pref_name = content::Details<std::string>(details).ptr();
     if (*pref_name == prefs::kDownloadExtensionsToOpen) {
       SetupAutoOpenFileTypesDisabledAttribute();
@@ skipping 104 matching lines @@
   bool enabled = checked_str == "true";
   content::RecordAction(enabled ?
       UserMetricsAction("Options_BackgroundMode_Enable") :
       UserMetricsAction("Options_BackgroundMode_Disable"));
   background_mode_enabled_.SetValue(enabled);
 }
 
 void AdvancedOptionsHandler::SetupBackgroundModeSettings() {
     base::FundamentalValue checked(background_mode_enabled_.GetValue());
     web_ui()->CallJavascriptFunction(
-        "options.AdvancedOptions.SetBackgroundModeCheckboxState", checked);
+        "AdvancedOptions.SetBackgroundModeCheckboxState", checked);
 }
 #endif
 
 #if !defined(OS_CHROMEOS)
 void AdvancedOptionsHandler::ShowNetworkProxySettings(const ListValue* args) {
   content::RecordAction(UserMetricsAction("Options_ShowProxySettings"));
   AdvancedOptionsUtilities::ShowNetworkProxySettings(web_ui()->web_contents());
 }
 #endif
 
@@ skipping 67 matching lines @@
         l10n_util::GetStringUTF16(IDS_GOOGLE_CLOUD_PRINT));
   } else {
     label_str = l10n_util::GetStringFUTF16(
         IDS_OPTIONS_CLOUD_PRINT_CONNECTOR_ENABLED_LABEL,
         l10n_util::GetStringUTF16(IDS_GOOGLE_CLOUD_PRINT),
         UTF8ToUTF16(email));
   }
   StringValue label(label_str);
 
   web_ui()->CallJavascriptFunction(
-      "options.AdvancedOptions.SetupCloudPrintConnectorSection",
-      disabled, label, allowed);
+      "AdvancedOptions.SetupCloudPrintConnectorSection", disabled, label,
+      allowed);
 }
 
 void AdvancedOptionsHandler::RemoveCloudPrintConnectorSection() {
   web_ui()->CallJavascriptFunction(
-      "options.AdvancedOptions.RemoveCloudPrintConnectorSection");
+      "AdvancedOptions.RemoveCloudPrintConnectorSection");
+}
+#endif
+
+#if defined(OS_CHROMEOS)
+void AdvancedOptionsHandler::SpokenFeedbackChangeCallback(
+    const ListValue* args) {
+  bool enabled = false;
+  args->GetBoolean(0, &enabled);
+
+  chromeos::accessibility::EnableAccessibility(enabled, NULL);
 }
 
+void AdvancedOptionsHandler::HighContrastChangeCallback(const ListValue* args) {
+  bool enabled = false;
+  args->GetBoolean(0, &enabled);
+
+  chromeos::accessibility::EnableHighContrast(enabled);
+}
+
+void AdvancedOptionsHandler::ScreenMagnifierChangeCallback(
+    const ListValue* args) {
+  bool enabled = false;
+  args->GetBoolean(0, &enabled);
+
+  chromeos::accessibility::EnableScreenMagnifier(enabled);
+}
+
+void AdvancedOptionsHandler::VirtualKeyboardChangeCallback(
+    const ListValue* args) {
+  bool enabled = false;
+  args->GetBoolean(0, &enabled);
+
+  chromeos::accessibility::EnableVirtualKeyboard(enabled);
+}
+
+void AdvancedOptionsHandler::SetupAccessibilityFeatures() {
+  PrefService* pref_service = g_browser_process->local_state();
+  base::FundamentalValue spoken_feedback_enabled(
+      pref_service->GetBoolean(prefs::kSpokenFeedbackEnabled));
+  web_ui()->CallJavascriptFunction(
+      "AdvancedOptions.setSpokenFeedbackCheckboxState",
+      spoken_feedback_enabled);
+  base::FundamentalValue high_contrast_enabled(
+      pref_service->GetBoolean(prefs::kHighContrastEnabled));
+  web_ui()->CallJavascriptFunction(
+      "AdvancedOptions.setHighContrastCheckboxState",
+      high_contrast_enabled);
+  base::FundamentalValue screen_magnifier_enabled(
+      pref_service->GetBoolean(prefs::kScreenMagnifierEnabled));
+  web_ui()->CallJavascriptFunction(
+      "AdvancedOptions.setScreenMagnifierCheckboxState",
+      screen_magnifier_enabled);
+  base::FundamentalValue virtual_keyboard_enabled(
+      pref_service->GetBoolean(prefs::kVirtualKeyboardEnabled));
+  web_ui()->CallJavascriptFunction(
+      "AdvancedOptions.setVirtualKeyboardCheckboxState",
+      virtual_keyboard_enabled);
+}
 #endif
 
 void AdvancedOptionsHandler::SetupMetricsReportingCheckbox() {
 #if defined(GOOGLE_CHROME_BUILD) && !defined(OS_CHROMEOS)
   base::FundamentalValue checked(enable_metrics_recording_.GetValue());
   base::FundamentalValue disabled(enable_metrics_recording_.IsManaged());
   web_ui()->CallJavascriptFunction(
-      "options.AdvancedOptions.SetMetricsReportingCheckboxState", checked,
-      disabled);
+      "AdvancedOptions.SetMetricsReportingCheckboxState", checked, disabled);
 #endif
 }
 
 void AdvancedOptionsHandler::SetupMetricsReportingSettingVisibility() {
 #if defined(GOOGLE_CHROME_BUILD) && defined(OS_CHROMEOS)
   // Don't show the reporting setting if we are in the guest mode.
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kGuestSession)) {
     base::FundamentalValue visible(false);
     web_ui()->CallJavascriptFunction(
-        "options.AdvancedOptions.SetMetricsReportingSettingVisibility",
-        visible);
+        "AdvancedOptions.SetMetricsReportingSettingVisibility", visible);
   }
 #endif
 }
 
 void AdvancedOptionsHandler::SetupFontSizeSelector() {
   // We're only interested in integer values, so convert to int.
   base::FundamentalValue font_size(default_font_size_.GetValue());
-  web_ui()->CallJavascriptFunction(
-      "options.AdvancedOptions.SetFontSize", font_size);
+  web_ui()->CallJavascriptFunction("AdvancedOptions.SetFontSize", font_size);
 }
 
 void AdvancedOptionsHandler::SetupPageZoomSelector() {
   PrefService* pref_service = Profile::FromWebUI(web_ui())->GetPrefs();
   double default_zoom_level = pref_service->GetDouble(prefs::kDefaultZoomLevel);
   double default_zoom_factor =
       WebKit::WebView::zoomLevelToZoomFactor(default_zoom_level);
 
   // Generate a vector of zoom factors from an array of known presets along with
   // the default factor added if necessary.
@@ skipping 14 matching lines @@
     int percent = static_cast<int>(factor * 100 + 0.5);
     option->Append(Value::CreateStringValue(
         l10n_util::GetStringFUTF16Int(IDS_ZOOM_PERCENT, percent)));
     option->Append(Value::CreateDoubleValue(factor));
     bool selected = content::ZoomValuesEqual(factor, default_zoom_factor);
     option->Append(Value::CreateBooleanValue(selected));
     zoom_factors_value.Append(option);
   }
 
   web_ui()->CallJavascriptFunction(
-      "options.AdvancedOptions.SetupPageZoomSelector", zoom_factors_value);
+      "AdvancedOptions.SetupPageZoomSelector", zoom_factors_value);
 }
 
 void AdvancedOptionsHandler::SetupAutoOpenFileTypesDisabledAttribute() {
   // Set the enabled state for the AutoOpenFileTypesResetToDefault button.
   // We enable the button if the user has any auto-open file types registered.
   DownloadManager* manager =
       web_ui()->web_contents()->GetBrowserContext()->GetDownloadManager();
   bool disabled = !(manager &&
       DownloadPrefs::FromDownloadManager(manager)->IsAutoOpenUsed());
   base::FundamentalValue value(disabled);
   web_ui()->CallJavascriptFunction(
-      "options.AdvancedOptions.SetAutoOpenFileTypesDisabledAttribute", value);
+      "AdvancedOptions.SetAutoOpenFileTypesDisabledAttribute", value);
 }
 
 void AdvancedOptionsHandler::SetupProxySettingsSection() {
 #if !defined(OS_CHROMEOS)
   // Disable the button if proxy settings are managed by a sysadmin or
   // overridden by an extension.
   PrefService* pref_service = Profile::FromWebUI(web_ui())->GetPrefs();
   const PrefService::Preference* proxy_config =
       pref_service->FindPreference(prefs::kProxy);
   bool is_extension_controlled = (proxy_config &&
                                   proxy_config->IsExtensionControlled());
 
   base::FundamentalValue disabled(proxy_prefs_->IsManaged() ||
                             is_extension_controlled);
 
   // Get the appropriate info string to describe the button.
   string16 label_str;
   if (is_extension_controlled) {
     label_str = l10n_util::GetStringUTF16(IDS_OPTIONS_EXTENSION_PROXIES_LABEL);
   } else {
     label_str = l10n_util::GetStringFUTF16(IDS_OPTIONS_SYSTEM_PROXIES_LABEL,
         l10n_util::GetStringUTF16(IDS_PRODUCT_NAME));
   }
   StringValue label(label_str);
 
   web_ui()->CallJavascriptFunction(
-      "options.AdvancedOptions.SetupProxySettingsSection", disabled, label);
+      "AdvancedOptions.SetupProxySettingsSection", disabled, label);
 #endif  // !defined(OS_CHROMEOS)
 }
 
 void AdvancedOptionsHandler::SetupSSLConfigSettings() {
   {
     base::FundamentalValue checked(rev_checking_enabled_.GetValue());
     base::FundamentalValue disabled(rev_checking_enabled_.IsManaged());
     web_ui()->CallJavascriptFunction(
-        "options.AdvancedOptions.SetCheckRevocationCheckboxState", checked,
-        disabled);
+        "AdvancedOptions.SetCheckRevocationCheckboxState", checked, disabled);
   }
 }
 
 }  // namespace options2