Cleanup: Remove empty array param from chrome.send('x', []).

chrome/browser/resources/chromeos/menu.js

 // Copyright (c) 2011 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.
 
 // How long to wait to open submenu when mouse hovers.
 var SUBMENU_OPEN_DELAY_MS = 200;
 // How long to wait to close submenu when mouse left.
 var SUBMENU_CLOSE_DELAY_MS = 500;
 // Scroll repeat interval.
 var SCROLL_INTERVAL_MS = 20;
@@ skipping 15 matching lines @@
 function sendActivate(index, mode) {
   chrome.send('activate', [String(index), mode]);
 }
 
 /**
  * MenuItem class.
  */
 var MenuItem = cr.ui.define('div');
 
 MenuItem.prototype = {
-  __proto__ : HTMLDivElement.prototype,
+  __proto__: HTMLDivElement.prototype,
 
   /**
    * Decorates the menu item element.
    */
   decorate: function() {
     this.className = 'menu-item';
   },
 
   /**
    * Initialize the MenuItem.
@@ skipping 136 matching lines @@
  */
 var Menu = cr.ui.define('div');
 
 Menu.prototype = {
   __proto__: HTMLDivElement.prototype,
 
   /**
    * Configuration object.
    * @type {Object}
    */
-  config_ : null,
+  config_: null,
 
   /**
    * Currently selected menu item.
    * @type {MenuItem}
    */
-  current_ : null,
+  current_: null,
 
   /**
    * Timers for opening/closing submenu.
    * @type {number}
    */
-  openSubmenuTimer_ : 0,
-  closeSubmenuTimer_ : 0,
+  openSubmenuTimer_: 0,
+  closeSubmenuTimer_: 0,
 
   /**
    * Auto scroll timer.
    * @type {number}
    */
-  scrollTimer_ : 0,
+  scrollTimer_: 0,
 
   /**
    * Pointer to a submenu currently shown, if any.
    * @type {MenuItem}
    */
-  submenuShown_ : null,
+  submenuShown_: null,
 
   /**
    * True if this menu is root.
    * @type {boolean}
    */
-  isRoot_ : false,
-
-  /**
-   * Scrollable Viewport.
-   * @type {HTMLElement}
-   */
-  viewpotr_ : null,
+  isRoot_: false,
 
   /**
    * Total hight of scroll buttons. Used to adjust the height of
    * viewport in order to show scroll bottons without scrollbar.
    * @type {number}
    */
-  buttonHeight_ : 0,
+  buttonHeight_: 0,
 
   /**
    * True to enable scroll button.
    * @type {boolean}
    */
-  scrollEnabled : false,
+  scrollEnabled: false,
 
   /**
    * Decorates the menu element.
    */
   decorate: function() {
     this.id = 'viewport';
   },
 
   /**
    * Initialize the menu.
    * @param {Object} config Configuration parameters in JSON format.
    *  See chromeos/views/native_menu_webui.cc for details.
    */
   init: function(config) {
     // List of menu items
     this.items_ = [];
     // Map from mnemonic character to item to activate
     this.mnemonics_ = {};
 
     this.config_ = config;
     this.addEventListener('mouseout', this.onMouseout_.bind(this));
 
     document.addEventListener('keydown', this.onKeydown_.bind(this));
     document.addEventListener('keypress', this.onKeypress_.bind(this));
     document.addEventListener('mousewheel', this.onMouseWheel_.bind(this));
     window.addEventListener('resize', this.onResize_.bind(this));
 
     // Setup scroll events.
-    var up = document.getElementById('scroll-up');
-    var down = document.getElementById('scroll-down');
+    var up = $('scroll-up');
+    var down = $('scroll-down');
     up.addEventListener('mouseout', this.stopScroll_.bind(this));
     down.addEventListener('mouseout', this.stopScroll_.bind(this));
     var menu = this;
     up.addEventListener('mouseover',
                         function() {
                           menu.autoScroll_(-SCROLL_TICK_PX);
                         });
     down.addEventListener('mouseover',
                           function() {
                             menu.autoScroll_(SCROLL_TICK_PX);
@@ skipping 29 matching lines @@
       targetDiv.appendChild(document.createElement('span'));
       targetDiv.appendChild(document.createTextNode(mnemonic[3]));
       targetDiv.childNodes[1].className = 'mnemonic';
       targetDiv.childNodes[1].textContent = mnemonic[2];
     } else {
       targetDiv.textContent = mnemonic.splice(1, 3).join('');
     }
   },
 
   /**
-   * Returns the index of the {@code item}.
+   * @return {number} The index of the {@code item}.
    */
   getMenuItemIndexOf: function(item) {
     return this.items_.indexOf(item);
   },
 
   /**
    * A template method to create an item object. It can be a subclass
    * of MenuItem, or any HTMLElement that implements {@code init},
    * {@code activate} methods as well as {@code selected} attribute.
    * @param {Object} attrs The menu item's properties passed from C++.
+   * @return {MenuItem} The created menu item.
    */
   createMenuItem: function(attrs) {
     return new MenuItem();
   },
 
   /**
    * Update and display the new model.
    */
   updateModel: function(model) {
     this.isRoot = model.isRoot;
@@ skipping 11 matching lines @@
     this.onResize_();
   },
 
   /**
    * Highlights the currently selected item, or
    * select the 1st selectable item if none is selected.
    */
   showSelection: function() {
     if (this.current_) {
       this.current_.selected = true;
-    } else  {
+    } else {
       this.findNextEnabled_(1).selected = true;
     }
   },
 
   /**
    * Add event handlers for the item.
    */
   addHandlers: function(item, target) {
     var menu = this;
     target.addEventListener('mouseover', function(event) {
@@ skipping 84 matching lines @@
         this.classList.add('mnemonic-enabled');
         this.findNextEnabled_(-1).selected = true;
       break;
       case 'Down':
         this.classList.add('mnemonic-enabled');
         this.findNextEnabled_(1).selected = true;
         break;
       case 'U+0009':  // tab
          break;
       case 'U+001B':  // escape
-        chrome.send('close_all', []);
+        chrome.send('close_all');
         break;
       case 'Enter':
       case 'U+0020':  // space
         if (this.current_) {
           this.current_.activate();
         }
         break;
     }
   },
 
@@ skipping 25 matching lines @@
     }
   },
 
   onMouseout_: function(event) {
     if (this.current_) {
       this.current_.selected = false;
     }
   },
 
   onResize_: function() {
-    var up = document.getElementById('scroll-up');
-    var down = document.getElementById('scroll-down');
+    var up = $('scroll-up');
+    var down = $('scroll-down');
     // this needs to be < 2 as empty page has height of 1.
     if (window.innerHeight < 2) {
       // menu window is not visible yet. just hide buttons.
       up.classList.add('hidden');
       down.classList.add('hidden');
       return;
     }
     // Do not use screen width to determin if we need scroll buttons
     // as the max renderer hight can be shorter than actual screen size.
     // TODO(oshima): Fix this when we implement transparent renderer.
@@ skipping 14 matching lines @@
   },
 
   /**
    * Closes the submenu.
    * a submenu.
    * @private
    */
   closeSubmenu_: function(item) {
     this.submenuShown_ = null;
     this.cancelSubmenuTimer_();
-    chrome.send('close_submenu', []);
+    chrome.send('close_submenu');
   },
 
   /**
    * Move the selection to parent menu if the current menu is
    * a submenu.
    * @private
    */
   moveToParent_: function() {
     if (!this.isRoot) {
       if (this.current_) {
         this.current_.selected = false;
       }
-      chrome.send('move_to_parent', []);
+      chrome.send('move_to_parent');
     }
   },
 
   /**
    * Move the selection to submenu if the currently selected
    * menu is a submenu.
    * @private
    */
-  moveToSubmenu_: function () {
+  moveToSubmenu_: function() {
     var current = this.current_;
     if (current && current.attrs.type == 'submenu') {
       this.openSubmenu(current);
-      chrome.send('move_to_submenu', []);
+      chrome.send('move_to_submenu');
     }
   },
 
   /**
-   * Find a next selectable item. If nothing is selected, the 1st
-   * selectable item will be chosen. Returns null if nothing is
-   * selectable.
+   * Finds the next selectable item. If nothing is selected, the first
+   * selectable item will be chosen. Returns null if nothing is selectable.
    * @param {number} incr Specifies the direction to search, 1 to
-   * downwards and -1 for upwards.
+   *     downwards and -1 for upwards.
    * @private
+   * @return {MenuItem} The next selectable item.
    */
   findNextEnabled_: function(incr) {
     var len = this.items_.length;
     var index;
     if (this.current_) {
       index = this.getMenuItemIndexOf(this.current_);
     } else {
       index = incr > 0 ? -1 : len;
     }
     for (var i = 0; i < len; i++) {
@@ skipping 30 matching lines @@
         function() {
           menu.autoScroll_(tick);
         },
         SCROLL_INTERVAL_MS);
   },
 
   /**
    * Stops auto scroll.
    * @private
    */
-  stopScroll_: function () {
+  stopScroll_: function() {
     clearTimeout(this.scrollTimer_);
     this.scrollTimer_ = 0;
   },
 
   /**
    * Scrolls the viewport to make the selected item visible.
    * @private
    */
-  makeSelectedItemVisible_: function(){
+  makeSelectedItemVisible_: function() {
     this.current_.scrollIntoViewIfNeeded(false);
   },
 };
 
 /**
  * functions to be called from C++.
+ * @param {Object} config The viewport configuration.
  */
 function init(config) {
-  document.getElementById('viewport').init(config);
+  $('viewport').init(config);
 }
 
 function selectItem() {
-  document.getElementById('viewport').showSelection();
+  $('viewport').showSelection();
 }
 
 function updateModel(model) {
-  document.getElementById('viewport').updateModel(model);
+  $('viewport').updateModel(model);
 }
 
 function modelUpdated() {
-  chrome.send('model_updated', []);
+  chrome.send('model_updated');
 }
 
 function enableScroll(enabled) {
-  document.getElementById('viewport').scrollEnabled = enabled;
+  $('viewport').scrollEnabled = enabled;
 }