[WIP] DevTools: user SourceMapManager in Debugger

third_party/WebKit/Source/devtools/front_end/sdk/DebuggerModel.js

 /*
  * Copyright (C) 2010 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 @@
 SDK.DebuggerModel = class extends SDK.SDKModel {
   /**
    * @param {!SDK.Target} target
    */
   constructor(target) {
     super(target);
 
     target.registerDebuggerDispatcher(new SDK.DebuggerDispatcher(this));
     this._agent = target.debuggerAgent();
     this._runtimeModel = /** @type {!SDK.RuntimeModel} */ (target.model(SDK.RuntimeModel));
+    this._runtimeModel.addEventListener(SDK.RuntimeModel.Events.ExecutionContextDestroyed, this._executionContextDestroyed, this);
+
+    /** @type {!SDK.SourceMapManager<!SDK.Script>} */
+    this._sourceMapManager = new SDK.SourceMapManager(target);
+    /** @type {!Map<string, !SDK.Script>} */
+    this._sourceMapIdToScript = new Map();
 
     /** @type {?SDK.DebuggerPausedDetails} */
     this._debuggerPausedDetails = null;
     /** @type {!Object.<string, !SDK.Script>} */
     this._scripts = {};
     /** @type {!Map.<string, !Array.<!SDK.Script>>} */
     this._scriptsBySourceURL = new Map();
     /** @type {!Array.<!SDK.Script>} */
     this._discardableScripts = [];
 
     /** @type {!Common.Object} */
     this._breakpointResolvedEventTarget = new Common.Object();
 
     this._isPausing = false;
     Common.moduleSetting('pauseOnExceptionEnabled').addChangeListener(this._pauseOnExceptionStateChanged, this);
     Common.moduleSetting('pauseOnCaughtException').addChangeListener(this._pauseOnExceptionStateChanged, this);
     Common.moduleSetting('enableAsyncStackTraces').addChangeListener(this.asyncStackTracesStateChanged, this);
 
     /** @type {!Map<string, string>} */
     this._fileURLToNodeJSPath = new Map();
     this.enableDebugger();
 
     /** @type {!Map<string, string>} */
     this._stringMap = new Map();
+    this._sourceMapManager.setEnabled(Common.moduleSetting('jsSourceMapsEnabled').get());
+    Common.moduleSetting('jsSourceMapsEnabled')
+        .addChangeListener(event => this._sourceMapManager.setEnabled(/** @type {boolean} */ (event.data)));
   }
 
   /**
+   * @param {string} executionContextId
+   * @param {string} sourceURL
+   * @param {?string} sourceMapURL
+   * @return {?string}
+   */
+  static _sourceMapId(executionContextId, sourceURL, sourceMapURL) {
+    if (!sourceMapURL)
+      return null;
+    return executionContextId + ':' + sourceURL + ':' + sourceMapURL;
+  }
+
+  /**
+   * @return {!SDK.SourceMapManager<!SDK.Script>}
+   */
+  sourceMapManager() {
+    return this._sourceMapManager;
+  }
+
+  /**
    * @return {!SDK.RuntimeModel}
    */
   runtimeModel() {
     return this._runtimeModel;
   }
 
   /**
    * @return {boolean}
    */
   debuggerEnabled() {
@@ skipping 230 matching lines @@
     this._reset();
     // TODO(dgozman): move clients to ExecutionContextDestroyed/ScriptCollected events.
     this.dispatchEventToListeners(SDK.DebuggerModel.Events.GlobalObjectCleared, this);
   }
 
   _reset() {
     this._scripts = {};
     this._scriptsBySourceURL.clear();
     this._stringMap.clear();
     this._discardableScripts = [];
+
+    for (var scriptWithSourceMap of this._sourceMapIdToScript.values())
+      this._sourceMapManager.detachSourceMap(scriptWithSourceMap);
+    this._sourceMapIdToScript.clear();
   }
 
   /**
    * @return {!Object.<string, !SDK.Script>}
    */
   get scripts() {
     return this._scripts;
   }
 
   /**
@@ skipping 148 matching lines @@
       sourceURL = this._internString(sourceURL);
     }
     var script = new SDK.Script(
         this, scriptId, sourceURL, startLine, startColumn, endLine, endColumn, executionContextId,
         this._internString(hash), isContentScript, isLiveEdit, sourceMapURL, hasSourceURL, length);
     this._registerScript(script);
     if (!hasSyntaxError)
       this.dispatchEventToListeners(SDK.DebuggerModel.Events.ParsedScriptSource, script);
     else
       this.dispatchEventToListeners(SDK.DebuggerModel.Events.FailedToParseScriptSource, script);
+
+    var sourceMapId = SDK.DebuggerModel._sourceMapId(script.executionContextId, script.sourceURL, script.sourceMapURL);
+    if (sourceMapId && !hasSyntaxError) {
+      var previousSourceMapClient = this._sourceMapIdToScript.get(sourceMapId);
+      if (previousSourceMapClient)
+        this._sourceMapManager.detachSourceMap(previousSourceMapClient);
+      this._sourceMapIdToScript.set(sourceMapId, script);
+      this._sourceMapManager.attachSourceMap(script, script.sourceURL, script.sourceMapURL);
+    }
+
     var isDiscardable = hasSyntaxError && script.isAnonymousScript();
     if (isDiscardable) {
       this._discardableScripts.push(script);
       this._collectDiscardedScripts();
     }
     return script;
   }
 
   /**
    * @param {!SDK.Script} script
+   * @param {string} newSourceMapURL
+   */
+  setSourceMapURL(script, newSourceMapURL) {
+    var sourceMapId = SDK.DebuggerModel._sourceMapId(script.executionContextId, script.sourceURL, script.sourceMapURL);
+    if (sourceMapId && this._sourceMapIdToScript.get(sourceMapId) === script)
+      this._sourceMapIdToScript.delete(sourceMapId);
+    this._sourceMapManager.detachSourceMap(script);
+
+    script.sourceMapURL = newSourceMapURL;
+    sourceMapId = SDK.DebuggerModel._sourceMapId(script.executionContextId, script.sourceURL, script.sourceMapURL);
+    this._sourceMapIdToScript.set(sourceMapId, script);
+    this._sourceMapManager.attachSourceMap(script, script.sourceURL, script.sourceMapURL);
+  }
+
+  /**
+   * @param {!Common.Event} event
+   */
+  _executionContextDestroyed(event) {
+    var executionContext = /** @type {!SDK.ExecutionContext} */ (event.data);
+    for (var script of this._sourceMapIdToScript.values()) {
+      if (script.executionContextId === executionContext.id)
+        this._sourceMapManager.detachSourceMap(script);
+    }
+  }
+
+  /**
+   * @param {!SDK.Script} script
    */
   _registerScript(script) {
     this._scripts[script.scriptId] = script;
     if (script.isAnonymousScript())
       return;
 
     var scripts = this._scriptsBySourceURL.get(script.sourceURL);
     if (!scripts) {
       scripts = [];
       this._scriptsBySourceURL.set(script.sourceURL, scripts);
@@ skipping 256 matching lines @@
       if (error)
         console.error(error);
       callback(!error);
     }
   }
 
   /**
    * @override
    */
   dispose() {
+    this._runtimeModel.removeEventListener(SDK.RuntimeModel.Events.ExecutionContextDestroyed, this._executionContextDestroyed, this);
     Common.moduleSetting('pauseOnExceptionEnabled').removeChangeListener(this._pauseOnExceptionStateChanged, this);
     Common.moduleSetting('pauseOnCaughtException').removeChangeListener(this._pauseOnExceptionStateChanged, this);
     Common.moduleSetting('enableAsyncStackTraces').removeChangeListener(this.asyncStackTracesStateChanged, this);
   }
 
   /**
    * @override
    * @return {!Promise}
    */
   suspendModel() {
@@ skipping 26 matching lines @@
 
   /**
    * @param {string} string
    * @return {string} string
    */
   _internString(string) {
     if (!this._stringMap.has(string))
       this._stringMap.set(string, string);
     return this._stringMap.get(string);
   }
+
+  /**
+   * @override
+   */
+  dispose() {
+    super.dispose();
+    this._sourceMapManager.dispose();
+  }
 };
 
 SDK.SDKModel.register(SDK.DebuggerModel, SDK.Target.Capability.JS, true);
 
 /** @typedef {{location: ?SDK.DebuggerModel.Location, functionName: string}} */
 SDK.DebuggerModel.FunctionDetails;
 
 /**
  * Keep these in sync with WebCore::V8Debugger
  *
  * @enum {string}
  */
 SDK.DebuggerModel.PauseOnExceptionsState = {
   DontPauseOnExceptions: 'none',
   PauseOnAllExceptions: 'all',
   PauseOnUncaughtExceptions: 'uncaught'
 };
 
 /** @enum {symbol} */
 SDK.DebuggerModel.Events = {
   DebuggerWasEnabled: Symbol('DebuggerWasEnabled'),
   DebuggerWasDisabled: Symbol('DebuggerWasDisabled'),
   DebuggerPaused: Symbol('DebuggerPaused'),
   DebuggerResumed: Symbol('DebuggerResumed'),
   ParsedScriptSource: Symbol('ParsedScriptSource'),
   FailedToParseScriptSource: Symbol('FailedToParseScriptSource'),
   DiscardedAnonymousScriptSource: Symbol('DiscardedAnonymousScriptSource'),
   GlobalObjectCleared: Symbol('GlobalObjectCleared'),
   CallFrameSelected: Symbol('CallFrameSelected'),
-  ConsoleCommandEvaluatedInSelectedCallFrame: Symbol('ConsoleCommandEvaluatedInSelectedCallFrame'),
-  SourceMapURLAdded: Symbol('SourceMapURLAdded')
+  ConsoleCommandEvaluatedInSelectedCallFrame: Symbol('ConsoleCommandEvaluatedInSelectedCallFrame')
 };
 
 /** @enum {string} */
 SDK.DebuggerModel.BreakReason = {
   DOM: 'DOM',
   EventListener: 'EventListener',
   XHR: 'XHR',
   Exception: 'exception',
   PromiseRejection: 'promiseRejection',
   Assert: 'assert',
@@ skipping 529 matching lines @@
         stack.callFrames.shift();
       if (previous && (!stack.callFrames.length && !stack.promiseCreationFrame))
         previous.parent = stack.parent;
       else
         previous = stack;
       stack = stack.parent;
     }
     return asyncStackTrace;
   }
 };