DO NOT SUBMIT: what chrome/browser/resources/ could eventually look like with clang-format

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 Page = cr.ui.pageManager.Page;
   /** @const */ var PageManager = cr.ui.pageManager.PageManager;
   /** @const */ var LanguageList = options.LanguageList;
   /** @const */ var ThirdPartyImeConfirmOverlay =
       options.ThirdPartyImeConfirmOverlay;
 
   /**
    * Spell check dictionary download status.
    * @type {Enum}
    */
-  /** @const*/ var DOWNLOAD_STATUS = {
-    IN_PROGRESS: 1,
-    FAILED: 2
-  };
+  /** @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
@@ skipping 42 matching lines @@
 
   /////////////////////////////////////////////////////////////////////////////
   // LanguageOptions class:
 
   /**
    * Encapsulated handling of ChromeOS language options page.
    * @constructor
    * @extends {cr.ui.pageManager.Page}
    */
   function LanguageOptions(model) {
-    Page.call(this, 'languages',
-              loadTimeData.getString('languagePageTabTitle'), 'languagePage');
+    Page.call(
+        this, 'languages', loadTimeData.getString('languagePageTabTitle'),
+        'languagePage');
   }
 
   cr.addSingletonGetter(LanguageOptions);
 
   // Inherit LanguageOptions from Page.
   LanguageOptions.prototype = {
     __proto__: Page.prototype,
 
     /**
      * For recording the prospective language (the next locale after relaunch).
@@ skipping 68 matching lines @@
      */
     enableTranslate_: false,
 
     /** @override */
     initializePage: function() {
       Page.prototype.initializePage.call(this);
 
       var languageOptionsList = $('language-options-list');
       LanguageList.decorate(languageOptionsList);
 
-      languageOptionsList.addEventListener('change',
-          this.handleLanguageOptionsListChange_.bind(this));
-      languageOptionsList.addEventListener('save',
-          this.handleLanguageOptionsListSave_.bind(this));
+      languageOptionsList.addEventListener(
+          'change', this.handleLanguageOptionsListChange_.bind(this));
+      languageOptionsList.addEventListener(
+          'save', this.handleLanguageOptionsListSave_.bind(this));
 
       this.prospectiveUiLanguageCode_ =
           loadTimeData.getString('prospectiveUiLanguageCode');
-      this.addEventListener('visibleChange',
-                            this.handleVisibleChange_.bind(this));
+      this.addEventListener(
+          'visibleChange', this.handleVisibleChange_.bind(this));
 
       if (cr.isChromeOS) {
         this.initializeInputMethodList_();
         this.initializeLanguageCodeToInputMethodIdsMap_();
       }
 
       var checkbox = $('offer-to-translate-in-this-language');
-      checkbox.addEventListener('click',
-          this.handleOfferToTranslateCheckboxClick_.bind(this));
+      checkbox.addEventListener(
+          'click', this.handleOfferToTranslateCheckboxClick_.bind(this));
 
       Preferences.getInstance().addEventListener(
           TRANSLATE_BLOCKED_LANGUAGES_PREF,
           this.handleTranslateBlockedLanguagesPrefChange_.bind(this));
-      Preferences.getInstance().addEventListener(SPELL_CHECK_DICTIONARIES_PREF,
+      Preferences.getInstance().addEventListener(
+          SPELL_CHECK_DICTIONARIES_PREF,
           this.handleSpellCheckDictionariesPrefChange_.bind(this));
-      Preferences.getInstance().addEventListener(ENABLE_TRANSLATE,
-          this.handleEnableTranslatePrefChange_.bind(this));
-      this.translateSupportedLanguages_ = /** @type {Array} */(
+      Preferences.getInstance().addEventListener(
+          ENABLE_TRANSLATE, this.handleEnableTranslatePrefChange_.bind(this));
+      this.translateSupportedLanguages_ = /** @type {Array} */ (
           loadTimeData.getValue('translateSupportedLanguages'));
 
       // Set up add button.
       var 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);
           this.addBlockedLanguage_(addLanguageCode);
         } else {
           PageManager.showPageByName('addLanguage');
-          chrome.send('coreOptionsUserMetricsAction',
-                      ['Options_Languages_Add']);
+          chrome.send(
+              'coreOptionsUserMetricsAction', ['Options_Languages_Add']);
         }
       };
       $('language-options-add-button').onclick = onclick.bind(this);
 
       if (!cr.isMac) {
         // Set up the button for editing custom spelling dictionary.
         $('edit-custom-dictionary-button').onclick = function(e) {
           PageManager.showPageByName('editDictionary');
         };
         $('dictionary-download-retry-button').onclick = function(e) {
-          chrome.send('retryDictionaryDownload',
-                      [e.currentTarget.languageCode]);
+          chrome.send(
+              'retryDictionaryDownload', [e.currentTarget.languageCode]);
         };
       }
 
       // Listen to add language dialog ok button.
-      $('add-language-overlay-ok-button').addEventListener(
-          'click', this.handleAddLanguageOkButtonClick_.bind(this));
+      $('add-language-overlay-ok-button')
+          .addEventListener(
+              'click', this.handleAddLanguageOkButtonClick_.bind(this));
 
       if (!(cr.isMac || cr.isChromeOS)) {
         // Handle spell check enable/disable.
         Preferences.getInstance().addEventListener(
             ENABLE_SPELL_CHECK_PREF, this.updateEnableSpellCheck_.bind(this));
       }
 
       // Handle clicks on "Use this language for spell checking" button.
       if (!cr.isMac) {
-        $('spellcheck-language-checkbox').addEventListener(
-            'change',
-            this.handleSpellCheckLanguageCheckboxClick_.bind(this));
+        $('spellcheck-language-checkbox')
+            .addEventListener(
+                'change',
+                this.handleSpellCheckLanguageCheckboxClick_.bind(this));
       }
 
       if (cr.isChromeOS) {
         $('language-options-ui-restart-button').onclick = function() {
           chrome.send('uiLanguageRestart');
         };
       }
 
       $('language-confirm').onclick =
           PageManager.closeOverlay.bind(PageManager);
 
       // Public session users cannot change the locale.
       if (cr.isChromeOS && UIAccountTweaks.loggedInAsPublicAccount())
         $('language-options-ui-language-section').hidden = true;
 
       // IME menu (CrOS only).
       if (cr.isChromeOS) {
         // Show the 'activate-ime-menu' checkbox if the flag is tured on.
         if (loadTimeData.getBoolean('enableLanguageOptionsImeMenu'))
           $('language-options-ime-menu-template').hidden = false;
 
         // Updates the initial checked state of the check box.
         Preferences.getInstance().addEventListener(
             ACTIVATE_IME_MENU_PREF, this.updateImeMenuCheckbox_.bind(this));
 
         // Listen to check on 'activate-ime-menu' checkbox.
         var checkboxImeMenu = $('activate-ime-menu');
-        checkboxImeMenu.addEventListener('click',
-            this.handleActivateImeMenuCheckboxClick_.bind(this));
+        checkboxImeMenu.addEventListener(
+            'click', this.handleActivateImeMenuCheckboxClick_.bind(this));
       }
     },
 
     /**
      * Initializes the input method list.
      */
     initializeInputMethodList_: function() {
       var inputMethodList = $('language-options-input-method-list');
       var inputMethodPrototype = $('language-options-input-method-template');
 
       // 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.
-      this.appendInputMethodElement_(/** @type {!Array} */(
-          loadTimeData.getValue('inputMethodList')));
-      this.appendComponentExtensionIme_(/** @type {!Array} */(
+      this.appendInputMethodElement_(
+          /** @type {!Array} */ (loadTimeData.getValue('inputMethodList')));
+      this.appendComponentExtensionIme_(/** @type {!Array} */ (
           loadTimeData.getValue('componentExtensionImeList')));
-      this.appendInputMethodElement_(/** @type {!Array} */(
-          loadTimeData.getValue('extensionImeList')));
+      this.appendInputMethodElement_(
+          /** @type {!Array} */ (loadTimeData.getValue('extensionImeList')));
 
       // Listen to pref change once the input method list is initialized.
       Preferences.getInstance().addEventListener(
           PRELOAD_ENGINES_PREF,
           this.handlePreloadEnginesPrefChange_.bind(this));
       Preferences.getInstance().addEventListener(
           ENABLED_EXTENSION_IME_PREF,
           this.handleEnabledExtensionsPrefChange_.bind(this));
     },
 
@@ skipping 45 matching lines @@
           var button = document.createElement('button');
           button.textContent = loadTimeData.getString('configure');
           button.inputMethodId = inputMethod.id;
           button.onclick = function(inputMethodId, e) {
             chrome.send('inputMethodOptionsOpen', [inputMethodId]);
           }.bind(this, inputMethod.id);
           element.appendChild(button);
         }
 
         // Listen to user clicks.
-        input.addEventListener('click',
-                               this.handleCheckboxClick_.bind(this));
+        input.addEventListener('click', this.handleCheckboxClick_.bind(this));
         inputMethodList.appendChild(element);
       }
     },
 
     /**
      * Adds a language to the preference 'translate_blocked_languages'. If
      * |langCode| is already added, nothing happens. |langCode| is converted
      * to a Translate language synonym before added.
      * @param {string} langCode A language code like 'en'
      * @private
      */
     addBlockedLanguage_: function(langCode) {
       langCode = this.convertLangCodeForTranslation_(langCode);
       if (this.translateBlockedLanguages_.indexOf(langCode) == -1) {
         this.translateBlockedLanguages_.push(langCode);
-        Preferences.setListPref(TRANSLATE_BLOCKED_LANGUAGES_PREF,
-                                this.translateBlockedLanguages_, true);
+        Preferences.setListPref(
+            TRANSLATE_BLOCKED_LANGUAGES_PREF, this.translateBlockedLanguages_,
+            true);
       }
     },
 
     /**
      * Removes a language from the preference 'translate_blocked_languages'.
      * If |langCode| doesn't exist in the preference, nothing happens.
      * |langCode| is converted to a Translate language synonym before removed.
      * @param {string} langCode A language code like 'en'
      * @private
      */
     removeBlockedLanguage_: function(langCode) {
       langCode = this.convertLangCodeForTranslation_(langCode);
       if (this.translateBlockedLanguages_.indexOf(langCode) != -1) {
         this.translateBlockedLanguages_ =
-            this.translateBlockedLanguages_.filter(
-                function(langCodeNotTranslated) {
-                  return langCodeNotTranslated != langCode;
-                });
-        Preferences.setListPref(TRANSLATE_BLOCKED_LANGUAGES_PREF,
-                                this.translateBlockedLanguages_, true);
+            this.translateBlockedLanguages_.filter(function(
+                langCodeNotTranslated) {
+              return langCodeNotTranslated != langCode;
+            });
+        Preferences.setListPref(
+            TRANSLATE_BLOCKED_LANGUAGES_PREF, this.translateBlockedLanguages_,
+            true);
       }
     },
 
     /**
      * Handles Page's visible property change event.
      * @param {Event} e Property change event.
      * @private
      */
     handleVisibleChange_: function(e) {
       if (this.visible) {
@@ skipping 76 matching lines @@
       // Convert the list into a dictonary for simpler lookup.
       var preloadEngineSet = {};
       for (var i = 0; i < preloadEngines.length; i++) {
         preloadEngineSet[preloadEngines[i]] = true;
       }
 
       // Create the new preload engine list per the language codes.
       var newPreloadEngines = [];
       for (var i = 0; i < languageCodes.length; i++) {
         var languageCode = languageCodes[i];
-        var inputMethodIds = this.languageCodeToInputMethodIdsMap_[
-            languageCode];
+        var inputMethodIds =
+            this.languageCodeToInputMethodIdsMap_[languageCode];
         if (!inputMethodIds)
           continue;
 
         // Check if we have active input methods associated with the language.
         for (var j = 0; j < inputMethodIds.length; j++) {
           var inputMethodId = inputMethodIds[j];
           if (inputMethodId in preloadEngineSet) {
             // If we have, add it to the new engine list.
             newPreloadEngines.push(inputMethodId);
             // And delete it from the set. This is necessary as one input
@@ skipping 26 matching lines @@
         }
       }
     },
 
     /**
      * Updates the currently selected language name.
      * @param {string} languageCode Language code (ex. "fr").
      * @private
      */
     updateSelectedLanguageName_: function(languageCode) {
-      var languageInfo = LanguageList.getLanguageInfoFromLanguageCode(
-          languageCode);
+      var languageInfo =
+          LanguageList.getLanguageInfoFromLanguageCode(languageCode);
       var languageDisplayName = languageInfo.displayName;
       var languageNativeDisplayName = languageInfo.nativeDisplayName;
       var textDirection = languageInfo.textDirection;
 
       // If the native name is different, add it.
       if (languageDisplayName != languageNativeDisplayName) {
         languageDisplayName += ' - ' + languageNativeDisplayName;
       }
 
       // Update the currently selected language name.
@@ skipping 112 matching lines @@
               [spellCheckLanguageSection, dictionaryDownloadFailed], 1);
           if (this.spellcheckDictionaryDownloadFailures_ > 1)
             dictionaryDownloadFailHelp.hidden = false;
           $('dictionary-download-retry-button').languageCode = languageCode;
           break;
       }
 
       var areNoLanguagesSelected =
           Object.keys(this.spellCheckLanguages_).length == 0;
       var usesSystemSpellchecker = !$('enable-spellcheck-container');
-      var isSpellcheckingEnabled = usesSystemSpellchecker ||
-          $('enable-spellcheck').checked;
+      var isSpellcheckingEnabled =
+          usesSystemSpellchecker || $('enable-spellcheck').checked;
       $('edit-custom-dictionary-button').hidden =
           areNoLanguagesSelected || !isSpellcheckingEnabled;
     },
 
     /**
      * Updates the checkbox for stopping translation.
      * @param {string} languageCode Language code (ex. "fr").
      * @private
      */
     updateOfferToTranslateCheckbox_: function(languageCode) {
@@ skipping 162 matching lines @@
      * Handles input method checkbox's click event.
      * @param {Event} e Click event.
      * @private
      */
     handleCheckboxClick_: function(e) {
       var checkbox = assertInstanceof(e.target, Element);
 
       // Third party IMEs require additional confirmation prior to enabling due
       // to privacy risk.
       if (/^_ext_ime_/.test(checkbox.inputMethodId) && checkbox.checked) {
-        var confirmationCallback = this.handleCheckboxUpdate_.bind(this,
-                                                                   checkbox);
+        var confirmationCallback =
+            this.handleCheckboxUpdate_.bind(this, checkbox);
         var cancellationCallback = function() {
           checkbox.checked = false;
         };
         ThirdPartyImeConfirmOverlay.showConfirmationDialog({
           extension: checkbox.imeProvider,
           confirm: confirmationCallback,
           cancel: cancellationCallback
         });
       } else {
         this.handleCheckboxUpdate_(checkbox);
       }
 
-      chrome.send('coreOptionsUserMetricsAction',
-                  ['Options_Languages_InputMethodCheckbox' +
-                   (checkbox.checked ? '_Enable' : '_Disable')]);
+      chrome.send(
+          'coreOptionsUserMetricsAction',
+          ['Options_Languages_InputMethodCheckbox' +
+           (checkbox.checked ? '_Enable' : '_Disable')]);
     },
 
     /**
      * Updates active IMEs based on change in state of a checkbox for an input
      * method.
      * @param {!Element} checkbox Updated checkbox element.
      * @private
      */
     handleCheckboxUpdate_: function(checkbox) {
       if (checkbox.inputMethodId.match(/^_ext_ime_/)) {
@@ skipping 37 matching lines @@
     },
 
     /**
      * 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 == this.prospectiveUiLanguageCode_)
         return false;
-      return (!cr.isChromeOS ||
-              this.canDeleteLanguage_(languageCode));
+      return (!cr.isChromeOS || this.canDeleteLanguage_(languageCode));
     },
 
     /**
      * Handles browser.enable_spellchecking change.
      * @param {Event} e Change event.
      * @private
      */
     updateEnableSpellCheck_: function(e) {
       var value = !$('enable-spellcheck').checked;
       var languageControl = $('spellcheck-language-checkbox');
@@ skipping 54 matching lines @@
      */
     handleSpellCheckLanguageCheckboxClick_: function(e) {
       var languageCode = e.currentTarget.languageCode;
 
       if (e.currentTarget.checked)
         this.spellCheckLanguages_[languageCode] = true;
       else
         delete this.spellCheckLanguages_[languageCode];
 
       var languageCodes = Object.keys(this.spellCheckLanguages_);
-      Preferences.setListPref(SPELL_CHECK_DICTIONARIES_PREF,
-                              languageCodes, true);
+      Preferences.setListPref(
+          SPELL_CHECK_DICTIONARIES_PREF, languageCodes, true);
 
       // The spellCheckLanguageChange argument is only used for logging.
       chrome.send('spellCheckLanguageChange', [languageCodes.join(',')]);
-      chrome.send('coreOptionsUserMetricsAction',
-                  ['Options_Languages_SpellCheck']);
+      chrome.send(
+          'coreOptionsUserMetricsAction', ['Options_Languages_SpellCheck']);
     },
 
     /**
      * 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").
      * @return {boolean} Returns true on success.
      * @private
@@ skipping 46 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(ENABLED_EXTENSION_IME_PREF,
-                                this.enabledExtensionImes_.join(','), true);
+      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.
       var dictionary = {};
@@ skipping 30 matching lines @@
             this.enabledExtensionImes_.push(checkboxes[i].inputMethodId);
         }
       }
     },
 
     /**
      * Saves the preload engines preference.
      * @private
      */
     savePreloadEnginesPref_: function() {
-      Preferences.setStringPref(PRELOAD_ENGINES_PREF,
-                                this.preloadEngines_.join(','), true);
+      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.
       var dictionary = {};
@@ skipping 144 matching lines @@
       // 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 == loadTimeData.getString('currentUiLanguageCode')) {
         this.updateUiLanguageButton_(languageCode);
         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);
+      showMutuallyExclusiveNodes(
+          [
+            $('language-options-ui-language-button'),
+            $('language-options-ui-notification-bar')
+          ],
+          1);
     },
 
     /**
      * A handler for when dictionary for |languageCode| begins downloading.
      * @param {string} languageCode The language of the dictionary that just
      *     began downloading.
      * @private
      */
     onDictionaryDownloadBegin_: function(languageCode) {
       this.spellcheckDictionaryDownloadStatus_[languageCode] =
@@ skipping 72 matching lines @@
     },
 
     /**
      * Handles activate-ime-menu checkbox's click event.
      * @param {Event} e Click event.
      * @private
      */
     handleActivateImeMenuCheckboxClick_: function(e) {
       if (cr.isChromeOS) {
         var checkbox = e.target;
-        Preferences.setBooleanPref(ACTIVATE_IME_MENU_PREF,
-                                   checkbox.checked, true);
+        Preferences.setBooleanPref(
+            ACTIVATE_IME_MENU_PREF, checkbox.checked, true);
       }
     },
 
     /**
      * Updates the activate-ime-menu check box's checked state.
      * @param {Event} e Change event.
      * @private
      */
     updateImeMenuCheckbox_: function(e) {
       $('activate-ime-menu').checked = e.value.value;
@@ skipping 23 matching lines @@
 
   LanguageOptions.onDictionaryDownloadSuccess = function(languageCode) {
     LanguageOptions.getInstance().onDictionaryDownloadSuccess_(languageCode);
   };
 
   LanguageOptions.onDictionaryDownloadFailure = function(languageCode) {
     LanguageOptions.getInstance().onDictionaryDownloadFailure_(languageCode);
   };
 
   // Export
-  return {
-    LanguageOptions: LanguageOptions
-  };
+  return {LanguageOptions: LanguageOptions};
 });