History: Fix JavaScript style issues so presubmit checks pass.

chrome/browser/resources/history/history.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.
 
 <include src="../uber/uber_utils.js">
 
 ///////////////////////////////////////////////////////////////////////////////
 // Globals:
-var RESULTS_PER_PAGE = 150;
-var MAX_SEARCH_DEPTH_MONTHS = 18;
+/** @const */ var RESULTS_PER_PAGE = 150;
+/** @const */ var MAX_SEARCH_DEPTH_MONTHS = 18;
 
 // Amount of time between pageviews that we consider a 'break' in browsing,
 // measured in milliseconds.
-var BROWSING_GAP_TIME = 15 * 60 * 1000;
+/** @const */ var BROWSING_GAP_TIME = 15 * 60 * 1000;
 
 function $(o) {return document.getElementById(o);}
 
 function createElementWithClassName(type, className) {
   var elm = document.createElement(type);
   elm.className = className;
   return elm;
 }
 
 // Escapes a URI as appropriate for CSS.
 function encodeURIForCSS(uri) {
   // CSS URIs need to have '(' and ')' escaped.
-  return uri.replace(/\(/g, "\\(").replace(/\)/g, "\\)");
+  return uri.replace(/\(/g, '\\(').replace(/\)/g, '\\)');
 }
 
 function findAncestorWithClass(node, className) {
   while ((node = node.parentNode)) {
     if (node.classList.contains(className)) return node;
   }
   return null;
 }
 
 // TODO(glen): Get rid of these global references, replace with a controller
 //     or just make the classes own more of the page.
 var historyModel;
 var historyView;
 var localStrings;
 var pageState;
 var deleteQueue = [];
 var selectionAnchor = -1;
 var activePage = null;
 
-const MenuButton = cr.ui.MenuButton;
-const Command = cr.ui.Command;
-const Menu = cr.ui.Menu;
+/** @const */ var MenuButton = cr.ui.MenuButton;
+/** @const */ var Command = cr.ui.Command;
+/** @const */ var Menu = cr.ui.Menu;
 
 function createDropDownBgImage(canvasName, colorSpec) {
   var ctx = document.getCSSCanvasContext('2d', canvasName, 6, 4);
   ctx.fillStyle = ctx.strokeStyle = colorSpec;
   ctx.beginPath();
   ctx.moveTo(0, 0);
   ctx.lineTo(6, 0);
   ctx.lineTo(3, 3);
   ctx.closePath();
   ctx.fill();
   ctx.stroke();
   return ctx;
 }
 
 // Create the canvases to be used as the drop down button background images.
 var arrow = createDropDownBgImage('drop-down-arrow', 'rgb(192, 195, 198)');
 var hoverArrow = createDropDownBgImage('drop-down-arrow-hover',
                                        'rgb(48, 57, 66)');
 var activeArrow = createDropDownBgImage('drop-down-arrow-active', 'white');
 
 ///////////////////////////////////////////////////////////////////////////////
 // Page:
+
 /**
  * Class to hold all the information about an entry in our model.
  * @param {Object} result An object containing the page's data.
  * @param {boolean} continued Whether this page is on the same day as the
  *     page before it
+ * @param {HistoryModel} model The model object this entry belongs to.
+ * @param {Number} id The identifier for the entry.
+ * @constructor
  */
 function Page(result, continued, model, id) {
   this.model_ = model;
   this.title_ = result.title;
   this.url_ = result.url;
   this.domain_ = this.getDomainFromURL_(this.url_);
   this.starred_ = result.starred;
-  this.snippet_ = result.snippet || "";
+  this.snippet_ = result.snippet || '';
   this.id_ = id;
 
   this.changed = false;
 
   this.isRendered = false;
 
   // All the date information is public so that owners can compare properties of
   // two items easily.
 
   // We get the time in seconds, but we want it in milliseconds.
   this.time = new Date(result.time * 1000);
 
   // See comment in BrowsingHistoryHandler::QueryComplete - we won't always
   // get all of these.
-  this.dateRelativeDay = result.dateRelativeDay || "";
-  this.dateTimeOfDay = result.dateTimeOfDay || "";
-  this.dateShort = result.dateShort || "";
+  this.dateRelativeDay = result.dateRelativeDay || '';
+  this.dateTimeOfDay = result.dateTimeOfDay || '';
+  this.dateShort = result.dateShort || '';
 
   // Whether this is the continuation of a previous day.
   this.continued = continued;
 }
 
 // Page, Public: --------------------------------------------------------------
