Add the ability to filter out extension IMEs from the language settings page.

chrome/browser/resources/options/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 75 matching lines @@
           var addLanguageCode = match[1];
           $('language-options-list').addLanguage(addLanguageCode);
         } else {
           OptionsPage.navigateToPage('addLanguage');
         }
       };
 
       if (cr.isChromeOS) {
         // Listen to user clicks on the add language list.
         var addLanguageList = $('add-language-overlay-language-list');
-        addLanguageList.addEventListener('click',
+        addLanguageList.addEventListener(
+            'click',
             this.handleAddLanguageListClick_.bind(this));
+        $('language-options-extension-ime-button').addEventListener(
+            'click',
+            this.handleExtensionImeButtonClick_.bind(this));
       } else {
         // Listen to add language dialog ok button.
         var addLanguageOkButton = $('add-language-overlay-ok-button');
-        addLanguageOkButton.addEventListener('click',
+        addLanguageOkButton.addEventListener(
+            'click',
             this.handleAddLanguageOkButtonClick_.bind(this));
 
         // Show experimental features if enabled.
         if (loadTimeData.getBoolean('experimentalSpellCheckFeatures'))
           $('auto-spell-correction-option').hidden = false;
 
         // Handle spell check enable/disable.
         if (!cr.isMac) {
           Preferences.getInstance().addEventListener(
               this.enableSpellCheckPref,
@@ skipping 17 matching lines @@
           OptionsPage.closeOverlay.bind(OptionsPage);
     },
 
     // The preference is a boolean that enables/disables spell checking.
     enableSpellCheckPref: 'browser.enable_spellchecking',
     // The preference is a CSV string that describes preload engines
     // (i.e. active input methods).
     preloadEnginesPref: 'settings.language.preload_engines',
     // The list of preload engines, like ['mozc', 'pinyin'].
     preloadEngines_: [],
+    // The preference that lists the extension IMEs that are filtered out of
+    // the language menu.
+    filteredExtensionImesPref: 'settings.language.filtered_extension_imes',
+    // The list of extension IMEs that are filtered out of the language menu.
+    filteredExtensionImes_: [],
     // The preference is a string that describes the spell check
     // dictionary language, like "en-US".
     spellCheckDictionaryPref: 'spellcheck.dictionary',
     spellCheckDictionary_: '',
     // The map of language code to input method IDs, like:
     // {'ja': ['mozc', 'mozc-jp'], 'zh-CN': ['pinyin'], ...}
     languageCodeToInputMethodIdsMap_: {},
 
     /**
      * Initializes the input method list.
@@ skipping 24 matching lines @@
         // Add the configure button if the config page is present for this
         // input method.
         if (inputMethod.id in INPUT_METHOD_ID_TO_CONFIG_PAGE_NAME) {
           var pageName = INPUT_METHOD_ID_TO_CONFIG_PAGE_NAME[inputMethod.id];
           var button = this.createConfigureInputMethodButton_(inputMethod.id,
                                                               pageName);
           element.appendChild(button);
         }
         inputMethodList.appendChild(element);
       }
+
+      var extensionImeList = loadTimeData.getValue('extensionImeList');
+      for (var i = 0; i < extensionImeList.length; i++) {
+        var inputMethod = extensionImeList[i];
+        var element = inputMethodPrototype.cloneNode(true);
+        element.id = '';
+        element.languageCodeSet = {};
+        var input = element.querySelectorAll('input')[0];
+        input.inputMethodId = inputMethod.id;
+        var span = element.querySelectorAll('span')[0];
+        span.textContent = inputMethod.displayName;
+
+        input.addEventListener('click',
+                               this.handleExtensionCheckboxClick_.bind(this));
+
+        inputMethodList.appendChild(element);
+      }
+
       // Listen to pref change once the input method list is initialized.
-      Preferences.getInstance().addEventListener(this.preloadEnginesPref,
+      Preferences.getInstance().addEventListener(
+          this.preloadEnginesPref,
           this.handlePreloadEnginesPrefChange_.bind(this));
+      Preferences.getInstance().addEventListener(
+          this.filteredExtensionImesPref,
+          this.handleFilteredExtensionsPrefChange_.bind(this));
     },
 
     /**
      * 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');
@@ skipping 23 matching lines @@
 
     /**
      * Handles languageOptionsList's change event.
      * @param {Event} e Change event.
      * @private
      */
     handleLanguageOptionsListChange_: function(e) {
       var languageOptionsList = $('language-options-list');
       var languageCode = languageOptionsList.getSelectedLanguageCode();
 
+      // If there's no selection, just return.
+      if (!languageCode)
+        return;
+
       // Select the language if it's specified in the URL hash (ex. lang=ja).
       // Used for automated testing.
       var match = document.location.hash.match(/\blang=([\w-]+)/);
       if (match) {
         var specifiedLanguageCode = match[1];
         if (languageOptionsList.selectLanguageByCode(specifiedLanguageCode)) {
           languageCode = specifiedLanguageCode;
         }
       }
 
@@ skipping 272 matching lines @@
      * @private
      */
     handlePreloadEnginesPrefChange_: function(e) {
       var value = e.value.value;
       this.preloadEngines_ = this.filterBadPreloadEngines_(value.split(','));
       this.updateCheckboxesFromPreloadEngines_();
       $('language-options-list').updateDeletable();
     },
 
     /**
+     * Handles filteredExtensionImesPref change.
+     * @param {Event} e Change event.
+     * @private
+     */
+    handleFilteredExtensionsPrefChange_: function(e) {
+      var value = e.value.value;
+      this.filteredExtensionImes_ = value.split(',');
+      this.updateCheckboxesFromFilteredExtensions_();
+    },
+
+    /**
      * 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_(
             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_);
       this.savePreloadEnginesPref_();
     },
 
     /**
+     * Handles extension input method checkbox's click event.
+     * @param {Event} e Click event.
+     * @private
+     */
+    handleExtensionCheckboxClick_: function(e) {
+      var checkbox = e.target;
+      this.updateFilteredExtensionsFromCheckboxes_();
+      this.saveFilteredExtensionPref_();
+    },
+
+    /**
      * Handles add language list's click event.
      * @param {Event} e Click event.
      */
     handleAddLanguageListClick_: function(e) {
       var languageOptionsList = $('language-options-list');
       var languageCode = e.target.languageCode;
       // languageCode can be undefined, if click was made on some random
       // place in the overlay, rather than a button. Ignore it.
       if (!languageCode) {
         return;
       }
       languageOptionsList.addLanguage(languageCode);
       var inputMethodIds = this.languageCodeToInputMethodIdsMap_[languageCode];
       // Enable the first input method for the language added.
       if (inputMethodIds && inputMethodIds[0] &&
           // Don't add the input method it's already present. This can
           // happen if the same input method is shared among multiple
           // languages (ex. English US keyboard is used for English US and
           // Filipino).
           this.preloadEngines_.indexOf(inputMethodIds[0]) == -1) {
         this.preloadEngines_.push(inputMethodIds[0]);
         this.updateCheckboxesFromPreloadEngines_();
         this.savePreloadEnginesPref_();
       }
       OptionsPage.closeOverlay();
     },
 
     /**
-     * Handles add language dialog ok button.
+     * Handles extension IME button.
      */
+    handleExtensionImeButtonClick_: function() {
+      $('language-options-list').clearSelection();
+
+      var languageName = $('language-options-language-name');
+      languageName.textContent = loadTimeData.getString('extension_ime_label');
+
+      var uiLanguageMessage = $('language-options-ui-language-message');
+      uiLanguageMessage.textContent =
+          loadTimeData.getString('extension_ime_description');
+
+      var uiLanguageButton = $('language-options-ui-language-button');
+      uiLanguageButton.onclick = null;
+      uiLanguageButton.hidden = true;
+
+      this.updateSpellCheckLanguageButton_();
+
+      // Hide all input method checkboxes that aren't extension IMEs.
+      var inputMethodList = $('language-options-input-method-list');
+      var methods = inputMethodList.querySelectorAll('.input-method');
+      for (var i = 0; i < methods.length; i++) {
+        var method = methods[i];
+        var input = method.querySelectorAll('input')[0];
+        // Give it focus if the ID matches.
+        if (input.inputMethodId.match(/^_ext_ime_/))
+          method.hidden = false;
+        else
+          method.hidden = true;
+      }
+    },
+
+
     handleAddLanguageOkButtonClick_: function() {
       var languagesSelect = $('add-language-overlay-language-list');
       var selectedIndex = languagesSelect.selectedIndex;
       if (selectedIndex >= 0) {
         var selection = languagesSelect.options[selectedIndex];
         $('language-options-list').addLanguage(String(selection.value));
         OptionsPage.closeOverlay();
       }
     },
 
@@ skipping 92 matching lines @@
         if (!(this.preloadEngines_[i] in enginesToBeRemovedSet)) {
           newPreloadEngines.push(this.preloadEngines_[i]);
         }
       }
       // Don't allow this operation if it causes the number of preload
       // engines to be zero.
       return (newPreloadEngines.length > 0);
     },
 
     /**
+     * Saves the filtered extension preference.
+     * @private
+     */
+    saveFilteredExtensionPref_: function() {
+      Preferences.setStringPref(this.filteredExtensionImesPref,
+                                this.filteredExtensionImes_.join(','), true);
+    },
+
+    /**
+     * Updates the checkboxes in the input method list from the filtered
+     * extensions preference.
+     * @private
+     */
+    updateCheckboxesFromFilteredExtensions_: function() {
+      // Convert the list into a dictonary for simpler lookup.
+      var dictionary = {};
+      for (var i = 0; i < this.filteredExtensionImes_.length; i++)
+        dictionary[this.filteredExtensionImes_[i]] = true;
+
+      var inputMethodList = $('language-options-input-method-list');
+      var checkboxes = inputMethodList.querySelectorAll('input');
+      for (var i = 0; i < checkboxes.length; i++) {
+        if (checkboxes[i].inputMethodId.match(/^_ext_ime_/))
+          checkboxes[i].checked = !(checkboxes[i].inputMethodId in dictionary);
+      }
+    },
+
+    /**
+     * Updates the filtered extensions preference from the checkboxes in the
+     * input method list.
+     * @private
+     */
+    updateFilteredExtensionsFromCheckboxes_: function() {
+      this.filteredExtensionImes_ = [];
+      var inputMethodList = $('language-options-input-method-list');
+      var checkboxes = inputMethodList.querySelectorAll('input');
+      for (var i = 0; i < checkboxes.length; i++) {
+        if (checkboxes[i].inputMethodId.match(/^_ext_ime_/)) {
+          if (!checkboxes[i].checked)
+            this.filteredExtensionImes_.push(checkboxes[i].inputMethodId);
+        }
+      }
+    },
+
+    /**
      * Saves the preload engines preference.
      * @private
      */
     savePreloadEnginesPref_: function() {
       Preferences.setStringPref(this.preloadEnginesPref,
                                 this.preloadEngines_.join(','), true);
     },
 
     /**
      * Updates the checkboxes in the input method list from the preload
      * engines preference.
      * @private
      */
     updateCheckboxesFromPreloadEngines_: function() {
       // Convert the list into a dictonary for simpler lookup.
       var dictionary = {};
       for (var i = 0; i < this.preloadEngines_.length; i++) {
         dictionary[this.preloadEngines_[i]] = true;
       }
 
       var inputMethodList = $('language-options-input-method-list');
       var checkboxes = inputMethodList.querySelectorAll('input');
       for (var i = 0; i < checkboxes.length; i++) {
-        checkboxes[i].checked = (checkboxes[i].inputMethodId in dictionary);
+        if (!checkboxes[i].inputMethodId.match(/^_ext_ime_/))
+          checkboxes[i].checked = (checkboxes[i].inputMethodId in dictionary);
       }
     },
 
     /**
      * Updates the preload engines preference from the checkboxes in the
      * input method list.
      * @private
      */
     updatePreloadEnginesFromCheckboxes_: function() {
       this.preloadEngines_ = [];
       var inputMethodList = $('language-options-input-method-list');
       var checkboxes = inputMethodList.querySelectorAll('input');
       for (var i = 0; i < checkboxes.length; i++) {
-        if (checkboxes[i].checked) {
-          this.preloadEngines_.push(checkboxes[i].inputMethodId);
+        if (!checkboxes[i].inputMethodId.match(/^_ext_ime_/)) {
+          if (checkboxes[i].checked)
+            this.preloadEngines_.push(checkboxes[i].inputMethodId);
         }
       }
       var languageOptionsList = $('language-options-list');
       languageOptionsList.updateDeletable();
     },
 
     /**
      * 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.
@@ skipping 114 matching lines @@
     // only take effect after restart.
     showMutuallyExclusiveNodes([$('language-options-ui-language-button'),
                                 $('language-options-ui-notification-bar')], 1);
   };
 
   // Export
   return {
     LanguageOptions: LanguageOptions
   };
 });