retry 136193 - convert localStrings to loadTimeData for options page

chrome/browser/resources/options2/language_options.js

 // 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.
 
 // TODO(kochi): Generalize the notification as a component and put it
 // in js/cr/ui/notification.js .
 
 cr.define('options', function() {
   /** @const */ var OptionsPage = options.OptionsPage;
   /** @const */ var LanguageList = options.LanguageList;
@@ skipping 11 matching lines @@
   };
 
   /////////////////////////////////////////////////////////////////////////////
   // LanguageOptions class:
 
   /**
    * Encapsulated handling of ChromeOS language options page.
    * @constructor
    */
   function LanguageOptions(model) {
-    OptionsPage.call(this, 'languages', templateData.languagePageTabTitle,
+    OptionsPage.call(this, 'languages',
+                     loadTimeData.getString('languagePageTabTitle'),
                      'languagePage');
   }
 
   cr.addSingletonGetter(LanguageOptions);
 
   // Inherit LanguageOptions from OptionsPage.
   LanguageOptions.prototype = {
     __proto__: OptionsPage.prototype,
 
     /**
@@ skipping 43 matching lines @@
         var addLanguageList = $('add-language-overlay-language-list');
         addLanguageList.addEventListener('click',
             this.handleAddLanguageListClick_.bind(this));
       } else {
         // Listen to add language dialog ok button.
         var addLanguageOkButton = $('add-language-overlay-ok-button');
         addLanguageOkButton.addEventListener('click',
             this.handleAddLanguageOkButtonClick_.bind(this));
 
         // Show experimental features if enabled.
-        if (templateData.experimentalSpellCheckFeatures == 'true')
+        if (loadTimeData.getBoolean('experimentalSpellCheckFeatures'))
           $('auto-spell-correction-option').hidden = false;
 
         // Handle spell check enable/disable.
         if (!cr.isMac) {
           Preferences.getInstance().addEventListener(
               this.enableSpellCheckPref,
               this.updateEnableSpellCheck_.bind(this));
 
           var spellCheckLanguageButton = getRequiredElement(
               'language-options-spell-check-language-button');
@@ skipping 36 matching lines @@
     spellCheckDictionary_: '',
     // The map of language code to input method IDs, like:
     // {'ja': ['mozc', 'mozc-jp'], 'zh-CN': ['pinyin'], ...}
     languageCodeToInputMethodIdsMap_: {},
 
     /**
      * Initializes the input method list.
      */
     initializeInputMethodList_: function() {
       var inputMethodList = $('language-options-input-method-list');
-      var inputMethodListData = templateData.inputMethodList;
+      var inputMethodListData = loadTimeData.getValue('inputMethodList');
       var inputMethodPrototype = $('language-options-input-method-proto');
 
       // Add all input methods, but make all of them invisible here. We'll
       // change the visibility in handleLanguageOptionsListChange_() based
       // on the selected language. Note that we only have less than 100
       // input methods, so creating DOM nodes at once here should be ok.
       for (var i = 0; i < inputMethodListData.length; i++) {
         var inputMethod = inputMethodListData[i];
         var element = inputMethodPrototype.cloneNode(true);
         element.id = '';
@@ skipping 23 matching lines @@
     },
 
     /**
      * Creates a configure button for the given input method ID.
      * @param {string} inputMethodId Input method ID (ex. "pinyin").
      * @param {string} pageName Name of the config page (ex. "languagePinyin").
      * @private
      */
     createConfigureInputMethodButton_: function(inputMethodId, pageName) {
       var button = document.createElement('button');
-      button.textContent = localStrings.getString('configure');
+      button.textContent = loadTimeData.getString('configure');
       button.onclick = function(e) {
         // Prevent the default action (i.e. changing the checked property
         // of the checkbox). The button click here should not be handled
         // as checkbox click.
         e.preventDefault();
         chrome.send('inputMethodOptionsOpen', [inputMethodId]);
         OptionsPage.navigateToPage(pageName);
       };
       return button;
     },
@@ skipping 40 matching lines @@
       if (cr.isChromeOS)
         this.updateInputMethodList_(languageCode);
 
       this.updateLanguageListInAddLanguageOverlay_();
     },
 
     /**
      * Happens when a user changes back to the language they're currently using.
      */
     currentLocaleWasReselected: function() {
-      this.updateUiLanguageButton_(templateData.currentUiLanguageCode);
+      this.updateUiLanguageButton_(
+          loadTimeData.getString('currentUiLanguageCode'));
     },
 
     /**
      * Handles languageOptionsList's save event.
      * @param {Event} e Save event.
      * @private
      */
     handleLanguageOptionsListSave_: function(e) {
       if (cr.isChromeOS) {
         // Sort the preload engines per the saved languages before save.
@@ skipping 48 matching lines @@
       }
 
       return newPreloadEngines;
     },
 
     /**
      * Initializes the map of language code to input method IDs.
      * @private
      */
     initializeLanguageCodeToInputMethodIdsMap_: function() {
-      var inputMethodList = templateData.inputMethodList;
+      var inputMethodList = loadTimeData.getValue('inputMethodList');
       for (var i = 0; i < inputMethodList.length; i++) {
         var inputMethod = inputMethodList[i];
         for (var languageCode in inputMethod.languageCodeSet) {
           if (languageCode in this.languageCodeToInputMethodIdsMap_) {
             this.languageCodeToInputMethodIdsMap_[languageCode].push(
                 inputMethod.id);
           } else {
             this.languageCodeToInputMethodIdsMap_[languageCode] =
                 [inputMethod.id];
           }
@@ skipping 34 matching lines @@
       var uiLanguageMessage = $('language-options-ui-language-message');
       var uiLanguageNotification = $('language-options-ui-notification-bar');
 
       // Remove the event listener and add it back if useful.
       uiLanguageButton.onclick = null;
 
       // Unhide the language button every time, as it could've been previously
       // hidden by a language change.
       uiLanguageButton.hidden = false;
 
-      if (languageCode == templateData.prospectiveUiLanguageCode) {
+      if (languageCode == loadTimeData.getString('prospectiveUiLanguageCode')) {
         uiLanguageMessage.textContent =
-            localStrings.getString('is_displayed_in_this_language');
+            loadTimeData.getString('is_displayed_in_this_language');
         showMutuallyExclusiveNodes(
             [uiLanguageButton, uiLanguageMessage, uiLanguageNotification], 1);
-      } else if (languageCode in templateData.uiLanguageCodeSet) {
+      } else if (languageCode in loadTimeData.getValue('uiLanguageCodeSet')) {
         if (cr.isChromeOS && UIAccountTweaks.loggedInAsGuest()) {
           // In the guest mode for ChromeOS, changing UI language does not make
           // sense because it does not take effect after browser restart.
           uiLanguageButton.hidden = true;
           uiLanguageMessage.hidden = true;
         } else {
           uiLanguageButton.textContent =
-              localStrings.getString('display_in_this_language');
+              loadTimeData.getString('display_in_this_language');
           showMutuallyExclusiveNodes(
               [uiLanguageButton, uiLanguageMessage, uiLanguageNotification], 0);
           uiLanguageButton.onclick = function(e) {
             chrome.send('uiLanguageChange', [languageCode]);
           };
         }
       } else {
         uiLanguageMessage.textContent =
-            localStrings.getString('cannot_be_displayed_in_this_language');
+            loadTimeData.getString('cannot_be_displayed_in_this_language');
         showMutuallyExclusiveNodes(
             [uiLanguageButton, uiLanguageMessage, uiLanguageNotification], 1);
       }
     },
 
     /**
      * Updates the spell check language button.
      * @param {string} languageCode Language code (ex. "fr").
      * @private
      */
     updateSpellCheckLanguageButton_: function(languageCode) {
       var spellCheckLanguageButton =
           $('language-options-spell-check-language-button');
       var spellCheckLanguageMessage =
           $('language-options-spell-check-language-message');
 
       if (languageCode == this.spellCheckDictionary_) {
         spellCheckLanguageMessage.textContent =
-            localStrings.getString('is_used_for_spell_checking');
+            loadTimeData.getString('is_used_for_spell_checking');
         showMutuallyExclusiveNodes(
             [spellCheckLanguageButton, spellCheckLanguageMessage], 1);
-      } else if (languageCode in templateData.spellCheckLanguageCodeSet) {
+      } else if (languageCode in
+          loadTimeData.getValue('spellCheckLanguageCodeSet')) {
         spellCheckLanguageButton.textContent =
-            localStrings.getString('use_this_for_spell_checking');
+            loadTimeData.getString('use_this_for_spell_checking');
         showMutuallyExclusiveNodes(
             [spellCheckLanguageButton, spellCheckLanguageMessage], 0);
         spellCheckLanguageButton.languageCode = languageCode;
       } else if (!languageCode) {
         spellCheckLanguageButton.hidden = true;
         spellCheckLanguageMessage.hidden = true;
       } else {
         spellCheckLanguageMessage.textContent =
-            localStrings.getString('cannot_be_used_for_spell_checking');
+            loadTimeData.getString('cannot_be_used_for_spell_checking');
         showMutuallyExclusiveNodes(
             [spellCheckLanguageButton, spellCheckLanguageMessage], 1);
       }
     },
 
     /**
      * Updates the input method list.
      * @param {string} languageCode Language code (ex. "fr").
      * @private
      */
@@ skipping 71 matching lines @@
     /**
      * Handles input method checkbox's click event.
      * @param {Event} e Click event.
      * @private
      */
     handleCheckboxClick_: function(e) {
       var checkbox = e.target;
       if (this.preloadEngines_.length == 1 && !checkbox.checked) {
         // Don't allow disabling the last input method.
         this.showNotification_(
-            localStrings.getString('please_add_another_input_method'),
-            localStrings.getString('ok_button'));
+            loadTimeData.getString('please_add_another_input_method'),
+            loadTimeData.getString('ok_button'));
         checkbox.checked = true;
         return;
       }
       if (checkbox.checked) {
         chrome.send('inputMethodEnable', [checkbox.inputMethodId]);
       } else {
         chrome.send('inputMethodDisable', [checkbox.inputMethodId]);
       }
       this.updatePreloadEnginesFromCheckboxes_();
       this.preloadEngines_ = this.sortPreloadEngines_(this.preloadEngines_);
@@ skipping 40 matching lines @@
         OptionsPage.closeOverlay();
       }
     },
 
     /**
      * Checks if languageCode is deletable or not.
      * @param {String} languageCode the languageCode to check for deletability.
      */
     languageIsDeletable: function(languageCode) {
       // Don't allow removing the language if it's a UI language.
-      if (languageCode == templateData.prospectiveUiLanguageCode)
+      if (languageCode == loadTimeData.getString('prospectiveUiLanguageCode'))
         return false;
       return (!cr.isChromeOS ||
               this.canDeleteLanguage_(languageCode));
     },
 
     /**
      * Handles browse.enable_spellchecking change.
      * @param {Event} e Change event.
      * @private
      */
@@ skipping 129 matching lines @@
 
     /**
      * Filters bad preload engines in case bad preload engines are
      * stored in the preference. Removes duplicates as well.
      * @param {Array} preloadEngines List of preload engines.
      * @private
      */
     filterBadPreloadEngines_: function(preloadEngines) {
       // Convert the list into a dictonary for simpler lookup.
       var dictionary = {};
-      for (var i = 0; i < templateData.inputMethodList.length; i++) {
-        dictionary[templateData.inputMethodList[i].id] = true;
+      var list = loadTimeData.getValue('inputMethodList');
+      for (var i = 0; i < list.length; i++) {
+        dictionary[list[i].id] = true;
       }
 
       var filteredPreloadEngines = [];
       var seen = {};
       for (var i = 0; i < preloadEngines.length; i++) {
         // Check if the preload engine is present in the
         // dictionary, and not duplicate. Otherwise, skip it.
         if (preloadEngines[i] in dictionary && !(preloadEngines[i] in seen)) {
           filteredPreloadEngines.push(preloadEngines[i]);
           seen[preloadEngines[i]] = true;
@@ skipping 71 matching lines @@
       assert(nodes[i] instanceof HTMLElement);  // TODO(dbeam): Ignore null?
       nodes[i].hidden = i != index;
     }
   }
 
   /**
    * Chrome callback for when the UI language preference is saved.
    * @param {string} languageCode The newly selected language to use.
    */
   LanguageOptions.uiLanguageSaved = function(languageCode) {
-    templateData.prospectiveUiLanguageCode = languageCode;
+    loadTimeData.getString('prospectiveUiLanguageCode') = languageCode;
 
     // If the user is no longer on the same language code, ignore.
     if ($('language-options-list').getSelectedLanguageCode() != languageCode)
       return;
 
     // Special case for when a user changes to a different language, and changes
     // back to the same language without having restarted Chrome or logged
     // in/out of ChromeOS.
-    if (languageCode == templateData.currentUiLanguageCode) {
+    if (languageCode == loadTimeData.getString('currentUiLanguageCode')) {
       LanguageOptions.getInstance().currentLocaleWasReselected();
       return;
     }
 
     // Otherwise, show a notification telling the user that their changes will
     // only take effect after restart.
     showMutuallyExclusiveNodes([$('language-options-ui-language-button'),
                                 $('language-options-ui-notification-bar')], 1);
   };
 
   // Export
   return {
     LanguageOptions: LanguageOptions
   };
 });