[MD History] Copy stats from the old history page.

chrome/browser/resources/md_history/app.crisper.js

 // Copyright 2016 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 PromiseResolver is a helper class that allows creating a
  * Promise that will be fulfilled (resolved or rejected) some time later.
  *
  * Example:
  *  var resolver = new PromiseResolver();
@@ skipping 10728 matching lines @@
     Polymer.IronControlState,
     Polymer.PaperItemBehaviorImpl
   ];
 Polymer({
       is: 'paper-item',
 
       behaviors: [
         Polymer.PaperItemBehavior
       ]
     });
+// Copyright 2016 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 Defines a singleton object, md_history.BrowserService, which
+ * provides access to chrome.send APIs.
+ */
+
+cr.define('md_history', function() {
+  /** @constructor */
+  function BrowserService() {
+    /** @private {Array<!HistoryEntry>} */
+    this.pendingDeleteItems_ = null;
+    /** @private {PromiseResolver} */
+    this.pendingDeletePromise_ = null;
+  }
+
+  BrowserService.prototype = {
+    /**
+     * @param {!Array<!HistoryEntry>} items
+     * @return {Promise<!Array<!HistoryEntry>>}
+     */
+    deleteItems: function(items) {
+      if (this.pendingDeleteItems_ != null) {
+        // There's already a deletion in progress, reject immediately.
+        return new Promise(function(resolve, reject) { reject(items); });
+      }
+
+      var removalList = items.map(function(item) {
+        return {
+          url: item.url,
+          timestamps: item.allTimestamps
+        };
+      });
+
+      this.pendingDeleteItems_ = items;
+      this.pendingDeletePromise_ = new PromiseResolver();
+
+      chrome.send('removeVisits', removalList);
+
+      return this.pendingDeletePromise_.promise;
+    },
+
+    /**
+     * @param {!string} url
+     */
+    removeBookmark: function(url) {
+      chrome.send('removeBookmark', [url]);
+    },
+
+    /**
+     * @param {string} sessionTag
+     */
+    openForeignSessionAllTabs: function(sessionTag) {
+      chrome.send('openForeignSession', [sessionTag]);
+    },
+
+    /**
+     * @param {string} sessionTag
+     * @param {number} windowId
+     * @param {number} tabId
+     * @param {MouseEvent} e
+     */
+    openForeignSessionTab: function(sessionTag, windowId, tabId, e) {
+      chrome.send('openForeignSession', [
+        sessionTag, String(windowId), String(tabId), e.button || 0, e.altKey,
+        e.ctrlKey, e.metaKey, e.shiftKey
+      ]);
+    },
+
+    /**
+     * @param {string} sessionTag
+     */
+    deleteForeignSession: function(sessionTag) {
+      chrome.send('deleteForeignSession', [sessionTag]);
+    },
+
+    openClearBrowsingData: function() {
+      chrome.send('clearBrowsingData');
+    },
+
+    /**
+     * @param {string} histogram
+     * @param {number} value
+     * @param {number} max
+     */
+    recordHistogram: function(histogram, value, max) {
+      chrome.send('metricsHandler:recordInHistogram', [histogram, value, max]);
+    },
+
+    /**
+    * Record an action in UMA.
+    * @param {string} action The name of the action to be logged.
+    */
+    recordAction: function(action) {
+      if (action.indexOf('_') == -1)
+        action = 'HistoryPage_' + action;
+      chrome.send('metricsHandler:recordAction', [action]);
+    },
+
+    /**
+     * @param {boolean} successful
+     * @private
+     */
+    resolveDelete_: function(successful) {
+      if (this.pendingDeleteItems_ == null ||
+          this.pendingDeletePromise_ == null) {
+        return;
+      }
+
+      if (successful)
+        this.pendingDeletePromise_.resolve(this.pendingDeleteItems_);
+      else
+        this.pendingDeletePromise_.reject(this.pendingDeleteItems_);
+
+      this.pendingDeleteItems_ = null;
+      this.pendingDeletePromise_ = null;
+    },
+  };
+
+  cr.addSingletonGetter(BrowserService);
+
+  return {BrowserService: BrowserService};
+});
+
+/**
+ * Called by the history backend when deletion was succesful.
+ */
+function deleteComplete() {
+  md_history.BrowserService.getInstance().resolveDelete_(true);
+}
+
+/**
+ * Called by the history backend when the deletion failed.
+ */
+function deleteFailed() {
+  md_history.BrowserService.getInstance().resolveDelete_(false);
+};
 Polymer({
 
     is: 'iron-collapse',
 
     behaviors: [
       Polymer.IronResizableBehavior
     ],
 
     properties: {
 
@@ skipping 594 matching lines @@
   return {
     getSupportedScaleFactors: getSupportedScaleFactors,
     getProfileAvatarIcon: getProfileAvatarIcon,
     getFaviconImageSet: getFaviconImageSet,
   };
 });
 // Copyright 2016 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 Defines a singleton object, md_history.BrowserService, which
- * provides access to chrome.send APIs.
- */
-
-cr.define('md_history', function() {
-  /** @constructor */
-  function BrowserService() {
-    /** @private {Array<!HistoryEntry>} */
-    this.pendingDeleteItems_ = null;
-    /** @private {PromiseResolver} */
-    this.pendingDeletePromise_ = null;
-  }
-
-  BrowserService.prototype = {
-    /**
-     * @param {!Array<!HistoryEntry>} items
-     * @return {Promise<!Array<!HistoryEntry>>}
-     */
-    deleteItems: function(items) {
-      if (this.pendingDeleteItems_ != null) {
-        // There's already a deletion in progress, reject immediately.
-        return new Promise(function(resolve, reject) { reject(items); });
-      }
-
-      var removalList = items.map(function(item) {
-        return {
-          url: item.url,
-          timestamps: item.allTimestamps
-        };
-      });
-
-      this.pendingDeleteItems_ = items;
-      this.pendingDeletePromise_ = new PromiseResolver();
-
-      chrome.send('removeVisits', removalList);
-
-      return this.pendingDeletePromise_.promise;
-    },
-
-    /**
-     * @param {!string} url
-     */
-    removeBookmark: function(url) {
-      chrome.send('removeBookmark', [url]);
-    },
-
-    /**
-     * @param {string} sessionTag
-     */
-    openForeignSessionAllTabs: function(sessionTag) {
-      chrome.send('openForeignSession', [sessionTag]);
-    },
-
-    /**
-     * @param {string} sessionTag
-     * @param {number} windowId
-     * @param {number} tabId
-     * @param {MouseEvent} e
-     */
-    openForeignSessionTab: function(sessionTag, windowId, tabId, e) {
-      chrome.send('openForeignSession', [
-        sessionTag, String(windowId), String(tabId), e.button || 0, e.altKey,
-        e.ctrlKey, e.metaKey, e.shiftKey
-      ]);
-    },
-
-    /**
-     * @param {string} sessionTag
-     */
-    deleteForeignSession: function(sessionTag) {
-      chrome.send('deleteForeignSession', [sessionTag]);
-    },
-
-    openClearBrowsingData: function() {
-      chrome.send('clearBrowsingData');
-    },
-
-    /**
-     * @param {string} histogram
-     * @param {number} value
-     * @param {number} max
-     */
-    recordHistogram: function(histogram, value, max) {
-      chrome.send('metricsHandler:recordInHistogram', [histogram, value, max]);
-    },
-
-    /**
-    * Record an action in UMA.
-    * @param {string} actionDesc The name of the action to be logged.
-    */
-    recordAction: function(actionDesc) {
-      chrome.send('metricsHandler:recordAction', [actionDesc]);
-    },
-
-    /**
-     * @param {boolean} successful
-     * @private
-     */
-    resolveDelete_: function(successful) {
-      if (this.pendingDeleteItems_ == null ||
-          this.pendingDeletePromise_ == null) {
-        return;
-      }
-
-      if (successful)
-        this.pendingDeletePromise_.resolve(this.pendingDeleteItems_);
-      else
-        this.pendingDeletePromise_.reject(this.pendingDeleteItems_);
-
-      this.pendingDeleteItems_ = null;
-      this.pendingDeletePromise_ = null;
-    },
-  };
-
-  cr.addSingletonGetter(BrowserService);
-
-  return {BrowserService: BrowserService};
-});
-
-/**
- * Called by the history backend when deletion was succesful.
- */
-function deleteComplete() {
-  md_history.BrowserService.getInstance().resolveDelete_(true);
-}
-
-/**
- * Called by the history backend when the deletion failed.
- */
-function deleteFailed() {
-  md_history.BrowserService.getInstance().resolveDelete_(false);
-};
-// Copyright 2016 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.
-
 Polymer({
   is: 'history-searched-label',
 
   properties: {
     // The text to show in this label.
     title: String,
 
     // The search term to bold within the title.
     searchTerm: String,
   },
@@ skipping 98 matching lines @@
      * Remove bookmark of current item when bookmark-star is clicked.
      * @private
      */
     onRemoveBookmarkTap_: function() {
       if (!this.item.starred)
         return;
 
       if (this.$$('#bookmark-star') == this.root.activeElement)
         this.$['menu-button'].focus();
 
-      md_history.BrowserService.getInstance()
-        .removeBookmark(this.item.url);
+      var browserService = md_history.BrowserService.getInstance();
+      browserService.removeBookmark(this.item.url);
+      browserService.recordAction('BookmarkStarClicked');
+
       this.fire('remove-bookmark-stars', this.item.url);
     },
 
     /**
      * Fires a custom event when the menu button is clicked. Sends the details
      * of the history item and where the menu should appear.
      */
     onMenuButtonTap_: function(e) {
       this.fire('toggle-menu', {
         target: Polymer.dom(e).localTarget,
         item: this.item,
         path: this.path,
       });
 
       // Stops the 'tap' event from closing the menu when it opens.
       e.stopPropagation();
     },
 
     /**
+     * Record metrics when a result is clicked. This is deliberately tied to
+     * on-click rather than on-tap, as on-click triggers from middle clicks.
+     */
+    onLinkClick_: function() {
+      var browserService = md_history.BrowserService.getInstance();
+      browserService.recordAction('EntryLinkClick');
+      browserService.recordHistogram(
+          'HistoryPage.ClickPosition', this.item.index, UMA_MAX_BUCKET_VALUE);
+
+      if (this.item.index <= UMA_MAX_SUBSET_BUCKET_VALUE) {
+        browserService.recordHistogram(
+            'HistoryPage.ClickPositionSubset', this.item.index,
+            UMA_MAX_SUBSET_BUCKET_VALUE);
+      }
+
+      if (this.searchTerm)
+        browserService.recordAction('SearchResultClick');
+    },
+
+    onLinkRightClick_: function() {
+      md_history.BrowserService.getInstance().recordAction(
+          'EntryLinkRightClick');
+    },
+
+    /**
      * Set the favicon image, based on the URL of the history item.
      * @private
      */
     showIcon_: function() {
       this.$.icon.style.backgroundImage =
           cr.icon.getFaviconImageSet(this.item.url);
     },
 
     selectionNotAllowed_: function() {
       return !loadTimeData.getBoolean('allowDeletingHistory');
@@ skipping 219 matching lines @@
     node.indexes.forEach(function(index) {
       if (node.leaf || this.removeItemsBeneathNode_(node.children[index])) {
         var item = array.splice(index, 1);
         splices.push({
           index: index,
           removed: [item],
           addedCount: 0,
           object: array,
           type: 'splice'
         });
+        var browserService = md_history.BrowserService.getInstance();
+        browserService.recordHistogram(
+            'HistoryPage.RemoveEntryPosition', index, UMA_MAX_BUCKET_VALUE);
+        if (index <= UMA_MAX_SUBSET_BUCKET_VALUE) {
+          browserService.recordHistogram(
+              'HistoryPage.RemoveEntryPositionSubset', index,
+              UMA_MAX_SUBSET_BUCKET_VALUE);
+        }
       }
     }.bind(this));
 
     if (array.length == 0)
       return true;
 
     // notifySplices gives better performance than individually splicing as it
     // batches all of the updates together.
     this.notifySplices(node.currentPath, splices);
     return false;
@@ skipping 163 matching lines @@
       pushCurrentDay();
 
       this.groupedHistoryData_ = days;
     } else if (this.range == HistoryRange.MONTH) {
       // Group each all visits into a single list.
       this.groupedHistoryData_ = [{
         title: this.queryStartTime + ' – ' + this.queryEndTime,
         domains: this.createHistoryDomains_(this.historyData)
       }];
     }
+
+    this.addItemIndexes();
+  },
+
+  addItemIndexes: function() {
+    var index = 0;
+    this.groupedHistoryData_.forEach(function(group) {
+      group.domains.forEach(function(domain) {
+        domain.visits.forEach(function(visit) {
+          visit.index = index++;
+        });
+      });
+    });
   },
 
   /**
    * @param {{model:Object, currentTarget:IronCollapseElement}} e
    */
   toggleDomainExpanded_: function(e) {
     var collapse = e.currentTarget.parentNode.querySelector('iron-collapse');
     e.model.set('domain.rendered', true);
 
     // Give the history-items time to render.
@@ skipping 2081 matching lines @@
         .clearTriggers();
 
     if (this.lastSearchedTerm_ != this.searchedTerm) {
       this.resultLoadingDisabled_ = false;
       if (this.historyData_)
         this.splice('historyData_', 0, this.historyData_.length);
       this.fire('unselect-all');
       this.lastSearchedTerm_ = this.searchedTerm;
     }
 
+    results.forEach(function(item, index) {
+      item.index = index + (this.historyData_ ? this.historyData_.length : 0);
+    });
+
     if (this.historyData_) {
       // If we have previously received data, push the new items onto the
       // existing array.
       results.unshift('historyData_');
       this.push.apply(this, results);
     } else {
       // The first time we receive data, use set() to ensure the iron-list is
       // initialized correctly.
       this.set('historyData_', results);
     }
@@ skipping 274 matching lines @@
       this.getSelectedList_().unselectAllItems(count);
   },
 
   /**
    * Delete all the currently selected history items. Will prompt the user with
    * a dialog to confirm that the deletion should be performed.
    */
   deleteSelectedWithPrompt: function() {
     if (!loadTimeData.getBoolean('allowDeletingHistory'))
       return;
+
+    var browserService = md_history.BrowserService.getInstance();
+    browserService.recordAction('RemoveSelected');
+    if (this.searchTerm != '')
+      browserService.recordAction('SearchResultRemove');
     this.$.dialog.get().then(function(dialog) {
       dialog.showModal();
     });
   },
 
   /**
    * @param {HistoryRange} range
    * @private
    */
   groupedRangeChanged_: function(range, oldRange) {
@@ skipping 28 matching lines @@
           info.term == '' ? results[i].dateTimeOfDay : results[i].dateShort;
 
       if (results[i].dateRelativeDay != currentDate) {
         currentDate = results[i].dateRelativeDay;
       }
     }
   },
 
   /** @private */
   onDialogConfirmTap_: function() {
+    md_history.BrowserService.getInstance().recordAction(
+        'ConfirmRemoveSelected');
+
     this.getSelectedList_().deleteSelected();
     var dialog = assert(this.$.dialog.getIfExists());
     dialog.close();
   },
 
   /** @private */
   onDialogCancelTap_: function() {
+    md_history.BrowserService.getInstance().recordAction(
+        'CancelRemoveSelected');
+
     var dialog = assert(this.$.dialog.getIfExists());
     dialog.close();
   },
 
   /**
    * Closes the overflow menu.
    * @private
    */
   closeMenu_: function() {
     var menu = this.$.sharedMenu.getIfExists();
@@ skipping 11 matching lines @@
   toggleMenu_: function(e) {
     var target = e.detail.target;
     return this.$.sharedMenu.get().then(function(menu) {
       /** @type {CrSharedMenuElement} */(menu).toggleMenu(
         target, e.detail);
     });
   },
 
   /** @private */
   onMoreFromSiteTap_: function() {
+    md_history.BrowserService.getInstance().recordAction(
+        'EntryMenuShowMoreFromSite');
+
     var menu = assert(this.$.sharedMenu.getIfExists());
     this.fire('search-domain', {domain: menu.itemData.item.domain});
     menu.closeMenu();
   },
 
   /** @private */
   onRemoveFromHistoryTap_: function() {
+    var browserService = md_history.BrowserService.getInstance();
+    browserService.recordAction('EntryMenuRemoveFromHistory');
     var menu = assert(this.$.sharedMenu.getIfExists());
     var itemData = menu.itemData;
-    md_history.BrowserService.getInstance()
-        .deleteItems([itemData.item])
+    browserService.deleteItems([itemData.item])
         .then(function(items) {
           this.getSelectedList_().removeItemsByPath([itemData.path]);
           // This unselect-all is to reset the toolbar when deleting a selected
           // item. TODO(tsergeant): Make this automatic based on observing list
           // modifications.
           this.fire('unselect-all');
         }.bind(this));
     menu.closeMenu();
   },
 
@@ skipping 47 matching lines @@
   },
 
   /**
    * Open a single synced tab. Listens to 'click' rather than 'tap'
    * to determine what modifier keys were pressed.
    * @param {DomRepeatClickEvent} e
    * @private
    */
   openTab_: function(e) {
     var tab = /** @type {ForeignSessionTab} */(e.model.tab);
-    md_history.BrowserService.getInstance().openForeignSessionTab(
+    var browserService = md_history.BrowserService.getInstance();
+    browserService.recordHistogram(
+        SYNCED_TABS_HISTOGRAM_NAME, SyncedTabsHistogram.LINK_CLICKED,
+        SyncedTabsHistogram.LIMIT);
+    browserService.openForeignSessionTab(
         this.sessionTag, tab.windowId, tab.sessionId, e);
     e.preventDefault();
   },
 
   /**
    * Toggles the dropdown display of synced tabs for each device card.
    */
   toggleTabCard: function() {
+    var histogramValue = this.$.collapse.opened ?
+        SyncedTabsHistogram.COLLAPSE_SESSION :
+        SyncedTabsHistogram.EXPAND_SESSION;
+
+    md_history.BrowserService.getInstance().recordHistogram(
+        SYNCED_TABS_HISTOGRAM_NAME, histogramValue,
+        SyncedTabsHistogram.LIMIT);
+
     this.$.collapse.toggle();
     this.$['dropdown-indicator'].icon =
         this.$.collapse.opened ? 'cr:expand-less' : 'cr:expand-more';
   },
 
   /**
    * When the synced tab information is set, the icon associated with the tab
    * website is also set.
    * @private
    */
@@ skipping 70 matching lines @@
      * @type {!Array<!ForeignDeviceInternal>}
      */
     syncedDevices_: {
       type: Array,
       value: function() { return []; }
     },
 
     /** @private */
     signInState: {
       type: Boolean,
-      // Updated on attach by chrome.sending 'otherDevicesInitialized'.
-      value: loadTimeData.getBoolean('isUserSignedIn'),
       observer: 'signInStateChanged_',
     },
 
     /** @private */
     guestSession_: {
       type: Boolean,
       value: loadTimeData.getBoolean('isGuestSession'),
     },
 
     /** @private */
     fetchingSyncedTabs_: {
       type: Boolean,
       value: false,
-    }
+    },
+
+    hasSeenForeignData_: Boolean,
   },
 
   listeners: {
     'toggle-menu': 'onToggleMenu_',
   },
 
   /** @override */
   attached: function() {
     // Update the sign in state.
     chrome.send('otherDevicesInitialized');
+    md_history.BrowserService.getInstance().recordHistogram(
+        SYNCED_TABS_HISTOGRAM_NAME, SyncedTabsHistogram.INITIALIZED,
+        SyncedTabsHistogram.LIMIT);
   },
 
   /**
    * @param {!ForeignSession} session
    * @return {!ForeignDeviceInternal}
    */
   createInternalDevice_: function(session) {
     var tabs = [];
     var separatorIndexes = [];
     for (var i = 0; i < session.windows.length; i++) {
@@ skipping 39 matching lines @@
   },
 
   onToggleMenu_: function(e) {
     this.$.menu.get().then(function(menu) {
       menu.toggleMenu(e.detail.target, e.detail.tag);
     });
   },
 
   onOpenAllTap_: function() {
     var menu = assert(this.$.menu.getIfExists());
-    md_history.BrowserService.getInstance().openForeignSessionAllTabs(
+    var browserService = md_history.BrowserService.getInstance();
+    browserService.recordHistogram(
+        SYNCED_TABS_HISTOGRAM_NAME, SyncedTabsHistogram.OPEN_ALL,
+        SyncedTabsHistogram.LIMIT);
+    browserService.openForeignSessionAllTabs(
         menu.itemData);
     menu.closeMenu();
   },
 
   onDeleteSessionTap_: function() {
     var menu = assert(this.$.menu.getIfExists());
-    md_history.BrowserService.getInstance().deleteForeignSession(
-        menu.itemData);
+    var browserService = md_history.BrowserService.getInstance();
+    browserService.recordHistogram(
+        SYNCED_TABS_HISTOGRAM_NAME, SyncedTabsHistogram.HIDE_FOR_NOW,
+        SyncedTabsHistogram.LIMIT);
+    browserService.deleteForeignSession(menu.itemData);
     menu.closeMenu();
   },
 
   /** @private */
   clearDisplayedSyncedDevices_: function() {
     this.syncedDevices_ = [];
   },
 
   /**
    * Decide whether or not should display no synced tabs message.
@@ skipping 45 matching lines @@
    * about updating individual tabs rather than replacing whole sessions, but
    * this approach seems to have acceptable performance.
    * @param {?Array<!ForeignSession>} sessionList
    */
   updateSyncedDevices: function(sessionList) {
     this.fetchingSyncedTabs_ = false;
 
     if (!sessionList)
       return;
 
+    if (sessionList.length > 0 && !this.hasSeenForeignData_) {
+      this.hasSeenForeignData_ = true;
+      md_history.BrowserService.getInstance().recordHistogram(
+        SYNCED_TABS_HISTOGRAM_NAME, SyncedTabsHistogram.HAS_FOREIGN_DATA,
+        SyncedTabsHistogram.LIMIT);
+    }
+
     // First, update any existing devices that have changed.
     var updateCount = Math.min(sessionList.length, this.syncedDevices_.length);
     for (var i = 0; i < updateCount; i++) {
       var oldDevice = this.syncedDevices_[i];
       if (oldDevice.tag != sessionList[i].tag ||
           oldDevice.timestamp != sessionList[i].timestamp) {
         this.splice(
             'syncedDevices_', i, 1, this.createInternalDevice_(sessionList[i]));
       }
     }
@@ skipping 11 matching lines @@
     this.fetchingSyncedTabs_ = false;
     this.clearDisplayedSyncedDevices_();
   },
 
   /**
    * Get called when user's sign in state changes, this will affect UI of synced
    * tabs page. Sign in promo gets displayed when user is signed out, and
    * different messages are shown when there are no synced tabs.
    * @param {boolean} signInState
    */
-  signInStateChanged_: function(signInState) {
+  signInStateChanged_: function() {
     this.fire('history-view-changed');
 
     // User signed out, clear synced device list and show the sign in promo.
-    if (!signInState) {
+    if (!this.signInState) {
       this.clearDisplayedSyncedDevices_();
       return;
     }
     // User signed in, show the loading message when querying for synced
     // devices.
     this.fetchingSyncedTabs_ = true;
   },
 
   searchTermChanged: function(searchTerm) {
     this.clearDisplayedSyncedDevices_();
@@ skipping 92 matching lines @@
    * @private
    */
   onSelectorActivate_: function() { this.fire('history-close-drawer'); },
 
   /**
    * Relocates the user to the clear browsing data section of the settings page.
    * @param {Event} e
    * @private
    */
   onClearBrowsingDataTap_: function(e) {
-    md_history.BrowserService.getInstance().recordAction(
-        'HistoryPage_InitClearBrowsingData');
-    md_history.BrowserService.getInstance().openClearBrowsingData();
+    var browserService = md_history.BrowserService.getInstance();
+    browserService.getInstance().recordAction('InitClearBrowsingData');
+    browserService.openClearBrowsingData();
     e.preventDefault();
   },
 
   /**
    * @param {Object} route
    * @private
    */
   getQueryString_: function(route) { return window.location.search; }
 });
 // Copyright 2016 The Chromium Authors. All rights reserved.
@@ skipping 26 matching lines @@
           searchTerm: '',
           // TODO(calamity): Make history toolbar buttons change the offset
           groupedOffset: 0,
 
           set range(val) { this._range = Number(val); },
           get range() { return this._range; },
         };
       }
     },
 
