third_party/WebKit/Source/devtools/front_end/workspace/Workspace.js

   1 /*
   2  * Copyright (C) 2012 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 /**
  32  * @interface
  33  */
  34 WebInspector.ProjectSearchConfig = function() {}
  35
  36 WebInspector.ProjectSearchConfig.prototype = {
  37     /**
  38      * @return {string}
  39      */
  40     query: function() { },
  41
  42     /**
  43      * @return {boolean}
  44      */
  45     ignoreCase: function() { },
  46
  47     /**
  48      * @return {boolean}
  49      */
  50     isRegex: function() { },
  51
  52     /**
  53      * @return {!Array.<string>}
  54      */
  55     queries: function() { },
  56
  57     /**
  58      * @param {string} filePath
  59      * @return {boolean}
  60      */
  61     filePathMatchesFileQuery: function(filePath) { }
  62 }
  63
  64 /**
  65  * @constructor
  66  * @param {string} parentPath
  67  * @param {string} name
  68  * @param {string} originURL
  69  * @param {string} url
  70  * @param {!WebInspector.ResourceType} contentType
  71  */
  72 WebInspector.FileDescriptor = function(parentPath, name, originURL, url, contentType)
  73 {
  74     this.parentPath = parentPath;
  75     this.name = name;
  76     this.originURL = originURL;
  77     this.url = url;
  78     this.contentType = contentType;
  79 }
  80
  81 /**
  82  * @interface
  83  * @extends {WebInspector.EventTarget}
  84  */
  85 WebInspector.ProjectDelegate = function() { }
  86
  87 WebInspector.ProjectDelegate.Events = {
  88     FileAdded: "FileAdded",
  89     FileRemoved: "FileRemoved",
  90 }
  91
  92 WebInspector.ProjectDelegate.prototype = {
  93     /**
  94      * @return {string}
  95      */
  96     type: function() { },
  97
  98     /**
  99      * @return {string}
 100      */
 101     displayName: function() { },
 102
 103     /**
 104      * @return {string}
 105      */
 106     url: function() { },
 107
 108     /**
 109      * @param {string} path
 110      * @param {function(?Date, ?number)} callback
 111      */
 112     requestMetadata: function(path, callback) { },
 113
 114     /**
 115      * @param {string} path
 116      * @param {function(?string)} callback
 117      */
 118     requestFileContent: function(path, callback) { },
 119
 120     /**
 121      * @return {boolean}
 122      */
 123     canSetFileContent: function() { },
 124
 125     /**
 126      * @param {string} path
 127      * @param {string} newContent
 128      * @param {function(?string)} callback
 129      */
 130     setFileContent: function(path, newContent, callback) { },
 131
 132     /**
 133      * @return {boolean}
 134      */
 135     canRename: function() { },
 136
 137     /**
 138      * @param {string} path
 139      * @param {string} newName
 140      * @param {function(boolean, string=, string=, string=, !WebInspector.ResourceType=)} callback
 141      */
 142     rename: function(path, newName, callback) { },
 143
 144     /**
 145      * @param {string} path
 146      * @param {function()=} callback
 147      */
 148     refresh: function(path, callback) { },
 149
 150     /**
 151      * @param {string} path
 152      */
 153     excludeFolder: function(path) { },
 154
 155     /**
 156      * @param {string} path
 157      * @param {?string} name
 158      * @param {string} content
 159      * @param {function(?string)} callback
 160      */
 161     createFile: function(path, name, content, callback) { },
 162
 163     /**
 164      * @param {string} path
 165      */
 166     deleteFile: function(path) { },
 167
 168     remove: function() { },
 169
 170     /**
 171      * @param {string} path
 172      * @param {string} query
 173      * @param {boolean} caseSensitive
 174      * @param {boolean} isRegex
 175      * @param {function(!Array.<!WebInspector.ContentProvider.SearchMatch>)} callback
 176      */
 177     searchInFileContent: function(path, query, caseSensitive, isRegex, callback) { },
 178
 179     /**
 180      * @param {!WebInspector.ProjectSearchConfig} searchConfig
 181      * @param {!Array.<string>} filesMathingFileQuery
 182      * @param {!WebInspector.Progress} progress
 183      * @param {function(!Array.<string>)} callback
 184      */
 185     findFilesMatchingSearchRequest: function(searchConfig, filesMathingFileQuery, progress, callback) { },
 186
 187     /**
 188      * @param {!WebInspector.Progress} progress
 189      */
 190     indexContent: function(progress) { }
 191 }
 192
 193 /**
 194  * @constructor
 195  * @extends {WebInspector.Object}
 196  * @param {!WebInspector.Workspace} workspace
 197  * @param {string} projectId
 198  * @param {!WebInspector.ProjectDelegate} projectDelegate
 199  */
 200 WebInspector.Project = function(workspace, projectId, projectDelegate)
 201 {
 202     /** @type {!Map.<string, !{uiSourceCode: !WebInspector.UISourceCode, index: number}>} */
 203     this._uiSourceCodesMap = new Map();
 204     /** @type {!Array.<!WebInspector.UISourceCode>} */
 205     this._uiSourceCodesList = [];
 206     this._workspace = workspace;
 207     this._projectId = projectId;
 208     this._projectDelegate = projectDelegate;
 209     this._url = this._projectDelegate.url();
 210     this._displayName = this._projectDelegate.displayName();
 211     projectDelegate.addEventListener(WebInspector.ProjectDelegate.Events.FileAdded, this._fileAdded, this);
 212     projectDelegate.addEventListener(WebInspector.ProjectDelegate.Events.FileRemoved, this._fileRemoved, this);
 213 }
 214
 215 /**
 216  * @enum {string}
 217  */
 218 WebInspector.Project.Events = {
 219     DisplayNameUpdated: "DisplayNameUpdated"
 220 };
 221
 222 WebInspector.Project.prototype = {
 223     /**
 224      * @return {string}
 225      */
 226     id: function()
 227     {
 228         return this._projectId;
 229     },
 230
 231     /**
 232      * @return {string}
 233      */
 234     type: function()
 235     {
 236         return this._projectDelegate.type();
 237     },
 238
 239     /**
 240      * @return {string}
 241      */
 242     displayName: function()
 243     {
 244         return this._displayName;
 245     },
 246
 247     /**
 248      * @param {string} displayName
 249      */
 250     setDisplayName: function(displayName)
 251     {
 252         if (this._displayName === displayName)
 253             return;
 254         this._displayName = displayName;
 255         this.dispatchEventToListeners(WebInspector.Project.Events.DisplayNameUpdated);
 256     },
 257
 258     /**
 259      * @return {string}
 260      */
 261     url: function()
 262     {
 263         return this._url;
 264     },
 265
 266     /**
 267      * @return {boolean}
 268      */
 269     isServiceProject: function()
 270     {
 271         return this._projectDelegate.type() === WebInspector.projectTypes.Debugger || this._projectDelegate.type() === WebInspector.projectTypes.Formatter || this._projectDelegate.type() === WebInspector.projectTypes.Service;
 272     },
 273
 274
 275     /**
 276      * @param {!WebInspector.Event} event
 277      */
 278     _fileAdded: function(event)
 279     {
 280         var fileDescriptor = /** @type {!WebInspector.FileDescriptor} */ (event.data);
 281         var path = fileDescriptor.parentPath ? fileDescriptor.parentPath + "/" + fileDescriptor.name : fileDescriptor.name;
 282         var uiSourceCode = this.uiSourceCode(path);
 283         if (uiSourceCode)
 284             return;
 285
 286         uiSourceCode = new WebInspector.UISourceCode(this, fileDescriptor.parentPath, fileDescriptor.name, fileDescriptor.originURL, fileDescriptor.url, fileDescriptor.contentType);
 287
 288         this._uiSourceCodesMap.set(path, {uiSourceCode: uiSourceCode, index: this._uiSourceCodesList.length});
 289         this._uiSourceCodesList.push(uiSourceCode);
 290         this._workspace.dispatchEventToListeners(WebInspector.Workspace.Events.UISourceCodeAdded, uiSourceCode);
 291     },
 292
 293     /**
 294      * @param {!WebInspector.Event} event
 295      */
 296     _fileRemoved: function(event)
 297     {
 298         var path = /** @type {string} */ (event.data);
 299         this._removeFile(path);
 300     },
 301
 302     /**
 303      * @param {string} path
 304      */
 305     _removeFile: function(path)
 306     {
 307         var uiSourceCode = this.uiSourceCode(path);
 308         if (!uiSourceCode)
 309             return;
 310
 311         var entry = this._uiSourceCodesMap.get(path);
 312         var movedUISourceCode = this._uiSourceCodesList[this._uiSourceCodesList.length - 1];
 313         this._uiSourceCodesList[entry.index] = movedUISourceCode;
 314         var movedEntry = this._uiSourceCodesMap.get(movedUISourceCode.path());
 315         movedEntry.index = entry.index;
 316         this._uiSourceCodesList.splice(this._uiSourceCodesList.length - 1, 1);
 317         this._uiSourceCodesMap.delete(path);
 318         this._workspace.dispatchEventToListeners(WebInspector.Workspace.Events.UISourceCodeRemoved, entry.uiSourceCode);
 319     },
 320
 321     _remove: function()
 322     {
 323         this._projectDelegate.removeEventListener(WebInspector.ProjectDelegate.Events.FileAdded, this._fileAdded, this);
 324         this._projectDelegate.removeEventListener(WebInspector.ProjectDelegate.Events.FileRemoved, this._fileRemoved, this);
 325         this._workspace.dispatchEventToListeners(WebInspector.Workspace.Events.ProjectRemoved, this);
 326         this._uiSourceCodesMap = new Map();
 327         this._uiSourceCodesList = [];
 328     },
 329
 330     /**
 331      * @return {!WebInspector.Workspace}
 332      */
 333     workspace: function()
 334     {
 335         return this._workspace;
 336     },
 337
 338     /**
 339      * @param {string} path
 340      * @return {?WebInspector.UISourceCode}
 341      */
 342     uiSourceCode: function(path)
 343     {
 344         var entry = this._uiSourceCodesMap.get(path);
 345         return entry ? entry.uiSourceCode : null;
 346     },
 347
 348     /**
 349      * @param {string} originURL
 350      * @return {?WebInspector.UISourceCode}
 351      */
 352     uiSourceCodeForOriginURL: function(originURL)
 353     {
 354         for (var i = 0; i < this._uiSourceCodesList.length; ++i) {
 355             var uiSourceCode = this._uiSourceCodesList[i];
 356             if (uiSourceCode.originURL() === originURL)
 357                 return uiSourceCode;
 358         }
 359         return null;
 360     },
 361
 362     /**
 363      * @return {!Array.<!WebInspector.UISourceCode>}
 364      */
 365     uiSourceCodes: function()
 366     {
 367         return this._uiSourceCodesList;
 368     },
 369
 370     /**
 371      * @param {!WebInspector.UISourceCode} uiSourceCode
 372      * @param {function(?Date, ?number)} callback
 373      */
 374     requestMetadata: function(uiSourceCode, callback)
 375     {
 376         this._projectDelegate.requestMetadata(uiSourceCode.path(), callback);
 377     },
 378
 379     /**
 380      * @param {!WebInspector.UISourceCode} uiSourceCode
 381      * @param {function(?string)} callback
 382      */
 383     requestFileContent: function(uiSourceCode, callback)
 384     {
 385         this._projectDelegate.requestFileContent(uiSourceCode.path(), callback);
 386     },
 387
 388     /**
 389      * @return {boolean}
 390      */
 391     canSetFileContent: function()
 392     {
 393         return this._projectDelegate.canSetFileContent();
 394     },
 395
 396     /**
 397      * @param {!WebInspector.UISourceCode} uiSourceCode
 398      * @param {string} newContent
 399      * @param {function(?string)} callback
 400      */
 401     setFileContent: function(uiSourceCode, newContent, callback)
 402     {
 403         this._projectDelegate.setFileContent(uiSourceCode.path(), newContent, onSetContent.bind(this));
 404
 405         /**
 406          * @param {?string} content
 407          * @this {WebInspector.Project}
 408          */
 409         function onSetContent(content)
 410         {
 411             this._workspace.dispatchEventToListeners(WebInspector.Workspace.Events.UISourceCodeContentCommitted, { uiSourceCode: uiSourceCode, content: newContent });
 412             callback(content);
 413         }
 414     },
 415
 416     /**
 417      * @return {boolean}
 418      */
 419     canRename: function()
 420     {
 421         return this._projectDelegate.canRename();
 422     },
 423
 424     /**
 425      * @param {!WebInspector.UISourceCode} uiSourceCode
 426      * @param {string} newName
 427      * @param {function(boolean, string=, string=, string=, !WebInspector.ResourceType=)} callback
 428      */
 429     rename: function(uiSourceCode, newName, callback)
 430     {
 431         if (newName === uiSourceCode.name()) {
 432             callback(true, uiSourceCode.name(), uiSourceCode.networkURL(), uiSourceCode.originURL(), uiSourceCode.contentType());
 433             return;
 434         }
 435
 436         this._projectDelegate.rename(uiSourceCode.path(), newName, innerCallback.bind(this));
 437
 438         /**
 439          * @param {boolean} success
 440          * @param {string=} newName
 441          * @param {string=} newURL
 442          * @param {string=} newOriginURL
 443          * @param {!WebInspector.ResourceType=} newContentType
 444          * @this {WebInspector.Project}
 445          */
 446         function innerCallback(success, newName, newURL, newOriginURL, newContentType)
 447         {
 448             if (!success || !newName) {
 449                 callback(false);
 450                 return;
 451             }
 452             var oldPath = uiSourceCode.path();
 453             var newPath = uiSourceCode.parentPath() ? uiSourceCode.parentPath() + "/" + newName : newName;
 454             var value = /** @type {!{uiSourceCode: !WebInspector.UISourceCode, index: number}} */ (this._uiSourceCodesMap.get(oldPath));
 455             this._uiSourceCodesMap.set(newPath, value);
 456             this._uiSourceCodesMap.delete(oldPath);
 457             callback(true, newName, newURL, newOriginURL, newContentType);
 458         }
 459     },
 460
 461     /**
 462      * @param {string} path
 463      * @param {function()=} callback
 464      */
 465     refresh: function(path, callback)
 466     {
 467         this._projectDelegate.refresh(path, callback);
 468     },
 469
 470     /**
 471      * @param {string} path
 472      */
 473     excludeFolder: function(path)
 474     {
 475         this._projectDelegate.excludeFolder(path);
 476         var uiSourceCodes = this._uiSourceCodesList.slice();
 477         for (var i = 0; i < uiSourceCodes.length; ++i) {
 478             var uiSourceCode = uiSourceCodes[i];
 479             if (uiSourceCode.path().startsWith(path.substr(1)))
 480                 this._removeFile(uiSourceCode.path());
 481         }
 482     },
 483
 484     /**
 485      * @param {string} path
 486      * @param {?string} name
 487      * @param {string} content
 488      * @param {function(?string)} callback
 489      */
 490     createFile: function(path, name, content, callback)
 491     {
 492         this._projectDelegate.createFile(path, name, content, innerCallback);
 493
 494         function innerCallback(filePath)
 495         {
 496             callback(filePath);
 497         }
 498     },
 499
 500     /**
 501      * @param {string} path
 502      */
 503     deleteFile: function(path)
 504     {
 505         this._projectDelegate.deleteFile(path);
 506     },
 507
 508     remove: function()
 509     {
 510         this._projectDelegate.remove();
 511     },
 512
 513     /**
 514      * @param {!WebInspector.UISourceCode} uiSourceCode
 515      * @param {string} query
 516      * @param {boolean} caseSensitive
 517      * @param {boolean} isRegex
 518      * @param {function(!Array.<!WebInspector.ContentProvider.SearchMatch>)} callback
 519      */
 520     searchInFileContent: function(uiSourceCode, query, caseSensitive, isRegex, callback)
 521     {
 522         this._projectDelegate.searchInFileContent(uiSourceCode.path(), query, caseSensitive, isRegex, callback);
 523     },
 524
 525     /**
 526      * @param {!WebInspector.ProjectSearchConfig} searchConfig
 527      * @param {!Array.<string>} filesMathingFileQuery
 528      * @param {!WebInspector.Progress} progress
 529      * @param {function(!Array.<string>)} callback
 530      */
 531     findFilesMatchingSearchRequest: function(searchConfig, filesMathingFileQuery, progress, callback)
 532     {
 533         this._projectDelegate.findFilesMatchingSearchRequest(searchConfig, filesMathingFileQuery, progress, callback);
 534     },
 535
 536     /**
 537      * @param {!WebInspector.Progress} progress
 538      */
 539     indexContent: function(progress)
 540     {
 541         this._projectDelegate.indexContent(progress);
 542     },
 543
 544     __proto__: WebInspector.Object.prototype
 545 }
 546
 547 /**
 548  * @enum {string}
 549  */
 550 WebInspector.projectTypes = {
 551     Debugger: "debugger",
 552     Formatter: "formatter",
 553     Network: "network",
 554     Snippets: "snippets",
 555     FileSystem: "filesystem",
 556     ContentScripts: "contentscripts",
 557     Service: "service"
 558 }
 559
 560 /**
 561  * @constructor
 562  * @extends {WebInspector.Object}
 563  * @param {!WebInspector.FileSystemMapping} fileSystemMapping
 564  */
 565 WebInspector.Workspace = function(fileSystemMapping)
 566 {
 567     this._fileSystemMapping = fileSystemMapping;
 568     /** @type {!Object.<string, !WebInspector.Project>} */
 569     this._projects = {};
 570     this._hasResourceContentTrackingExtensions = false;
 571 }
 572
 573 WebInspector.Workspace.Events = {
 574     UISourceCodeAdded: "UISourceCodeAdded",
 575     UISourceCodeRemoved: "UISourceCodeRemoved",
 576     UISourceCodeContentCommitted: "UISourceCodeContentCommitted",
 577     UISourceCodeWorkingCopyChanged: "UISourceCodeWorkingCopyChanged",
 578     ProjectAdded: "ProjectAdded",
 579     ProjectRemoved: "ProjectRemoved"
 580 }
 581
 582 WebInspector.Workspace.prototype = {
 583     /**
 584      * @return {!Array.<!WebInspector.UISourceCode>}
 585      */
 586     unsavedSourceCodes: function()
 587     {
 588         /**
 589          * @param {!WebInspector.UISourceCode} sourceCode
 590          * @return {boolean}
 591          */
 592         function filterUnsaved(sourceCode)
 593         {
 594             return sourceCode.isDirty();
 595         }
 596
 597         var unsavedSourceCodes = [];
 598         var projects = this.projectsForType(WebInspector.projectTypes.FileSystem);
 599         for (var i = 0; i < projects.length; ++i)
 600             unsavedSourceCodes = unsavedSourceCodes.concat(projects[i].uiSourceCodes().filter(filterUnsaved));
 601
 602         return unsavedSourceCodes;
 603     },
 604
 605     /**
 606      * @param {string} projectId
 607      * @param {string} path
 608      * @return {?WebInspector.UISourceCode}
 609      */
 610     uiSourceCode: function(projectId, path)
 611     {
 612         var project = this._projects[projectId];
 613         return project ? project.uiSourceCode(path) : null;
 614     },
 615
 616     /**
 617      * @param {string} originURL
 618      * @return {?WebInspector.UISourceCode}
 619      */
 620     uiSourceCodeForOriginURL: function(originURL)
 621     {
 622         var projects = this.projectsForType(WebInspector.projectTypes.Network);
 623         projects = projects.concat(this.projectsForType(WebInspector.projectTypes.ContentScripts));
 624         for (var i = 0; i < projects.length; ++i) {
 625             var project = projects[i];
 626             var uiSourceCode = project.uiSourceCodeForOriginURL(originURL);
 627             if (uiSourceCode)
 628                 return uiSourceCode;
 629         }
 630         return null;
 631     },
 632
 633     /**
 634      * @param {string} originURL
 635      * @return {?WebInspector.UISourceCode}
 636      */
 637     filesystemUISourceCode: function(originURL)
 638     {
 639         var projects = this.projectsForType(WebInspector.projectTypes.FileSystem);
 640         for (var i = 0; i < projects.length; ++i) {
 641             var project = projects[i];
 642             var uiSourceCode = project.uiSourceCodeForOriginURL(originURL);
 643             if (uiSourceCode)
 644                 return uiSourceCode;
 645         }
 646         return null;
 647     },
 648
 649     /**
 650      * @param {string} type
 651      * @return {!Array.<!WebInspector.UISourceCode>}
 652      */
 653     uiSourceCodesForProjectType: function(type)
 654     {
 655         var result = [];
 656         for (var projectName in this._projects) {
 657             var project = this._projects[projectName];
 658             if (project.type() === type)
 659                 result = result.concat(project.uiSourceCodes());
 660         }
 661         return result;
 662     },
 663
 664     /**
 665      * @param {string} projectId
 666      * @param {!WebInspector.ProjectDelegate} projectDelegate
 667      * @return {!WebInspector.Project}
 668      */
 669     addProject: function(projectId, projectDelegate)
 670     {
 671         var project = new WebInspector.Project(this, projectId, projectDelegate);
 672         this._projects[projectId] = project;
 673         this.dispatchEventToListeners(WebInspector.Workspace.Events.ProjectAdded, project);
 674         return project;
 675     },
 676
 677     /**
 678      * @param {string} projectId
 679      */
 680     removeProject: function(projectId)
 681     {
 682         var project = this._projects[projectId];
 683         if (!project)
 684             return;
 685         delete this._projects[projectId];
 686         project._remove();
 687     },
 688
 689     /**
 690      * @param {string} projectId
 691      * @return {!WebInspector.Project}
 692      */
 693     project: function(projectId)
 694     {
 695         return this._projects[projectId];
 696     },
 697
 698     /**
 699      * @return {!Array.<!WebInspector.Project>}
 700      */
 701     projects: function()
 702     {
 703         return Object.values(this._projects);
 704     },
 705
 706     /**
 707      * @param {string} type
 708      * @return {!Array.<!WebInspector.Project>}
 709      */
 710     projectsForType: function(type)
 711     {
 712         function filterByType(project)
 713         {
 714             return project.type() === type;
 715         }
 716         return this.projects().filter(filterByType);
 717     },
 718
 719     /**
 720      * @return {!Array.<!WebInspector.UISourceCode>}
 721      */
 722     uiSourceCodes: function()
 723     {
 724         var result = [];
 725         for (var projectId in this._projects) {
 726             var project = this._projects[projectId];
 727             result = result.concat(project.uiSourceCodes());
 728         }
 729         return result;
 730     },
 731
 732     /**
 733      * @param {boolean} hasExtensions
 734      */
 735     setHasResourceContentTrackingExtensions: function(hasExtensions)
 736     {
 737         this._hasResourceContentTrackingExtensions = hasExtensions;
 738     },
 739
 740     /**
 741      * @return {boolean}
 742      */
 743     hasResourceContentTrackingExtensions: function()
 744     {
 745         return this._hasResourceContentTrackingExtensions;
 746     },
 747
 748     __proto__: WebInspector.Object.prototype
 749 }
 750
 751 /**
 752  * @type {!WebInspector.Workspace}
 753  */
 754 WebInspector.workspace;