Flesh out the location-page class to make it more general.

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
@@ skipping 174 matching lines @@
 /**
  * Singleton element created when settings-languages is registered.
  * 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.
  */
 Polymer({
   is: 'settings-languages-singleton',
 
+  behaviors: [PrefsBehavior],
+
   properties: {
     /**
      * @type {LanguagesModel|undefined}
      */
     languages: {
       type: Object,
       notify: true,
     },
 
     /**
@@ skipping 96 matching lines @@
    * Returns a list of LanguageInfos for each enabled language in the supported
    * languages list.
    * @param {string} translateTarget Language code of the default translate
    *     target language.
    * @return {!Array<!LanguageInfo>}
    * @private
    */
   getEnabledLanguages_: function(translateTarget) {
     assert(CrSettingsPrefs.isInitialized);
 
-    var pref = this.getPref_(preferredLanguagesPrefName);
+    var pref = this.getPref(preferredLanguagesPrefName);
     var enabledLanguageCodes = pref.value.split(',');
     var enabledLanguages = /** @type {!Array<!LanguageInfo>} */ [];
 
-    var spellCheckPref = this.getPref_('spellcheck.dictionaries');
+    var spellCheckPref = this.getPref('spellcheck.dictionaries');
     var spellCheckMap = this.makeMapFromArray_(/** @type {!Array<string>} */(
         spellCheckPref.value));
 
-    var translateBlockedPref = this.getPref_('translate_blocked_languages');
+    var translateBlockedPref = this.getPref('translate_blocked_languages');
     var translateBlockedMap = this.makeMapFromArray_(
         /** @type {!Array<string>} */(translateBlockedPref.value));
 
     for (var i = 0; i < enabledLanguageCodes.length; i++) {
       var code = enabledLanguageCodes[i];
       var language = this.supportedLanguageMap_[code];
       if (!language)
         continue;
       var state = {};
       state.spellCheckEnabled = !!spellCheckMap[code];
@@ skipping 42 matching lines @@
 
   /**
    * Updates the spellCheckEnabled state of each enabled language.
    * @private
    */
   spellCheckDictionariesPrefChanged_: function() {
     if (!this.initialized_)
       return;
 
     var spellCheckMap = this.makeMapFromArray_(/** @type {!Array<string>} */(
-        this.getPref_('spellcheck.dictionaries').value));
+        this.getPref('spellcheck.dictionaries').value));
     for (var i = 0; i < this.languages.enabledLanguages.length; i++) {
       var languageCode = this.languages.enabledLanguages[i].language.code;
       this.set('languages.enabledLanguages.' + i + '.state.spellCheckEnabled',
                !!spellCheckMap[languageCode]);
     }
   },
 
   translateLanguagesPrefChanged_: function() {
     if (!this.initialized_)
       return;
 
-    var translateBlockedPref = this.getPref_('translate_blocked_languages');
+    var translateBlockedPref = this.getPref('translate_blocked_languages');
     var translateBlockedMap = this.makeMapFromArray_(
         /** @type {!Array<string>} */(translateBlockedPref.value));
 
     for (var i = 0; i < this.languages.enabledLanguages.length; i++) {
       var translateCode = this.convertLanguageCodeForTranslate(
           this.languages.enabledLanguages[i].language.code);
       this.set(
           'languages.enabledLanguages.' + i + '.state.translateEnabled',
           !translateBlockedMap[translateCode]);
     }
   },
 
   /**
-   * Gets the pref at the given key. Asserts if the pref is not found.
-   * @param {string} key
-   * @return {!chrome.settingsPrivate.PrefObject}
-   */
-  getPref_: function(key) {
-    var pref = /** @type {!chrome.settingsPrivate.PrefObject} */(
-        this.get(key, this.prefs));
-    assert(typeof pref != 'undefined', 'Pref is missing: ' + key);
-    return pref;
-  },
-
-  /**
-   * Sets the value of the pref at the given key. Asserts if the pref is not
-   * found.
-   * @param {string} key
-   * @param {*} value
-   */
-  setPrefValue_: function(key, value) {
-    this.getPref_(key);
-    this.set('prefs.' + key + '.value', value);
-  },
-
-  /**
    * Deletes the given item from the pref at the given key if the item is found.
    * Asserts if the pref itself is not found or is not an Array type.
    * @param {string} key
    * @param {*} item
    */
   deletePrefItem_: function(key, item) {
-    assert(this.getPref_(key).type == chrome.settingsPrivate.PrefType.LIST);
+    assert(this.getPref(key).type == chrome.settingsPrivate.PrefType.LIST);
     this.arrayDelete('prefs.' + key + '.value', item);
   },
 
   /**
    * Windows and Chrome OS only: Sets the prospective UI language to the chosen
    * language. This dosen't affect the actual UI language until a restart.
    * @param {string} languageCode
    */
   setUILanguage: function(languageCode) {
     chrome.send('setUILanguage', [languageCode]);
   },
 
   /**
    * Windows and Chrome OS only: Resets the prospective UI language back to the
    * actual UI language.
    */
   resetUILanguage: function() {
     chrome.send('setUILanguage', [navigator.language]);
   },
 
   /**
    * Returns the "prospective" UI language, i.e. the one to be used on next
    * restart. If the pref is not set, the current UI language is also the
    * "prospective" language.
    * @return {string} Language code of the prospective UI language.
    * @private
    */
   getProspectiveUILanguage: function() {
-    return /** @type {string} */(this.getPref_('intl.app_locale').value) ||
+    return /** @type {string} */(this.getPref('intl.app_locale').value) ||
         navigator.language;
   },
 
   /**
    * Enables the language, making it available for spell check and input.
    * @param {string} languageCode
    */
   enableLanguage: function(languageCode) {
     if (!CrSettingsPrefs.isInitialized)
       return;
 
     var languageCodes =
-        this.getPref_(preferredLanguagesPrefName).value.split(',');
+        this.getPref(preferredLanguagesPrefName).value.split(',');
     if (languageCodes.indexOf(languageCode) > -1)
       return;
     languageCodes.push(languageCode);
     chrome.languageSettingsPrivate.setLanguageList(languageCodes);
     this.disableTranslateLanguage(languageCode);
   },
 
   /**
    * Disables the language.
    * @param {string} languageCode
    */
   disableLanguage: function(languageCode) {
     if (!CrSettingsPrefs.isInitialized)
       return;
 
     // Cannot disable the UI language.
     assert(languageCode != this.getProspectiveUILanguage());
 
     // Cannot disable the only enabled language.
     var languageCodes =
-        this.getPref_(preferredLanguagesPrefName).value.split(',');
+        this.getPref(preferredLanguagesPrefName).value.split(',');
     assert(languageCodes.length > 1);
 
     // Remove the language from spell check.
     this.deletePrefItem_('spellcheck.dictionaries', languageCode);
 
     var languageIndex = languageCodes.indexOf(languageCode);
     if (languageIndex == -1)
       return;
     languageCodes.splice(languageIndex, 1);
     chrome.languageSettingsPrivate.setLanguageList(languageCodes);
@@ skipping 18 matching lines @@
     this.arrayDelete('prefs.translate_blocked_languages.value', languageCode);
   },
 
   /**
    * Disables translate for the given language by adding the translate
    * language to the blocked languages preference.
    * @param {string} languageCode
    */
   disableTranslateLanguage: function(languageCode) {
     languageCode = this.convertLanguageCodeForTranslate(languageCode);
-    if (this.getPref_('translate_blocked_languages').value
+    if (this.getPref('translate_blocked_languages').value
             .indexOf(languageCode) == -1) {
       this.push('prefs.translate_blocked_languages.value', languageCode);
     }
   },
 
   /**
    * Enables or disables spell check for the given language.
    * @param {string} languageCode
    * @param {boolean} enable
    */
   toggleSpellCheck: function(languageCode, enable) {
     if (!this.initialized_)
       return;
 
     if (enable) {
-      var spellCheckPref = this.getPref_('spellcheck.dictionaries');
+      var spellCheckPref = this.getPref('spellcheck.dictionaries');
       if (spellCheckPref.value.indexOf(languageCode) == -1)
         this.push('prefs.spellcheck.dictionaries.value', languageCode);
     } else {
       this.arrayDelete('prefs.spellcheck.dictionaries.value', languageCode);
     }
   },
 
   /**
    * Converts the language code for translate. There are some differences
    * between the language set the Translate server uses and that for
@@ skipping 12 matching lines @@
       // necessary as a language code for the Translate server.
       return languageCode;
     }
     if (main in kTranslateLanguageSynonyms)
       return kTranslateLanguageSynonyms[main];
 
     return main;
   },
 });
 })();