-   /** @type {!QueryResult} */
+    /** @type {!QueryResult} */
     queryResult_: {
       type: Object,
       value: function() {
         return {
           info: null,
           results: null,
           sessionList: null,
         };
       }
     },
 
     // Route data for the current page.
     routeData_: Object,
 
     // The query params for the page.
     queryParams_: Object,
 
     // True if the window is narrow enough for the page to have a drawer.
     hasDrawer: Boolean,
+
+    isUserSignedIn_: {
+      type: Boolean,
+      // Updated on synced-device-manager attach by chrome.sending
+      // 'otherDevicesInitialized'.
+      value: loadTimeData.getBoolean('isUserSignedIn'),
+    },
   },
 
   observers: [
     // routeData_.page <=> selectedPage
     'routeDataChanged_(routeData_.page)',
     'selectedPageChanged_(selectedPage_)',
 
     // queryParams_.q <=> queryState.searchTerm
     'searchTermChanged_(queryState_.searchTerm)',
     'searchQueryParamChanged_(queryParams_.q)',
@@ skipping 50 matching lines @@
    * @private
    */
   unselectAll: function() {
     var listContainer =
         /** @type {HistoryListContainerElement} */ (this.$.history);
     var toolbar = /** @type {HistoryToolbarElement} */ (this.$.toolbar);
     listContainer.unselectAllItems(toolbar.count);
     toolbar.count = 0;
   },
 
-  deleteSelected: function() {
-    this.$.history.deleteSelectedWithPrompt();
-  },
+  deleteSelected: function() { this.$.history.deleteSelectedWithPrompt(); },
 
   /**
    * @param {HistoryQuery} info An object containing information about the
    *    query.
    * @param {!Array<HistoryEntry>} results A list of results.
    */
   historyResult: function(info, results) {
     this.set('queryState_.querying', false);
     this.set('queryResult_.info', info);
     this.set('queryResult_.results', results);
     var listContainer =
         /** @type {HistoryListContainerElement} */ (this.$['history']);
     listContainer.historyResult(info, results);
   },
 
   /**
    * Focuses the search bar in the toolbar.
    */
-  focusToolbarSearchField: function() {
-    this.$.toolbar.showSearchField();
-  },
+  focusToolbarSearchField: function() { this.$.toolbar.showSearchField(); },
 
   /**
    * Fired when the user presses 'More from this site'.
    * @param {{detail: {domain: string}}} e
    */
   searchDomain_: function(e) { this.$.toolbar.setSearchTerm(e.detail.domain); },
 
   /**
    * @param {Event} e
    * @private
@@ skipping 13 matching lines @@
     }
   },
 
   /**
    * @param {string} searchTerm
    * @private
    */
   searchTermChanged_: function(searchTerm) {
     this.set('queryParams_.q', searchTerm || null);
     this.$['history'].queryHistory(false);
+    // TODO(tsergeant): Ignore incremental searches in this metric.
+    if (this.queryState_.searchTerm)
+      md_history.BrowserService.getInstance().recordAction('Search');
   },
 
   /**
    * @param {string} searchQuery
    * @private
    */
   searchQueryParamChanged_: function(searchQuery) {
     this.$.toolbar.setSearchTerm(searchQuery || '');
   },
 
@@ skipping 24 matching lines @@
     }
 
     this.set('queryResult_.sessionList', sessionList);
   },
 
   /**
    * Update sign in state of synced device manager after user logs in or out.
    * @param {boolean} isUserSignedIn
    */
   updateSignInState: function(isUserSignedIn) {
-    var syncedDeviceManagerElem =
-      /** @type {HistorySyncedDeviceManagerElement} */this
-          .$$('history-synced-device-manager');
-    if (syncedDeviceManagerElem)
-      syncedDeviceManagerElem.signInState = isUserSignedIn;
+    this.isUserSignedIn_ = isUserSignedIn;
   },
 
   /**
    * @param {string} selectedPage
    * @return {boolean}
    * @private
    */
   syncedTabsSelected_: function(selectedPage) {
     return selectedPage == 'syncedTabs';
   },
 
   /**
    * @param {boolean} querying
    * @param {boolean} incremental
    * @param {string} searchTerm
    * @return {boolean} Whether a loading spinner should be shown (implies the
    *     backend is querying a new search term).
    * @private
    */
   shouldShowSpinner_: function(querying, incremental, searchTerm) {
     return querying && !incremental && searchTerm != '';
   },
 
   /**
    * @param {string} page
    * @private
    */
