[DevTools] Added setBlackboxPatterns method to protocol

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.
 
 /**
  * @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>>>} */
     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);
@@ skipping 108 matching lines @@
          */
         function mappingComparator(a, b)
         {
             if (a.lineNumber !== b.lineNumber)
                 return a.lineNumber - b.lineNumber;
             return a.columnNumber - b.columnNumber;
         }
     },
 
     /**
+     * @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<!DebuggerAgent.BlackboxPattern>} */([]);
+        for (var item of regexPatterns) {
+            if (!item.disabled && item.pattern)
+                patterns.push({ regexp: item.pattern });
+        }
+        return debuggerModel.addBlackboxPatterns(patterns);
+    },
+
+    /**
      * @param {!WebInspector.UISourceCode} uiSourceCode
      * @return {?string}
      */
     _uiSourceCodeURL: function(uiSourceCode)
     {
         var networkURL = this._networkMapping.networkURL(uiSourceCode);
         var projectType = uiSourceCode.project().type();
         if (projectType === WebInspector.projectTypes.Debugger)
             return null;
         var url = projectType === WebInspector.projectTypes.Formatter ? uiSourceCode.url() : networkURL;
@@ skipping 93 matching lines @@
     {
         this._isBlackboxedURLCache.clear();
 
         var promises = [];
         for (var debuggerModel of WebInspector.DebuggerModel.instances()) {
             for (var scriptId in debuggerModel.scripts) {
                 var script = debuggerModel.scripts[scriptId];
                 promises.push(this._addScript(script)
                                   .then(loadSourceMap.bind(this, script)));
             }
+            promises.push(clearBlackboxPatterns(debuggerModel).then(addBlackboxPatterns.bind(this, debuggerModel)));

[dgozman, 2016/03/08 18:48:12]

This should go before _addScript calls.

         }
         Promise.all(promises).then(this._patternChangeFinishedForTests.bind(this));
 
         /**
          * @param {!WebInspector.Script} script
          * @return {!Promise<undefined>}
          * @this {WebInspector.BlackboxManager}
          */
         function loadSourceMap(script)
         {
             return this.sourceMapLoaded(script, this._debuggerWorkspaceBinding.sourceMapForScript(script));
         }
+
+        /**
+         * @param {!WebInspector.DebuggerModel} debuggerModel
+         * @return {!Promise<boolean>}
+         */
+        function clearBlackboxPatterns(debuggerModel)
+        {
+            return debuggerModel.clearBlackboxPatterns();

[dgozman, 2016/03/08 18:48:12]

Inline it!

+        }
+
+        /**
+         * @param {!WebInspector.DebuggerModel} debuggerModel
+         * @param {boolean} wasCleared
+         * @return {!Promise<boolean>}
+         * @this {WebInspector.BlackboxManager}
+         */
+        function addBlackboxPatterns(debuggerModel, wasCleared)
+        {
+            if (!wasCleared)

[dgozman, 2016/03/08 18:48:12]

Ignore this and inline.

+                return Promise.resolve(false);
+            else
+                return this._addBlackboxPatterns(debuggerModel);
+        }
     },
 
     _patternChangeFinishedForTests: function()
     {
         // This method is sniffed in tests.
     },
 
     /**
      * @param {!WebInspector.Event} event
      */
@@ skipping 68 matching lines @@
             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.addBlackboxPattern(positions).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;