Add "Don't translate" preference to chrome://settings/languages

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 12 matching lines @@
 
   /**
    * Spell check dictionary download status.
    * @type {Enum}
    */
   /** @const*/ var DOWNLOAD_STATUS = {
     IN_PROGRESS: 1,
     FAILED: 2
   };
 
+  /**
+   * The preference is a boolean that enables/disables spell checking.
+   * @type {string}
+   * @const
+   */
+  var ENABLE_SPELL_CHECK_PREF = 'browser.enable_spellchecking';
+
+  /**
+   * The preference is a CSV string that describes preload engines
+   * (i.e. active input methods).
+   * @type {string}
+   * @const
+   */
+  var PRELOAD_ENGINES_PREF = 'settings.language.preload_engines';
+
+  /**
+   * The preference that lists the extension IMEs that are enabled in the
+   * language menu.
+   * @type {string}
+   * @const
+   */
+  var ENABLED_EXTENSION_IME_PREF = 'settings.language.enabled_extension_imes';
+
+  /**
+   * The preference that lists the languages which are not translated.
+   * @type {string}
+   * @const
+   */
+  var TRANSLATE_LANGUAGE_BLACKLIST_PREF = 'translate_language_blacklist';
+
+  /**
+   * The preference key that is a string that describes the spell check
+   * dictionary language, like "en-US".
+   * @type {string}
+   * @const
+   */
+  var SPELL_CHECK_DICTIONARY_PREF = 'spellcheck.dictionary';
+
   /////////////////////////////////////////////////////////////////////////////
   // LanguageOptions class:
 
   /**
    * Encapsulated handling of ChromeOS language options page.
    * @constructor
    */
   function LanguageOptions(model) {
     OptionsPage.call(this, 'languages',
                      loadTimeData.getString('languagePageTabTitle'),
@@ skipping 21 matching lines @@
     spellcheckDictionaryDownloadStatus_: [],
 
     /**
      * Number of times a spell check dictionary download failed.
      * @type {int}
      * @private
      */
     spellcheckDictionaryDownloadFailures_: 0,
 
     /**
-     * The preference is a boolean that enables/disables spell checking.
-     * @type {string}
-     * @private
-     * @const
-     */
-    enableSpellCheckPref_: 'browser.enable_spellchecking',
-
-    /**
-     * The preference is a CSV string that describes preload engines
-     * (i.e. active input methods).
-     * @type {string}
-     * @private
-     * @const
-     */
-    preloadEnginesPref_: 'settings.language.preload_engines',
-
-    /**
      * The list of preload engines, like ['mozc', 'pinyin'].
      * @type {Array}
      * @private
      */
     preloadEngines_: [],
 
     /**
-     * The preference that lists the extension IMEs that are enabled in the
-     * language menu.
-     * @type {string}
-     * @private
-     * @const
-     */
-    enabledExtensionImePref_: 'settings.language.enabled_extension_imes',
-
-    /**
      * The list of extension IMEs that are enabled out of the language menu.
      * @type {Array}
      * @private
      */
     enabledExtensionImes_: [],
 
     /**
-     * The preference key that is a string that describes the spell check
-     * dictionary language, like "en-US".
-     * @type {string}
+     * The list of the languages which is not translated.
+     * @type {Array}
      * @private
-     * @const
      */
-    spellCheckDictionaryPref_: 'spellcheck.dictionary',
+    translateLanguageBlacklist_: [],
 
     /**
      * The preference is a string that describes the spell check dictionary
      * language, like "en-US".
      * @type {string}
      * @private
      */
     spellCheckDictionary_: '',
 
     /**
@@ skipping 25 matching lines @@
                             this.handleVisibleChange_.bind(this));
 
       if (cr.isChromeOS) {
         $('chewing-confirm').onclick = $('hangul-confirm').onclick =
             $('mozc-confirm').onclick = $('pinyin-confirm').onclick =
                 OptionsPage.closeOverlay.bind(OptionsPage);
 
         this.initializeInputMethodList_();
         this.initializeLanguageCodeToInputMethodIdsMap_();
       }
-      Preferences.getInstance().addEventListener(this.spellCheckDictionaryPref_,
+
+      var checkbox =
+          $('language-options-dont-translate').querySelector('input');
+      checkbox.addEventListener('click',
+          this.handleDontTranslateCheckboxClick_.bind(this));
+
+      Preferences.getInstance().addEventListener(
+          TRANSLATE_LANGUAGE_BLACKLIST_PREF,
+          this.handleTranslateLanguageBlacklistPrefChange_.bind(this));
+      Preferences.getInstance().addEventListener(SPELL_CHECK_DICTIONARY_PREF,
           this.handleSpellCheckDictionaryPrefChange_.bind(this));
 
       // Set up add button.
       $('language-options-add-button').onclick = function(e) {
         // Add the language without showing the overlay if it's specified in
         // the URL hash (ex. lang_add=ja).  Used for automated testing.
         var match = document.location.hash.match(/\blang_add=([\w-]+)/);
         if (match) {
           var addLanguageCode = match[1];
           $('language-options-list').addLanguage(addLanguageCode);
@@ skipping 17 matching lines @@
           'click', this.handleAddLanguageOkButtonClick_.bind(this));
 
       if (!cr.isChromeOS) {
         // Show experimental features if enabled.
         if (loadTimeData.getBoolean('enableSpellingAutoCorrect'))
           $('auto-spell-correction-option').hidden = false;
 
         // Handle spell check enable/disable.
         if (!cr.isMac) {
           Preferences.getInstance().addEventListener(
-              this.enableSpellCheckPref_,
+              ENABLE_SPELL_CHECK_PREF,
               this.updateEnableSpellCheck_.bind(this));
         }
       }
 
       // Handle clicks on "Use this language for spell checking" button.
       if (!cr.isMac) {
         var spellCheckLanguageButton = getRequiredElement(
             'language-options-spell-check-language-button');
         spellCheckLanguageButton.addEventListener(
             'click',
@@ skipping 21 matching lines @@
       // 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.
       this.appendInputMethodElement_(loadTimeData.getValue('inputMethodList'));
       this.appendInputMethodElement_(loadTimeData.getValue('extensionImeList'));
       this.appendComponentExtensionIme_(
           loadTimeData.getValue('componentExtensionImeList'));
 
       // Listen to pref change once the input method list is initialized.
       Preferences.getInstance().addEventListener(
-          this.preloadEnginesPref_,
+          PRELOAD_ENGINES_PREF,
           this.handlePreloadEnginesPrefChange_.bind(this));
       Preferences.getInstance().addEventListener(
-          this.enabledExtensionImePref_,
+          ENABLED_EXTENSION_IME_PREF,
           this.handleEnabledExtensionsPrefChange_.bind(this));
     },
 
     /**
      * Appends input method lists based on component extension ime list.
      * @param {!Array} componentExtensionImeList A list of input method
      *     descriptors.
      * @private
      */
     appendComponentExtensionIme_: function(componentExtensionImeList) {
@@ skipping 106 matching lines @@
       // 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;
         }
       }
 
+      this.updateDontTranslateCheckbox_(languageCode);
+
       if (cr.isWindows || cr.isChromeOS)
         this.updateUiLanguageButton_(languageCode);
 
       if (!cr.isMac) {
         this.updateSelectedLanguageName_(languageCode);
         this.updateSpellCheckLanguageButton_(languageCode);
       }
 
       if (cr.isChromeOS)
         this.updateInputMethodList_(languageCode);
@@ skipping 213 matching lines @@
         spellCheckLanguageMessage.hidden = true;
       } else {
         spellCheckLanguageMessage.textContent =
             loadTimeData.getString('cannot_be_used_for_spell_checking');
         showMutuallyExclusiveNodes(
             [spellCheckLanguageButton, spellCheckLanguageMessage], 1);
       }
     },
 
     /**
+     * Updates the checkbox for stopping translation.
+     * @param {string} languageCode Language code (ex. "fr").
+     * @private
+     */
+    updateDontTranslateCheckbox_: function(languageCode) {
+      var dontTranslate = $('language-options-dont-translate');
+      var checkbox = dontTranslate.querySelector('input');
+
+      // TODO(hajimehoshi): Create more general function to determine this.
+      if (this.isTranslatableLanguage_(languageCode)) {
+        dontTranslate.hidden = false;
+      } else {
+        dontTranslate.hidden = true;
+        return;
+      }
+
+      var lang = this.convertLangCodeForTranslation_(languageCode);
+      var checked = (this.translateLanguageBlacklist_.indexOf(lang) != -1);
+      checkbox.checked = checked;
+    },
+
+    /**
      * Updates the input method list.
      * @param {string} languageCode Language code (ex. "fr").
      * @private
      */
     updateInputMethodList_: function(languageCode) {
       // Give one of the checkboxes or buttons focus, if it's specified in the
       // URL hash (ex. focus=mozc). Used for automated testing.
       var focusInputMethodId = -1;
       var match = document.location.hash.match(/\bfocus=([\w:-]+)\b/);
       if (match) {
@@ skipping 74 matching lines @@
      * @param {Event} e Change event.
      * @private
      */
     handleEnabledExtensionsPrefChange_: function(e) {
       var value = e.value.value;
       this.enabledExtensionImes_ = value.split(',');
       this.updateCheckboxesFromEnabledExtensions_();
     },
 
     /**
+     * Handles don't-translate checkbox's click event.
+     * @param {Event} e Click event.
+     * @private
+     */
+    handleDontTranslateCheckboxClick_: function(e) {
+      var checkbox = e.target;
+      var checked = checkbox.checked;
+
+      var languageOptionsList = $('language-options-list');
+      var selectedLanguageCode = languageOptionsList.getSelectedLanguageCode();
+
+      var langCode = this.convertLangCodeForTranslation_(selectedLanguageCode);
+      var blacklist = this.translateLanguageBlacklist_;
+      if (checked && blacklist.indexOf(langCode) == -1) {
+        blacklist.push(langCode);
+      } else if (!checked && blacklist.indexOf(langCode) != -1) {
+        blacklist = blacklist.filter(function(blacklistedLangCode) {
+          return blacklistedLangCode != langCode;
+        });
+      }
+      this.translateLanguageBlacklist_ = blacklist;
+
+      Preferences.setListPref(TRANSLATE_LANGUAGE_BLACKLIST_PREF,
+                              this.translateLanguageBlacklist_, true);
+    },
+
+    /**
      * Handles input method checkbox's click event.
      * @param {Event} e Click event.
      * @private
      */
     handleCheckboxClick_: function(e) {
       var checkbox = e.target;
 
       if (checkbox.inputMethodId.match(/^_ext_ime_/)) {
         this.updateEnabledExtensionsFromCheckboxes_();
         this.saveEnabledExtensionPref_();
@@ skipping 37 matching lines @@
         return false;
       return (!cr.isChromeOS ||
               this.canDeleteLanguage_(languageCode));
     },
 
     /**
      * Handles browse.enable_spellchecking change.
      * @param {Event} e Change event.
      * @private
      */
-     updateEnableSpellCheck_: function() {
+    updateEnableSpellCheck_: function() {
        var value = !$('enable-spell-check').checked;
        $('language-options-spell-check-language-button').disabled = value;
        if (!cr.IsMac)
          $('edit-dictionary-button').hidden = value;
      },
 
     /**
+     * Handles translateLanguageBlacklistPref change.
+     * @param {Event} e Change event.
+     * @private
+     */
+    handleTranslateLanguageBlacklistPrefChange_: function(e) {
+      var languageOptionsList = $('language-options-list');
+      var selectedLanguageCode = languageOptionsList.getSelectedLanguageCode();
+      this.translateLanguageBlacklist_ = e.value.value;
+
+      this.updateDontTranslateCheckbox_(selectedLanguageCode);
+    },
+
+    /**
      * Handles spellCheckDictionaryPref change.
      * @param {Event} e Change event.
      * @private
      */
     handleSpellCheckDictionaryPrefChange_: function(e) {
       var languageCode = e.value.value;
       this.spellCheckDictionary_ = languageCode;
       var languageOptionsList = $('language-options-list');
       var selectedLanguageCode = languageOptionsList.getSelectedLanguageCode();
       if (!cr.isMac)
         this.updateSpellCheckLanguageButton_(selectedLanguageCode);
     },
 
     /**
      * Handles spellCheckLanguageButton click.
      * @param {Event} e Click event.
      * @private
      */
     handleSpellCheckLanguageButtonClick_: function(e) {
       var languageCode = e.target.languageCode;
       // Save the preference.
-      Preferences.setStringPref(this.spellCheckDictionaryPref_,
+      Preferences.setStringPref(SPELL_CHECK_DICTIONARY_PREF,
                                 languageCode, true);
       chrome.send('spellCheckLanguageChange', [languageCode]);
     },
 
     /**
      * Checks whether it's possible to remove the language specified by
      * languageCode and returns true if possible. This function returns false
      * if the removal causes the number of preload engines to be zero.
      *
      * @param {string} languageCode Language code (ex. "fr").
@@ skipping 48 matching lines @@
       // Don't allow this operation if it causes the number of preload
       // engines to be zero.
       return (newPreloadEngines.length > 0);
     },
 
     /**
      * Saves the enabled extension preference.
      * @private
      */
     saveEnabledExtensionPref_: function() {
-      Preferences.setStringPref(this.enabledExtensionImePref_,
+      Preferences.setStringPref(ENABLED_EXTENSION_IME_PREF,
                                 this.enabledExtensionImes_.join(','), true);
     },
 
     /**
      * Updates the checkboxes in the input method list from the enabled
      * extensions preference.
      * @private
      */
     updateCheckboxesFromEnabledExtensions_: function() {
       // Convert the list into a dictonary for simpler lookup.
@@ skipping 24 matching lines @@
             this.enabledExtensionImes_.push(checkboxes[i].inputMethodId);
         }
       }
     },
 
     /**
      * Saves the preload engines preference.
      * @private
      */
     savePreloadEnginesPref_: function() {
-      Preferences.setStringPref(this.preloadEnginesPref_,
+      Preferences.setStringPref(PRELOAD_ENGINES_PREF,
                                 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.
@@ skipping 138 matching lines @@
 
     onDictionaryDownloadFailure_: function(languageCode) {
       this.spellcheckDictionaryDownloadStatus_[languageCode] =
           DOWNLOAD_STATUS.FAILED;
       this.spellcheckDictionaryDownloadFailures_++;
       if (!cr.isMac &&
           languageCode ==
               $('language-options-list').getSelectedLanguageCode()) {
         this.updateSpellCheckLanguageButton_(languageCode);
       }
-    }
+    },
+
+    /*
+     * Converts the language code for Translation. There are some differences
+     * between the language set for Translation and that for Accept-Language.
+     * @param {string} languageCode The language code like 'fr'.
+     * @return {string} The converted language code.
+     * @private
+     */
+    convertLangCodeForTranslation_: function(languageCode) {
+      var tokens = languageCode.split('-');
+      var main = tokens[0];
+      var dialect = tokens[1];
+
+      // See also: chrome/renderer/translate/translate_helper.cc.
+      var synonyms = {
+        'nb': 'no',
+        'he': 'iw',
+        'jv': 'jw',
+        'fil': 'tl',
+      };
+
+      if (main in synonyms) {
+        return synonyms[main];
+      } else if (main == 'zh') {
+        // In Translation, general Chinese is not used.
+        assert(dialect);
+        return languageCode;
+      }
+
+      return main;
+    },
+
+    /*
+     * Checks whether or not |languageCode| is supported for Translation.
+     * @param {string} languageCode The language code like 'fr'.
+     * @return {boolean} Retruns true if |languageCode| is supported for
+     *    Translation.
+     * @private
+     */
+    isTranslatableLanguage_: function(languageCode) {
+      if (languageCode == 'zh')
+        return false;
+
+      return true;
+    },
   };
 
   /**
    * Shows the node at |index| in |nodes|, hides all others.
    * @param {Array<HTMLElement>} nodes The nodes to be shown or hidden.
    * @param {number} index The index of |nodes| to show.
    */
   function showMutuallyExclusiveNodes(nodes, index) {
     assert(index >= 0 && index < nodes.length);
     for (var i = 0; i < nodes.length; ++i) {
@@ skipping 41 matching lines @@
 
   LanguageOptions.onComponentManagerInitialized = function(componentImes) {
     LanguageOptions.getInstance().appendComponentExtensionIme_(componentImes);
   };
 
   // Export
   return {
     LanguageOptions: LanguageOptions
   };
 });