MD Settings: reduce complexity and overhead of Languages singleton

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' provides convenient access to
- * Chrome's language and input method settings.
- *
- * Instances of this element have a 'languages' property, which reflects the
- * current language settings. The 'languages' property is read-only, meaning
- * hosts using this element cannot change it directly. Instead, changes to
- * language settings should be made using the LanguageHelperImpl singleton.
- *
- * Use upward binding syntax to propagate changes from child to host, so that
- * changes made internally to 'languages' propagate to your host element:
- *
- *     <template>
- *       <settings-languages languages="{{languages}}">
- *       </settings-languages>
- *       <div>[[languages.someProperty]]</div>
- *     </template>
+ * @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 settings.LanguageHelperImpl.
  */
 
-var SettingsLanguagesSingletonElement;
-
-cr.exportPath('languageSettings');
-
-(function() {
+cr.define('settings', function() {
 'use strict';

[michaelpg, 2016/08/18 03:05:28]

Everything inside this function will be indented (see previous patchset). But it
completely destroys the diff, so please review with this diff.

[stevenjb, 2016/08/18 16:22:03]

Thank you!

[michaelpg, 2016/08/18 22:32:27]

I've further decided to leave it this way -- the horrible diff and
every-line-blame isn't worth the consistency, since it was incorrect before
anyway.

 
 // Translate server treats some language codes the same.
 // See also: components/translate/core/common/translate_util.cc.
 var kLanguageCodeToTranslateCode = {
   'nb': 'no',
   'fil': 'tl',
   'zh-HK': 'zh-TW',
   'zh-MO': 'zh-TW',
   'zh-SG': 'zh-CN',
 };
 
 // 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';
 
 /**
  * Singleton element that generates the languages model on start-up and
- * updates it whenever Chrome's pref store and other settings change. These
- * updates propagate to each <settings-language> instance so that their
- * 'languages' property updates like any other Polymer property.
+ * updates it whenever Chrome's pref store and other settings change.
  * @implements {LanguageHelper}
  */
-SettingsLanguagesSingletonElement = Polymer({
-  is: 'settings-languages-singleton',
+var SettingsLanguagesElement = Polymer({
+  is: 'settings-languages',
 
   behaviors: [PrefsBehavior],
 
   properties: {
     /**
      * @type {!LanguagesModel|undefined}
      */
     languages: {
       type: Object,
       notify: true,
+      readOnly: true,
     },
 
     /**
      * Object containing all preferences.
      */
     prefs: {
       type: Object,
       notify: true,
     },
 
     /**
      * PromiseResolver to be resolved when the singleton has been initialized.
      * @private {!PromiseResolver}
      */
     resolver_: {
       type: Object,
       value: function() {
         return new PromiseResolver();
       },
     },
 
     /** @type {!LanguageSettingsPrivate} */
     languageSettingsPrivate: Object,
 
     /** @type {!InputMethodPrivate} */
     inputMethodPrivate: Object,
+
+    /**
+     * 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(); },
+    },
+
+    /**
+     * Hash set of enabled language codes for membership testing.
+     * @private {!Set<string>}
+     */
+    enabledLanguageSet_: {
+      type: Object,
+      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(); },
+    },
+
+    /**
+     * 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(); },
+    },
   },
 
-  /**
-   * Hash map of supported languages by language codes for fast lookup.
-   * @private {!Map<string, !chrome.languageSettingsPrivate.Language>}
-   */
-  supportedLanguageMap_: new Map(),
-
-  /**
-   * Hash set of enabled language codes for membership testing.
-   * @private {!Set<string>}
-   */
-  enabledLanguageSet_: new Set(),
-
-  /**
-   * Hash map of supported input methods by ID for fast lookup.
-   * @private {!Map<string, chrome.languageSettingsPrivate.InputMethod>}
-   */
-  supportedInputMethodMap_: new Map(),
-
-  /**
-   * Hash map of input methods supported for each language.
-   * @type {!Map<string, !Array<!chrome.languageSettingsPrivate.InputMethod>>}
-   * @private
-   */
-  languageInputMethods_: new Map(),
-
   observers: [
     'preferredLanguagesPrefChanged_(' +
         'prefs.' + preferredLanguagesPrefName + '.value, languages)',
     'spellCheckDictionariesPrefChanged_(' +
         'prefs.spellcheck.dictionaries.value.*, languages)',
     'translateLanguagesPrefChanged_(' +
         'prefs.translate_blocked_languages.value.*, languages)',
     'prospectiveUILanguageChanged_(' +
         'prefs.intl.app_locale.value, languages)',
     // Observe Chrome OS prefs (ignored for non-Chrome OS).
     'updateRemovableLanguages_(' +
         'prefs.settings.language.preload_engines.value, ' +
         'prefs.settings.language.enabled_extension_imes.value, ' +
         'languages)',
   ],
 
   /** @override */
   created: function() {
+    // This element can now be used through the LanguageHelper API.
+    SettingsLanguagesElement.instance_ = /** @type {!LanguageHelper} */(this);
+
     this.languageSettingsPrivate =
-        languageSettings.languageSettingsPrivateApiForTest ||
-        /** @type {!LanguageSettingsPrivate} */(chrome.languageSettingsPrivate);
+        settings.languageSettingsPrivateApiForTest ||
+        /** @type {!LanguageSettingsPrivate} */(
+            chrome.languageSettingsPrivate);
 
     this.inputMethodPrivate =
-        languageSettings.inputMethodPrivateApiForTest ||
+        settings.inputMethodPrivateApiForTest ||
         /** @type {!InputMethodPrivate} */(chrome.inputMethodPrivate);
 
     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) {
@@ skipping 101 matching lines @@
       language.supportsSpellcheck = !!language.supportsSpellcheck;
       this.supportedLanguageMap_.set(language.code, language);
     }
 
     if (supportedInputMethods) {
       // Populate the hash map of supported input methods.
       for (var inputMethod of supportedInputMethods) {
         inputMethod.enabled = !!inputMethod.enabled;
         // Add the input method to the map of IDs.
         this.supportedInputMethodMap_.set(inputMethod.id, inputMethod);
-        // Add the input method to the list of input methods for each language
-        // it supports.
+        // Add the input method to the list of input methods for each
+        // language it supports.
         for (var languageCode of inputMethod.languageCodes) {
           if (!this.supportedLanguageMap_.has(languageCode))
             continue;
           if (!this.languageInputMethods_.has(languageCode))
             this.languageInputMethods_.set(languageCode, [inputMethod]);
           else
             this.languageInputMethods_.get(languageCode).push(inputMethod);
         }
       }
     }
 
     // Create a list of enabled languages from the supported languages.
-    var enabledLanguageStates = this.getEnabledLanguageStates_(translateTarget);
+    var enabledLanguageStates =
+        this.getEnabledLanguageStates_(translateTarget);
+
     // Populate the hash set of enabled languages.
     for (var languageState of enabledLanguageStates)
       this.enabledLanguageSet_.add(languageState.language.code);
 
     var model = /** @type {!LanguagesModel} */({
       supported: supportedLanguages,
       enabled: enabledLanguageStates,
       translateTarget: translateTarget,
     });
     if (cr.isChromeOS) {
       model.inputMethods = /** @type {!InputMethodsModel} */({
         supported: supportedInputMethods,
         enabled: this.getEnabledInputMethods_(),
         currentId: currentInputMethodId,
       });
     }
 
     // Initialize the Polymer languages model.
-    this.languages = model;
+    this._setLanguages(model);
   },
 
   /**
-   * Returns a list of LanguageStates for each enabled language in the supported
-   * languages list.
+   * 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.
    * @return {!Array<!LanguageState>}
    * @private
    */
   getEnabledLanguageStates_: function(translateTarget) {
     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 translateBlockedPref = this.getPref('translate_blocked_languages');
     var translateBlockedSet = this.makeSetFromArray_(
         /** @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} */({});
       languageState.language = language;
       languageState.spellCheckEnabled = !!spellCheckSet.has(code);
-      // Translate is considered disabled if this language maps to any translate
-      // language that is blocked.
+      // Translate is considered disabled if this language maps to any
+      // translate language that is blocked.
       var translateCode = this.convertLanguageCodeForTranslate(code);
       languageState.translateEnabled = !!language.supportsTranslate &&
           !translateBlockedSet.has(translateCode) &&
           translateCode != translateTarget;
       enabledLanguageStates.push(languageState);
     }
     return enabledLanguageStates;
   },
 
   /**
@@ skipping 19 matching lines @@
   },
 
   /** @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',
-          enabledInputMethodSet.has(this.languages.inputMethods.supported[i]));
+          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() {
@@ skipping 28 matching lines @@
   // LanguageHelper implementation.
   // TODO(michaelpg): replace duplicate docs with @override once b/24294625
   // is fixed.
 
   /** @return {!Promise} */
   whenReady: function() {
     return this.resolver_.promise;
   },
 
   /**
-   * Sets the prospective UI language to the chosen language. This won't affect
-   * the actual UI language until a restart.
+   * Sets the prospective UI language to the chosen language. This won't
+   * affect the actual UI language until a restart.
    * @param {string} languageCode
    */
   setUILanguage: function(languageCode) {
     assert(cr.isChromeOS || cr.isWindows);
     chrome.send('setUILanguage', [languageCode]);
   },
 
   /** Resets the prospective UI language back to the actual UI language. */
   resetUILanguage: function() {
     assert(cr.isChromeOS || cr.isWindows);
@@ skipping 42 matching lines @@
    */
   disableLanguage: function(languageCode) {
     if (!CrSettingsPrefs.isInitialized)
       return;
 
     assert(this.canDisableLanguage(languageCode));
 
     // Remove the language from spell check.
     this.deletePrefListItem('spellcheck.dictionaries', languageCode);
 
+    // Remove input methods that don't support any other enabled language.
     if (cr.isChromeOS) {
-      // Remove input methods that don't support any other enabled language.
       var inputMethods = this.languageInputMethods_.get(languageCode) || [];
       for (var inputMethod of inputMethods) {
         var supportsOtherEnabledLanguages = inputMethod.languageCodes.some(
             function(otherLanguageCode) {
               return otherLanguageCode != languageCode &&
                   this.isLanguageEnabled(otherLanguageCode);
             }.bind(this));
         if (!supportsOtherEnabledLanguages)
           this.removeInputMethod(inputMethod.id);
       }
@@ skipping 28 matching lines @@
     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 otherLanguageCode = languageState.language.code;
           if (otherLanguageCode == languageCode)
             return false;
-          var inputMethods = this.languageInputMethods_.get(otherLanguageCode);
+          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;
   },
 
   /**
    * Moves the language in the list of enabled languages by the given offset.
    * @param {string} languageCode
-   * @param {number} offset Negative offset moves the language toward the front
-   *     of the list. A Positive one moves the language toward the back.
+   * @param {number} offset Negative offset moves the language toward the
+   *     front of the list. A Positive one moves the language toward the back.
    */
   moveLanguage: function(languageCode, offset) {
     if (!CrSettingsPrefs.isInitialized)
       return;
 
     var languageCodes =
         this.getPref(preferredLanguagesPrefName).value.split(',');
 
     var originalIndex = languageCodes.indexOf(languageCode);
     var newIndex = originalIndex + offset;
-    if (originalIndex == -1 || newIndex < 0 || newIndex >= languageCodes.length)
+    if (originalIndex == -1 || newIndex < 0 ||
+        newIndex >= languageCodes.length) {
       return;
+    }
 
     languageCodes.splice(originalIndex, 1);
     languageCodes.splice(newIndex, 0, languageCode);
     this.languageSettingsPrivate.setLanguageList(languageCodes);
   },
 
   /**
    * Enables translate for the given language by removing the translate
    * language from the blocked languages preference.
    * @param {string} languageCode
@@ skipping 103 matching lines @@
     this.languageSettingsPrivate.removeInputMethod(id);
   },
 
   /** @param {string} id */
   setCurrentInputMethod: function(id) {
     assert(cr.isChromeOS);
     this.inputMethodPrivate.setCurrentInputMethod(id);
   },
 
   /**
-   * param {string} languageCode
+   * @param {string} languageCode
    * @return {!Array<!chrome.languageSettingsPrivate.InputMethod>}
    */
   getInputMethodsForLanguage: function(languageCode) {
     return this.languageInputMethods_.get(languageCode) || [];
   },
 
   /**
    * @param {!chrome.languageSettingsPrivate.InputMethod} inputMethod
    * @return {boolean}
    */
@@ skipping 19 matching lines @@
     assert(cr.isChromeOS);
     this.updateEnabledInputMethods_();
   },
 
   /** @param {string} id Removed input method ID. */
   onInputMethodRemoved_: function(id) {
     assert(cr.isChromeOS);
     this.updateEnabledInputMethods_();
   },
 });
-})();
 
-/**
- * A reference to the singleton under the guise of a LanguageHelper
- * implementation. This provides a limited API but implies the singleton
- * should not be used directly for data binding.
- */
-var LanguageHelperImpl = SettingsLanguagesSingletonElement;
-cr.addSingletonGetter(LanguageHelperImpl);
+return {
+  LanguageHelperImpl: SettingsLanguagesElement,
+};
+});
 
-/**
- * This element has a reference to the singleton, exposing the singleton's
- * |languages| model to the host of this element.
- */
-Polymer({
-  is: 'settings-languages',
-
-  properties: {
-    /**
-     * A reference to the languages model from the singleton, exposed as a
-     * read-only property so hosts can bind to it, but not change it.
-     * @type {LanguagesModel|undefined}
-     */
-    languages: {
-      type: Object,
-      notify: true,
-      readOnly: true,
-    },
-  },
-
-  ready: function() {
-    var singleton = /** @type {!SettingsLanguagesSingletonElement} */
-        (LanguageHelperImpl.getInstance());
-    singleton.whenReady().then(function() {
-      // Set the 'languages' property to reference the singleton's model.
-      this._setLanguages(singleton.languages);
-      // Listen for changes to the singleton's languages property, so we know
-      // when to notify hosts of changes to (our reference to) the property.
-      this.listen(singleton, 'languages-changed', 'singletonLanguagesChanged_');
-    }.bind(this));
-  },
-
-  /**
-   * Takes changes reported by the singleton and forwards them to the host,
-   * manually sending a change notification for our 'languages' property (since
-   * it's the same object as the singleton's property, but isn't bound by
-   * Polymer).
-   * @private
-   */
-  singletonLanguagesChanged_: function(e) {
-    // Forward the change notification to the host.
-    this.fire(e.type, e.detail, {bubbles: false});
-  },
-});
+/** @return {!LanguageHelper} */
+settings.LanguageHelperImpl.getInstance = function() {
+  // <settings-languages> must have been created before this is called, so it
+  // can set itself as the LanguageHelperImpl instance.
+  return assert(settings.LanguageHelperImpl.instance_);
+};