DevTools: rename WebInspector into modules.

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 48 matching lines @@
 SourceMapV3.Offset = class {
   constructor() {
     /** @type {number} */ this.line;
     /** @type {number} */ this.column;
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.SourceMapEntry = class {
+SDK.SourceMapEntry = class {
   /**
    * @param {number} lineNumber
    * @param {number} columnNumber
    * @param {string=} sourceURL
    * @param {number=} sourceLineNumber
    * @param {number=} sourceColumnNumber
    * @param {string=} name
    */
   constructor(lineNumber, columnNumber, sourceURL, sourceLineNumber, sourceColumnNumber, name) {
     this.lineNumber = lineNumber;
     this.columnNumber = columnNumber;
     this.sourceURL = sourceURL;
     this.sourceLineNumber = sourceLineNumber;
     this.sourceColumnNumber = sourceColumnNumber;
     this.name = name;
   }
 };
 
 /**
  * @interface
  */
-WebInspector.SourceMap = function() {};
+SDK.SourceMap = function() {};
 
-WebInspector.SourceMap.prototype = {
+SDK.SourceMap.prototype = {
   /**
    * @return {string}
    */
   compiledURL: function() {},
 
   /**
    * @return {string}
    */
   url: function() {},
 
   /**
    * @return {!Array<string>}
    */
   sourceURLs: function() {},
 
   /**
    * @param {string} sourceURL
-   * @param {!WebInspector.ResourceType} contentType
-   * @return {!WebInspector.ContentProvider}
+   * @param {!Common.ResourceType} contentType
+   * @return {!Common.ContentProvider}
    */
   sourceContentProvider: function(sourceURL, contentType) {},
 
   /**
    * @param {string} sourceURL
    * @return {?string}
    */
   embeddedContentByURL: function(sourceURL) {},
 
   /**
    * @param {number} lineNumber in compiled resource
    * @param {number} columnNumber in compiled resource
-   * @return {?WebInspector.SourceMapEntry}
+   * @return {?SDK.SourceMapEntry}
    */
   findEntry: function(lineNumber, columnNumber) {},
 
   /**
    * @return {boolean}
    */
   editable: function() {},
 
   /**
-   * @param {!Array<!WebInspector.TextRange>} ranges
+   * @param {!Array<!Common.TextRange>} ranges
    * @param {!Array<string>} texts
-   * @return {!Promise<?WebInspector.SourceMap.EditResult>}
+   * @return {!Promise<?SDK.SourceMap.EditResult>}
    */
   editCompiled: function(ranges, texts) {},
 };
 
 /**
  * @unrestricted
  */
-WebInspector.SourceMap.EditResult = class {
+SDK.SourceMap.EditResult = class {
   /**
-   * @param {!WebInspector.SourceMap} map
-   * @param {!Array<!WebInspector.SourceEdit>} compiledEdits
+   * @param {!SDK.SourceMap} map
+   * @param {!Array<!Common.SourceEdit>} compiledEdits
    * @param {!Map<string, string>} newSources
    */
   constructor(map, compiledEdits, newSources) {
     this.map = map;
     this.compiledEdits = compiledEdits;
     this.newSources = newSources;
   }
 };
 
 /**
  * @interface
  */
-WebInspector.SourceMapFactory = function() {};
+SDK.SourceMapFactory = function() {};
 
-WebInspector.SourceMapFactory.prototype = {
+SDK.SourceMapFactory.prototype = {
   /**
-   * @param {!WebInspector.Target} target
-   * @param {!WebInspector.SourceMap} sourceMap
-   * @return {!Promise<?WebInspector.SourceMap>}
+   * @param {!SDK.Target} target
+   * @param {!SDK.SourceMap} sourceMap
+   * @return {!Promise<?SDK.SourceMap>}
    */
   editableSourceMap: function(target, sourceMap) {},
 };
 
 /**
- * @implements {WebInspector.SourceMap}
+ * @implements {SDK.SourceMap}
  * @unrestricted
  */
-WebInspector.TextSourceMap = class {
+SDK.TextSourceMap = class {
   /**
    * Implements Source Map V3 model. See https://github.com/google/closure-compiler/wiki/Source-Maps
    * for format description.
    * @param {string} compiledURL
    * @param {string} sourceMappingURL
    * @param {!SourceMapV3} payload
    */
   constructor(compiledURL, sourceMappingURL, payload) {
-    if (!WebInspector.TextSourceMap._base64Map) {
+    if (!SDK.TextSourceMap._base64Map) {
       const base64Digits = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-      WebInspector.TextSourceMap._base64Map = {};
+      SDK.TextSourceMap._base64Map = {};
       for (var i = 0; i < base64Digits.length; ++i)
-        WebInspector.TextSourceMap._base64Map[base64Digits.charAt(i)] = i;
+        SDK.TextSourceMap._base64Map[base64Digits.charAt(i)] = i;
     }
 
     this._json = payload;
     this._compiledURL = compiledURL;
     this._sourceMappingURL = sourceMappingURL;
-    /** @type {?Array<!WebInspector.SourceMapEntry>} */
+    /** @type {?Array<!SDK.SourceMapEntry>} */
     this._mappings = null;
-    /** @type {!Map<string, !WebInspector.TextSourceMap.SourceInfo>} */
+    /** @type {!Map<string, !SDK.TextSourceMap.SourceInfo>} */
     this._sourceInfos = new Map();
     this._eachSection(this._parseSources.bind(this));
   }
 
   /**
    * @param {string} sourceMapURL
    * @param {string} compiledURL
-   * @return {!Promise<?WebInspector.TextSourceMap>}
-   * @this {WebInspector.TextSourceMap}
+   * @return {!Promise<?SDK.TextSourceMap>}
+   * @this {SDK.TextSourceMap}
    */
   static load(sourceMapURL, compiledURL) {
     var callback;
     var promise = new Promise(fulfill => callback = fulfill);
-    WebInspector.multitargetNetworkManager.loadResource(sourceMapURL, contentLoaded);
+    SDK.multitargetNetworkManager.loadResource(sourceMapURL, contentLoaded);
     return promise;
 
     /**
      * @param {number} statusCode
      * @param {!Object.<string, string>} headers
      * @param {string} content
      */
     function contentLoaded(statusCode, headers, content) {
       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));
+        callback(new SDK.TextSourceMap(compiledURL, baseURL, payload));
       } catch (e) {
         console.error(e);
-        WebInspector.console.warn('DevTools failed to parse SourceMap: ' + sourceMapURL);
+        Common.console.warn('DevTools failed to parse SourceMap: ' + sourceMapURL);
         callback(null);
       }
     }
   }
 
   /**
    * @override
    * @return {string}
    */
   compiledURL() {
@@ skipping 12 matching lines @@
    * @override
    * @return {!Array.<string>}
    */
   sourceURLs() {
     return this._sourceInfos.keysArray();
   }
 
   /**
    * @override
    * @param {string} sourceURL
-   * @param {!WebInspector.ResourceType} contentType
-   * @return {!WebInspector.ContentProvider}
+   * @param {!Common.ResourceType} contentType
+   * @return {!Common.ContentProvider}
    */
   sourceContentProvider(sourceURL, contentType) {
     var info = this._sourceInfos.get(sourceURL);
     if (info.content)
-      return WebInspector.StaticContentProvider.fromString(sourceURL, contentType, info.content);
-    return new WebInspector.CompilerSourceMappingContentProvider(sourceURL, contentType);
+      return Common.StaticContentProvider.fromString(sourceURL, contentType, info.content);
+    return new SDK.CompilerSourceMappingContentProvider(sourceURL, contentType);
   }
 
   /**
    * @override
    * @param {string} sourceURL
    * @return {?string}
    */
   embeddedContentByURL(sourceURL) {
     if (!this._sourceInfos.has(sourceURL))
       return null;
     return this._sourceInfos.get(sourceURL).content;
   }
 
   /**
    * @override
    * @return {boolean}
    */
   editable() {
     return false;
   }
 
   /**
    * @override
-   * @param {!Array<!WebInspector.TextRange>} ranges
+   * @param {!Array<!Common.TextRange>} ranges
    * @param {!Array<string>} texts
-   * @return {!Promise<?WebInspector.SourceMap.EditResult>}
+   * @return {!Promise<?SDK.SourceMap.EditResult>}
    */
   editCompiled(ranges, texts) {
-    return Promise.resolve(/** @type {?WebInspector.SourceMap.EditResult} */ (null));
+    return Promise.resolve(/** @type {?SDK.SourceMap.EditResult} */ (null));
   }
 
   /**
    * @override
    * @param {number} lineNumber in compiled resource
    * @param {number} columnNumber in compiled resource
-   * @return {?WebInspector.SourceMapEntry}
+   * @return {?SDK.SourceMapEntry}
    */
   findEntry(lineNumber, columnNumber) {
     var first = 0;
     var mappings = this.mappings();
     var count = mappings.length;
     while (count > 1) {
       var step = count >> 1;
       var middle = first + step;
       var mapping = mappings[middle];
       if (lineNumber < mapping.lineNumber ||
           (lineNumber === mapping.lineNumber && columnNumber < mapping.columnNumber)) {
         count = step;
       } else {
         first = middle;
         count -= step;
       }
     }
     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}
+   * @return {?SDK.SourceMapEntry}
    */
   firstSourceLineMapping(sourceURL, lineNumber) {
     var mappings = this._reversedMappings(sourceURL);
     var index = mappings.lowerBound(lineNumber, lineComparator);
     if (index >= mappings.length || mappings[index].sourceLineNumber !== lineNumber)
       return null;
     return mappings[index];
 
     /**
      * @param {number} lineNumber
-     * @param {!WebInspector.SourceMapEntry} mapping
+     * @param {!SDK.SourceMapEntry} mapping
      * @return {number}
      */
     function lineComparator(lineNumber, mapping) {
       return lineNumber - mapping.sourceLineNumber;
     }
   }
 
   /**
-   * @return {!Array<!WebInspector.SourceMapEntry>}
+   * @return {!Array<!SDK.SourceMapEntry>}
    */
   mappings() {
     if (this._mappings === null) {
       this._mappings = [];
       this._eachSection(this._parseMap.bind(this));
       this._json = null;
     }
-    return /** @type {!Array<!WebInspector.SourceMapEntry>} */ (this._mappings);
+    return /** @type {!Array<!SDK.SourceMapEntry>} */ (this._mappings);
   }
 
   /**
    * @param {string} sourceURL
-   * @return {!Array.<!WebInspector.SourceMapEntry>}
+   * @return {!Array.<!SDK.SourceMapEntry>}
    */
   _reversedMappings(sourceURL) {
     if (!this._sourceInfos.has(sourceURL))
       return [];
     var mappings = this.mappings();
     var info = this._sourceInfos.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
+     * @param {!SDK.SourceMapEntry} a
+     * @param {!SDK.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;
@@ skipping 17 matching lines @@
   /**
    * @param {!SourceMapV3} sourceMap
    */
   _parseSources(sourceMap) {
     var sourcesList = [];
     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 url = Common.ParsedURL.completeURL(this._sourceMappingURL, href) || href;
       var source = sourceMap.sourcesContent && sourceMap.sourcesContent[i];
       if (url === this._compiledURL && source)
-        url += WebInspector.UIString(' [sm]');
-      this._sourceInfos.set(url, new WebInspector.TextSourceMap.SourceInfo(source, null));
+        url += Common.UIString(' [sm]');
+      this._sourceInfos.set(url, new SDK.TextSourceMap.SourceInfo(source, null));
       sourcesList.push(url);
     }
-    sourceMap[WebInspector.TextSourceMap._sourcesListSymbol] = sourcesList;
+    sourceMap[SDK.TextSourceMap._sourcesListSymbol] = sourcesList;
   }
 
   /**
    * @param {!SourceMapV3} map
    * @param {number} lineNumber
    * @param {number} columnNumber
    */
   _parseMap(map, lineNumber, columnNumber) {
     var sourceIndex = 0;
     var sourceLineNumber = 0;
     var sourceColumnNumber = 0;
     var nameIndex = 0;
-    var sources = map[WebInspector.TextSourceMap._sourcesListSymbol];
+    var sources = map[SDK.TextSourceMap._sourcesListSymbol];
     var names = map.names || [];
-    var stringCharIterator = new WebInspector.TextSourceMap.StringCharIterator(map.mappings);
+    var stringCharIterator = new SDK.TextSourceMap.StringCharIterator(map.mappings);
     var sourceURL = sources[sourceIndex];
 
     while (true) {
       if (stringCharIterator.peek() === ',')
         stringCharIterator.next();
       else {
         while (stringCharIterator.peek() === ';') {
           lineNumber += 1;
           columnNumber = 0;
           stringCharIterator.next();
         }
         if (!stringCharIterator.hasNext())
           break;
       }
 
       columnNumber += this._decodeVLQ(stringCharIterator);
       if (!stringCharIterator.hasNext() || this._isSeparator(stringCharIterator.peek())) {
-        this._mappings.push(new WebInspector.SourceMapEntry(lineNumber, columnNumber));
+        this._mappings.push(new SDK.SourceMapEntry(lineNumber, columnNumber));
         continue;
       }
 
       var sourceIndexDelta = this._decodeVLQ(stringCharIterator);
       if (sourceIndexDelta) {
         sourceIndex += sourceIndexDelta;
         sourceURL = sources[sourceIndex];
       }
       sourceLineNumber += this._decodeVLQ(stringCharIterator);
       sourceColumnNumber += this._decodeVLQ(stringCharIterator);
 
       if (!stringCharIterator.hasNext() || this._isSeparator(stringCharIterator.peek())) {
         this._mappings.push(
-            new WebInspector.SourceMapEntry(lineNumber, columnNumber, sourceURL, sourceLineNumber, sourceColumnNumber));
+            new SDK.SourceMapEntry(lineNumber, columnNumber, sourceURL, sourceLineNumber, sourceColumnNumber));
         continue;
       }
 
       nameIndex += this._decodeVLQ(stringCharIterator);
-      this._mappings.push(new WebInspector.SourceMapEntry(
+      this._mappings.push(new SDK.SourceMapEntry(
           lineNumber, columnNumber, sourceURL, sourceLineNumber, sourceColumnNumber, names[nameIndex]));
     }
   }
 
   /**
    * @param {string} char
    * @return {boolean}
    */
   _isSeparator(char) {
     return char === ',' || char === ';';
   }
 
   /**
-   * @param {!WebInspector.TextSourceMap.StringCharIterator} stringCharIterator
+   * @param {!SDK.TextSourceMap.StringCharIterator} stringCharIterator
    * @return {number}
    */
   _decodeVLQ(stringCharIterator) {
     // Read unsigned value.
     var result = 0;
     var shift = 0;
     do {
-      var digit = WebInspector.TextSourceMap._base64Map[stringCharIterator.next()];
-      result += (digit & WebInspector.TextSourceMap._VLQ_BASE_MASK) << shift;
-      shift += WebInspector.TextSourceMap._VLQ_BASE_SHIFT;
-    } while (digit & WebInspector.TextSourceMap._VLQ_CONTINUATION_MASK);
+      var digit = SDK.TextSourceMap._base64Map[stringCharIterator.next()];
+      result += (digit & SDK.TextSourceMap._VLQ_BASE_MASK) << shift;
+      shift += SDK.TextSourceMap._VLQ_BASE_SHIFT;
+    } while (digit & SDK.TextSourceMap._VLQ_CONTINUATION_MASK);
 
     // Fix the sign.
     var negative = result & 1;
     result >>= 1;
     return negative ? -result : result;
   }
 
   /**
    * @param {string} url
-   * @param {!WebInspector.TextRange} textRange
-   * @return {!WebInspector.TextRange}
+   * @param {!Common.TextRange} textRange
+   * @return {!Common.TextRange}
    */
   reverseMapTextRange(url, textRange) {
     /**
      * @param {!{lineNumber: number, columnNumber: number}} position
-     * @param {!WebInspector.SourceMapEntry} mapping
+     * @param {!SDK.SourceMapEntry} mapping
      * @return {number}
      */
     function comparator(position, mapping) {
       if (position.lineNumber !== mapping.sourceLineNumber)
         return position.lineNumber - mapping.sourceLineNumber;
 
       return position.columnNumber - mapping.sourceColumnNumber;
     }
 
     var mappings = this._reversedMappings(url);
     var startIndex =
         mappings.lowerBound({lineNumber: textRange.startLine, columnNumber: textRange.startColumn}, comparator);
     var endIndex = mappings.upperBound({lineNumber: textRange.endLine, columnNumber: textRange.endColumn}, comparator);
 
     var startMapping = mappings[startIndex];
     var endMapping = mappings[endIndex];
-    return new WebInspector.TextRange(
+    return new Common.TextRange(
         startMapping.lineNumber, startMapping.columnNumber, endMapping.lineNumber, endMapping.columnNumber);
   }
 };
 
-WebInspector.TextSourceMap._VLQ_BASE_SHIFT = 5;
-WebInspector.TextSourceMap._VLQ_BASE_MASK = (1 << 5) - 1;
-WebInspector.TextSourceMap._VLQ_CONTINUATION_MASK = 1 << 5;
+SDK.TextSourceMap._VLQ_BASE_SHIFT = 5;
+SDK.TextSourceMap._VLQ_BASE_MASK = (1 << 5) - 1;
+SDK.TextSourceMap._VLQ_CONTINUATION_MASK = 1 << 5;
 
 
 /**
  * @unrestricted
  */
-WebInspector.TextSourceMap.StringCharIterator = class {
+SDK.TextSourceMap.StringCharIterator = class {
   /**
    * @param {string} string
    */
   constructor(string) {
     this._string = string;
     this._position = 0;
   }
 
   /**
    * @return {string}
@@ skipping 13 matching lines @@
    * @return {boolean}
    */
   hasNext() {
     return this._position < this._string.length;
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.TextSourceMap.SourceInfo = class {
+SDK.TextSourceMap.SourceInfo = class {
   /**
    * @param {?string} content
-   * @param {?Array<!WebInspector.SourceMapEntry>} reverseMappings
+   * @param {?Array<!SDK.SourceMapEntry>} reverseMappings
    */
   constructor(content, reverseMappings) {
     this.content = content;
     this.reverseMappings = reverseMappings;
   }
 };
 
-WebInspector.TextSourceMap._sourcesListSymbol = Symbol('sourcesList');
+SDK.TextSourceMap._sourcesListSymbol = Symbol('sourcesList');