Timeline: do not start timeline on regular page reloads

third_party/WebKit/Source/devtools/front_end/timeline/TimelinePanel.js

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  * Copyright (C) 2012 Intel 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.
@@ skipping 28 matching lines @@
     super('timeline');
     this.registerRequiredCSS('timeline/timelinePanel.css');
     this.element.addEventListener('contextmenu', this._contextMenu.bind(this), false);
     this._dropTarget = new UI.DropTarget(
         this.element, [UI.DropTarget.Types.Files, UI.DropTarget.Types.URIList],
         Common.UIString('Drop timeline file or URL here'), this._handleDrop.bind(this));
 
     /** @type {!Array<!UI.ToolbarItem>} */
     this._recordingOptionUIControls = [];
     this._state = Timeline.TimelinePanel.State.Idle;
+    this._recordingPageReload = false;
     this._windowStartTime = 0;
     this._windowEndTime = Infinity;
     this._millisecondsToRecordAfterLoadEvent = 3000;
     this._toggleRecordAction =
         /** @type {!UI.Action }*/ (UI.actionRegistry.action('timeline.toggle-recording'));
 
     /** @type {!Array<!TimelineModel.TimelineModelFilter>} */
     this._filters = [];
     if (!Runtime.experiments.isEnabled('timelineShowAllEvents')) {
       this._filters.push(Timeline.TimelineUIUtils.visibleEventsFilter());
@@ skipping 39 matching lines @@
         PerfUI.TimelineOverviewPane.Events.WindowChanged, this._onWindowChanged.bind(this));
     this._overviewPane.show(topPaneElement);
     /** @type {!Array<!Timeline.TimelineEventOverview>} */
     this._overviewControls = [];
 
     this._statusPaneContainer = this._timelinePane.element.createChild('div', 'status-pane-container fill');
 
     this._createFileSelector();
 
     SDK.targetManager.addModelListener(
-        SDK.ResourceTreeModel, SDK.ResourceTreeModel.Events.PageReloadRequested, this._pageReloadRequested, this);
-    SDK.targetManager.addModelListener(
         SDK.ResourceTreeModel, SDK.ResourceTreeModel.Events.Load, this._loadEventFired, this);
 
     if (Runtime.experiments.isEnabled('timelineMultipleMainViews')) {
       var viewMode = Timeline.TimelinePanel.ViewMode;
       this._tabbedPane = new UI.TabbedPane();
       this._tabbedPane.appendTab(viewMode.FlameChart, Common.UIString('Flame Chart'), new UI.VBox());
       this._tabbedPane.appendTab(viewMode.BottomUp, Common.UIString('Bottom-Up'), new UI.VBox());
       this._tabbedPane.appendTab(viewMode.CallTree, Common.UIString('Call Tree'), new UI.VBox());
       this._tabbedPane.appendTab(viewMode.EventLog, Common.UIString('Event Log'), new UI.VBox());
       this._tabbedPane.addEventListener(UI.TabbedPane.Events.TabSelected, this._onMainViewChanged.bind(this));
@@ skipping 90 matching lines @@
    */
   _createSettingCheckbox(setting, tooltip) {
     const checkboxItem = new UI.ToolbarSettingCheckbox(setting, tooltip);
     this._recordingOptionUIControls.push(checkboxItem);
     return checkboxItem;
   }
 
   _populateToolbar() {
     // Record
     this._panelToolbar.appendToolbarItem(UI.Toolbar.createActionButton(this._toggleRecordAction));
-    this._panelToolbar.appendToolbarItem(UI.Toolbar.createActionButtonForId('main.reload'));
+    this._panelToolbar.appendToolbarItem(UI.Toolbar.createActionButtonForId('timeline.record-reload'));
     this._clearButton = new UI.ToolbarButton(Common.UIString('Clear'), 'largeicon-clear');
     this._clearButton.addEventListener(UI.ToolbarButton.Events.Click, () => this._clear());
     this._panelToolbar.appendToolbarItem(this._clearButton);
     this._panelToolbar.appendSeparator();
 
     // View
     this._panelToolbar.appendSeparator();
     this._showScreenshotsToolbarCheckbox =
         this._createSettingCheckbox(this._showScreenshotsSetting, Common.UIString('Capture screenshots'));
     this._panelToolbar.appendToolbarItem(this._showScreenshotsToolbarCheckbox);
@@ skipping 269 matching lines @@
   }
 
   /**
    * @param {boolean} enabled
    */
   _setUIControlsEnabled(enabled) {
     this._recordingOptionUIControls.forEach(control => control.setEnabled(enabled));
   }
 
   /**
-   * @param {!SDK.TracingManager} tracingManager
-   * @param {boolean} userInitiated
    * @return {!Promise}
    */
-  _startRecording(tracingManager, userInitiated) {
+  _startRecording() {
+    var tracingManagers = SDK.targetManager.models(SDK.TracingManager);
+    if (!tracingManagers.length)
+      return Promise.resolve();
+
     console.assert(!this._statusPane, 'Status pane is already opened.');
     this._setState(Timeline.TimelinePanel.State.StartPending);
     this._showRecordingStarted();
 
-    this._autoRecordGeneration = userInitiated ? null : {tracingManager: tracingManager};
     var enabledTraceProviders = Extensions.extensionServer.traceProviders().filter(
         provider => Timeline.TimelinePanel._settingForTraceProvider(provider).get());
 
     const recordingOptions = {
       enableJSSampling: !this._disableCaptureJSProfileSetting.get(),
       capturePictures: this._captureLayersAndPicturesSetting.get(),
       captureFilmStrip: this._showScreenshotsSetting.get()
     };
 
     this._pendingPerformanceModel = new Timeline.PerformanceModel();
-    this._controller = new Timeline.TimelineController(tracingManager, this._pendingPerformanceModel, this);
-    Host.userMetrics.actionTaken(
-        userInitiated ? Host.UserMetrics.Action.TimelineStarted : Host.UserMetrics.Action.TimelinePageReloadStarted);
+    this._controller = new Timeline.TimelineController(tracingManagers[0], this._pendingPerformanceModel, this);
+    Host.userMetrics.actionTaken(Host.UserMetrics.Action.TimelineStarted);
     this._setUIControlsEnabled(false);
     this._hideLandingPage();
     return this._controller.startRecording(recordingOptions, enabledTraceProviders)
         .then(() => this._recordingStarted());
   }
 
   _stopRecording() {
     if (this._statusPane) {
       this._statusPane.finish();
       this._statusPane.updateStatus(Common.UIString('Stopping timeline\u2026'));
       this._statusPane.updateProgressBar(Common.UIString('Received'), 0);
     }
     this._setState(Timeline.TimelinePanel.State.StopPending);
-    this._autoRecordGeneration = null;
     this._controller.stopRecording();
     this._controller = null;
     this._setUIControlsEnabled(true);
   }
 
   _onSuspendStateChanged() {
     this._updateTimelineControls();
   }
 
   _updateTimelineControls() {
     var state = Timeline.TimelinePanel.State;
     this._toggleRecordAction.setToggled(this._state === state.Recording);
     this._toggleRecordAction.setEnabled(this._state === state.Recording || this._state === state.Idle);
     this._clearButton.setEnabled(this._state === state.Idle);
     this._panelToolbar.setEnabled(this._state !== state.Loading);
     this._dropTarget.setEnabled(this._state === state.Idle);
   }
 
   _toggleRecording() {
     if (this._state === Timeline.TimelinePanel.State.Idle) {
-      var tracingManagers = SDK.targetManager.models(SDK.TracingManager);
-      if (tracingManagers.length)
-        this._startRecording(tracingManagers[0], true);
+      this._recordingPageReload = false;
+      this._startRecording();
     } else if (this._state === Timeline.TimelinePanel.State.Recording) {
       this._stopRecording();
     }
   }
 
+  _recordReload() {
+    if (this._state !== Timeline.TimelinePanel.State.Idle)
+      return;
+    this._recordingPageReload = true;
+    this._startRecording();
+  }
+
   _clear() {
     this._showLandingPage();
     this._reset();
   }
 
   _reset() {
     PerfUI.LineLevelProfile.instance().reset();
     this._setModel(null);
     delete this._selection;
   }
@@ skipping 25 matching lines @@
       this.requestWindowTimes(0, Infinity);
     }
     this._overviewPane.scheduleUpdate();
 
     this.select(null);
     if (this._flameChart)
       this._flameChart.resizeToPreferredHeights();
   }
 
   _recordingStarted() {
+    if (this._recordingPageReload) {
+      var target = this._controller.mainTarget();
+      var resourceModel = target.model(SDK.ResourceTreeModel);
+      if (resourceModel)
+        resourceModel.reloadPage();
+    }
     this._reset();
     this._setState(Timeline.TimelinePanel.State.Recording);
     this._showRecordingStarted();
     this._statusPane.updateStatus(Common.UIString('Profiling\u2026'));
     this._statusPane.updateProgressBar(Common.UIString('Buffer usage'), 0);
     this._statusPane.startTimer();
     this._hideLandingPage();
   }
 
   /**
@@ skipping 30 matching lines @@
     var recordKey =
         encloseWithTag('b', UI.shortcutRegistry.shortcutDescriptorsForAction('timeline.toggle-recording')[0].name);
     var reloadKey = encloseWithTag('b', UI.shortcutRegistry.shortcutDescriptorsForAction('main.reload')[0].name);
     var navigateNode = encloseWithTag('b', Common.UIString('WASD'));
 
     this._landingPage = new UI.VBox();
     this._landingPage.contentElement.classList.add('timeline-landing-page', 'fill');
     var centered = this._landingPage.contentElement.createChild('div');
 
     var recordButton = UI.createInlineButton(UI.Toolbar.createActionButton(this._toggleRecordAction));
-    var reloadButton = UI.createInlineButton(UI.Toolbar.createActionButtonForId('main.reload'));
+    var reloadButton = UI.createInlineButton(UI.Toolbar.createActionButtonForId('timeline.record-reload'));
 
     centered.createChild('p').appendChild(UI.formatLocalized(
         'Click the record button %s or hit %s to capture a new recording.\n' +
         'Click the reload button %s or hit %s to record and evaluate the page load.',
         [recordButton, recordKey, reloadButton, reloadKey]));
 
     centered.createChild('p').appendChild(UI.formatLocalized(
         'After recording, select an area of interest in the overview by dragging.\n' +
         'Then, zoom and pan the timeline with the mousewheel or %s keys.\n%s',
         [navigateNode, learnMoreNode]));
@@ skipping 105 matching lines @@
       if (event.name === recordTypes.TimeStamp || event.name === recordTypes.ConsoleTime)
         continue;
       markers.set(event.startTime, Timeline.TimelineUIUtils.createEventDivider(event, zeroTime));
     }
     this._overviewPane.setMarkers(markers);
   }
 
   /**
    * @param {!Common.Event} event
    */