+
 /**
  * Returns a dom structure for a browse page result or a search page result.
- * @param {boolean} Flag to indicate if result is a search result.
- * @return {Element} The dom structure.
+ * @param {boolean} searchResultFlag Indicates whether the result is a search
+ *     result or not.
+ * @return {Node} A DOM node to represent the history entry or search result.
  */
 Page.prototype.getResultDOM = function(searchResultFlag) {
   var node = createElementWithClassName('li', 'entry');
   var time = createElementWithClassName('div', 'time');
   var entryBox = createElementWithClassName('label', 'entry-box');
   var domain = createElementWithClassName('div', 'domain');
 
   var dropDown = createElementWithClassName('button', 'drop-down');
   dropDown.value = 'Open action menu';
   dropDown.title = localStrings.getString('actionMenuDescription');
@@ skipping 15 matching lines @@
   var setActivePage = function(e) {
     activePage = self;
   };
   dropDown.addEventListener('mousedown', setActivePage);
   dropDown.addEventListener('focus', setActivePage);
 
   domain.textContent = this.domain_;
 
   // Clicking anywhere in the entryBox will check/uncheck the checkbox.
   entryBox.setAttribute('for', checkbox.id);
-  entryBox.addEventListener('mousedown', entryBoxMousedown, false);
+  entryBox.addEventListener('mousedown', entryBoxMousedown);
 
   // Prevent clicks on the drop down from affecting the checkbox.
   dropDown.addEventListener('click', function(e) { e.preventDefault(); });
 
   // We use a wrapper div so that the entry contents will be shinkwrapped.
   entryBox.appendChild(time);
   entryBox.appendChild(this.getTitleDOM_());
   entryBox.appendChild(domain);
   entryBox.appendChild(dropDown);
 
@@ skipping 20 matching lines @@
 
   if (typeof this.domNode_ != 'undefined') {
       console.error('Already generated node for page.');
   }
   this.domNode_ = node;
 
   return node;
 };
 
 // Page, private: -------------------------------------------------------------
