DevTools: carefully cleanup script UISourceCodes

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 31 matching lines @@
     this._agent = target.debuggerAgent();
     this._runtimeModel = /** @type {!SDK.RuntimeModel} */ (target.model(SDK.RuntimeModel));
 
     /** @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, !SDK.Script>} */
+    this._scripts = new Map();

[dgozman, 2017/04/05 18:22:55]

Is it as performant? We have a lot of scripts!

[lushnikov, 2017/04/06 03:32:35]

According to 
https://docs.google.com/spreadsheets/d/1lQTC4ZG3XY33Gdw7Ibla30fz3HQHqWZ87DQjH...

Map is more performant for storing rather then for querying. And this is the
case we have!

     /** @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);
@@ skipping 274 matching lines @@
     this._reset();
     // TODO(dgozman): move clients to ExecutionContextDestroyed/ScriptCollected events.
     this.dispatchEventToListeners(SDK.DebuggerModel.Events.GlobalObjectCleared, this);
   }
 
   _reset() {
     for (var scriptWithSourceMap of this._sourceMapIdToScript.values())
       this._sourceMapManager.detachSourceMap(scriptWithSourceMap);
     this._sourceMapIdToScript.clear();
 
-    this._scripts = {};
+    this._scripts.clear();
     this._scriptsBySourceURL.clear();
     this._stringMap.clear();
     this._discardableScripts = [];
   }
 
   /**
-   * @return {!Object.<string, !SDK.Script>}
+   * @return {!Array<!SDK.Script>}
    */
-  get scripts() {
-    return this._scripts;
+  scripts() {
+    return Array.from(this._scripts.values());

[dgozman, 2017/04/05 18:22:55]

Is this method performance-critical? Does it make sense to return an iterator or
map itself?

[lushnikov, 2017/04/06 03:32:35]

No, it's used by blackbox model only

   }
 
   /**
    * @param {!Protocol.Runtime.ScriptId} scriptId
    * @return {?SDK.Script}
    */
   scriptForId(scriptId) {
-    return this._scripts[scriptId] || null;
+    return this._scripts.get(scriptId) || null;
   }
 
   /**
    * @return {!Array.<!SDK.Script>}
    */
   scriptsForSourceURL(sourceURL) {
     if (!sourceURL)
       return [];
     return this._scriptsBySourceURL.get(sourceURL) || [];
   }
 
   /**
    * @param {!Protocol.Runtime.ScriptId} scriptId
    * @param {string} newSource
    * @param {function(?Protocol.Error, !Protocol.Runtime.ExceptionDetails=)} callback
    */
   setScriptSource(scriptId, newSource, callback) {
-    this._scripts[scriptId].editSource(newSource, this._didEditScriptSource.bind(this, scriptId, newSource, callback));
+    this._scripts.get(scriptId).editSource(
+        newSource, this._didEditScriptSource.bind(this, scriptId, newSource, callback));
   }
 
   /**
    * @param {!Protocol.Runtime.ScriptId} scriptId
    * @param {string} newSource
    * @param {function(?Protocol.Error, !Protocol.Runtime.ExceptionDetails=)} callback
    * @param {?Protocol.Error} error
    * @param {!Protocol.Runtime.ExceptionDetails=} exceptionDetails
    * @param {!Array.<!Protocol.Debugger.CallFrame>=} callFrames
    * @param {!Protocol.Runtime.StackTrace=} asyncStackTrace
@@ skipping 165 matching lines @@
    */
   executionContextDestroyed(executionContext) {
     var sourceMapIds = Array.from(this._sourceMapIdToScript.keys());
     for (var sourceMapId of sourceMapIds) {
       var script = this._sourceMapIdToScript.get(sourceMapId);
       if (script.executionContextId === executionContext.id) {
         this._sourceMapIdToScript.delete(sourceMapId);
         this._sourceMapManager.detachSourceMap(script);
       }
     }
+    var affectedScripts = [];
+    for (var script of this._scripts.values()) {
+      if (script.executionContextId === executionContext.id)
+        affectedScripts.push(script);
+    }
+    this.dispatchEventToListeners(SDK.DebuggerModel.Events.ExecutionContextDestroyed, affectedScripts);
   }
 
   /**
    * @param {!SDK.Script} script
    */
   _registerScript(script) {
-    this._scripts[script.scriptId] = script;
+    this._scripts.set(script.scriptId, script);
     if (script.isAnonymousScript())
       return;
 
     var scripts = this._scriptsBySourceURL.get(script.sourceURL);
     if (!scripts) {
       scripts = [];
       this._scriptsBySourceURL.set(script.sourceURL, scripts);
     }
     scripts.push(script);
   }
 
   /**
    * @param {!SDK.Script} script
    */
   _unregisterScript(script) {
     console.assert(script.isAnonymousScript());
-    delete this._scripts[script.scriptId];
+    this._scripts.delete(script.scriptId);
   }
 
   _collectDiscardedScripts() {
     if (this._discardableScripts.length < 1000)
       return;
     var scriptsToDiscard = this._discardableScripts.splice(0, 100);
     for (var script of scriptsToDiscard) {
       this._unregisterScript(script);
       this.dispatchEventToListeners(SDK.DebuggerModel.Events.DiscardedAnonymousScriptSource, script);
     }
@@ skipping 307 matching lines @@
   PauseOnAllExceptions: 'all',
   PauseOnUncaughtExceptions: 'uncaught'
 };
 
 /** @enum {symbol} */
 SDK.DebuggerModel.Events = {
   DebuggerWasEnabled: Symbol('DebuggerWasEnabled'),
   DebuggerWasDisabled: Symbol('DebuggerWasDisabled'),
   DebuggerPaused: Symbol('DebuggerPaused'),
   DebuggerResumed: Symbol('DebuggerResumed'),
+  ExecutionContextDestroyed: Symbol('ExecutionContextDestroyed'),

[dgozman, 2017/04/05 18:22:55]

DiscardedScriptSources, and merge with DiscardedAnonymousScriptSource

[lushnikov, 2017/04/06 03:32:35]

As discussed offline, i'm started to listen to
RuntimeModel.ExecutionContextDestroyed in NetworkPanel

   ParsedScriptSource: Symbol('ParsedScriptSource'),
   FailedToParseScriptSource: Symbol('FailedToParseScriptSource'),
   DiscardedAnonymousScriptSource: Symbol('DiscardedAnonymousScriptSource'),
   GlobalObjectCleared: Symbol('GlobalObjectCleared'),
   CallFrameSelected: Symbol('CallFrameSelected'),
   ConsoleCommandEvaluatedInSelectedCallFrame: Symbol('ConsoleCommandEvaluatedInSelectedCallFrame')
 };
 
 /** @enum {string} */
 SDK.DebuggerModel.BreakReason = {
@@ skipping 535 matching lines @@
         stack.callFrames.shift();
       if (previous && (!stack.callFrames.length && !stack.promiseCreationFrame))
         previous.parent = stack.parent;
       else
         previous = stack;
       stack = stack.parent;
     }
     return asyncStackTrace;
   }
 };