[DevTools] Introduce provisional blackboxing

third_party/WebKit/Source/devtools/front_end/bindings/BlackboxManager.js

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+/** @typedef {!{line: number, column: number}} */
+var ScriptPosition;
+
 /**
  * @constructor
  * @param {!WebInspector.DebuggerWorkspaceBinding} debuggerWorkspaceBinding
  * @param {!WebInspector.NetworkMapping} networkMapping
+ * @implements {WebInspector.TargetManager.Observer}
  */
 WebInspector.BlackboxManager = function(debuggerWorkspaceBinding, networkMapping)
 {
     this._debuggerWorkspaceBinding = debuggerWorkspaceBinding;
     this._networkMapping = networkMapping;
 
     WebInspector.targetManager.addModelListener(WebInspector.DebuggerModel, WebInspector.DebuggerModel.Events.ParsedScriptSource, this._parsedScriptSource, this);
     WebInspector.targetManager.addModelListener(WebInspector.DebuggerModel, WebInspector.DebuggerModel.Events.GlobalObjectCleared, this._globalObjectCleared, this);
     WebInspector.moduleSetting("skipStackFramesPattern").addChangeListener(this._patternChanged.bind(this));
     WebInspector.moduleSetting("skipContentScripts").addChangeListener(this._patternChanged.bind(this));
 
-    /** @type {!Map<!WebInspector.DebuggerModel, !Map<string, !Array<!DebuggerAgent.ScriptPosition>>>} */
+    /** @type {!Map<!WebInspector.DebuggerModel, !Map<string, !Array<!ScriptPosition>>>} */
     this._debuggerModelData = new Map();
     /** @type {!Map<string, boolean>} */
     this._isBlackboxedURLCache = new Map();
+
+    WebInspector.targetManager.observeTargets(this);
 }
 
 WebInspector.BlackboxManager.prototype = {
     /**
      * @param {function(!WebInspector.Event)} listener
      * @param {!Object=} thisObject
      */
     addChangeListener: function(listener, thisObject)
     {
         WebInspector.moduleSetting("skipStackFramesPattern").addChangeListener(listener, thisObject);
     },
 
     /**
      * @param {function(!WebInspector.Event)} listener
      * @param {!Object=} thisObject
      */
     removeChangeListener: function(listener, thisObject)
     {
         WebInspector.moduleSetting("skipStackFramesPattern").removeChangeListener(listener, thisObject);
     },
 
     /**
+     * @override
+     * @param {!WebInspector.Target} target
+     */
+    targetAdded: function(target)
+    {
+        var debuggerModel = WebInspector.DebuggerModel.fromTarget(target);
+        if (debuggerModel)
+            this._addBlackboxPatterns(debuggerModel);
+    },
+
+    /**
+     * @override
+     * @param {!WebInspector.Target} target
+     */
+    targetRemoved: function(target)
+    {
+    },
+
+    /**
+     * @param {!WebInspector.DebuggerModel} debuggerModel
+     * @return {!Promise<boolean>}
+     */
+    _addBlackboxPatterns: function(debuggerModel)
+    {
+        var regexPatterns = WebInspector.moduleSetting("skipStackFramesPattern").getAsArray();
+        var patterns = /** @type {!Array<string>} */([]);
+        for (var item of regexPatterns) {
+            if (!item.disabled && item.pattern)
+                patterns.push(item.pattern);
+        }
+        return debuggerModel.setBlackboxPatterns(patterns);
+    },
+
+    /**
      * @param {!WebInspector.DebuggerModel.Location} location
      * @return {boolean}
      */
     isBlackboxedRawLocation: function(location)
     {
         var positions = this._scriptPositions(location.script());
         if (!positions)
             return this._isBlackboxedScript(location.script());
         var index = positions.lowerBound(location, comparator);
         return !!(index % 2);
 
         /**
          * @param {!WebInspector.DebuggerModel.Location} a
-         * @param {!DebuggerAgent.ScriptPosition} b
+         * @param {!ScriptPosition} b
          * @return {number}
          */
         function comparator(a, b)
         {
             if (a.lineNumber !== b.line)
                 return a.lineNumber - b.line;
             return a.columnNumber - b.column;
         }
     },
 
@@ skipping 39 matching lines @@
             return Promise.resolve();
         var previousScriptState = this._scriptPositions(script);
         if (!previousScriptState)
             return Promise.resolve();
 
         var mappings = sourceMap.mappings().slice();
         mappings.sort(mappingComparator);
 
         if (!mappings.length) {
             if (previousScriptState.length > 0)
-                return this._setScriptState(script, []);
+                return this._setScriptState(script, null);
             return Promise.resolve();
         }
 
-        var currentBlackboxed = false;
-        var isBlackboxed = false;
-        var positions = [];
-        // If content in script file begin is not mapped and one or more ranges are blackboxed then blackbox it.
-        if (mappings[0].lineNumber !== 0 || mappings[0].columnNumber !== 0) {
-            positions.push({ line: 0, column: 0});
-            currentBlackboxed = true;
+        var ranges = [];
+        var prevMapping = null;
+        for (var mapping of mappings) {
+            if (mapping.sourceURL && !this.isBlackboxedURL(mapping.sourceURL)) {
+                prevMapping = mapping;
+                continue;
+            }
+            if (prevMapping)
+                ranges.push({ startLine: prevMapping.lineNumber, startColumn: prevMapping.columnNumber, endLine: mapping.lineNumber, endColumn: mapping.columnNumber });
+            else
+                ranges.push({ startLine: 0, startColumn: 0, endLine: mapping.lineNumber, endColumn: mapping.columnNumber });

[dgozman, 2016/04/20 02:06:40]

Let's send merged ranges.

+            prevMapping = mapping;
         }
-        for (var mapping of mappings) {
-            if (mapping.sourceURL && currentBlackboxed !== this.isBlackboxedURL(mapping.sourceURL)) {
-                positions.push({ line: mapping.lineNumber, column: mapping.columnNumber });
-                currentBlackboxed = !currentBlackboxed;
-            }
-            isBlackboxed = currentBlackboxed || isBlackboxed;
-        }
-        return this._setScriptState(script, !isBlackboxed ? [] : positions);
+        return this._setScriptState(script, ranges);
         /**
          * @param {!WebInspector.SourceMapEntry} a
          * @param {!WebInspector.SourceMapEntry} b
          * @return {number}
          */
         function mappingComparator(a, b)
         {
             if (a.lineNumber !== b.lineNumber)
                 return a.lineNumber - b.lineNumber;
             return a.columnNumber - b.columnNumber;
@@ skipping 102 matching lines @@
         }
         WebInspector.moduleSetting("skipStackFramesPattern").setAsArray(regexPatterns);
     },
 
     _patternChanged: function()
     {
         this._isBlackboxedURLCache.clear();
 
         var promises = [];
         for (var debuggerModel of WebInspector.DebuggerModel.instances()) {
+            promises.push(this._addBlackboxPatterns.bind(this, debuggerModel));
             for (var scriptId in debuggerModel.scripts) {
                 var script = debuggerModel.scripts[scriptId];
                 promises.push(this._addScript(script)
                                   .then(loadSourceMap.bind(this, script)));
             }
         }
         Promise.all(promises).then(this._patternChangeFinishedForTests.bind(this));
 
         /**
          * @param {!WebInspector.Script} script
@@ skipping 30 matching lines @@
         this._addScript(script);
     },
 
     /**
      * @param {!WebInspector.Script} script
      * @return {!Promise<undefined>}
      */
     _addScript: function(script)
     {
         var blackboxed = this._isBlackboxedScript(script);
-        return this._setScriptState(script, blackboxed ? [ { line: 0, column: 0 } ] : []);
+        return this._setScriptState(script, blackboxed ? null : []);
     },
 
     /**
      * @param {!WebInspector.Script} script
      * @return {boolean}
      */
     _isBlackboxedScript: function(script)
     {
         return this.isBlackboxedURL(script.sourceURL, script.isContentScript());
     },
 
     /**
      * @param {!WebInspector.Script} script
-     * @return {?Array<!DebuggerAgent.ScriptPosition>}
+     * @return {?Array<!ScriptPosition>}
      */
     _scriptPositions: function(script)
     {
         if (this._debuggerModelData.has(script.debuggerModel))
             return this._debuggerModelData.get(script.debuggerModel).get(script.scriptId) || null;
         return null;
     },
 
     /**
      * @param {!WebInspector.Script} script
-     * @param {!Array<!DebuggerAgent.ScriptPosition>} positions
+     * @param {!Array<!ScriptPosition>} positions
      */
     _setScriptPositions: function(script, positions)
     {
         var debuggerModel = script.debuggerModel;
         if (!this._debuggerModelData.has(debuggerModel))
             this._debuggerModelData.set(debuggerModel, new Map());
         this._debuggerModelData.get(debuggerModel).set(script.scriptId, positions);
     },
 
     /**
      * @param {!WebInspector.Script} script
-     * @param {!Array<!DebuggerAgent.ScriptPosition>} positions
+     * @param {?Array<!RuntimeAgent.SourceRange>} ranges
      * @return {!Promise<undefined>}
      */
-    _setScriptState: function(script, positions)
+    _setScriptState: function(script, ranges)
     {
+        var positions = [];
+        if (ranges) {
+            for (var range of ranges) {
+                positions.push({ line: range.startLine, column: range.startColumn });
+                positions.push({ line: range.endLine, column: range.endColumn });
+            }
+        } else {
+            positions.push({ line: 0, column: 0 });
+        }
+
         var previousScriptState = this._scriptPositions(script);
         if (previousScriptState) {
             var hasChanged = false;
             hasChanged = previousScriptState.length !== positions.length;
             for (var i = 0; !hasChanged && i < positions.length; ++i)
                 hasChanged = positions[i].line !== previousScriptState[i].line || positions[i].column !== previousScriptState[i].column;
             if (!hasChanged)
                 return Promise.resolve();
         } else {
             if (positions.length === 0)
                 return Promise.resolve().then(updateState.bind(this, false));
         }
 
-        return script.setBlackboxedRanges(positions).then(updateState.bind(this));
+        return script.setBlackboxedRanges(ranges).then(updateState.bind(this));
 
         /**
          * @param {boolean} success
          * @this {WebInspector.BlackboxManager}
          */
         function updateState(success)
         {
             if (success) {
                 this._setScriptPositions(script, positions);
                 this._debuggerWorkspaceBinding.updateLocations(script);
@@ skipping 35 matching lines @@
             if (scheme === "chrome-extension")
                 prefix += parsedURL.host + "\\b";
             prefix += ".*";
         }
         return prefix + name.escapeForRegExp() + (url.endsWith(name) ? "$" : "\\b");
     }
 }
 
 /** @type {!WebInspector.BlackboxManager} */
 WebInspector.blackboxManager;