DevTools: Do not show heap snapshot comparison when there's just one snapshot.

third_party/WebKit/Source/devtools/front_end/profiler/HeapSnapshotView.js

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 23 matching lines @@
  */
 Profiler.HeapSnapshotView = class extends UI.SimpleView {
   /**
    * @param {!Profiler.ProfileType.DataDisplayDelegate} dataDisplayDelegate
    * @param {!Profiler.HeapProfileHeader} profile
    */
   constructor(dataDisplayDelegate, profile) {
     super(Common.UIString('Heap Snapshot'));
 
     this.element.classList.add('heap-snapshot-view');
+    this._profile = profile;
 
     profile.profileType().addEventListener(
         Profiler.HeapSnapshotProfileType.SnapshotReceived, this._onReceiveSnapshot, this);
     profile.profileType().addEventListener(
         Profiler.ProfileType.Events.RemoveProfileHeader, this._onProfileHeaderRemoved, this);
 
     var isHeapTimeline = profile.profileType().id === Profiler.TrackingHeapSnapshotProfileType.TypeId;
     if (isHeapTimeline) {
       this._trackingOverviewGrid = new Profiler.HeapTrackingOverviewGrid(profile);
       this._trackingOverviewGrid.addEventListener(
@@ skipping 62 matching lines @@
       this._objectDetailsView.element.appendChild(retainmentViewHeader);
       this._retainmentWidget.show(this._objectDetailsView.element);
     }
     this._splitWidget.hideDefaultResizer();
     this._splitWidget.installResizer(splitWidgetResizer);
 
     this._retainmentDataGrid.addEventListener(UI.DataGrid.Events.SelectedNode, this._inspectedObjectChanged, this);
     this._retainmentDataGrid.reset();
 
     this._perspectives = [];
+    this._comparisonPerspective = new Profiler.HeapSnapshotView.ComparisonPerspective();
     this._perspectives.push(new Profiler.HeapSnapshotView.SummaryPerspective());
     if (profile.profileType() !== Profiler.ProfileTypeRegistry.instance.trackingHeapSnapshotProfileType)
-      this._perspectives.push(new Profiler.HeapSnapshotView.ComparisonPerspective());
+      this._perspectives.push(this._comparisonPerspective);
     this._perspectives.push(new Profiler.HeapSnapshotView.ContainmentPerspective());
     if (this._allocationWidget)
       this._perspectives.push(new Profiler.HeapSnapshotView.AllocationPerspective());
     this._perspectives.push(new Profiler.HeapSnapshotView.StatisticsPerspective());
 
     this._perspectiveSelect = new UI.ToolbarComboBox(this._onSelectedPerspectiveChanged.bind(this));
-    for (var i = 0; i < this._perspectives.length; ++i)
-      this._perspectiveSelect.createOption(this._perspectives[i].title());
-
-    this._profile = profile;
+    this._updatePerspectiveOptions();
 
     this._baseSelect = new UI.ToolbarComboBox(this._changeBase.bind(this));
     this._baseSelect.setVisible(false);
     this._updateBaseOptions();
 
     this._filterSelect = new UI.ToolbarComboBox(this._changeFilter.bind(this));
     this._filterSelect.setVisible(false);
     this._updateFilterOptions();
 
     this._classNameFilter = new UI.ToolbarInput('Class filter');
@@ skipping 333 matching lines @@
         this._allocationStackView.clear();
       this._retainmentDataGrid.reset();
     }
   }
 
   /**
    * @param {string} perspectiveTitle
    * @param {function()} callback
    */
   _changePerspectiveAndWait(perspectiveTitle, callback) {
-    var perspectiveIndex = null;
-    for (var i = 0; i < this._perspectives.length; ++i) {
-      if (this._perspectives[i].title() === perspectiveTitle) {
-        perspectiveIndex = i;
-        break;
-      }
-    }
-    if (this._currentPerspectiveIndex === perspectiveIndex || perspectiveIndex === null) {
+    const perspectiveIndex = this._perspectives.findIndex(perspective => perspective.title() === perspectiveTitle);
+    if (perspectiveIndex === -1 || this._currentPerspectiveIndex === perspectiveIndex) {
       setTimeout(callback, 0);
       return;
     }
 
     /**
+     * @param {!Common.Event} event
      * @this {Profiler.HeapSnapshotView}
      */
     function dataGridContentShown(event) {
       var dataGrid = event.data;
       dataGrid.removeEventListener(
           Profiler.HeapSnapshotSortableDataGrid.Events.ContentShown, dataGridContentShown, this);
       if (dataGrid === this._dataGrid)
         callback();
     }
     this._perspectives[perspectiveIndex].masterGrid(this).addEventListener(
         Profiler.HeapSnapshotSortableDataGrid.Events.ContentShown, dataGridContentShown, this);
 
-    this._perspectiveSelect.setSelectedIndex(perspectiveIndex);
+    const option = this._perspectiveSelect.options().find(option => option.value === perspectiveIndex);

[caseq, 2016/12/14 00:43:37]

nit: I'd rather have a perspective option associated with perspective with a
symbol instead of using option values here.

[alph, 2016/12/14 22:38:55]

I tried that, and it doesn't seem to make the code more clear. So I'll keep the
current one.

+    this._perspectiveSelect.select(/** @type {!Element} */ (option));
     this._changePerspective(perspectiveIndex);
   }
 
   _updateDataSourceAndView() {
     var dataGrid = this._dataGrid;
     if (!dataGrid || dataGrid.snapshot)
       return;
 
     this._profile._loadPromise.then(didLoadSnapshot.bind(this));
 
@@ skipping 15 matching lines @@
     /**
      * @this {Profiler.HeapSnapshotView}
      */
     function didLoadBaseSnapshot(baseSnapshotProxy) {
       if (this._diffDataGrid.baseSnapshot !== baseSnapshotProxy)
         this._diffDataGrid.setBaseDataSource(baseSnapshotProxy);
     }
   }
 
   _onSelectedPerspectiveChanged(event) {
-    this._changePerspective(event.target.selectedIndex);
+    this._changePerspective(event.target.selectedOptions[0].value);
   }
 
   /**
    * @param {number} selectedIndex
    */
   _changePerspective(selectedIndex) {
     if (selectedIndex === this._currentPerspectiveIndex)
       return;
 
     this._currentPerspectiveIndex = selectedIndex;
@@ skipping 56 matching lines @@
   }
 
   _resolveObjectForPopover(element, showCallback, objectGroupName) {
     if (!this._profile.target())
       return;
     if (!element.node)
       return;
     element.node.queryObjectContent(this._profile.target(), showCallback, objectGroupName);
   }
 
+  _updatePerspectiveOptions() {
+    const multipleSnapshots = this._profiles().length > 1;
+    this._perspectiveSelect.removeOptions();
+    this._perspectives.forEach((perspective, index) => {
+      if (multipleSnapshots || perspective !== this._comparisonPerspective)
+        this._perspectiveSelect.createOption(perspective.title(), '', String(index));
+    });
+  }
+
   _updateBaseOptions() {
     var list = this._profiles();
     // We're assuming that snapshots can only be added.
     if (this._baseSelect.size() === list.length)
       return;
 
     for (var i = this._baseSelect.size(), n = list.length; i < n; ++i) {
       var title = list[i].title;
       this._baseSelect.createOption(title);
     }
@@ skipping 12 matching lines @@
       var title = list[i].title;
       if (!i)
         title = Common.UIString('Objects allocated before %s', title);
       else
         title = Common.UIString('Objects allocated between %s and %s', list[i - 1].title, title);
       this._filterSelect.createOption(title);
     }
   }
 
   _updateControls() {
+    this._updatePerspectiveOptions();
     this._updateBaseOptions();
     this._updateFilterOptions();
   }
 
   /**
    * @param {!Common.Event} event
    */
   _onReceiveSnapshot(event) {
     this._updateControls();
   }
@@ skipping 94 matching lines @@
   /**
    * @override
    * @param {!Profiler.HeapSnapshotView} heapSnapshotView
    */
   activate(heapSnapshotView) {
     heapSnapshotView._splitWidget.setMainWidget(heapSnapshotView._constructorsWidget);
     heapSnapshotView._splitWidget.setSidebarWidget(heapSnapshotView._objectDetailsView);
     heapSnapshotView._splitWidget.show(heapSnapshotView._searchableView.element);
     heapSnapshotView._filterSelect.setVisible(true);
     heapSnapshotView._classNameFilter.setVisible(true);
-    if (heapSnapshotView._trackingOverviewGrid) {
-      heapSnapshotView._trackingOverviewGrid.show(
-          heapSnapshotView._searchableView.element, heapSnapshotView._splitWidget.element);
-      heapSnapshotView._trackingOverviewGrid.update();
-      heapSnapshotView._trackingOverviewGrid._updateGrid();
-    }
+    if (!heapSnapshotView._trackingOverviewGrid)
+      return;
+    heapSnapshotView._trackingOverviewGrid.show(
+        heapSnapshotView._searchableView.element, heapSnapshotView._splitWidget.element);
+    heapSnapshotView._trackingOverviewGrid.update();
+    heapSnapshotView._trackingOverviewGrid._updateGrid();
   }
 
   /**
    * @override
    * @param {!Profiler.HeapSnapshotView} heapSnapshotView
    * @return {?UI.DataGrid}
    */
   masterGrid(heapSnapshotView) {
     return heapSnapshotView._constructorsDataGrid;
   }
@@ skipping 1299 matching lines @@
       var name = frameDiv.createChild('div');
       name.textContent = UI.beautifyFunctionName(frame.functionName);
       if (frame.scriptId) {
         var urlElement = this._linkifier.linkifyScriptLocation(
             this._target, String(frame.scriptId), frame.scriptName, frame.line - 1, frame.column - 1);
         frameDiv.appendChild(urlElement);
       }
     }
   }
 };