-  _pageReloadRequested(event) {
-    if (this._state !== Timeline.TimelinePanel.State.Idle || !this.isShowing())
-      return;
-    var resourceTreeModel = /** @type {!SDK.ResourceTreeModel} */ (event.data);
-    var tracingManager = resourceTreeModel.target().model(SDK.TracingManager);
-    if (resourceTreeModel.target() !== SDK.targetManager.mainTarget() || !tracingManager)
-      return;
-
-    resourceTreeModel.suspendReload();
-    this._startRecording(tracingManager, false).then(() => resourceTreeModel.resumeReload());
-  }
-
-  /**
-   * @param {!Common.Event} event
-   */
   _loadEventFired(event) {
-    if (this._state !== Timeline.TimelinePanel.State.Recording || !this._autoRecordGeneration ||
-        this._autoRecordGeneration.tracingManager.target() !== event.data.resourceTreeModel.target())
+    if (this._state !== Timeline.TimelinePanel.State.Recording || !this._recordingPageReload ||
+        this._controller.mainTarget() !== event.data.resourceTreeModel.target())
       return;
-    setTimeout(stopRecordingOnReload.bind(this, this._autoRecordGeneration), this._millisecondsToRecordAfterLoadEvent);
+    setTimeout(stopRecordingOnReload.bind(this, this._controller), this._millisecondsToRecordAfterLoadEvent);

[alph, 2017/05/15 23:56:45]

await sleep(...)

 
     /**
+     * @param {!Timeline.TimelineController} controller
      * @this {Timeline.TimelinePanel}
-     * @param {!Object} recordGeneration
      */
-    function stopRecordingOnReload(recordGeneration) {
+    function stopRecordingOnReload(controller) {
       // Check if we're still in the same recording session.
-      if (this._state !== Timeline.TimelinePanel.State.Recording || this._autoRecordGeneration !== recordGeneration)
+      if (controller !== this._controller)
         return;
+      this._recordingPageReload = false;
       this._stopRecording();
     }
   }
 
   /**
    * @param {!Timeline.TimelineSelection} selection
    * @return {?TimelineModel.TimelineFrame}
    */
   _frameForSelection(selection) {
     switch (selection.type()) {
@@ skipping 452 matching lines @@
    * @param {string} actionId
    * @return {boolean}
    */
   handleAction(context, actionId) {
     var panel = UI.context.flavor(Timeline.TimelinePanel);
     console.assert(panel && panel instanceof Timeline.TimelinePanel);
     switch (actionId) {
       case 'timeline.toggle-recording':
         panel._toggleRecording();
         return true;
+      case 'timeline.record-reload':
+        panel._recordReload();
+        return true;
       case 'timeline.save-to-file':
         panel._saveToFile();
         return true;
       case 'timeline.load-from-file':
         panel._selectFileToLoad();
         return true;
       case 'timeline.jump-to-previous-frame':
         panel._jumpToFrame(-1);
         return true;
       case 'timeline.jump-to-next-frame':
         panel._jumpToFrame(1);
         return true;
     }
     return false;
   }
 };
 
 Timeline.TimelinePanel._traceProviderSettingSymbol = Symbol('traceProviderSetting');