DevTools: show filesystem file by default

third_party/WebKit/Source/devtools/front_end/sources/JavaScriptSourceFrame.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 19 matching lines @@
 
 /**
  * @unrestricted
  */
 Sources.JavaScriptSourceFrame = class extends Sources.UISourceCodeFrame {
   /**
    * @param {!Workspace.UISourceCode} uiSourceCode
    */
   constructor(uiSourceCode) {
     super(uiSourceCode);
+    this._debuggerSourceCode = uiSourceCode;
 
     this._scriptsPanel = Sources.SourcesPanel.instance();
     this._breakpointManager = Bindings.breakpointManager;
     if (uiSourceCode.project().type() === Workspace.projectTypes.Debugger)
       this.element.classList.add('source-frame-debugger-script');
 
     this._popoverHelper = new Components.ObjectPopoverHelper(
         this._scriptsPanel.element, this._getPopoverAnchor.bind(this), this._resolveObjectForPopover.bind(this),
         this._onHidePopover.bind(this), true);
     this._popoverHelper.setTimeout(250, 250);
 
     this.textEditor.element.addEventListener('keydown', this._onKeyDown.bind(this), true);
 
     this.textEditor.addEventListener(
         SourceFrame.SourcesTextEditor.Events.GutterClick, this._handleGutterClick.bind(this), this);
 
     this._breakpointManager.addEventListener(
         Bindings.BreakpointManager.Events.BreakpointAdded, this._breakpointAdded, this);
     this._breakpointManager.addEventListener(
         Bindings.BreakpointManager.Events.BreakpointRemoved, this._breakpointRemoved, this);
 
     this.uiSourceCode().addEventListener(
-        Workspace.UISourceCode.Events.SourceMappingChanged, this._onSourceMappingChanged, this);
-    this.uiSourceCode().addEventListener(
         Workspace.UISourceCode.Events.WorkingCopyChanged, this._workingCopyChanged, this);
     this.uiSourceCode().addEventListener(
         Workspace.UISourceCode.Events.WorkingCopyCommitted, this._workingCopyCommitted, this);
     this.uiSourceCode().addEventListener(
         Workspace.UISourceCode.Events.TitleChanged, this._showBlackboxInfobarIfNeeded, this);
 
     /** @type {!Set<!Sources.JavaScriptSourceFrame.BreakpointDecoration>} */
     this._breakpointDecorations = new Set();
     /** @type {!Map<!Bindings.BreakpointManager.Breakpoint, !Sources.JavaScriptSourceFrame.BreakpointDecoration>} */
     this._decorationByBreakpoint = new Map();
 
     /** @type {!Map.<!SDK.Target, !Bindings.ResourceScriptFile>}*/
     this._scriptFileForTarget = new Map();
-    var targets = SDK.targetManager.targets();
-    for (var i = 0; i < targets.length; ++i) {
-      var scriptFile = Bindings.debuggerWorkspaceBinding.scriptFile(uiSourceCode, targets[i]);
-      if (scriptFile)
-        this._updateScriptFile(targets[i]);
-    }
-
-    if (this._scriptFileForTarget.size || uiSourceCode.extension() === 'js' ||
-        uiSourceCode.project().type() === Workspace.projectTypes.Snippets)
-      this._compiler = new Sources.JavaScriptCompiler(this);
 
     Common.moduleSetting('skipStackFramesPattern').addChangeListener(this._showBlackboxInfobarIfNeeded, this);
     Common.moduleSetting('skipContentScripts').addChangeListener(this._showBlackboxInfobarIfNeeded, this);
-    this._showBlackboxInfobarIfNeeded();
+
     /** @type {!Map.<number, !Element>} */
     this._valueWidgets = new Map();
+    this.onBindingChanged();
   }
 
   /**
    * @override
    * @return {!Array<!UI.ToolbarItem>}
    */
   syncToolbarItems() {
     var result = super.syncToolbarItems();
-    var originURL = Bindings.CompilerScriptMapping.uiSourceCodeOrigin(this.uiSourceCode());
+    var originURL = Bindings.CompilerScriptMapping.uiSourceCodeOrigin(this._debuggerSourceCode);
     if (originURL) {
       var parsedURL = originURL.asParsedURL();
       if (parsedURL)
         result.push(new UI.ToolbarText(Common.UIString('(source mapped from %s)', parsedURL.displayName)));
     }
 
     if (this.uiSourceCode().project().type() === Workspace.projectTypes.Snippets) {
       result.push(new UI.ToolbarSeparator(true));
       var runSnippet = UI.Toolbar.createActionButtonForId('debugger.run-snippet');
       runSnippet.setText(Host.isMac() ? Common.UIString('\u2318+Enter') : Common.UIString('Ctrl+Enter'));
       result.push(runSnippet);
     }
 
     return result;
   }
 
   _showBlackboxInfobarIfNeeded() {
-    var uiSourceCode = this.uiSourceCode();
+    var uiSourceCode = this._debuggerSourceCode;
     if (!uiSourceCode.contentType().hasScripts())
       return;
     var projectType = uiSourceCode.project().type();
     if (!Bindings.blackboxManager.isBlackboxedUISourceCode(uiSourceCode)) {
       this._hideBlackboxInfobar();
       return;
     }
 
     if (this._blackboxInfobar)
       this._blackboxInfobar.dispose();
@@ skipping 72 matching lines @@
 
   /**
    * @override
    * @return {!Promise}
    */
   populateLineGutterContextMenu(contextMenu, lineNumber) {
     /**
      * @this {Sources.JavaScriptSourceFrame}
      */
     function populate(resolve, reject) {
-      var uiLocation = new Workspace.UILocation(this.uiSourceCode(), lineNumber, 0);
+      var uiLocation = new Workspace.UILocation(this._debuggerSourceCode, lineNumber, 0);
       this._scriptsPanel.appendUILocationItems(contextMenu, uiLocation);
       var breakpoints = this._lineBreakpointDecorations(lineNumber)
                             .map(decoration => decoration.breakpoint)
                             .filter(breakpoint => !!breakpoint);
       if (!breakpoints.length) {
         contextMenu.appendItem(
             Common.UIString('Add breakpoint'), this._createNewBreakpoint.bind(this, lineNumber, '', true));
         contextMenu.appendItem(
             Common.UIString('Add conditional breakpoint\u2026'),
             this._editBreakpointCondition.bind(this, lineNumber, null, null));
@@ skipping 46 matching lines @@
     function addSourceMapURLDialogCallback(scriptFile, url) {
       if (!url)
         return;
       scriptFile.addSourceMapURL(url);
     }
 
     /**
      * @this {Sources.JavaScriptSourceFrame}
      */
     function populateSourceMapMembers() {
-      if (this.uiSourceCode().project().type() === Workspace.projectTypes.Network &&
+      if (this._debuggerSourceCode.project().type() === Workspace.projectTypes.Network &&
           Common.moduleSetting('jsSourceMapsEnabled').get() &&
-          !Bindings.blackboxManager.isBlackboxedUISourceCode(this.uiSourceCode())) {
+          !Bindings.blackboxManager.isBlackboxedUISourceCode(this._debuggerSourceCode)) {
         if (this._scriptFileForTarget.size) {
           var scriptFile = this._scriptFileForTarget.valuesArray()[0];
           var addSourceMapURLLabel = Common.UIString.capitalize('Add ^source ^map\u2026');
           contextMenu.appendItem(addSourceMapURLLabel, addSourceMapURL.bind(null, scriptFile));
           contextMenu.appendSeparator();
         }
       }
     }
 
     return super.populateTextAreaContextMenu(contextMenu, lineNumber, columnNumber)
@@ skipping 143 matching lines @@
         if (!token || !token.type) {
           this._popoverHelper.hidePopover();
           return;
         }
         startHighlight = token.startColumn;
       }
     }
     var evaluationText = line.substring(startHighlight, endHighlight + 1);
     Sources.SourceMapNamesResolver
         .resolveExpression(
-            selectedCallFrame, evaluationText, this.uiSourceCode(), lineNumber, startHighlight, endHighlight)
+            selectedCallFrame, evaluationText, this._debuggerSourceCode, lineNumber, startHighlight, endHighlight)
         .then(onResolve.bind(this));
 
     /**
      * @param {?string=} text
      * @this {Sources.JavaScriptSourceFrame}
      */
     function onResolve(text) {
       selectedCallFrame.evaluate(
           text || evaluationText, objectGroupName, false, true, false, false, showObjectPopover.bind(this));
     }
@@ skipping 132 matching lines @@
    */
   _prepareScopeVariables(callFrame, properties, internalProperties) {
     if (!properties || !properties.length || properties.length > 500) {
       this._clearValueWidgets();
       return;
     }
 
     var functionUILocation = Bindings.debuggerWorkspaceBinding.rawLocationToUILocation(
         /** @type {!SDK.DebuggerModel.Location} */ (callFrame.functionLocation()));
     var executionUILocation = Bindings.debuggerWorkspaceBinding.rawLocationToUILocation(callFrame.location());
-    if (functionUILocation.uiSourceCode !== this.uiSourceCode() ||
-        executionUILocation.uiSourceCode !== this.uiSourceCode()) {
+    if (functionUILocation.uiSourceCode !== this._debuggerSourceCode ||
+        executionUILocation.uiSourceCode !== this._debuggerSourceCode) {
       this._clearValueWidgets();
       return;
     }
 
     var fromLine = functionUILocation.lineNumber;
     var fromColumn = functionUILocation.columnNumber;
     var toLine = executionUILocation.lineNumber;
 
     // Make sure we have a chance to update all existing widgets.
     if (this._valueWidgets) {
@@ skipping 259 matching lines @@
     }
     contextMenu.show();
   }
 
   /**
    * @param {!Common.Event} event
    * @return {boolean}
    */
   _shouldIgnoreExternalBreakpointEvents(event) {
     var uiLocation = /** @type {!Workspace.UILocation} */ (event.data.uiLocation);
-    if (uiLocation.uiSourceCode !== this.uiSourceCode() || !this.loaded)
+    if (uiLocation.uiSourceCode !== this._debuggerSourceCode || !this.loaded)
       return true;
     if (this._supportsEnabledBreakpointsWhileEditing())
       return false;
     if (this._muted)
       return true;
     var scriptFiles = this._scriptFileForTarget.valuesArray();
     for (var i = 0; i < scriptFiles.length; ++i) {
       if (scriptFiles[i].isDivergingFromVM() || scriptFiles[i].isMergingToVM())
         return true;
     }
     return false;
   }
 
   /**
    * @param {!Common.Event} event
    */
   _breakpointAdded(event) {
     if (this._shouldIgnoreExternalBreakpointEvents(event))
       return;
     var uiLocation = /** @type {!Workspace.UILocation} */ (event.data.uiLocation);
+    var breakpoint = /** @type {!Bindings.BreakpointManager.Breakpoint} */ (event.data.breakpoint);
+    this._addBreakpoint(uiLocation, breakpoint);
+  }
+
+  /**
+   * @param {!Workspace.UILocation} uiLocation
+   * @param {!Bindings.BreakpointManager.Breakpoint} breakpoint
+   */
+  _addBreakpoint(uiLocation, breakpoint) {
     var lineDecorations = this._lineBreakpointDecorations(uiLocation.lineNumber);
-    var breakpoint = /** @type {!Bindings.BreakpointManager.Breakpoint} */ (event.data.breakpoint);
-
     var decoration = this._breakpointDecoration(uiLocation.lineNumber, uiLocation.columnNumber);
     if (decoration) {
       decoration.breakpoint = breakpoint;
       decoration.condition = breakpoint.condition();
       decoration.enabled = breakpoint.enabled();
     } else {
       var handle = this._textEditor.textEditorPositionHandle(uiLocation.lineNumber, uiLocation.columnNumber);
       decoration = new Sources.JavaScriptSourceFrame.BreakpointDecoration(
           this._textEditor, handle, breakpoint.condition(), breakpoint.enabled(), breakpoint);
       decoration.element.addEventListener('click', this._inlineBreakpointClick.bind(this, decoration), true);
       decoration.element.addEventListener(
           'contextmenu', this._inlineBreakpointContextMenu.bind(this, decoration), true);
       this._breakpointDecorations.add(decoration);
     }
     this._decorationByBreakpoint.set(breakpoint, decoration);
     this._updateBreakpointDecoration(decoration);
     if (!lineDecorations.length) {
       this._willAddInlineDecorationsForTest();
       this._breakpointManager
           .possibleBreakpoints(
-              this.uiSourceCode(), new Common.TextRange(uiLocation.lineNumber, 0, uiLocation.lineNumber + 1, 0))
+              this._debuggerSourceCode, new Common.TextRange(uiLocation.lineNumber, 0, uiLocation.lineNumber + 1, 0))
           .then(addInlineDecorations.bind(this, uiLocation.lineNumber));
     }
 
     /**
      * @this {Sources.JavaScriptSourceFrame}
      * @param {number} lineNumber
      * @param {!Array<!Workspace.UILocation>} possibleLocations
      */
     function addInlineDecorations(lineNumber, possibleLocations) {
       var decorations = this._lineBreakpointDecorations(lineNumber);
@@ skipping 57 matching lines @@
       for (var lineDecoration of lineDecorations) {
         this._breakpointDecorations.delete(lineDecoration);
         this._updateBreakpointDecoration(lineDecoration);
       }
     } else {
       this._updateBreakpointDecoration(decoration);
     }
   }
 
   /**
+   * @override
+   */
+  onBindingChanged() {
+    this._updateDebuggerSourceCode();
+    this._updateScriptFiles();
+    this._refreshBreakpoints();
+
+    var canLiveCompileJavascript = this._scriptFileForTarget.size || this._debuggerSourceCode.extension() === 'js' ||
+        this._debuggerSourceCode.project().type() === Workspace.projectTypes.Snippets;
+    if (!!canLiveCompileJavascript !== !!this._compiler)
+      this._compiler = canLiveCompileJavascript ? new Sources.JavaScriptCompiler(this) : null;
+
+    this._showBlackboxInfobarIfNeeded();
+    this._updateLinesWithoutMappingHighlight();
+  }
+
+  _refreshBreakpoints() {
+    if (!this.loaded)
+      return;
+    for (var lineDecoration of this._breakpointDecorations.valuesArray()) {
+      this._breakpointDecorations.delete(lineDecoration);
+      this._updateBreakpointDecoration(lineDecoration);
+    }
+    var breakpointLocations = this._breakpointManager.breakpointLocationsForUISourceCode(this._debuggerSourceCode);
+    for (var breakpointLocation of breakpointLocations)
+      this._addBreakpoint(breakpointLocation.uiLocation, breakpointLocation.breakpoint);
+  }
+
+  _updateDebuggerSourceCode() {
+    if (this._debuggerSourceCode) {
+      this._debuggerSourceCode.removeEventListener(
+          Workspace.UISourceCode.Events.SourceMappingChanged, this._onSourceMappingChanged, this);
+    }
+
+    var binding = Persistence.persistence.binding(this.uiSourceCode());
+    this._debuggerSourceCode = binding ? binding.network : this.uiSourceCode();
+    this._debuggerSourceCode.addEventListener(
+        Workspace.UISourceCode.Events.SourceMappingChanged, this._onSourceMappingChanged, this);
+  }
+
+  /**
    * @param {!Common.Event} event
    */
   _onSourceMappingChanged(event) {
     var data = /** @type {{target: !SDK.Target}} */ (event.data);
     this._updateScriptFile(data.target);
     this._updateLinesWithoutMappingHighlight();
   }
 
   _updateLinesWithoutMappingHighlight() {
     var linesCount = this.textEditor.linesCount;
     for (var i = 0; i < linesCount; ++i) {
-      var lineHasMapping = Bindings.debuggerWorkspaceBinding.uiLineHasMapping(this.uiSourceCode(), i);
+      var lineHasMapping = Bindings.debuggerWorkspaceBinding.uiLineHasMapping(this._debuggerSourceCode, i);
       if (!lineHasMapping)
         this._hasLineWithoutMapping = true;
       if (this._hasLineWithoutMapping)
         this.textEditor.toggleLineClass(i, 'cm-line-without-source-mapping', !lineHasMapping);
     }
   }
 
+  _updateScriptFiles() {
+    for (var target of SDK.targetManager.targets()) {
+      var scriptFile = Bindings.debuggerWorkspaceBinding.scriptFile(this._debuggerSourceCode, target);
+      if (scriptFile)
+        this._updateScriptFile(target);
+    }
+  }
+
   /**
    * @param {!SDK.Target} target
    */
   _updateScriptFile(target) {
     var oldScriptFile = this._scriptFileForTarget.get(target);
-    var newScriptFile = Bindings.debuggerWorkspaceBinding.scriptFile(this.uiSourceCode(), target);
+    var newScriptFile = Bindings.debuggerWorkspaceBinding.scriptFile(this._debuggerSourceCode, target);
     this._scriptFileForTarget.remove(target);
     if (oldScriptFile) {
       oldScriptFile.removeEventListener(Bindings.ResourceScriptFile.Events.DidMergeToVM, this._didMergeToVM, this);
       oldScriptFile.removeEventListener(
           Bindings.ResourceScriptFile.Events.DidDivergeFromVM, this._didDivergeFromVM, this);
       if (this._muted && !this.uiSourceCode().isDirty())
         this._restoreBreakpointsIfConsistentScripts();
     }
     if (newScriptFile)
       this._scriptFileForTarget.set(target, newScriptFile);
@@ skipping 20 matching lines @@
   }
 
   /**
    * @override
    */
   onTextEditorContentSet() {
     super.onTextEditorContentSet();
     if (this._executionLocation)
       this.setExecutionLocation(this._executionLocation);
 
-    var breakpointLocations = this._breakpointManager.breakpointLocationsForUISourceCode(this.uiSourceCode());
-    for (var i = 0; i < breakpointLocations.length; ++i)
-      this._breakpointAdded(/** @type {!Common.Event} */ ({data: breakpointLocations[i]}));
+    var breakpointLocations = this._breakpointManager.breakpointLocationsForUISourceCode(this._debuggerSourceCode);
+    for (var breakpointLocation of breakpointLocations)
+      this._addBreakpoint(breakpointLocation.uiLocation, breakpointLocation.breakpoint);
 
     var scriptFiles = this._scriptFileForTarget.valuesArray();
     for (var i = 0; i < scriptFiles.length; ++i)
       scriptFiles[i].checkMapping();
 
     this._updateLinesWithoutMappingHighlight();
     this._detectMinified();
   }
 
   _detectMinified() {
@@ skipping 87 matching lines @@
      * @param {number} lineNumber
      * @return {!Promise<?Array<!Workspace.UILocation>>}
      */
     function findPossibleBreakpoints(lineNumber) {
       const maxLengthToCheck = 1024;
       if (lineNumber >= this._textEditor.linesCount)
         return Promise.resolve(/** @type {?Array<!Workspace.UILocation>} */ ([]));
       if (this._textEditor.line(lineNumber).length >= maxLengthToCheck)
         return Promise.resolve(/** @type {?Array<!Workspace.UILocation>} */ ([]));
       return this._breakpointManager
-          .possibleBreakpoints(this.uiSourceCode(), new Common.TextRange(lineNumber, 0, lineNumber + 1, 0))
+          .possibleBreakpoints(this._debuggerSourceCode, new Common.TextRange(lineNumber, 0, lineNumber + 1, 0))
           .then(locations => locations.length ? locations : null);
     }
 
     /**
      * @this {!Sources.JavaScriptSourceFrame}
      * @param {number} currentLineNumber
      * @param {number} linesToCheck
      * @param {?Array<!Workspace.UILocation>} locations
      * @return {!Promise<?Array<!Workspace.UILocation>>}
      */
@@ skipping 29 matching lines @@
     this._toggleBreakpoint(selection.startLine, false);
   }
 
   /**
    * @param {number} lineNumber
    * @param {number} columnNumber
    * @param {string} condition
    * @param {boolean} enabled
    */
   _setBreakpoint(lineNumber, columnNumber, condition, enabled) {
-    if (!Bindings.debuggerWorkspaceBinding.uiLineHasMapping(this.uiSourceCode(), lineNumber))
+    if (!Bindings.debuggerWorkspaceBinding.uiLineHasMapping(this._debuggerSourceCode, lineNumber))
       return;
 
-    this._breakpointManager.setBreakpoint(this.uiSourceCode(), lineNumber, columnNumber, condition, enabled);
+    this._breakpointManager.setBreakpoint(this._debuggerSourceCode, lineNumber, columnNumber, condition, enabled);
     this._breakpointWasSetForTest(lineNumber, columnNumber, condition, enabled);
   }
 
   /**
    * @param {number} lineNumber
    * @param {number} columnNumber
    * @param {string} condition
    * @param {boolean} enabled
    */
   _breakpointWasSetForTest(lineNumber, columnNumber, condition, enabled) {
   }
 
   /**
    * @override
    */
   dispose() {
     this._breakpointManager.removeEventListener(
         Bindings.BreakpointManager.Events.BreakpointAdded, this._breakpointAdded, this);
     this._breakpointManager.removeEventListener(
         Bindings.BreakpointManager.Events.BreakpointRemoved, this._breakpointRemoved, this);
     this.uiSourceCode().removeEventListener(
-        Workspace.UISourceCode.Events.SourceMappingChanged, this._onSourceMappingChanged, this);
-    this.uiSourceCode().removeEventListener(
         Workspace.UISourceCode.Events.WorkingCopyChanged, this._workingCopyChanged, this);
     this.uiSourceCode().removeEventListener(
         Workspace.UISourceCode.Events.WorkingCopyCommitted, this._workingCopyCommitted, this);
     this.uiSourceCode().removeEventListener(
         Workspace.UISourceCode.Events.TitleChanged, this._showBlackboxInfobarIfNeeded, this);
+    if (this._debuggerSourceCode) {
+      this._debuggerSourceCode.removeEventListener(
+          Workspace.UISourceCode.Events.SourceMappingChanged, this._onSourceMappingChanged, this);
+    }
+
     Common.moduleSetting('skipStackFramesPattern').removeChangeListener(this._showBlackboxInfobarIfNeeded, this);
     Common.moduleSetting('skipContentScripts').removeChangeListener(this._showBlackboxInfobarIfNeeded, this);
     super.dispose();
   }
 };
 
 /**
  * @unrestricted
  */
 Sources.JavaScriptSourceFrame.BreakpointDecoration = class {
@@ skipping 53 matching lines @@
   hide() {
     if (!this.bookmark)
       return;
     this.bookmark.clear();
     this.bookmark = null;
   }
 };
 
 Sources.JavaScriptSourceFrame.BreakpointDecoration.bookmarkSymbol = Symbol('bookmark');
 Sources.JavaScriptSourceFrame.BreakpointDecoration._elementSymbolForTest = Symbol('element');