Run clang-format on .js files in c/b/r/settings

chrome/browser/resources/settings/languages_page/languages.js

 // Copyright 2015 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.
 
 /**
  * @fileoverview 'settings-languages' handles Chrome's language and input
  * method settings. The 'languages' property, which reflects the current
  * language settings, must not be changed directly. Instead, changes to
  * language settings should be made using the LanguageHelper APIs provided by
  * this class via languageHelper.
@@ skipping 16 matching lines @@
 
 // Some ISO 639 language codes have been renamed, e.g. "he" to "iw", but
 // Translate still uses the old versions. TODO(michaelpg): Chrome does too.
 // Follow up with Translate owners to understand the right thing to do.
 var kTranslateLanguageSynonyms = {
   'he': 'iw',
   'jv': 'jw',
 };
 
 var preferredLanguagesPrefName = cr.isChromeOS ?
-    'settings.language.preferred_languages' : 'intl.accept_languages';
+    'settings.language.preferred_languages' :
+    'intl.accept_languages';
 
 /**
  * Singleton element that generates the languages model on start-up and
  * updates it whenever Chrome's pref store and other settings change.
  * @implements {LanguageHelper}
  */
 Polymer({
   is: 'settings-languages',
 
   behaviors: [PrefsBehavior],
 
   properties: {
     /**
      * @type {!LanguagesModel|undefined}
      */
     languages: {
       type: Object,
       notify: true,
       readOnly: true,
     },
 
     /**
      * This element, as a LanguageHelper instance for API usage.
      * @type {!LanguageHelper}
      */
     languageHelper: {
       type: Object,
       notify: true,
       readOnly: true,
-      value: function() { return /** @type {!LanguageHelper} */(this); },
+      value: function() {
+        return /** @type {!LanguageHelper} */ (this);
+      },
     },
 
     /**
      * PromiseResolver to be resolved when the singleton has been initialized.
      * @private {!PromiseResolver}
      */
     resolver_: {
       type: Object,
       value: function() {
         return new PromiseResolver();
       },
     },
 
     /**
      * Hash map of supported languages by language codes for fast lookup.
      * @private {!Map<string, !chrome.languageSettingsPrivate.Language>}
      */
     supportedLanguageMap_: {
       type: Object,
-      value: function() { return new Map(); },
+      value: function() {
+        return new Map();
+      },
     },
 
     /**
      * Hash set of enabled language codes for membership testing.
      * @private {!Set<string>}
      */
     enabledLanguageSet_: {
       type: Object,
-      value: function() { return new Set(); },
+      value: function() {
+        return new Set();
+      },
     },
 
     /**
      * Hash map of supported input methods by ID for fast lookup.
      * @private {!Map<string, chrome.languageSettingsPrivate.InputMethod>}
      */
     supportedInputMethodMap_: {
       type: Object,
-      value: function() { return new Map(); },
+      value: function() {
+        return new Map();
+      },
     },
 
     /**
      * Hash map of input methods supported for each language.
      * @type {!Map<string,
      *             !Array<!chrome.languageSettingsPrivate.InputMethod>>}
      * @private
      */
     languageInputMethods_: {
       type: Object,
-      value: function() { return new Map(); },
+      value: function() {
+        return new Map();
+      },
     },
 
     /** @private Prospective UI language when the page was loaded. */
     originalProspectiveUILanguage_: String,
   },
 
   observers: [
     // All observers wait for the model to be populated by including the
     // |languages| property.
     'prospectiveUILanguageChanged_(prefs.intl.app_locale.value, languages)',
@@ skipping 14 matching lines @@
 
   /** @private {?Function} */
   boundOnInputMethodChanged_: null,
 
   /** @private {?settings.LanguagesBrowserProxy} */
   browserProxy_: null,
 
   /** @private {?LanguageSettingsPrivate} */
   languageSettingsPrivate_: null,
 
-// <if expr="chromeos">
+  // <if expr="chromeos">
   /** @private {?InputMethodPrivate} */
   inputMethodPrivate_: null,
-// </if>
+  // </if>
 
   /** @override */
   attached: function() {
     this.browserProxy_ = settings.LanguagesBrowserProxyImpl.getInstance();
     this.languageSettingsPrivate_ =
         this.browserProxy_.getLanguageSettingsPrivate();
-// <if expr="chromeos">
+    // <if expr="chromeos">
     this.inputMethodPrivate_ = this.browserProxy_.getInputMethodPrivate();
-// </if>
+    // </if>
 
     var promises = [];
 
     // Wait until prefs are initialized before creating the model, so we can
     // include information about enabled languages.
     promises[0] = CrSettingsPrefs.initialized;
 
     // Get the language list.
     promises[1] = new Promise(function(resolve) {
       this.languageSettingsPrivate_.getLanguageList(resolve);
@@ skipping 55 matching lines @@
       this.boundOnInputMethodChanged_ = null;
     }
   },
 
   /**
    * Updates the prospective UI language based on the new pref value.
    * @param {string} prospectiveUILanguage
    * @private
    */
   prospectiveUILanguageChanged_: function(prospectiveUILanguage) {
-    this.set('languages.prospectiveUILanguage',
+    this.set(
+        'languages.prospectiveUILanguage',
         prospectiveUILanguage || this.originalProspectiveUILanguage_);
   },
 
   /**
    * Updates the list of enabled languages from the preferred languages pref.
    * @private
    */
   preferredLanguagesPrefChanged_: function() {
     var enabledLanguageStates = this.getEnabledLanguageStates_(
         this.languages.translateTarget, this.languages.prospectiveUILanguage);
 
     // Recreate the enabled language set before updating languages.enabled.
     this.enabledLanguageSet_.clear();
     for (var i = 0; i < enabledLanguageStates.length; i++)
       this.enabledLanguageSet_.add(enabledLanguageStates[i].language.code);
 
     this.set('languages.enabled', enabledLanguageStates);
   },
 
   /**
    * Updates the spellCheckEnabled state of each enabled language.
    * @private
    */
   spellCheckDictionariesPrefChanged_: function() {
-    var spellCheckSet = this.makeSetFromArray_(/** @type {!Array<string>} */(
+    var spellCheckSet = this.makeSetFromArray_(/** @type {!Array<string>} */ (
         this.getPref('spellcheck.dictionaries').value));
     for (var i = 0; i < this.languages.enabled.length; i++) {
       var languageState = this.languages.enabled[i];
-      this.set('languages.enabled.' + i + '.spellCheckEnabled',
-               !!spellCheckSet.has(languageState.language.code));
+      this.set(
+          'languages.enabled.' + i + '.spellCheckEnabled',
+          !!spellCheckSet.has(languageState.language.code));
     }
   },
 
   /** @private */
   translateLanguagesPrefChanged_: function() {
     var translateBlockedPref = this.getPref('translate_blocked_languages');
     var translateBlockedSet = this.makeSetFromArray_(
-        /** @type {!Array<string>} */(translateBlockedPref.value));
+        /** @type {!Array<string>} */ (translateBlockedPref.value));
 
     for (var i = 0; i < this.languages.enabled.length; i++) {
       if (this.languages.enabled[i].language.code ==
           this.languages.prospectiveUILanguage) {
         continue;
       }
       var translateCode = this.convertLanguageCodeForTranslate(
           this.languages.enabled[i].language.code);
       this.set(
           'languages.enabled.' + i + '.translateEnabled',
           !translateBlockedSet.has(translateCode));
     }
   },
 
   /**
    * Constructs the languages model.
    * @param {!Array<!chrome.languageSettingsPrivate.Language>}
    *     supportedLanguages
    * @param {string} translateTarget Language code of the default translate
    *     target language.
    * @param {!Array<!chrome.languageSettingsPrivate.InputMethod>|undefined}
    *     supportedInputMethods Input methods (Chrome OS only).
    * @param {string|undefined} currentInputMethodId ID of the currently used
    *     input method (Chrome OS only).
    * @private
    */
-  createModel_: function(supportedLanguages, translateTarget,
-                         supportedInputMethods, currentInputMethodId) {
+  createModel_: function(
+      supportedLanguages, translateTarget, supportedInputMethods,
+      currentInputMethodId) {
     // Populate the hash map of supported languages.
     for (var i = 0; i < supportedLanguages.length; i++) {
       var language = supportedLanguages[i];
       language.supportsUI = !!language.supportsUI;
       language.supportsTranslate = !!language.supportsTranslate;
       language.supportsSpellcheck = !!language.supportsSpellcheck;
       this.supportedLanguageMap_.set(language.code, language);
     }
 
     if (supportedInputMethods) {
@@ skipping 13 matching lines @@
             this.languageInputMethods_.set(languageCode, [inputMethod]);
           else
             this.languageInputMethods_.get(languageCode).push(inputMethod);
         }
       }
     }
 
     var prospectiveUILanguage;
     if (cr.isChromeOS || cr.isWindows) {
       prospectiveUILanguage =
-          /** @type {string} */(this.getPref('intl.app_locale').value) ||
+          /** @type {string} */ (this.getPref('intl.app_locale').value) ||
           this.originalProspectiveUILanguage_;
     }
 
     // Create a list of enabled languages from the supported languages.
     var enabledLanguageStates =
         this.getEnabledLanguageStates_(translateTarget, prospectiveUILanguage);
     // Populate the hash set of enabled languages.
     for (var l = 0; l < enabledLanguageStates.length; l++)
       this.enabledLanguageSet_.add(enabledLanguageStates[l].language.code);
 
-    var model = /** @type {!LanguagesModel} */({
+    var model = /** @type {!LanguagesModel} */ ({
       supported: supportedLanguages,
       enabled: enabledLanguageStates,
       translateTarget: translateTarget,
     });
 
     if (cr.isChromeOS || cr.isWindows)
       model.prospectiveUILanguage = prospectiveUILanguage;
 
     if (cr.isChromeOS) {
-      model.inputMethods = /** @type {!InputMethodsModel} */({
+      model.inputMethods = /** @type {!InputMethodsModel} */ ({
         supported: supportedInputMethods,
         enabled: this.getEnabledInputMethods_(),
         currentId: currentInputMethodId,
       });
     }
 
     // Initialize the Polymer languages model.
     this._setLanguages(model);
   },
 
   /**
    * Returns a list of LanguageStates for each enabled language in the supported
    * languages list.
    * @param {string} translateTarget Language code of the default translate
    *     target language.
    * @param {(string|undefined)} prospectiveUILanguage Prospective UI display
    *     language. Only defined on Windows and Chrome OS.
    * @return {!Array<!LanguageState>}
    * @private
    */
   getEnabledLanguageStates_: function(translateTarget, prospectiveUILanguage) {
     assert(CrSettingsPrefs.isInitialized);
 
     var pref = this.getPref(preferredLanguagesPrefName);
     var enabledLanguageCodes = pref.value.split(',');
     var spellCheckPref = this.getPref('spellcheck.dictionaries');
-    var spellCheckSet = this.makeSetFromArray_(/** @type {!Array<string>} */(
-        spellCheckPref.value));
+    var spellCheckSet = this.makeSetFromArray_(
+        /** @type {!Array<string>} */ (spellCheckPref.value));
 
     var translateBlockedPref = this.getPref('translate_blocked_languages');
     var translateBlockedSet = this.makeSetFromArray_(
-        /** @type {!Array<string>} */(translateBlockedPref.value));
+        /** @type {!Array<string>} */ (translateBlockedPref.value));
 
     var enabledLanguageStates = [];
     for (var i = 0; i < enabledLanguageCodes.length; i++) {
       var code = enabledLanguageCodes[i];
       var language = this.supportedLanguageMap_.get(code);
       // Skip unsupported languages.
       if (!language)
         continue;
-      var languageState = /** @type {LanguageState} */({});
+      var languageState = /** @type {LanguageState} */ ({});
       languageState.language = language;
       languageState.spellCheckEnabled = !!spellCheckSet.has(code);
       // Translate is considered disabled if this language maps to any translate
       // language that is blocked.
       var translateCode = this.convertLanguageCodeForTranslate(code);
-      languageState.translateEnabled =
-          !!language.supportsTranslate &&
+      languageState.translateEnabled = !!language.supportsTranslate &&
           !translateBlockedSet.has(translateCode) &&
           translateCode != translateTarget &&
           (!prospectiveUILanguage || code != prospectiveUILanguage);
       enabledLanguageStates.push(languageState);
     }
     return enabledLanguageStates;
   },
 
   /**
    * Returns a list of enabled input methods.
    * @return {!Array<!chrome.languageSettingsPrivate.InputMethod>}
    * @private
    */
   getEnabledInputMethods_: function() {
     assert(cr.isChromeOS);
     assert(CrSettingsPrefs.isInitialized);
 
     var enabledInputMethodIds =
         this.getPref('settings.language.preload_engines').value.split(',');
-    enabledInputMethodIds = enabledInputMethodIds.concat(this.getPref(
-        'settings.language.enabled_extension_imes').value.split(','));
+    enabledInputMethodIds = enabledInputMethodIds.concat(
+        this.getPref('settings.language.enabled_extension_imes')
+            .value.split(','));
 
     // Return only supported input methods.
-    return enabledInputMethodIds.map(function(id) {
-      return this.supportedInputMethodMap_.get(id);
-    }.bind(this)).filter(function(inputMethod) {
-      return !!inputMethod;
-    });
+    return enabledInputMethodIds
+        .map(function(id) {
+          return this.supportedInputMethodMap_.get(id);
+        }.bind(this))
+        .filter(function(inputMethod) {
+          return !!inputMethod;
+        });
   },
 
   /** @private */
   updateEnabledInputMethods_: function() {
     assert(cr.isChromeOS);
     var enabledInputMethods = this.getEnabledInputMethods_();
     var enabledInputMethodSet = this.makeSetFromArray_(enabledInputMethods);
 
     for (var i = 0; i < this.languages.inputMethods.supported.length; i++) {
-      this.set('languages.inputMethods.supported.' + i + '.enabled',
+      this.set(
+          'languages.inputMethods.supported.' + i + '.enabled',
           enabledInputMethodSet.has(this.languages.inputMethods.supported[i]));
     }
     this.set('languages.inputMethods.enabled', enabledInputMethods);
   },
 
   /**
    * Updates the |removable| property of the enabled language states based
    * on what other languages and input methods are enabled.
    * @private
    */
   updateRemovableLanguages_: function() {
     assert(this.languages);
     // TODO(michaelpg): Enabled input methods can affect which languages are
     // removable, so run updateEnabledInputMethods_ first (if it has been
     // scheduled).
     if (cr.isChromeOS)
       this.updateEnabledInputMethods_();
 
     for (var i = 0; i < this.languages.enabled.length; i++) {
       var languageState = this.languages.enabled[i];
-      this.set('languages.enabled.' + i + '.removable',
+      this.set(
+          'languages.enabled.' + i + '.removable',
           this.canDisableLanguage(languageState.language.code));
     }
   },
 
   /**
    * Creates a Set from the elements of the array.
    * @param {!Array<T>} list
    * @return {!Set<T>}
    * @template T
    * @private
    */
   makeSetFromArray_: function(list) {
     return new Set(list);
   },
 
   // LanguageHelper implementation.
   // TODO(michaelpg): replace duplicate docs with @override once b/24294625
   // is fixed.
 
   /** @return {!Promise} */
   whenReady: function() {
     return this.resolver_.promise;
   },
 
-// <if expr="chromeos or is_win">
+  // <if expr="chromeos or is_win">
   /**
    * Sets the prospective UI language to the chosen language. This won't affect
    * the actual UI language until a restart.
    * @param {string} languageCode
    */
   setProspectiveUILanguage: function(languageCode) {
     this.browserProxy_.setProspectiveUILanguage(languageCode);
   },
 
   /**
    * True if the prospective UI language was changed from its starting value.
    * @return {boolean}
    */
   requiresRestart: function() {
     return this.originalProspectiveUILanguage_ !=
         this.languages.prospectiveUILanguage;
   },
-// </if>
+  // </if>
 
   /**
    * @param {string} languageCode
    * @return {boolean} True if the language is enabled.
    */
   isLanguageEnabled: function(languageCode) {
     return this.enabledLanguageSet_.has(languageCode);
   },
 
   /**
@@ skipping 19 matching lines @@
     assert(this.canDisableLanguage(languageCode));
 
     // Remove the language from spell check.
     this.deletePrefListItem('spellcheck.dictionaries', languageCode);
 
     if (cr.isChromeOS) {
       // Remove input methods that don't support any other enabled language.
       var inputMethods = this.languageInputMethods_.get(languageCode) || [];
       for (var i = 0; i < inputMethods.length; i++) {
         var inputMethod = inputMethods[i];
-        var supportsOtherEnabledLanguages = inputMethod.languageCodes.some(
-            function(otherLanguageCode) {
+        var supportsOtherEnabledLanguages =
+            inputMethod.languageCodes.some(function(otherLanguageCode) {
               return otherLanguageCode != languageCode &&
                   this.isLanguageEnabled(otherLanguageCode);
             }.bind(this));
         if (!supportsOtherEnabledLanguages)
           this.removeInputMethod(inputMethod.id);
       }
     }
 
     // Remove the language from preferred languages.
     this.languageSettingsPrivate_.disableLanguage(languageCode);
@@ skipping 11 matching lines @@
 
     // Cannot disable the only enabled language.
     if (this.languages.enabled.length == 1)
       return false;
 
     if (!cr.isChromeOS)
       return true;
 
     // If this is the only enabled language that is supported by all enabled
     // component IMEs, it cannot be disabled because we need those IMEs.
-    var otherInputMethodsEnabled = this.languages.enabled.some(
-        function(languageState) {
+    var otherInputMethodsEnabled =
+        this.languages.enabled.some(function(languageState) {
           var otherLanguageCode = languageState.language.code;
           if (otherLanguageCode == languageCode)
             return false;
           var inputMethods = this.languageInputMethods_.get(otherLanguageCode);
           return inputMethods && inputMethods.some(function(inputMethod) {
             return this.isComponentIme(inputMethod) &&
                 this.supportedInputMethodMap_.get(inputMethod.id).enabled;
           }, this);
         }, this);
     return otherInputMethodsEnabled;
@@ skipping 62 matching lines @@
     languageCode = this.convertLanguageCodeForTranslate(languageCode);
     this.deletePrefListItem('translate_blocked_languages', languageCode);
   },
 
   /**
    * Disables translate for the given language by adding the translate
    * language to the blocked languages preference.
    * @param {string} languageCode
    */
   disableTranslateLanguage: function(languageCode) {
-    this.appendPrefListItem('translate_blocked_languages',
+    this.appendPrefListItem(
+        'translate_blocked_languages',
         this.convertLanguageCodeForTranslate(languageCode));
   },
 
   /**
    * Enables or disables spell check for the given language.
    * @param {string} languageCode
    * @param {boolean} enable
    */
   toggleSpellCheck: function(languageCode, enable) {
     if (!this.languages)
@@ skipping 48 matching lines @@
   },
 
   /**
    * @param {string} languageCode
    * @return {!chrome.languageSettingsPrivate.Language|undefined}
    */
   getLanguage: function(languageCode) {
     return this.supportedLanguageMap_.get(languageCode);
   },
 
-// <if expr="chromeos">
+  // <if expr="chromeos">
   /** @param {string} id */
   addInputMethod: function(id) {
     if (!this.supportedInputMethodMap_.has(id))
       return;
     this.languageSettingsPrivate_.addInputMethod(id);
   },
 
   /** @param {string} id */
   removeInputMethod: function(id) {
     if (!this.supportedInputMethodMap_.has(id))
@@ skipping 34 matching lines @@
 
   /** @param {string} id Added input method ID. */
   onInputMethodAdded_: function(id) {
     this.updateEnabledInputMethods_();
   },
 
   /** @param {string} id Removed input method ID. */
   onInputMethodRemoved_: function(id) {
     this.updateEnabledInputMethods_();
   },
-// </if>
+  // </if>
 });
 })();