[Devtools] Lazily build reverse mappings

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

 /*
  * Copyright (C) 2012 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 62 matching lines @@
 {
     this.lineNumber = lineNumber;
     this.columnNumber = columnNumber;
     this.sourceURL = sourceURL;
     this.sourceLineNumber = sourceLineNumber;
     this.sourceColumnNumber = sourceColumnNumber;
     this.name = name;
 }
 
 /**
+ * @constructor
+ * @param {?string} content
+ * @param {?Array<!WebInspector.SourceMapEntry>} reverseMappings
+ */
+WebInspector.SourceURLInfo = function(content, reverseMappings) {

[lushnikov, 2016/09/29 16:29:52]

WebInspector.SourceMap.SourceInfo?

[eostroukhov, 2016/09/30 19:14:41]

Done, made it TextSourceMap implementation detail.

+    this.content = content;
+    this.reverseMappings = reverseMappings;
+}
+
+/**
  * @interface
  */
 WebInspector.SourceMap = function() { }
 
 WebInspector.SourceMap.prototype = {
     /**
      * @return {string}
      */
     compiledURL: function() { },
 
@@ skipping 72 matching lines @@
  */
 WebInspector.TextSourceMap = function(compiledURL, sourceMappingURL, payload)
 {
     if (!WebInspector.TextSourceMap.prototype._base64Map) {
         const base64Digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
         WebInspector.TextSourceMap.prototype._base64Map = {};
         for (var i = 0; i < base64Digits.length; ++i)
             WebInspector.TextSourceMap.prototype._base64Map[base64Digits.charAt(i)] = i;
     }
 
+    this._json = payload;
     this._compiledURL = compiledURL;
     this._sourceMappingURL = sourceMappingURL;
-    this._reverseMappingsBySourceURL = new Map();
-    this._mappings = [];
-    this._sources = {};
-    this._sourceContentByURL = {};
-    this._parseMappingPayload(payload);
+    /** @type {?Array<!WebInspector.SourceMapEntry>} */
+    this._mappings = null;
+    /** @type {!Map<string, !WebInspector.SourceURLInfo>} */
+    this._sourceURLInfos = new Map();
+    this._eachSection(this._parseSources.bind(this));
 }
 
 /**
  * @param {string} sourceMapURL
  * @param {string} compiledURL
  * @return {!Promise<?WebInspector.TextSourceMap>}
  * @this {WebInspector.TextSourceMap}
  */
 WebInspector.TextSourceMap.load = function(sourceMapURL, compiledURL)
 {
@@ skipping 12 matching lines @@
         if (!content || statusCode >= 400) {
             callback(null);
             return;
         }
 
         if (content.slice(0, 3) === ")]}")
             content = content.substring(content.indexOf("\n"));
         try {
             var payload = /** @type {!SourceMapV3} */ (JSON.parse(content));
             var baseURL = sourceMapURL.startsWith("data:") ? compiledURL : sourceMapURL;
-
             callback(new WebInspector.TextSourceMap(compiledURL, baseURL, payload));
         } catch (e) {
             console.error(e);
             WebInspector.console.warn("DevTools failed to parse SourceMap: " + sourceMapURL);
             callback(null);
         }
     }
 }
 
 WebInspector.TextSourceMap.prototype = {
@@ skipping 14 matching lines @@
     {
         return this._sourceMappingURL;
     },
 
     /**
      * @override
      * @return {!Array.<string>}
      */
     sourceURLs: function()
     {
-        return Object.keys(this._sources);
+        return this._sourceURLInfos.keysArray();
     },
 
     /**
      * @override
      * @param {string} sourceURL
      * @param {!WebInspector.ResourceType} contentType
      * @return {!WebInspector.ContentProvider}
      */
     sourceContentProvider: function(sourceURL, contentType)
     {
-        var sourceContent = this._sourceContentByURL[sourceURL];
-        if (sourceContent)
-            return WebInspector.StaticContentProvider.fromString(sourceURL, contentType, sourceContent);
+        var info = this._sourceURLInfos.get(sourceURL);
+        if (info.content)
+            return WebInspector.StaticContentProvider.fromString(sourceURL, contentType, info.content);
         return new WebInspector.CompilerSourceMappingContentProvider(sourceURL, contentType);
     },
 
     /**
      * @override
      * @return {boolean}
      */
     editable: function()
     {
         return false;
     },
 
     /**
      * @override
      * @param {!Array<!WebInspector.TextRange>} ranges
      * @param {!Array<string>} texts
      * @return {!Promise<?WebInspector.SourceMap.EditResult>}
      */
     editCompiled: function(ranges, texts)
     {
         return Promise.resolve(/** @type {?WebInspector.SourceMap.EditResult} */(null));
     },
 
     /**
-     * @param {!SourceMapV3} mappingPayload
-     */
-    _parseMappingPayload: function(mappingPayload)
-    {
-        if (mappingPayload.sections)
-            this._parseSections(mappingPayload.sections);
-        else
-            this._parseMap(mappingPayload, 0, 0);
-    },
-
-    /**
-     * @param {!Array.<!SourceMapV3.Section>} sections
-     */
-    _parseSections: function(sections)
-    {
-        for (var i = 0; i < sections.length; ++i) {
-            var section = sections[i];
-            this._parseMap(section.map, section.offset.line, section.offset.column);
-        }
-    },
-
-    /**
      * @override
      * @param {number} lineNumber in compiled resource
      * @param {number} columnNumber in compiled resource
      * @return {?WebInspector.SourceMapEntry}
      */
     findEntry: function(lineNumber, columnNumber)
     {
         var first = 0;
-        var count = this._mappings.length;
+        var mappings = this.mappings();
+        var count = mappings.length;
         while (count > 1) {
             var step = count >> 1;
             var middle = first + step;
-            var mapping = this._mappings[middle];
+            var mapping = mappings[middle];
             if (lineNumber < mapping.lineNumber || (lineNumber === mapping.lineNumber && columnNumber < mapping.columnNumber)) {
                 count = step;
             } else {
                 first = middle;
                 count -= step;
             }
         }
-        var entry = this._mappings[first];
+        var entry = mappings[first];
         if (!first && entry && (lineNumber < entry.lineNumber || (lineNumber === entry.lineNumber && columnNumber < entry.columnNumber)))
             return null;
         return entry;
     },
 
     /**
      * @param {string} sourceURL
      * @param {number} lineNumber
      * @return {?WebInspector.SourceMapEntry}
      */
@@ skipping 14 matching lines @@
         {
             return lineNumber - mapping.sourceLineNumber;
         }
     },
 
     /**
      * @return {!Array<!WebInspector.SourceMapEntry>}
      */
     mappings: function()
     {
-        return this._mappings;
+        if (this._mappings === null) {
+            this._mappings = [];
+            this._eachSection(this._parseMap.bind(this));
+            this._json = null;
+        }
+        return /** @type {!Array<!WebInspector.SourceMapEntry>} */ (this._mappings);
     },
 
     /**
      * @param {string} sourceURL
      * @return {!Array.<!WebInspector.SourceMapEntry>}
      */
     _reversedMappings: function(sourceURL)
     {
-        var mappings = this._reverseMappingsBySourceURL.get(sourceURL);
-        if (!mappings)
+        if (this._sourceURLInfos && !this._sourceURLInfos.has(sourceURL))

[lushnikov, 2016/09/29 16:29:52]

how could this._sourceURLInfos be null?

[eostroukhov, 2016/09/30 19:14:41]

It can't. Thanks for pointing out.

             return [];
-        if (!mappings._sorted) {
-            mappings.sort(sourceMappingComparator);
-            mappings._sorted = true;
-        }
-        return mappings;
+        var mappings = this.mappings();
+        var info = this._sourceURLInfos.get(sourceURL);
+        if (info.reverseMappings === null)
+            info.reverseMappings = mappings.filter((mapping) => mapping.sourceURL === sourceURL).sort(sourceMappingComparator);
+        return info.reverseMappings;
 
         /**
          * @param {!WebInspector.SourceMapEntry} a
          * @param {!WebInspector.SourceMapEntry} b
          * @return {number}
          */
         function sourceMappingComparator(a, b)
         {
             if (a.sourceLineNumber !== b.sourceLineNumber)
                 return a.sourceLineNumber - b.sourceLineNumber;
             if (a.sourceColumnNumber !== b.sourceColumnNumber)
                 return a.sourceColumnNumber - b.sourceColumnNumber;
 
             if (a.lineNumber !== b.lineNumber)
                 return a.lineNumber - b.lineNumber;
 
             return a.columnNumber - b.columnNumber;
         }
     },
 
     /**
+     * @param {function(!SourceMapV3, number, number)} callback
+     */
+    _eachSection: function(callback) {
+        if (!this._json.sections) {
+            callback(this._json, 0, 0);
+            return;
+        }
+        for (var section of this._json.sections)
+            callback(section.map, section.offset.line, section.offset.column);
+    },
+
+    /**
+     * @param {!SourceMapV3} sourceMap
+     * @param {function(string, ?string)} callback
+     */
+    _visitSourceURLs: function(sourceMap, callback) {
+        var sourceRoot = sourceMap.sourceRoot || "";
+        if (sourceRoot && !sourceRoot.endsWith("/"))
+            sourceRoot += "/";
+        for (var i = 0; i < sourceMap.sources.length; ++i) {
+            var href = sourceRoot + sourceMap.sources[i];
+            var url = WebInspector.ParsedURL.completeURL(this._sourceMappingURL, href) || href;
+            var source = sourceMap.sourcesContent && sourceMap.sourcesContent[i];
+            if (url === this._compiledURL && source)
+                url += WebInspector.UIString(" [sm]");
+            callback(url, source);
+        }
+    },
+
+    /**
+     * @param {!SourceMapV3} sourceMap
+     */
+    _parseSources: function(sourceMap) {

[lushnikov, 2016/09/29 16:29:53]

yeah, callback is unfortunate

Let's do the following:

_parseSources: function(sourceMap)
{
    var sources = getSourcesForSourceMap(sourceMap);
    this._sourceURLInfos.addAll(sources);
    sourceMap[sourcesSymbol] = sources;
}

and later, in the _parseMap, we can just get sources for the SourceMap:

   ...
   var sources = sourceMap[sourcesSymbol];
   ...

[eostroukhov, 2016/09/30 19:14:41]

Done.

+        this._visitSourceURLs(sourceMap,
+            (url, source) => this._sourceURLInfos.set(url, new WebInspector.SourceURLInfo(source, null)));
+    },
+
+    /**
      * @param {!SourceMapV3} map
      * @param {number} lineNumber
      * @param {number} columnNumber
      */
     _parseMap: function(map, lineNumber, columnNumber)
     {
         var sourceIndex = 0;
         var sourceLineNumber = 0;
         var sourceColumnNumber = 0;
         var nameIndex = 0;
-
         var sources = [];
         var names = map.names || [];
-        var sourceRoot = map.sourceRoot || "";
-        if (sourceRoot && !sourceRoot.endsWith("/"))
-            sourceRoot += "/";
-        for (var i = 0; i < map.sources.length; ++i) {
-            var href = sourceRoot + map.sources[i];
-            var url = WebInspector.ParsedURL.completeURL(this._sourceMappingURL, href) || href;
-            var hasSource = map.sourcesContent && map.sourcesContent[i];
-            if (url === this._compiledURL && hasSource)
-                url += WebInspector.UIString(" [sm]");
-            sources.push(url);
-            this._sources[url] = true;
-
-            if (hasSource)
-                this._sourceContentByURL[url] = map.sourcesContent[i];
-        }
-
         var stringCharIterator = new WebInspector.TextSourceMap.StringCharIterator(map.mappings);
+        this._visitSourceURLs(map, (url) => sources.push(url));
         var sourceURL = sources[sourceIndex];
 
         while (true) {
             if (stringCharIterator.peek() === ",")
                 stringCharIterator.next();
             else {
                 while (stringCharIterator.peek() === ";") {
                     lineNumber += 1;
                     columnNumber = 0;
                     stringCharIterator.next();
@@ skipping 17 matching lines @@
             sourceColumnNumber += this._decodeVLQ(stringCharIterator);
 
             if (!stringCharIterator.hasNext() || this._isSeparator(stringCharIterator.peek())) {
                 this._mappings.push(new WebInspector.SourceMapEntry(lineNumber, columnNumber, sourceURL, sourceLineNumber, sourceColumnNumber));
                 continue;
             }
 
             nameIndex += this._decodeVLQ(stringCharIterator);
             this._mappings.push(new WebInspector.SourceMapEntry(lineNumber, columnNumber, sourceURL, sourceLineNumber, sourceColumnNumber, names[nameIndex]));
         }
-
-        for (var i = 0; i < this._mappings.length; ++i) {
-            var mapping = this._mappings[i];
-            var url = mapping.sourceURL;
-            if (!url)
-                continue;
-            if (!this._reverseMappingsBySourceURL.has(url))
-                this._reverseMappingsBySourceURL.set(url, []);
-            var reverseMappings = this._reverseMappingsBySourceURL.get(url);
-            reverseMappings.push(mapping);
-        }
     },
 
     /**
      * @param {string} char
      * @return {boolean}
      */
     _isSeparator: function(char)
     {
         return char === "," || char === ";";
     },
@@ skipping 81 matching lines @@
     },
 
     /**
      * @return {boolean}
      */
     hasNext: function()
     {
         return this._position < this._string.length;
     }
 }