retry 136193 - convert localStrings to loadTimeData for options page

chrome/browser/resources/options2/chromeos/network_list.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.
 
 cr.define('options.network', function() {
 
   var ArrayDataModel = cr.ui.ArrayDataModel;
   var List = cr.ui.List;
   var ListItem = cr.ui.ListItem;
   var Menu = cr.ui.Menu;
@@ skipping 207 matching lines @@
       this.className = 'network-group';
       this.icon_ = this.ownerDocument.createElement('div');
       this.icon_.className = 'network-icon';
       this.appendChild(this.icon_);
       var textContent = this.ownerDocument.createElement('div');
       textContent.className = 'network-group-labels';
       this.appendChild(textContent);
       var categoryLabel = this.ownerDocument.createElement('div');
       var title = this.data_.key + 'Title';
       categoryLabel.className = 'network-title';
-      categoryLabel.textContent = templateData[title];
+      categoryLabel.textContent = loadTimeData.getString(title);
       textContent.appendChild(categoryLabel);
       this.subtitle_ = this.ownerDocument.createElement('div');
       this.subtitle_.className = 'network-subtitle';
       textContent.appendChild(this.subtitle_);
     },
   };
 
   /**
    * Creates a control that displays a popup menu when clicked.
    * @param {Object} data  Description of the control.
@@ skipping 116 matching lines @@
 
   NetworkSelectorItem.prototype = {
     __proto__: NetworkMenuItem.prototype,
 
     /* @inheritDoc */
     decorate: function() {
       // TODO(kevers): Generalize method of setting default label.
       var policyManaged = false;
       var defaultMessage = this.data_.key == 'wifi' ?
           'networkOffline' : 'networkNotConnected';
-      this.subtitle = templateData[defaultMessage];
+      this.subtitle = loadTimeData.getString(defaultMessage);
       var list = this.data_.networkList;
       var candidateURL = null;
       for (var i = 0; i < list.length; i++) {
         var networkDetails = list[i];
         if (networkDetails.connecting || networkDetails.connected) {
           this.subtitle = networkDetails.networkName;
           this.setSubtitleDirection('ltr');
           policyManaged = networkDetails.policyManaged;
           candidateURL = networkDetails.iconURL;
           // Only break when we see a connecting network as it is possible to
@@ skipping 35 matching lines @@
      * @return {Element} The newly created menu.
      */
     createMenu: function() {
       var menu = this.ownerDocument.createElement('div');
       menu.id = this.getMenuName_();
       menu.className = 'network-menu';
       menu.hidden = true;
       Menu.decorate(menu);
       var addendum = [];
       if (this.data_.key == 'wifi') {
-        addendum.push({label: localStrings.getString('joinOtherNetwork'),
+        addendum.push({label: loadTimeData.getString('joinOtherNetwork'),
                        command: 'connect',
                        data: {networkType: Constants.TYPE_WIFI,
                               servicePath: '?'}});
       } else if (this.data_.key == 'cellular') {
         var label = enableDataRoaming_ ? 'disableDataRoaming' :
             'enableDataRoaming';
         var disabled = !UIAccountTweaks.currentUserIsOwner();
-        var entry = {label: localStrings.getString(label),
+        var entry = {label: loadTimeData.getString(label),
                      data: {}};
         if (disabled) {
           entry.command = null;
           entry.tooltip =
-              localStrings.getString('dataRoamingDisableToggleTooltip');
+              loadTimeData.getString('dataRoamingDisableToggleTooltip');
         } else {
           entry.command = function() {
             options.Preferences.setBooleanPref(
                 'cros.signed.data_roaming_enabled',
                 !enableDataRoaming_);
             // Force revalidation of the menu the next time it is
             // displayed.
             this.menu_ = null;
           };
         }
         addendum.push(entry);
       }
       var list = this.data.rememberedNetworks;
       if (list && list.length > 0) {
         var callback = function(list) {
           $('remembered-network-list').clear();
           var dialog = options.PreferredNetworks.getInstance();
           OptionsPage.showPageByName('preferredNetworksPage', false);
           dialog.update(list);
         };
-        addendum.push({label: localStrings.getString('preferredNetworks'),
+        addendum.push({label: loadTimeData.getString('preferredNetworks'),
                        command: callback,
                        data: list});
       }
 
       var networkGroup = this.ownerDocument.createElement('div');
       networkGroup.className = 'network-menu-group';
       var empty = true;
       list = this.data.networkList;
       if (list) {
         for (var i = 0; i < list.length; i++) {
           var data = list[i];
           if (!data.connected && !data.connecting) {
             if (data.networkType != Constants.TYPE_ETHERNET) {
               if (data.networkType == Constants.TYPE_CELLULAR) {
                 // Test if cellular network has an activated data plan.
                 var activate = data.needs_new_plan ||
                    (data.activation_state !=
                    Constants.ACTIVATION_STATE_ACTIVATED &&
                    data.activation_state !=
                    Constants.ACTIVATION_STATE_ACTIVATING);
                 var cmd = activate ? 'activate' : 'connect';
                 this.createConnectCallback_(networkGroup, data, cmd);
               } else {
                 this.createConnectCallback_(networkGroup, data);
               }
               empty = false;
             }
           } else if (data.connected) {
-            addendum.push({label: localStrings.getString('networkOptions'),
+            addendum.push({label: loadTimeData.getString('networkOptions'),
                            command: 'options',
                            data: data});
             if (data.networkType == Constants.TYPE_VPN) {
               // Add separator
               addendum.push({});
               var i18nKey = 'disconnectNetwork';
-              addendum.push({label: localStrings.getString(i18nKey),
+              addendum.push({label: loadTimeData.getString(i18nKey),
                              command: 'disconnect',
                              data: data});
             }
             if (data.networkType != Constants.TYPE_ETHERNET) {
               var onlineMessage = this.ownerDocument.createElement('div');
               onlineMessage.textContent =
-                  localStrings.getString('networkOnline');
+                  loadTimeData.getString('networkOnline');
               onlineMessage.className = 'network-menu-header';
               menu.insertBefore(onlineMessage, menu.firstChild);
             }
           }
         }
       }
       if (this.data_.key == 'wifi' || this.data_.key == 'cellular') {
         addendum.push({});
         if (this.data_.key == 'wifi') {
-          addendum.push({label: localStrings.getString('turnOffWifi'),
+          addendum.push({label: loadTimeData.getString('turnOffWifi'),
                        command: function() {
                          chrome.send('disableWifi');
                        },
                        data: {}});
         } else if (this.data_.key == 'cellular') {
-          addendum.push({label: localStrings.getString('turnOffCellular'),
+          addendum.push({label: loadTimeData.getString('turnOffCellular'),
                        command: function() {
                          chrome.send('disableCellular');
                        },
                        data: {}});
         }
       }
       if (!empty)
         menu.appendChild(networkGroup);
       if (addendum.length > 0) {
         var separator = false;
@@ skipping 65 matching lines @@
      * Adds a menu item for connecting to a network.
      * @param {!Element} menu Parent menu.
      * @param {Object} data Description of the network.
      * @param {string=} opt_connect Optional connection method.
      * @private
      */
     createConnectCallback_: function(menu, data, opt_connect) {
       var cmd = opt_connect ? opt_connect : 'connect';
       var label = data.networkName;
       if (cmd == 'activate') {
-        label = localStrings.getString('activateNetwork');
+        label = loadTimeData.getString('activateNetwork');
         label = label.replace('$1', data.networkName);
       }
       var menuItem = this.createCallback_(menu,
                                           data,
                                           label,
                                           cmd);
       menuItem.style.backgroundImage = url(data.iconURL);
 
       if (data.policyManaged)
         menuItem.appendChild(new ManagedNetworkIndicator());
@@ skipping 58 matching lines @@
       List.prototype.decorate.call(this);
       this.autoExpand = true;
       this.addEventListener('blur', this.onBlur_);
       this.dataModel = new ArrayDataModel([]);
 
       // Wi-Fi control is always visible.
       this.update({key: 'wifi', networkList: []});
 
       if (airplaneModeAvailable_()) {
         this.update({key: 'airplaneMode',
-                     subtitle: localStrings.getString('airplaneModeLabel'),
+                     subtitle: loadTimeData.getString('airplaneModeLabel'),
                      command: function() {
                        chrome.send('toggleAirplaneMode');
                      }});
       }
 
       // Add connection control.
       var addConnection = function(type) {
         var callback = function() {
           chrome.send('networkCommand',
                       [String(type), '?', 'connect']);
         }
         return callback;
       }
       this.update({key: 'addConnection',
                    iconType: 'add-connection',
-                   menu: [{label: localStrings.getString('addConnectionWifi'),
+                   menu: [{label: loadTimeData.getString('addConnectionWifi'),
                            command: addConnection(Constants.TYPE_WIFI)},
-                          {label: localStrings.getString('addConnectionVPN'),
+                          {label: loadTimeData.getString('addConnectionVPN'),
                            command: addConnection(Constants.TYPE_VPN)}]
                   });
 
       var prefs = options.Preferences.getInstance();
       prefs.addEventListener('cros.signed.data_roaming_enabled',
           function(event) {
             enableDataRoaming_ = event.value && event.value['value'] !=
                 undefined ? event.value['value'] : event.value;
           });
     },
@@ skipping 126 matching lines @@
     // Only show Ethernet control if connected.
     var ethernetConnection = getConnection_(data.wiredList);
     if (ethernetConnection) {
       var type = String(Constants.TYPE_ETHERNET);
       var path = ethernetConnection.servicePath;
       var ethernetOptions = function() {
         chrome.send('networkCommand',
                     [type, path, 'options']);
       };
       networkList.update({key: 'ethernet',
-                          subtitle: localStrings.getString('networkConnected'),
+                          subtitle: loadTimeData.getString('networkConnected'),
                           iconURL: ethernetConnection.iconURL,
                           command: ethernetOptions});
     } else {
       networkList.deleteItem('ethernet');
     }
 
     if (data.wifiEnabled) {
       loadData_('wifi', data.wirelessList, data.rememberedList);
     } else {
       var enableWifi = function() {
         chrome.send('enableWifi');
       };
       networkList.update({key: 'wifi',
-                          subtitle: localStrings.getString('networkDisabled'),
+                          subtitle: loadTimeData.getString('networkDisabled'),
                           iconType: 'wifi',
                           command: enableWifi});
     }
 
     // Only show cellular control if available and not in airplane mode.
     if (data.cellularAvailable && !data.airplaneMode) {
       if (data.cellularEnabled) {
         loadData_('cellular', data.wirelessList, data.rememberedList);
       } else {
-        var subtitle = localStrings.getString('networkDisabled');
+        var subtitle = loadTimeData.getString('networkDisabled');
         var enableCellular = function() {
           chrome.send('enableCellular');
         };
         networkList.update({key: 'cellular',
                             subtitle: subtitle,
                             iconType: 'cellular',
                             command: enableCellular});
       }
     } else {
       networkList.deleteItem('cellular');
@@ skipping 20 matching lines @@
     return el;
   }
 
   ManagedNetworkIndicator.prototype = {
     __proto__: ControlledSettingIndicator.prototype,
 
     /** @inheritDoc */
     decorate: function() {
       ControlledSettingIndicator.prototype.decorate.call(this);
       this.controlledBy = 'policy';
-      var policyLabel = localStrings.getString('managedNetwork');
+      var policyLabel = loadTimeData.getString('managedNetwork');
       this.setAttribute('textPolicy', policyLabel);
       this.className = 'controlled-setting-indicator';
       // The default popup clips to the bounds of the list of networks in the
       // drop-down because it has enforced size constraints with auto-
       // scrolling. Use a tooltip in place of the bubble popup until the
       // clipping issues are resolved.
       this.setAttribute('title', policyLabel);
       this.addEventListener('click', function(e) {
         e.preventDefault();
         e.stopPropagation();
@@ skipping 82 matching lines @@
    * Whether the Network list is disabled. Only used for display purpose.
    * @type {boolean}
    */
   cr.defineProperty(NetworkList, 'disabled', cr.PropertyKind.BOOL_ATTR);
 
   // Export
   return {
     NetworkList: NetworkList
   };
 });