MD Settings: Use a browser proxy from the languages page. Re-enable test.

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 60 matching lines @@
      * 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(); },
     },
 
     /**
@@ skipping 44 matching lines @@
     // Observe Chrome OS prefs (ignored for non-Chrome OS).
     'updateRemovableLanguages_(' +
         'prefs.settings.language.preload_engines.value, ' +
         'prefs.settings.language.enabled_extension_imes.value, ' +
         'languages)',
   ],
 
   /** @private {?Function} */
   boundOnInputMethodChanged_: null,
 
+  /** @private {?settings.LanguagesBrowserProxy} */
+  browserProxy_: null,
+
+  /** @private {?LanguageSettingsPrivate} */
+  languageSettingsPrivate_: null,
+
+// <if expr="chromeos">
+  /** @private {?InputMethodPrivate} */
+  inputMethodPrivate_: null,
+// </if>
+
   /** @override */
   attached: function() {
-    this.languageSettingsPrivate =
-        settings.languageSettingsPrivateApiForTest ||
-        /** @type {!LanguageSettingsPrivate} */(chrome.languageSettingsPrivate);
-
-    this.inputMethodPrivate =
-        settings.inputMethodPrivateApiForTest ||
-        /** @type {!InputMethodPrivate} */(chrome.inputMethodPrivate);
+    this.browserProxy_ = settings.LanguagesBrowserProxyImpl.getInstance();
+    this.languageSettingsPrivate_ =
+        this.browserProxy_.getLanguageSettingsPrivate();
+// <if expr="chromeos">
+    this.inputMethodPrivate_ = this.browserProxy_.getInputMethodPrivate();
+// </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);
+      this.languageSettingsPrivate_.getLanguageList(resolve);
     }.bind(this));
 
     // Get the translate target language.
     promises[2] = new Promise(function(resolve) {
-      this.languageSettingsPrivate.getTranslateTargetLanguage(resolve);
+      this.languageSettingsPrivate_.getTranslateTargetLanguage(resolve);
     }.bind(this));
 
     if (cr.isChromeOS) {
       promises[3] = new Promise(function(resolve) {
-        this.languageSettingsPrivate.getInputMethodLists(function(lists) {
+        this.languageSettingsPrivate_.getInputMethodLists(function(lists) {
           resolve(lists.componentExtensionImes.concat(
               lists.thirdPartyExtensionImes));
         });
       }.bind(this));
 
       promises[4] = new Promise(function(resolve) {
-        this.inputMethodPrivate.getCurrentInputMethod(resolve);
+        this.inputMethodPrivate_.getCurrentInputMethod(resolve);
       }.bind(this));
     }
 
     if (cr.isWindows || cr.isChromeOS) {
       // Fetch the starting UI language, which affects which actions should be
       // enabled.
-      promises.push(cr.sendWithPromise('getProspectiveUILanguage').then(
+      promises.push(this.browserProxy_.getProspectiveUILanguage().then(
           function(prospectiveUILanguage) {
             this.originalProspectiveUILanguage_ =
                 prospectiveUILanguage || window.navigator.language;
           }.bind(this)));
     }
 
     Promise.all(promises).then(function(results) {
       if (!this.isConnected) {
         // Return early if this element was detached from the DOM before this
         // async callback executes (can happen during testing).
         return;
       }
 
       // TODO(dpapad): Cleanup this code. It uses results[3] and results[4]
       // which only exist for ChromeOS.
       this.createModel_(results[1], results[2], results[3], results[4]);
       this.resolver_.resolve();
     }.bind(this));
 
     if (cr.isChromeOS) {
       this.boundOnInputMethodChanged_ = this.onInputMethodChanged_.bind(this);
-      this.inputMethodPrivate.onChanged.addListener(
+      this.inputMethodPrivate_.onChanged.addListener(
           assert(this.boundOnInputMethodChanged_));
     }
   },
 
   /** @override */
   detached: function() {
     if (cr.isChromeOS) {
-      this.inputMethodPrivate.onChanged.removeListener(
+      this.inputMethodPrivate_.onChanged.removeListener(
           assert(this.boundOnInputMethodChanged_));
       this.boundOnInputMethodChanged_ = null;
     }
   },
 
   /**
    * Updates the prospective UI language based on the new pref value.
    * @param {string} prospectiveUILanguage
    * @private
    */
@@ skipping 251 matching lines @@
     return this.resolver_.promise;
   },
 
 // <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) {
-    chrome.send('setProspectiveUILanguage', [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>
 
   /**
    * @param {string} languageCode
    * @return {boolean} True if the language is enabled.
    */
   isLanguageEnabled: function(languageCode) {
     return this.enabledLanguageSet_.has(languageCode);
   },
 
   /**
    * Enables the language, making it available for spell check and input.
    * @param {string} languageCode
    */
   enableLanguage: function(languageCode) {
     if (!CrSettingsPrefs.isInitialized)
       return;
 
-    this.languageSettingsPrivate.enableLanguage(languageCode);
+    this.languageSettingsPrivate_.enableLanguage(languageCode);
     this.disableTranslateLanguage(languageCode);
   },
 
   /**
    * Disables the language.
    * @param {string} languageCode
    */
   disableLanguage: function(languageCode) {
     if (!CrSettingsPrefs.isInitialized)
       return;
@@ skipping 12 matching lines @@
             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);
+    this.languageSettingsPrivate_.disableLanguage(languageCode);
     this.enableTranslateLanguage(languageCode);
   },
 
   /**
    * @param {string} languageCode Language code for an enabled language.
    * @return {boolean}
    */
   canDisableLanguage: function(languageCode) {
     // Cannot disable the prospective UI language.
     if (languageCode == this.languages.prospectiveUILanguage)
@@ skipping 159 matching lines @@
    */
   getLanguage: function(languageCode) {
     return this.supportedLanguageMap_.get(languageCode);
   },
 
 // <if expr="chromeos">
   /** @param {string} id */
   addInputMethod: function(id) {
     if (!this.supportedInputMethodMap_.has(id))
       return;
-    this.languageSettingsPrivate.addInputMethod(id);
+    this.languageSettingsPrivate_.addInputMethod(id);
   },
 
   /** @param {string} id */
   removeInputMethod: function(id) {
     if (!this.supportedInputMethodMap_.has(id))
       return;
-    this.languageSettingsPrivate.removeInputMethod(id);
+    this.languageSettingsPrivate_.removeInputMethod(id);
   },
 
   /** @param {string} id */
   setCurrentInputMethod: function(id) {
-    this.inputMethodPrivate.setCurrentInputMethod(id);
+    this.inputMethodPrivate_.setCurrentInputMethod(id);
   },
 
   /**
    * @param {string} languageCode
    * @return {!Array<!chrome.languageSettingsPrivate.InputMethod>}
    */
   getInputMethodsForLanguage: function(languageCode) {
     return this.languageInputMethods_.get(languageCode) || [];
   },
 
   /**
    * @param {!chrome.languageSettingsPrivate.InputMethod} inputMethod
    * @return {boolean}
    */
   isComponentIme: function(inputMethod) {
     return inputMethod.id.startsWith('_comp_');
   },
 
   /** @param {string} id Input method ID. */
   openInputMethodOptions: function(id) {
-    this.inputMethodPrivate.openOptionsPage(id);
+    this.inputMethodPrivate_.openOptionsPage(id);
   },
 
   /** @param {string} id New current input method ID. */
   onInputMethodChanged_: function(id) {
     this.set('languages.inputMethods.currentId', id);
   },
 
   /** @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>
 });
 })();