Typecheck JS files for chrome://history

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">
 <include src="history_focus_manager.js">
 
 ///////////////////////////////////////////////////////////////////////////////
 // Globals:
 /** @const */ var RESULTS_PER_PAGE = 150;
@@ skipping 20 matching lines @@
 /** @const */ var Command = cr.ui.Command;
 /** @const */ var Menu = cr.ui.Menu;
 /** @const */ var MenuButton = cr.ui.MenuButton;
 
 /**
  * Enum that shows the filtering behavior for a host or URL to a supervised
  * user. Must behave like the FilteringBehavior enum from
  * supervised_user_url_filter.h.
  * @enum {number}
  */
-SupervisedUserFilteringBehavior = {
+var SupervisedUserFilteringBehavior = {
   ALLOW: 0,
   WARN: 1,
   BLOCK: 2
 };
 
+/**
+ * The type of the history result object. The definition is based on
+ * chrome/browser/ui/webui/history_ui.cc:
+ *     BrowsingHistoryHandler::HistoryEntry::ToValue()
+ * @typedef {{allTimestamps: Array.<number>,
+ *            blockedVisit: (boolean|undefined),
+ *            dateRelativeDay: (string|undefined),
+ *            dateShort: string,
+ *            dateTimeOfDay: (string|undefined),
+ *            deviceName: string,
+ *            deviceType: string,
+ *            domain: string,
+ *            hostFilteringBehavior: (number|undefined),
+ *            snippet: (string|undefined),
+ *            starred: boolean,
+ *            time: number,
+ *            title: string,
+ *            url: string}}
+ */
+var HistoryEntry;
+
+/**
+ * The type of the history results info object. The definition is based on
+ * chrome/browser/ui/webui/history_ui.cc:
+ *     BrowsingHistoryHandler::QueryComplete()
+ * @typedef {{finished: boolean,
+ *            hasSyncedResults: (boolean|undefined),
+ *            queryEndTime: string,
+ *            queryStartTime: string,
+ *            term: string}}
+ */
+var HistoryQuery;
+
 MenuButton.createDropDownArrows();
 
 /**
  * Returns true if the mobile (non-desktop) version is being shown.
  * @return {boolean} true if the mobile version is being shown.
  */
 function isMobileVersion() {
   return !document.body.classList.contains('uber-frame');
 }
 
 /**
  * Record an action in UMA.
  * @param {string} actionDesc The name of the action to be logged.
  */
 function recordUmaAction(actionDesc) {
   chrome.send('metricsHandler:recordAction', [actionDesc]);
 }
 
 /**
  * Record a histogram value in UMA. If specified value is larger than the max
  * bucket value, record the value in the largest bucket.
  * @param {string} histogram The name of the histogram to be recorded in.
- * @param {integer} maxBucketValue The max value for the last histogram bucket.
- * @param {integer} value The value to record in the histogram.
+ * @param {number} maxBucketValue The max value for the last histogram bucket.
+ * @param {number} value The value to record in the histogram.
  */
 function recordUmaHistogram(histogram, maxBucketValue, value) {
   chrome.send('metricsHandler:recordInHistogram',
               [histogram,
               ((value > maxBucketValue) ? maxBucketValue : value),
               maxBucketValue]);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Visit:
 
 /**
  * Class to hold all the information about an entry in our model.
- * @param {Object} result An object containing the visit's data.
+ * @param {HistoryEntry} result An object containing the visit's data.
  * @param {boolean} continued Whether this visit is on the same day as the
  *     visit before it.
  * @param {HistoryModel} model The model object this entry belongs to.
  * @constructor
  */
 function Visit(result, continued, model) {
   this.model_ = model;
   this.title_ = result.title;
   this.url_ = result.url;
   this.domain_ = result.domain;
@@ skipping 102 matching lines @@
     bookmarkSection.addEventListener('click', function f(e) {
       recordUmaAction('HistoryPage_BookmarkStarClicked');
       bookmarkSection.classList.remove('starred');
       chrome.send('removeBookmark', [self.url_]);
       bookmarkSection.removeEventListener('click', f);
       e.preventDefault();
     });
   }
   entryBox.appendChild(bookmarkSection);
 
-  var visitEntryWrapper = entryBox.appendChild(document.createElement('div'));
+  var visitEntryWrapper = /** @type {HTMLElement} */(
+      entryBox.appendChild(document.createElement('div')));
   if (addTitleFavicon || this.blockedVisit)
     visitEntryWrapper.classList.add('visit-entry');
   if (this.blockedVisit) {
     visitEntryWrapper.classList.add('blocked-indicator');
     visitEntryWrapper.appendChild(this.getVisitAttemptDOM_());
   } else {
     var title = visitEntryWrapper.appendChild(
         this.getTitleDOM_(isSearchResult));
 
     if (addTitleFavicon)
@@ skipping 74 matching lines @@
 /**
  * Remove this visit from the history.
  */
 Visit.prototype.removeFromHistory = function() {
   recordUmaAction('HistoryPage_EntryMenuRemoveFromHistory');
   this.model_.removeVisitsFromHistory([this], function() {
     this.model_.getView().removeVisit(this);
   }.bind(this));
 };
 
+// Closure Compiler doesn't support Object.defineProperty().
+// https://github.com/google/closure-compiler/issues/302
 Object.defineProperty(Visit.prototype, 'checkBox', {
-  get: function() {
+  get: /** @this {Visit} */function() {
     return this.domNode_.querySelector('input[type=checkbox]');
   },
 });
 
 Object.defineProperty(Visit.prototype, 'bookmarkStar', {
-  get: function() {
+  get: /** @this {Visit} */function() {
     return this.domNode_.querySelector('.bookmark-section.starred');
   },
 });
 
 Object.defineProperty(Visit.prototype, 'titleLink', {
-  get: function() {
+  get: /** @this {Visit} */function() {
     return this.domNode_.querySelector('.title a');
   },
 });
 
 Object.defineProperty(Visit.prototype, 'dropDown', {
-  get: function() {
+  get: /** @this {Visit} */function() {
     return this.domNode_.querySelector('button.drop-down');
   },
 });
 
 // Visit, private: ------------------------------------------------------------
 
 /**
  * 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
@@ skipping 221 matching lines @@
  * the data becomes available, the model will call the view back.
  * @param {number} page The page we want to view.
  */
 HistoryModel.prototype.requestPage = function(page) {
   this.requestedPage_ = page;
   this.updateSearch_();
 };
 
 /**
  * Receiver for history query.
- * @param {Object} info An object containing information about the query.
- * @param {Array} results A list of results.
+ * @param {HistoryQuery} info An object containing information about the query.
+ * @param {Array.<HistoryEntry>} results A list of results.
  */
 HistoryModel.prototype.addResults = function(info, results) {
   // If no requests are in flight then this was an old request so we drop the
   // results. Double check the search term as well.
   if (!this.inFlight_ || info.term != this.searchText_)
     return;
 
   $('loading-spinner').hidden = true;
   this.inFlight_ = false;
   this.isQueryFinished_ = info.finished;
@@ skipping 41 matching lines @@
  * @return {boolean} true if the there are more results, otherwise false.
  */
 HistoryModel.prototype.hasMoreResults = function() {
   return this.haveDataForPage_(this.requestedPage_ + 1) ||
       !this.isQueryFinished_;
 };
 
 /**
  * Removes a list of visits from the history, and calls |callback| when the
  * removal has successfully completed.
- * @param {Array<Visit>} visits The visits to remove.
+ * @param {Array.<Visit>} visits The visits to remove.
  * @param {Function} callback The function to call after removal succeeds.
  */
 HistoryModel.prototype.removeVisitsFromHistory = function(visits, callback) {
   assert(this.deletingHistoryAllowed);
 
   var toBeRemoved = [];
   for (var i = 0; i < visits.length; i++) {
     toBeRemoved.push({
       url: visits[i].url_,
       timestamps: visits[i].allTimestamps
@@ skipping 13 matching lines @@
  * Called when visits have been succesfully removed from the history.
  */
 HistoryModel.prototype.deleteComplete = function() {
   // Call the callback, with 'this' undefined inside the callback.
   this.deleteCompleteCallback_.call();
   this.deleteCompleteCallback_ = null;
 };
 
 // Getter and setter for HistoryModel.rangeInDays_.
 Object.defineProperty(HistoryModel.prototype, 'rangeInDays', {
-  get: function() {
+  get: /** @this {HistoryModel} */function() {
     return this.rangeInDays_;
   },
-  set: function(range) {
+  set: /** @this {HistoryModel} */function(range) {
     this.rangeInDays_ = range;
   }
 });
 
 /**
  * Getter and setter for HistoryModel.offset_. The offset moves the current
  * query 'window' |range| days behind. As such for range set to WEEK an offset
  * of 0 refers to the last 7 days, an offset of 1 refers to the 7 day period
  * that ended 7 days ago, etc. For MONTH an offset of 0 refers to the current
  * calendar month, 1 to the previous one, etc.
  */
 Object.defineProperty(HistoryModel.prototype, 'offset', {
-  get: function() {
+  get: /** @this {HistoryModel} */function() {
     return this.offset_;
   },
-  set: function(offset) {
+  set: /** @this {HistoryModel} */function(offset) {
     this.offset_ = offset;
   }
 });
 
 // Setter for HistoryModel.requestedPage_.
 Object.defineProperty(HistoryModel.prototype, 'requestedPage', {
-  set: function(page) {
+  set: /** @this {HistoryModel} */function(page) {
     this.requestedPage_ = page;
   }
 });
 
 /**
  * Removes |visit| from this model.
  * @param {Visit} visit A visit to remove.
  */
 HistoryModel.prototype.removeVisit = function(visit) {
   var index = this.visits_.indexOf(visit);
@@ skipping 117 matching lines @@
  * Gets whether we are grouped by domain.
  * @return {boolean} Whether the results are grouped by domain.
  */
 HistoryModel.prototype.getGroupByDomain = function() {
   return this.groupByDomain_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // HistoryFocusObserver:
 
-/** @implements {cr.ui.FocusRow.Observer} */
+/**
+ * @constructor
+ * @implements {cr.ui.FocusRow.Observer}
+ */
 function HistoryFocusObserver() {}
 
 HistoryFocusObserver.prototype = {
   /** @override */
   onActivate: function(row) {
     this.getActiveRowElement_(row).classList.add('active');
   },
 
   /** @override */
   onDeactivate: function(row) {
@@ skipping 55 matching lines @@
     recordUmaAction('HistoryPage_NewerHistoryClick');
     self.setPage(self.pageIndex_ - 1);
   });
   $('older-button').addEventListener('click', function() {
     recordUmaAction('HistoryPage_OlderHistoryClick');
     self.setPage(self.pageIndex_ + 1);
   });
 
   var handleRangeChange = function(e) {
     // Update the results and save the last state.
-    self.setRangeInDays(parseInt(e.target.value, 10));
+    var value = parseInt(e.target.value, 10);
+    self.setRangeInDays(/** @type {HistoryModel.Range.<number>} */(value));
   };
 
   // Add handlers for the range options.
   $('timeframe-filter-all').addEventListener('change', handleRangeChange);
   $('timeframe-filter-week').addEventListener('change', handleRangeChange);
   $('timeframe-filter-month').addEventListener('change', handleRangeChange);
 
   $('range-previous').addEventListener('click', function(e) {
     if (self.getRangeInDays() == HistoryModel.Range.ALL_TIME)
       self.setPage(self.pageIndex_ + 1);
@@ skipping 77 matching lines @@
 
 /**
  * @return {number} The page number being viewed.
  */
 HistoryView.prototype.getPage = function() {
   return this.pageIndex_;
 };
 
 /**
  * Set the current range for grouped results.
- * @param {string} range The number of days to which the range should be set.
+ * @param {HistoryModel.Range} range The number of days to which the range
+ *     should be set.
  */
 HistoryView.prototype.setRangeInDays = function(range) {
   // Set the range, offset and reset the page.
   this.setPageState(this.model_.getSearchText(), 0, range, 0);
 };
 
 /**
  * Get the current range in days.
- * @return {number} Current range in days from the model.
+ * @return {HistoryModel.Range} Current range in days from the model.
  */
 HistoryView.prototype.getRangeInDays = function() {
   return this.model_.rangeInDays;
 };
 
 /**
  * Set the current offset for grouped results.
  * @param {number} offset Offset to set.
  */
 HistoryView.prototype.setOffset = function(offset) {
@@ skipping 337 matching lines @@
 
   for (var i = 0; i < domains.length; ++i) {
     var domain = domains[i];
     this.getGroupedVisitsDOM_(results, domain, visitsByDomain[domain]);
   }
 };
 
 /**
  * Adds the results for a month.
  * @param {Array} visits Visits returned by the query.
- * @param {Element} parentElement Element to which to add the results to.
+ * @param {Node} parentNode Node to which to add the results to.
  * @private
  */
-HistoryView.prototype.addMonthResults_ = function(visits, parentElement) {
+HistoryView.prototype.addMonthResults_ = function(visits, parentNode) {
   if (visits.length == 0)
     return;
 
-  var monthResults = parentElement.appendChild(
-      createElementWithClassName('ol', 'month-results'));
+  var monthResults = /** @type {HTMLOListElement} */(parentNode.appendChild(
+      createElementWithClassName('ol', 'month-results')));
   // Don't add checkboxes if entries can not be edited.
   if (!this.model_.editingEntriesAllowed)
     monthResults.classList.add('no-checkboxes');
 
   this.groupVisitsByDomain_(visits, monthResults);
 };
 
 /**
  * Adds the results for a certain day. This includes a title with the day of
  * the results and the results themselves, grouped or not.
  * @param {Array} visits Visits returned by the query.
- * @param {Element} parentElement Element to which to add the results to.
+ * @param {Node} parentNode Node to which to add the results to.
  * @private
  */
-HistoryView.prototype.addDayResults_ = function(visits, parentElement) {
+HistoryView.prototype.addDayResults_ = function(visits, parentNode) {
   if (visits.length == 0)
     return;
 
   var firstVisit = visits[0];
-  var day = parentElement.appendChild(createElementWithClassName('h3', 'day'));
+  var day = parentNode.appendChild(createElementWithClassName('h3', 'day'));
   day.appendChild(document.createTextNode(firstVisit.dateRelativeDay));
   if (firstVisit.continued) {
     day.appendChild(document.createTextNode(' ' +
                                             loadTimeData.getString('cont')));
   }
-  var dayResults = parentElement.appendChild(
-      createElementWithClassName('ol', 'day-results'));
+  var dayResults = /** @type {HTMLElement} */(parentNode.appendChild(
+      createElementWithClassName('ol', 'day-results')));
 
   // Don't add checkboxes if entries can not be edited.
   if (!this.model_.editingEntriesAllowed)
     dayResults.classList.add('no-checkboxes');
 
   if (this.model_.getGroupByDomain()) {
     this.groupVisitsByDomain_(visits, dayResults);
   } else {
     var lastTime;
 
     for (var i = 0, visit; visit = visits[i]; i++) {
       // If enough time has passed between visits, indicate a gap in browsing.
       var thisTime = visit.date.getTime();
       if (lastTime && lastTime - thisTime > BROWSING_GAP_TIME)
         dayResults.appendChild(createElementWithClassName('li', 'gap'));
 
       // Insert the visit into the DOM.
       dayResults.appendChild(visit.getResultDOM({ addTitleFavicon: true }));
       this.setVisitRendered_(visit);
 
       lastTime = thisTime;
     }
   }
 };
 
 /**
  * Adds the text that shows the current interval, used for week and month
  * results.
- * @param {Element} resultsFragment The element to which the interval will be
+ * @param {Node} resultsFragment The element to which the interval will be
  *     added to.
  * @private
  */
 HistoryView.prototype.addTimeframeInterval_ = function(resultsFragment) {
   if (this.getRangeInDays() == HistoryModel.Range.ALL_TIME)
     return;
 
   // If this is a time range result add some text that shows what is the
   // time range for the results the user is viewing.
   var timeFrame = resultsFragment.appendChild(
@@ skipping 79 matching lines @@
       // Go through all of the visits and process them in chunks of one day.
       while (dayEnd < results.length) {
         // Skip over the ones that are already rendered.
         while (dayStart < results.length && results[dayStart].isRendered)
           ++dayStart;
         var dayEnd = dayStart + 1;
         while (dayEnd < results.length && results[dayEnd].continued)
           ++dayEnd;
 
         this.addDayResults_(
-            results.slice(dayStart, dayEnd), resultsFragment, groupByDomain);
+            results.slice(dayStart, dayEnd), resultsFragment);
       }
     }
 
     // Add all the days and their visits to the page.
     this.resultDiv_.appendChild(resultsFragment);
   }
   // After the results have been added to the DOM, determine the size of the
   // time column.
-  this.setTimeColumnWidth_(this.resultDiv_);
+  this.setTimeColumnWidth_();
 };
 
 var focusGridRowSelector = [
   '.day-results > .entry:not(.fade-out)',
   '.expand .grouped .entry:not(.fade-out)',
   '.site-domain-wrapper'
 ].join(', ');
 
 var focusGridColumnSelector = [
   '.entry-box input',
@@ skipping 73 matching lines @@
   var styleEl = $('timeColumnStyle');
   if (!styleEl) {
     styleEl = document.head.appendChild(document.createElement('style'));
     styleEl.id = 'timeColumnStyle';
   }
   styleEl.textContent = '.entry .time { min-width: ' + maxWidth + 'px; }';
 };
 
 /**
  * Toggles an element in the grouped history.
- * @param {Element} e The element which was clicked on.
+ * @param {Event} e The event with element |e.target| which was clicked on.
  * @private
  */
 HistoryView.prototype.toggleGroupedVisits_ = function(e) {
-  var entry = findAncestorByClass(e.target, 'site-entry');
+  var entry = findAncestorByClass(/** @type {Element} */(e.target),
+                                  'site-entry');
   var innerResultList = entry.querySelector('.site-results');
 
   if (entry.classList.contains('expand')) {
     innerResultList.style.height = 0;
   } else {
     innerResultList.style.height = 'auto';
     // -webkit-transition does not work on height:auto elements so first set
     // the height to auto so that it is computed and then set it to the
     // computed value in pixels so the transition works properly.
     var height = innerResultList.clientHeight;
@@ skipping 132 matching lines @@
   var searchField = $('search-field');
 
   historyModel = new HistoryModel();
   historyView = new HistoryView(historyModel);
   pageState = new PageState(historyModel, historyView);
 
   // Create default view.
   var hashData = pageState.getHashData();
   var grouped = (hashData.grouped == 'true') || historyModel.getGroupByDomain();
   var page = parseInt(hashData.page, 10) || historyView.getPage();
-  var range = parseInt(hashData.range, 10) || historyView.getRangeInDays();
+  var range = /** @type {HistoryModel.Range} */(parseInt(hashData.range, 10)) ||
+      historyView.getRangeInDays();
   var offset = parseInt(hashData.offset, 10) || historyView.getOffset();
   historyView.setPageState(hashData.q, page, range, offset);
 
   if ($('overlay')) {
     cr.ui.overlay.setupOverlay($('overlay'));
     cr.ui.overlay.globalInitialization();
   }
   HistoryFocusManager.getInstance().initialize();
 
   var doSearch = function(e) {
@@ skipping 53 matching lines @@
     // visibility, otherwise the button will flash on the screen before the
     // keyboard animates away.
     searchField.addEventListener('blur', function() {
       setTimeout(historyView.updateClearBrowsingDataButton_, 250);
     });
 
     // Move the button to the bottom of the page.
     $('history-page').appendChild($('clear-browsing-data'));
   } else {
     window.addEventListener('message', function(e) {
+      e = /** @type {!MessageEvent.<!{method: string}>} */(e);
       if (e.data.method == 'frameSelected')
         searchField.focus();
     });
     searchField.focus();
   }
 
 <if expr="is_ios">
   function checkKeyboardVisibility() {
     // Figure out the real height based on the orientation, becauase
     // screen.width and screen.height don't update after rotation.
@@ skipping 53 matching lines @@
  */
 function hideConfirmationOverlay() {
   $('alertOverlay').classList.remove('showing');
   $('overlay').hidden = true;
   uber.invokeMethodOnParent('stopInterceptingEvents');
 }
 
 /**
  * Shows the confirmation alert for history deletions and permits browser tests
  * to override the dialog.
- * @param {function=} okCallback A function to be called when the user presses
+ * @param {function()=} okCallback A function to be called when the user presses
  *     the ok button.
- * @param {function=} cancelCallback A function to be called when the user
+ * @param {function()=} cancelCallback A function to be called when the user
  *     presses the cancel button.
  */
 function confirmDeletion(okCallback, cancelCallback) {
   alertOverlay.setValues(
       loadTimeData.getString('removeSelected'),
       loadTimeData.getString('deleteWarning'),
       loadTimeData.getString('cancel'),
       loadTimeData.getString('deleteConfirm'),
       cancelCallback,
       okCallback);
@@ skipping 65 matching lines @@
     confirmDeletion(onConfirmRemove, onCancelRemove);
     $('overlay').addEventListener('cancelOverlay', onCancelRemove);
   }
 }
 
 /**
  * Handler for the 'click' event on a checkbox.
  * @param {Event} e The click event.
  */
 function checkboxClicked(e) {
-  handleCheckboxStateChange(e.currentTarget, e.shiftKey);
+  handleCheckboxStateChange(/** @type {!HTMLInputElement} */(e.currentTarget),
+                            e.shiftKey);
 }
 
 /**
  * Post-process of checkbox state change. This handles range selection and
  * updates internal state.
  * @param {!HTMLInputElement} checkbox Clicked checkbox.
  * @param {boolean} shiftKey true if shift key is pressed.
  */
 function handleCheckboxStateChange(checkbox, shiftKey) {
   updateParentCheckbox(checkbox);
   var id = Number(checkbox.id.slice('checkbox-'.length));
   // Handle multi-select if shift was pressed.
   if (shiftKey && (selectionAnchor != -1)) {
     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;
-        updateParentCheckbox(checkbox);
+      var ithCheckbox = document.querySelector('#checkbox-' + i);
+      if (ithCheckbox) {
+        ithCheckbox.checked = checked;
+        updateParentCheckbox(ithCheckbox);
       }
     }
   }
   selectionAnchor = id;
 
   historyView.updateSelectionEditButtons();
 }
 
 /**
  * Handler for the 'click' event on a domain checkbox. Checkes or unchecks the
  * checkboxes of the visits to this domain in the respective group.
  * @param {Event} e The click event.
  */
 function domainCheckboxClicked(e) {
-  var siteEntry = findAncestorByClass(e.currentTarget, 'site-entry');
+  var siteEntry = findAncestorByClass(/** @type {Element} */(e.currentTarget),
+                                      'site-entry');
   var checkboxes =
       siteEntry.querySelectorAll('.site-results input[type=checkbox]');
   for (var i = 0; i < checkboxes.length; i++)
     checkboxes[i].checked = e.currentTarget.checked;
   historyView.updateSelectionEditButtons();
   // Stop propagation as clicking the checkbox would otherwise trigger the
   // group to collapse/expand.
   e.stopPropagation();
 }
 
@@ skipping 16 matching lines @@
 }
 
 function entryBoxMousedown(event) {
   // Prevent text selection when shift-clicking to select multiple entries.
   if (event.shiftKey)
     event.preventDefault();
 }
 
 /**
  * Handle click event for entryBox labels.
- * @param {!MouseEvent} event A click event.
+ * @param {!Event} event A click event.
  */
 function entryBoxClick(event) {
+  event = /** @type {!MouseEvent} */(event);
   // Do nothing if a bookmark star is clicked.
   if (event.defaultPrevented)
     return;
   var element = event.target;
   // Do nothing if the event happened in an interactive element.
   for (; element != event.currentTarget; element = element.parentNode) {
     switch (element.tagName) {
       case 'A':
       case 'BUTTON':
       case 'INPUT':
@@ skipping 54 matching lines @@
   updateHostStatus(filterStatusDiv, filteringBehavior);
   return filterStatusDiv;
 }
 
 
 ///////////////////////////////////////////////////////////////////////////////
 // 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.
+ * @param {HistoryQuery} info An object containing information about the query.
+ * @param {Array.<HistoryEntry>} results A list of results.
  */
 function historyResult(info, results) {
   historyModel.addResults(info, results);
 }
 
 /**
  * Called by the history backend when history removal is successful.
  */
 function deleteComplete() {
   historyModel.deleteComplete();
@@ skipping 17 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;
 });