+
 /**
  * Extracts and returns the domain (and subdomains) from a URL.
- * @param {string} The url
- * @return (string) The domain. An empty string is returned if no domain can
+ * @param {string} url The url.
+ * @return {string} The domain. An empty string is returned if no domain can
  *     be found.
+ * @private
  */
 Page.prototype.getDomainFromURL_ = function(url) {
   var domain = url.replace(/^.+:\/\//, '').match(/[^/]+/);
   return domain ? domain[0] : '';
 };
 
 /**
  * Add child text nodes to a node such that occurrences of the specified text is
  * highlighted.
  * @param {Node} node The node under which new text nodes will be made as
  *     children.
  * @param {string} content Text to be added beneath |node| as one or more
  *     text nodes.
  * @param {string} highlightText Occurences of this text inside |content| will
  *     be highlighted.
+ * @private
  */
 Page.prototype.addHighlightedText_ = function(node, content, highlightText) {
   var i = 0;
   if (highlightText) {
     var re = new RegExp(Page.pregQuote_(highlightText), 'gim');
     var match;
     while (match = re.exec(content)) {
       if (match.index > i)
         node.appendChild(document.createTextNode(content.slice(i,
                                                                match.index)));
       i = re.lastIndex;
       // Mark the highlighted text in bold.
       var b = document.createElement('b');
       b.textContent = content.substring(match.index, i);
       node.appendChild(b);
     }
   }
   if (i < content.length)
     node.appendChild(document.createTextNode(content.slice(i)));
 };
 
 /**
  * @return {DOMObject} DOM representation for the title block.
+ * @private
  */
 Page.prototype.getTitleDOM_ = function() {
   var node = createElementWithClassName('div', 'title');
   node.style.backgroundImage =
       'url(chrome://favicon/' + encodeURIForCSS(this.url_) + ')';
 
   var link = document.createElement('a');
   link.href = this.url_;
-  link.id = "id-" + this.id_;
-  link.target = "_top";
+  link.id = 'id-' + this.id_;
+  link.target = '_top';
 
   // Add a tooltip, since it might be ellipsized.
   // TODO(dubroy): Find a way to show the tooltip only when necessary.
   link.title = this.title_;
 
   this.addHighlightedText_(link, this.title_, this.model_.getSearchText());
   node.appendChild(link);
 
   if (this.starred_) {
     var star = createElementWithClassName('div', 'starred');
     node.appendChild(star);
     star.addEventListener('click', this.starClicked_.bind(this));
   }
 
   return node;
 };
 
 /**
  * Launch a search for more history entries from the same domain.
+ * @private
  */
 Page.prototype.showMoreFromSite_ = function() {
   setSearch(this.domain_);
 };
 
 /**
  * Remove a single entry from the history.
+ * @private
  */
 Page.prototype.removeFromHistory_ = function() {
   var self = this;
   var onSuccessCallback = function() {
     removeEntryFromView(self.domNode_);
   };
   queueURLsForDeletion(this.time, [this.url_], onSuccessCallback);
   deleteNextInQueue();
 };
 
 /**
  * Click event handler for the star icon that appears beside bookmarked URLs.
  * When clicked, the bookmark is removed for that URL.
+ * @param {Event} event The click event.
  * @private
  */
 Page.prototype.starClicked_ = function(event) {
   chrome.send('removeBookmark', [this.url_]);
   event.currentTarget.hidden = true;
   event.preventDefault();
-}
+};
 
 // Page, private, static: -----------------------------------------------------
 
 /**
  * Quote a string so it can be used in a regular expression.
  * @param {string} str The source string
  * @return {string} The escaped string
+ * @private
  */
 Page.pregQuote_ = function(str) {
-  return str.replace(/([\\\.\+\*\?\[\^\]\$\(\)\{\}\=\!\<\>\|\:])/g, "\\$1");
+  return str.replace(/([\\\.\+\*\?\[\^\]\$\(\)\{\}\=\!\<\>\|\:])/g, '\\$1');
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // HistoryModel:
+
 /**
  * Global container for history data. Future optimizations might include
  * allowing the creation of a HistoryModel for each search string, allowing
  * quick flips back and forth between results.
  *
  * The history model is based around pages, and only fetching the data to
  * fill the currently requested page. This is somewhat dependent on the view,
  * and so future work may wish to change history model to operate on
  * timeframe (day or week) based containers.
+ *
+ * @constructor
  */
 function HistoryModel() {
   this.clearModel_();
 }
 
 // HistoryModel, Public: ------------------------------------------------------
+
 /**
  * Sets our current view that is called when the history model changes.
  * @param {HistoryView} view The view to set our current view to.
  */
 HistoryModel.prototype.setView = function(view) {
   this.view_ = view;
 };
 
 /**
  * Start a new search - this will clear out our model.
@@ skipping 23 matching lines @@
 /**
  * @return {String} The current search text.
  */
 HistoryModel.prototype.getSearchText = function() {
   return this.searchText_;
 };
 
 /**
  * Tell the model that the view will want to see the current page. When
  * the data becomes available, the model will call the view back.
- * @page {Number} page The page we want to view.
+ * @param {Number} page The page we want to view.
  */
 HistoryModel.prototype.requestPage = function(page) {
   this.requestedPage_ = page;
   this.changed = true;
   this.updateSearch_(false);
 };
 
 /**
  * Receiver for history query.
- * @param {String} term The search term that the results are for.
- * @param {Array} results A list of results
+ * @param {Object} info An object containing information about the query.
+ * @param {Array} results A list of results.
  */
 HistoryModel.prototype.addResults = function(info, results) {
   this.inFlight_ = false;
   if (info.term != this.searchText_) {
     // If our results aren't for our current search term, they're rubbish.
     return;
   }
 
   // Currently we assume we're getting things in date order. This needs to
   // be updated if that ever changes.
@@ skipping 50 matching lines @@
  */
 HistoryModel.prototype.getNumberedRange = function(start, end) {
   if (start >= this.getSize())
     return [];
 
   var end = end > this.getSize() ? this.getSize() : end;
   return this.pages_.slice(start, end);
 };
 
 // HistoryModel, Private: -----------------------------------------------------
+
+/**
+ * Clear the history model.
+ * @private
+ */
 HistoryModel.prototype.clearModel_ = function() {
   this.inFlight_ = false; // Whether a query is inflight.
   this.searchText_ = '';
   this.searchDepth_ = 0;
   this.pages_ = []; // Date-sorted list of pages.
   this.last_id_ = 0;
   selectionAnchor = -1;
 
   // The page that the view wants to see - we only fetch slightly past this
   // point. If the view requests a page that we don't have data for, we try
   // to fetch it and call back when we're done.
   this.requestedPage_ = 0;
 
   this.complete_ = false;
 
   if (this.view_) {
     this.view_.clear_();
   }
 };
 
 /**
  * Figure out if we need to do more searches to fill the currently requested
  * page. If we think we can fill the page, call the view and let it know
  * we're ready to show something.
+ * @param {boolean} finished Indicates if there is any more data to come.
+ * @private
  */
 HistoryModel.prototype.updateSearch_ = function(finished) {
   if ((this.searchText_ && this.searchDepth_ >= MAX_SEARCH_DEPTH_MONTHS) ||
       finished) {
     // We have maxed out. There will be no more data.
     this.complete_ = true;
     this.view_.onModelReady();
     this.changed = false;
   } else {
     // If we can't fill the requested page, ask for more data unless a request
@@ skipping 11 matching lines @@
 };
 
 /**
  * Get search results for a selected depth. Our history system is optimized
  * for queries that don't cross month boundaries, but an entire month's
  * worth of data is huge. When we're in browse mode (searchText is empty)
  * we request the data a day at a time. When we're searching, a month is
  * used.
  *
  * TODO: Fix this for when the user's clock goes across month boundaries.
- * @param {number} opt_day How many days back to do the search.
+ * @param {number=} depth How many days (or months, if the search text is
+ *     non-empty) back to do the search.
+ * @private
  */
 HistoryModel.prototype.getSearchResults_ = function(depth) {
   this.searchDepth_ = depth || 0;
 
-  if (this.searchText_ == "") {
+  if (this.searchText_ == '') {
     chrome.send('getHistory',
         [String(this.searchDepth_)]);
   } else {
     chrome.send('searchHistory',
         [this.searchText_, String(this.searchDepth_)]);
   }
 
   this.inFlight_ = true;
 };
 
 /**
  * Check to see if we have data for a given page.
  * @param {number} page The page number
  * @return {boolean} Whether we have any data for the given page.
+ * @private
  */
 HistoryModel.prototype.haveDataForPage_ = function(page) {
   return (page * RESULTS_PER_PAGE < this.getSize());
 };
 
 /**
  * Check to see if we have data to fill a page.
  * @param {number} page The page number.
  * @return {boolean} Whether we have data to fill the page.
+ * @private
  */
 HistoryModel.prototype.canFillPage_ = function(page) {
   return ((page + 1) * RESULTS_PER_PAGE <= this.getSize());
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // HistoryView:
+
 /**
  * Functions and state for populating the page with HTML. This should one-day
  * contain the view and use event handlers, rather than pushing HTML out and
  * getting called externally.
  * @param {HistoryModel} model The model backing this view.
+ * @constructor
  */
 function HistoryView(model) {
   this.editButtonTd_ = $('edit-button');
   this.editingControlsDiv_ = $('editing-controls');
   this.resultDiv_ = $('results-display');
   this.pageDiv_ = $('results-pagination');
-  this.model_ = model
+  this.model_ = model;
   this.pageIndex_ = 0;
   this.lastDisplayed_ = [];
 
   this.model_.setView(this);
 
   this.currentPages_ = [];
 
   var self = this;
   window.onresize = function() {
     self.updateEntryAnchorWidth_();
@@ skipping 51 matching lines @@
 HistoryView.prototype.onModelReady = function() {
   this.displayResults_();
 };
 
 /**
  * Enables or disables the 'Remove selected items' button as appropriate.
  */
 HistoryView.prototype.updateRemoveButton = function() {
   var anyChecked = document.querySelector('.entry input:checked') != null;
   $('remove-selected').disabled = !anyChecked;
-}
+};
 
 // HistoryView, private: ------------------------------------------------------
+
 /**
  * Clear the results in the view.  Since we add results piecemeal, we need
  * to clear them out when we switch to a new page or reload.
+ * @private
  */
 HistoryView.prototype.clear_ = function() {
   this.resultDiv_.textContent = '';
 
   var pages = this.currentPages_;
   for (var i = 0; i < pages.length; i++) {
     pages[i].isRendered = false;
   }
   this.currentPages_ = [];
 };
 
+/**
+ * Record that the given page has been rendered.
+ * @param {Page} page The page that was rendered.
+ * @private
+ */
 HistoryView.prototype.setPageRendered_ = function(page) {
   page.isRendered = true;
   this.currentPages_.push(page);
 };
 
 /**
  * Update the page with results.
+ * @private
  */
 HistoryView.prototype.displayResults_ = function() {
   var results = this.model_.getNumberedRange(
       this.pageIndex_ * RESULTS_PER_PAGE,
       this.pageIndex_ * RESULTS_PER_PAGE + RESULTS_PER_PAGE);
 
   var searchText = this.model_.getSearchText();
   if (searchText) {
     // Add a header for the search results, if there isn't already one.
     if (!this.resultDiv_.querySelector('h3')) {
@@ skipping 54 matching lines @@
       resultsFragment.appendChild(dayResults);
     }
     this.resultDiv_.appendChild(resultsFragment);
   }
   this.displayNavBar_();
   this.updateEntryAnchorWidth_();
 };
 
 /**
  * Update the pagination tools.
+ * @private
  */
 HistoryView.prototype.displayNavBar_ = function() {
   this.pageDiv_.textContent = '';
 
   if (this.pageIndex_ > 0) {
     this.pageDiv_.appendChild(
         this.createPageNav_(0, localStrings.getString('newest')));
     this.pageDiv_.appendChild(
         this.createPageNav_(this.pageIndex_ - 1,
                             localStrings.getString('newer')));
   }
 
   // TODO(feldstein): this causes the navbar to not show up when your first
   // page has the exact amount of results as RESULTS_PER_PAGE.
   if (this.model_.getSize() > (this.pageIndex_ + 1) * RESULTS_PER_PAGE) {
     this.pageDiv_.appendChild(
         this.createPageNav_(this.pageIndex_ + 1,
                             localStrings.getString('older')));
   }
 };
 
 /**
  * Make a DOM object representation of a page navigation link.
  * @param {number} page The page index the navigation element should link to
  * @param {string} name The text content of the link
  * @return {HTMLAnchorElement} the pagination link
+ * @private
  */
 HistoryView.prototype.createPageNav_ = function(page, name) {
   var navButton = createElementWithClassName('button', 'link-button');
   navButton.textContent = name;
   navButton.onclick = function() {
     setPage(page);
   };
   return navButton;
 };
 
@@ skipping 26 matching lines @@
   // var anchorMaxWith = titleElement.offsetWidth;
   // this.entryAnchorRule_.style.maxWidth = anchorMaxWith + 'px';
   // // Adjust by the width of star plus its margin.
   // this.entryAnchorStarredRule_.style.maxWidth = anchorMaxWith - 23 + 'px';
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // State object:
 /**
  * An 'AJAX-history' implementation.
- * @param {HistoryModel} model The model we're representing
- * @param {HistoryView} view The view we're representing
+ * @param {HistoryModel} model The model we're representing.
+ * @param {HistoryView} view The view we're representing.
+ * @constructor
  */
 function PageState(model, view) {
   // Enforce a singleton.
   if (PageState.instance) {
     return PageState.instance;
   }
 
   this.model = model;
   this.view = view;
 
   if (typeof this.checker_ != 'undefined' && this.checker_) {
     clearInterval(this.checker_);
   }
 
   // TODO(glen): Replace this with a bound method so we don't need
   //     public model and view.
   this.checker_ = setInterval((function(state_obj) {
     var hashData = state_obj.getHashData();
     if (hashData.q != state_obj.model.getSearchText()) {
       state_obj.view.setSearch(hashData.q, parseInt(hashData.p, 10));
     } else if (parseInt(hashData.p, 10) != state_obj.view.getPage()) {
       state_obj.view.setPage(hashData.p);
     }
   }), 50, this);
 }
 
+/**
+ * Holds the singleton instance.
+ */
 PageState.instance = null;
 
 /**
  * @return {Object} An object containing parameters from our window hash.
  */
 PageState.prototype.getHashData = function() {
   var result = {
-    e : 0,
-    q : '',
-    p : 0
+    e: 0,
+    q: '',
+    p: 0
   };
 
   if (!window.location.hash) {
     return result;
   }
 
   var hashSplit = window.location.hash.substr(1).split('&');
   for (var i = 0; i < hashSplit.length; i++) {
     var pair = hashSplit[i].split('=');
     if (pair.length > 1) {
@@ skipping 111 matching lines @@
     // Call the native function to remove history entries.
     // First arg is a time in seconds (passed as String) identifying the day.
     // Remaining args are URLs of history entries from that day to delete.
     var timeInSeconds = Math.floor(deleteQueue[0].date.getTime() / 1000);
     chrome.send('removeURLsOnOneDay',
                 [String(timeInSeconds)].concat(deleteQueue[0].urls));
   }
 }
 
 /**
- * Open the clear browsing data dialog.
+ * Click handler for the 'Clear browsing data' dialog.
+ * @param {Event} e The click event.
  */
-function openClearBrowsingData() {
-  chrome.send('clearBrowsingData', []);
-  return false;
+function openClearBrowsingData(e) {
+  chrome.send('clearBrowsingData');
 }
 
 /**
  * Queue a set of URLs from the same day for deletion.
  * @param {Date} date A date indicating the day the URLs were visited.
  * @param {Array} urls Array of URLs from the same day to be deleted.
  * @param {Function} opt_callback An optional callback to be executed when
  *        the deletion is complete.
  */
 function queueURLsForDeletion(date, urls, opt_callback) {
   deleteQueue.push({ 'date': date, 'urls': urls, 'callback': opt_callback });
 }
 
 function reloadHistory() {
   historyView.reload();
 }
 
 /**
- * Collect IDs from checked checkboxes and send to Chrome for deletion.
+ * Click handler for the 'Remove selected items' button.
+ * Collect IDs from the checked checkboxes and send to Chrome for deletion.
  */
 function removeItems() {
   var checked = document.querySelectorAll(
       'input[type=checkbox]:checked:not([disabled])');
   var urls = [];
   var disabledItems = [];
   var queue = [];
   var date = new Date();
 
   for (var i = 0; i < checked.length; i++) {
@@ skipping 29 matching lines @@
     // If the remove is cancelled, return the checkboxes to their
     // enabled, non-line-through state.
     for (var i = 0; i < disabledItems.length; i++) {
       var checkbox = disabledItems[i];
       var link = findAncestorWithClass(
           checkbox, 'entry-box').querySelector('a');
       checkbox.disabled = false;
       link.classList.remove('to-be-removed');
     }
   }
-  return false;
 }
 
 /**
- * Toggle state of checkbox and handle Shift modifier.
+ * Handler for the 'click' event on a checkbox.
+ * @param {Event} e The click event.
  */
-function checkboxClicked(event) {
-  var id = Number(this.id.slice("checkbox-".length));
+function checkboxClicked(e) {
+  var checkbox = e.currentTarget;
+  var id = Number(checkbox.id.slice('checkbox-'.length));
+  // Handle multi-select if shift was pressed.
   if (event.shiftKey && (selectionAnchor != -1)) {
-    var checked = this.checked;
+    var checked = checkbox.checked;
     // Set all checkboxes from the anchor up to the clicked checkbox to the
     // state of the clicked one.
     var begin = Math.min(id, selectionAnchor);
     var end = Math.max(id, selectionAnchor);
     for (var i = begin; i <= end; i++) {
       var checkbox = document.querySelector('#checkbox-' + i);
       if (checkbox)
         checkbox.checked = checked;
     }
   }
@@ skipping 14 matching lines @@
 
   // Delete the node when the animation is complete.
   node.addEventListener('webkitTransitionEnd', function() {
     node.parentNode.removeChild(node);
   });
 }
 
 /**
  * Removes a single entry from the view. Also removes gaps before and after
  * entry if necessary.
+ * @param {Node} entry The DOM node representing the entry to be removed.
  */
 function removeEntryFromView(entry) {
   var nextEntry = entry.nextSibling;
   var previousEntry = entry.previousSibling;
 
   removeNode(entry);
 
   // if there is no previous entry, and the next entry is a gap, remove it
   if (!previousEntry && nextEntry && nextEntry.className == 'gap') {
     removeNode(nextEntry);
   }
 
   // if there is no next entry, and the previous entry is a gap, remove it
   if (!nextEntry && previousEntry && previousEntry.className == 'gap') {
     removeNode(previousEntry);
   }
 
   // if both the next and previous entries are gaps, remove one
   if (nextEntry && nextEntry.className == 'gap' &&
       previousEntry && previousEntry.className == 'gap') {
     removeNode(nextEntry);
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Chrome callbacks:
+
 /**
  * Our history system calls this function with results from searches.
+ * @param {Object} info An object containing information about the query.
+ * @param {Array} results A list of results.
  */
 function historyResult(info, results) {
   historyModel.addResults(info, results);
 }
 
 /**
  * Our history system calls this function when a deletion has finished.
  */
 function deleteComplete() {
   if (deleteQueue.length > 0) {
@@ skipping 31 matching lines @@
     historyView.reload();
 }
 
 // Add handlers to HTML elements.
 document.addEventListener('DOMContentLoaded', load);
 
 // This event lets us enable and disable menu items before the menu is shown.
 document.addEventListener('canExecute', function(e) {
   e.canExecute = true;
 });