-  routeDataChanged_: function(page) {
-    this.selectedPage_ = page;
-  },
+  routeDataChanged_: function(page) { this.selectedPage_ = page; },
 
   /**
    * @param {string} selectedPage
    * @private
    */
   selectedPageChanged_: function(selectedPage) {
     this.set('routeData_.page', selectedPage);
-
-    // Log the current view on the next animation frame to allow the iron-pages
-    // to detect that the synced-device-manager has been rendered.
-    requestAnimationFrame(function() {
-      this.recordHistoryView_();
-    }.bind(this));
+    this.recordHistoryView_();
   },
 
   /**
    * This computed binding is needed to make the iron-pages selector update when
    * the synced-device-manager is instantiated for the first time. Otherwise the
    * fallback selection will continue to be used after the corresponding item is
    * added as a child of iron-pages.
    * @param {string} selectedPage
    * @param {Array} items
    * @return {string}
    * @private
    */
-  getSelectedPage_: function(selectedPage, items) {
-    return selectedPage;
-  },
+  getSelectedPage_: function(selectedPage, items) { return selectedPage; },
 
   /** @private */
   closeDrawer_: function() {
     var drawer = this.$$('#drawer');
     if (drawer)
       drawer.close();
   },
 
   /** @private */
   recordHistoryView_: function() {
     var histogramValue = HistoryViewHistogram.END;
-    switch (this.$.content.selectedItem.id) {
-      case 'history':
+    switch (this.selectedPage_) {
+      case 'syncedTabs':
+        histogramValue = this.isUserSignedIn_ ?
+            HistoryViewHistogram.SYNCED_TABS :
+            HistoryViewHistogram.SIGNIN_PROMO;
+        break;
+      default:
         switch (this.queryState_.range) {
           case HistoryRange.ALL_TIME:
             histogramValue = HistoryViewHistogram.HISTORY;
             break;
           case HistoryRange.WEEK:
             histogramValue = HistoryViewHistogram.GROUPED_WEEK;
             break;
           case HistoryRange.MONTH:
             histogramValue = HistoryViewHistogram.GROUPED_MONTH;
             break;
         }
         break;
-      case 'synced-devices':
-        var syncedDeviceManager =
-            /** @type {HistorySyncedDeviceManagerElement} */ this.$.content
-                .selectedItem;
-        histogramValue = syncedDeviceManager.signInState ?
-            HistoryViewHistogram.SYNCED_TABS :
-            HistoryViewHistogram.SIGNIN_PROMO;
-        break;
     }
 
     md_history.BrowserService.getInstance().recordHistogram(
       'History.HistoryView', histogramValue, HistoryViewHistogram.END
     );
   },
 });