third_party/WebKit/Source/devtools/front_end/snippets/ScriptSnippetModel.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  * @constructor
  33  * @extends {WebInspector.Object}
  34  * @implements {WebInspector.TargetManager.Observer}
  35  * @param {!WebInspector.Workspace} workspace
  36  */
  37 WebInspector.ScriptSnippetModel = function(workspace)
  38 {
  39     this._workspace = workspace;
  40     /** @type {!Object.<string, !WebInspector.UISourceCode>} */
  41     this._uiSourceCodeForSnippetId = {};
  42     /** @type {!Map.<!WebInspector.UISourceCode, string>} */
  43     this._snippetIdForUISourceCode = new Map();
  44
  45     /** @type {!Map.<!WebInspector.Target, !WebInspector.SnippetScriptMapping>} */
  46     this._mappingForTarget = new Map();
  47     this._snippetStorage = new WebInspector.SnippetStorage("script", "Script snippet #");
  48     this._lastSnippetEvaluationIndexSetting = WebInspector.settings.createSetting("lastSnippetEvaluationIndex", 0);
  49     this._projectId = WebInspector.projectTypes.Snippets + ":";
  50     this._projectDelegate = new WebInspector.SnippetsProjectDelegate(workspace, this, this._projectId);
  51     this._project = this._workspace.project(this._projectId);
  52     this._loadSnippets();
  53     WebInspector.targetManager.observeTargets(this);
  54 }
  55
  56 WebInspector.ScriptSnippetModel.snippetSourceURLPrefix = "snippets:///";
  57
  58
  59 WebInspector.ScriptSnippetModel.prototype = {
  60
  61     /**
  62      * @override
  63      * @param {!WebInspector.Target} target
  64      */
  65     targetAdded: function(target)
  66     {
  67         var debuggerModel = WebInspector.DebuggerModel.fromTarget(target);
  68         if (debuggerModel)
  69             this._mappingForTarget.set(target, new WebInspector.SnippetScriptMapping(debuggerModel, this));
  70     },
  71
  72     /**
  73      * @override
  74      * @param {!WebInspector.Target} target
  75      */
  76     targetRemoved: function(target)
  77     {
  78         if (WebInspector.DebuggerModel.fromTarget(target))
  79             this._mappingForTarget.remove(target);
  80     },
  81
  82     /**
  83      * @param {!WebInspector.Target} target
  84      * @return {!WebInspector.SnippetScriptMapping|undefined}
  85      */
  86     snippetScriptMapping: function(target)
  87     {
  88         return this._mappingForTarget.get(target);
  89     },
  90
  91     /**
  92      * @return {!WebInspector.Project}
  93      */
  94     project: function()
  95     {
  96         return this._project;
  97     },
  98
  99     _loadSnippets: function()
 100     {
 101         var snippets = this._snippetStorage.snippets();
 102         for (var i = 0; i < snippets.length; ++i)
 103             this._addScriptSnippet(snippets[i]);
 104     },
 105
 106     /**
 107      * @param {string} content
 108      * @return {string}
 109      */
 110     createScriptSnippet: function(content)
 111     {
 112         var snippet = this._snippetStorage.createSnippet();
 113         snippet.content = content;
 114         return this._addScriptSnippet(snippet);
 115     },
 116
 117     /**
 118      * @param {!WebInspector.Snippet} snippet
 119      * @return {string}
 120      */
 121     _addScriptSnippet: function(snippet)
 122     {
 123         var path = this._projectDelegate.addSnippet(snippet.name, new WebInspector.SnippetContentProvider(snippet));
 124         var uiSourceCode = this._workspace.uiSourceCode(this._projectId, path);
 125         if (!uiSourceCode) {
 126             console.assert(uiSourceCode);
 127             return "";
 128         }
 129         uiSourceCode.addEventListener(WebInspector.UISourceCode.Events.WorkingCopyChanged, this._workingCopyChanged, this);
 130         this._snippetIdForUISourceCode.set(uiSourceCode, snippet.id);
 131         var breakpointLocations = this._removeBreakpoints(uiSourceCode);
 132         this._restoreBreakpoints(uiSourceCode, breakpointLocations);
 133         this._uiSourceCodeForSnippetId[snippet.id] = uiSourceCode;
 134         return path;
 135     },
 136
 137     /**
 138      * @param {!WebInspector.Event} event
 139      */
 140     _workingCopyChanged: function(event)
 141     {
 142         var uiSourceCode = /** @type {!WebInspector.UISourceCode} */ (event.target);
 143         this._scriptSnippetEdited(uiSourceCode);
 144     },
 145
 146     /**
 147      * @param {string} path
 148      */
 149     deleteScriptSnippet: function(path)
 150     {
 151         var uiSourceCode = this._workspace.uiSourceCode(this._projectId, path);
 152         if (!uiSourceCode)
 153             return;
 154         var snippetId = this._snippetIdForUISourceCode.get(uiSourceCode) || "";
 155         var snippet = this._snippetStorage.snippetForId(snippetId);
 156         this._snippetStorage.deleteSnippet(snippet);
 157         this._removeBreakpoints(uiSourceCode);
 158         this._releaseSnippetScript(uiSourceCode);
 159         delete this._uiSourceCodeForSnippetId[snippet.id];
 160         this._snippetIdForUISourceCode.remove(uiSourceCode);
 161         this._projectDelegate.removeFile(snippet.name);
 162     },
 163
 164     /**
 165      * @param {string} name
 166      * @param {string} newName
 167      * @param {function(boolean, string=)} callback
 168      */
 169     renameScriptSnippet: function(name, newName, callback)
 170     {
 171         newName = newName.trim();
 172         if (!newName || newName.indexOf("/") !== -1 || name === newName || this._snippetStorage.snippetForName(newName)) {
 173             callback(false);
 174             return;
 175         }
 176         var snippet = this._snippetStorage.snippetForName(name);
 177         console.assert(snippet, "Snippet '" + name + "' was not found.");
 178         var uiSourceCode = this._uiSourceCodeForSnippetId[snippet.id];
 179         console.assert(uiSourceCode, "No uiSourceCode was found for snippet '" + name + "'.");
 180
 181         var breakpointLocations = this._removeBreakpoints(uiSourceCode);
 182         snippet.name = newName;
 183         this._restoreBreakpoints(uiSourceCode, breakpointLocations);
 184         callback(true, newName);
 185     },
 186
 187     /**
 188      * @param {string} name
 189      * @param {string} newContent
 190      */
 191     _setScriptSnippetContent: function(name, newContent)
 192     {
 193         var snippet = this._snippetStorage.snippetForName(name);
 194         snippet.content = newContent;
 195     },
 196
 197     /**
 198      * @param {!WebInspector.UISourceCode} uiSourceCode
 199      */
 200     _scriptSnippetEdited: function(uiSourceCode)
 201     {
 202         var breakpointLocations = this._removeBreakpoints(uiSourceCode);
 203         this._releaseSnippetScript(uiSourceCode);
 204         this._restoreBreakpoints(uiSourceCode, breakpointLocations);
 205         this._mappingForTarget.valuesArray().forEach(function(mapping) {mapping._restoreBreakpoints(uiSourceCode, breakpointLocations);});
 206     },
 207
 208     /**
 209      * @return {number}
 210      */
 211     _nextEvaluationIndex: function()
 212     {
 213         var evaluationIndex = this._lastSnippetEvaluationIndexSetting.get() + 1;
 214         this._lastSnippetEvaluationIndexSetting.set(evaluationIndex);
 215         return evaluationIndex;
 216     },
 217
 218     /**
 219      * @param {!WebInspector.ExecutionContext} executionContext
 220      * @param {!WebInspector.UISourceCode} uiSourceCode
 221      */
 222     evaluateScriptSnippet: function(executionContext, uiSourceCode)
 223     {
 224         var breakpointLocations = this._removeBreakpoints(uiSourceCode);
 225         this._releaseSnippetScript(uiSourceCode);
 226         this._restoreBreakpoints(uiSourceCode, breakpointLocations);
 227
 228         var target = executionContext.target();
 229         var debuggerModel = executionContext.debuggerModel;
 230         var evaluationIndex = this._nextEvaluationIndex();
 231         var mapping = this._mappingForTarget.get(target);
 232         mapping._setEvaluationIndex(evaluationIndex, uiSourceCode);
 233         var evaluationUrl = mapping._evaluationSourceURL(uiSourceCode);
 234         var expression = uiSourceCode.workingCopy();
 235         WebInspector.console.show();
 236         debuggerModel.compileScript(expression, "", true, executionContext.id, compileCallback.bind(this));
 237
 238         /**
 239          * @param {!DebuggerAgent.ScriptId=} scriptId
 240          * @param {?DebuggerAgent.ExceptionDetails=} exceptionDetails
 241          * @this {WebInspector.ScriptSnippetModel}
 242          */
 243         function compileCallback(scriptId, exceptionDetails)
 244         {
 245             var mapping = this._mappingForTarget.get(target);
 246             if (mapping.evaluationIndex(uiSourceCode) !== evaluationIndex)
 247                 return;
 248
 249             if (!scriptId) {
 250                 this._printRunOrCompileScriptResultFailure(target, exceptionDetails, evaluationUrl);
 251                 return;
 252             }
 253
 254             mapping._addScript(debuggerModel.scriptForId(scriptId), uiSourceCode);
 255             var breakpointLocations = this._removeBreakpoints(uiSourceCode);
 256             this._restoreBreakpoints(uiSourceCode, breakpointLocations);
 257
 258             this._runScript(scriptId, executionContext, evaluationUrl);
 259         }
 260     },
 261
 262     /**
 263      * @param {!DebuggerAgent.ScriptId} scriptId
 264      * @param {!WebInspector.ExecutionContext} executionContext
 265      * @param {?string=} sourceURL
 266      */
 267     _runScript: function(scriptId, executionContext, sourceURL)
 268     {
 269         var target = executionContext.target();
 270         executionContext.debuggerModel.runScript(scriptId, executionContext.id, "console", false, runCallback.bind(this, target));
 271
 272         /**
 273          * @param {!WebInspector.Target} target
 274          * @param {?RuntimeAgent.RemoteObject} result
 275          * @param {?DebuggerAgent.ExceptionDetails=} exceptionDetails
 276          * @this {WebInspector.ScriptSnippetModel}
 277          */
 278         function runCallback(target, result, exceptionDetails)
 279         {
 280             if (!exceptionDetails)
 281                 this._printRunScriptResult(target, result, sourceURL);
 282             else
 283                 this._printRunOrCompileScriptResultFailure(target, exceptionDetails, sourceURL);
 284         }
 285     },
 286
 287     /**
 288      * @param {!WebInspector.Target} target
 289      * @param {?RuntimeAgent.RemoteObject} result
 290      * @param {?string=} sourceURL
 291      */
 292     _printRunScriptResult: function(target, result, sourceURL)
 293     {
 294         var consoleMessage = new WebInspector.ConsoleMessage(
 295             target,
 296             WebInspector.ConsoleMessage.MessageSource.JS,
 297             WebInspector.ConsoleMessage.MessageLevel.Log,
 298             "",
 299             undefined,
 300             sourceURL,
 301             undefined,
 302             undefined,
 303             undefined,
 304             [result],
 305             undefined);
 306         target.consoleModel.addMessage(consoleMessage);
 307     },
 308
 309     /**
 310      * @param {!WebInspector.Target} target
 311      * @param {?DebuggerAgent.ExceptionDetails=} exceptionDetails
 312      * @param {?string=} sourceURL
 313      */
 314     _printRunOrCompileScriptResultFailure: function(target, exceptionDetails, sourceURL)
 315     {
 316         var consoleMessage = new WebInspector.ConsoleMessage(
 317             target,
 318             exceptionDetails.source,
 319             WebInspector.ConsoleMessage.MessageLevel.Error,
 320             exceptionDetails.text,
 321             undefined,
 322             sourceURL,
 323             exceptionDetails.line,
 324             exceptionDetails.column,
 325             undefined,
 326             undefined,
 327             exceptionDetails.stackTrace);
 328         target.consoleModel.addMessage(consoleMessage);
 329     },
 330
 331     /**
 332      * @param {!WebInspector.UISourceCode} uiSourceCode
 333      * @return {!Array.<!{breakpoint: !WebInspector.BreakpointManager.Breakpoint, uiLocation: !WebInspector.UILocation}>}
 334      */
 335     _removeBreakpoints: function(uiSourceCode)
 336     {
 337         var breakpointLocations = WebInspector.breakpointManager.breakpointLocationsForUISourceCode(uiSourceCode);
 338         for (var i = 0; i < breakpointLocations.length; ++i)
 339             breakpointLocations[i].breakpoint.remove();
 340         return breakpointLocations;
 341     },
 342
 343     /**
 344      * @param {!WebInspector.UISourceCode} uiSourceCode
 345      * @param {!Array.<!{breakpoint: !WebInspector.BreakpointManager.Breakpoint, uiLocation: !WebInspector.UILocation}>} breakpointLocations
 346      */
 347     _restoreBreakpoints: function(uiSourceCode, breakpointLocations)
 348     {
 349         for (var i = 0; i < breakpointLocations.length; ++i) {
 350             var uiLocation = breakpointLocations[i].uiLocation;
 351             var breakpoint = breakpointLocations[i].breakpoint;
 352             WebInspector.breakpointManager.setBreakpoint(uiSourceCode, uiLocation.lineNumber, uiLocation.columnNumber, breakpoint.condition(), breakpoint.enabled());
 353         }
 354     },
 355
 356     /**
 357      * @param {!WebInspector.UISourceCode} uiSourceCode
 358      */
 359     _releaseSnippetScript: function(uiSourceCode)
 360     {
 361         this._mappingForTarget.valuesArray().forEach(function(mapping) {mapping._releaseSnippetScript(uiSourceCode);});
 362     },
 363
 364     /**
 365      * @param {string} sourceURL
 366      * @return {?string}
 367      */
 368     _snippetIdForSourceURL: function(sourceURL)
 369     {
 370         var snippetPrefix = WebInspector.ScriptSnippetModel.snippetSourceURLPrefix;
 371         if (!sourceURL.startsWith(snippetPrefix))
 372             return null;
 373         var splitURL = sourceURL.substring(snippetPrefix.length).split("_");
 374         var snippetId = splitURL[0];
 375         return snippetId;
 376     },
 377
 378     __proto__: WebInspector.Object.prototype
 379 }
 380
 381 /**
 382  * @constructor
 383  * @implements {WebInspector.DebuggerSourceMapping}
 384  * @param {!WebInspector.DebuggerModel} debuggerModel
 385  * @param {!WebInspector.ScriptSnippetModel} scriptSnippetModel
 386  */
 387 WebInspector.SnippetScriptMapping = function(debuggerModel, scriptSnippetModel)
 388 {
 389     this._target = debuggerModel.target();
 390     this._debuggerModel = debuggerModel;
 391     this._scriptSnippetModel = scriptSnippetModel;
 392     /** @type {!Object.<string, !WebInspector.UISourceCode>} */
 393     this._uiSourceCodeForScriptId = {};
 394     /** @type {!Map.<!WebInspector.UISourceCode, !WebInspector.Script>} */
 395     this._scriptForUISourceCode = new Map();
 396     /** @type {!Map.<!WebInspector.UISourceCode, number>} */
 397     this._evaluationIndexForUISourceCode = new Map();
 398     debuggerModel.addEventListener(WebInspector.DebuggerModel.Events.GlobalObjectCleared, this._reset, this);
 399 }
 400
 401 WebInspector.SnippetScriptMapping.prototype = {
 402     /**
 403      * @param {!WebInspector.UISourceCode} uiSourceCode
 404      */
 405     _releaseSnippetScript: function(uiSourceCode)
 406     {
 407         var script = this._scriptForUISourceCode.get(uiSourceCode);
 408         if (!script)
 409             return;
 410
 411         delete this._uiSourceCodeForScriptId[script.scriptId];
 412         this._scriptForUISourceCode.remove(uiSourceCode);
 413         this._evaluationIndexForUISourceCode.remove(uiSourceCode);
 414     },
 415
 416     /**
 417      +* @param {number} evaluationIndex
 418      * @param {!WebInspector.UISourceCode} uiSourceCode
 419      */
 420     _setEvaluationIndex: function(evaluationIndex, uiSourceCode)
 421     {
 422         this._evaluationIndexForUISourceCode.set(uiSourceCode, evaluationIndex);
 423     },
 424
 425     /**
 426      * @param {!WebInspector.UISourceCode} uiSourceCode
 427      * @return {number|undefined}
 428      */
 429     evaluationIndex: function(uiSourceCode)
 430     {
 431         return this._evaluationIndexForUISourceCode.get(uiSourceCode);
 432     },
 433
 434     /**
 435      * @param {!WebInspector.UISourceCode} uiSourceCode
 436      * @return {string}
 437      */
 438     _evaluationSourceURL: function(uiSourceCode)
 439     {
 440         var evaluationSuffix = "_" + this._evaluationIndexForUISourceCode.get(uiSourceCode);
 441         var snippetId = this._scriptSnippetModel._snippetIdForUISourceCode.get(uiSourceCode);
 442         return WebInspector.ScriptSnippetModel.snippetSourceURLPrefix + snippetId + evaluationSuffix;
 443     },
 444
 445     _reset: function()
 446     {
 447         this._uiSourceCodeForScriptId = {};
 448         this._scriptForUISourceCode.clear();
 449         this._evaluationIndexForUISourceCode.clear();
 450     },
 451
 452     /**
 453      * @override
 454      * @param {!WebInspector.DebuggerModel.Location} rawLocation
 455      * @return {?WebInspector.UILocation}
 456      */
 457     rawLocationToUILocation: function(rawLocation)
 458     {
 459         var debuggerModelLocation = /** @type {!WebInspector.DebuggerModel.Location} */(rawLocation);
 460         var uiSourceCode = this._uiSourceCodeForScriptId[debuggerModelLocation.scriptId];
 461         if (!uiSourceCode)
 462             return null;
 463
 464         return uiSourceCode.uiLocation(debuggerModelLocation.lineNumber, debuggerModelLocation.columnNumber || 0);
 465     },
 466
 467     /**
 468      * @override
 469      * @param {!WebInspector.UISourceCode} uiSourceCode
 470      * @param {number} lineNumber
 471      * @param {number} columnNumber
 472      * @return {?WebInspector.DebuggerModel.Location}
 473      */
 474     uiLocationToRawLocation: function(uiSourceCode, lineNumber, columnNumber)
 475     {
 476         var script = this._scriptForUISourceCode.get(uiSourceCode);
 477         if (!script)
 478             return null;
 479
 480         return this._debuggerModel.createRawLocation(script, lineNumber, columnNumber);
 481     },
 482
 483     /**
 484      * @param {!WebInspector.Script} script
 485      * @param {!WebInspector.UISourceCode} uiSourceCode
 486      */
 487     _addScript: function(script, uiSourceCode)
 488     {
 489         console.assert(!this._scriptForUISourceCode.get(uiSourceCode));
 490         WebInspector.debuggerWorkspaceBinding.setSourceMapping(this._target, uiSourceCode, this);
 491         this._uiSourceCodeForScriptId[script.scriptId] = uiSourceCode;
 492         this._scriptForUISourceCode.set(uiSourceCode, script);
 493         WebInspector.debuggerWorkspaceBinding.pushSourceMapping(script, this);
 494     },
 495
 496     /**
 497      * @param {!WebInspector.UISourceCode} uiSourceCode
 498      * @param {!Array.<!{breakpoint: !WebInspector.BreakpointManager.Breakpoint, uiLocation: !WebInspector.UILocation}>} breakpointLocations
 499      */
 500     _restoreBreakpoints: function(uiSourceCode, breakpointLocations)
 501     {
 502         var script = this._scriptForUISourceCode.get(uiSourceCode);
 503         if (!script)
 504             return;
 505         var rawLocation = /** @type {!WebInspector.DebuggerModel.Location} */ (this._debuggerModel.createRawLocation(script, 0, 0));
 506         var scriptUISourceCode = WebInspector.debuggerWorkspaceBinding.rawLocationToUILocation(rawLocation).uiSourceCode;
 507         if (scriptUISourceCode)
 508             this._scriptSnippetModel._restoreBreakpoints(scriptUISourceCode, breakpointLocations);
 509     },
 510
 511     /**
 512      * @override
 513      * @return {boolean}
 514      */
 515     isIdentity: function()
 516     {
 517         return false;
 518     },
 519
 520     /**
 521      * @override
 522      * @param {!WebInspector.UISourceCode} uiSourceCode
 523      * @param {number} lineNumber
 524      * @return {boolean}
 525      */
 526     uiLineHasMapping: function(uiSourceCode, lineNumber)
 527     {
 528         return true;
 529     }
 530 }
 531
 532 /**
 533  * @constructor
 534  * @implements {WebInspector.ContentProvider}
 535  * @param {!WebInspector.Snippet} snippet
 536  */
 537 WebInspector.SnippetContentProvider = function(snippet)
 538 {
 539     this._snippet = snippet;
 540 }
 541
 542 WebInspector.SnippetContentProvider.prototype = {
 543     /**
 544      * @override
 545      * @return {string}
 546      */
 547     contentURL: function()
 548     {
 549         return "";
 550     },
 551
 552     /**
 553      * @override
 554      * @return {!WebInspector.ResourceType}
 555      */
 556     contentType: function()
 557     {
 558         return WebInspector.resourceTypes.Script;
 559     },
 560
 561     /**
 562      * @override
 563      * @param {function(?string)} callback
 564      */
 565     requestContent: function(callback)
 566     {
 567         callback(this._snippet.content);
 568     },
 569
 570     /**
 571      * @override
 572      * @param {string} query
 573      * @param {boolean} caseSensitive
 574      * @param {boolean} isRegex
 575      * @param {function(!Array.<!WebInspector.ContentProvider.SearchMatch>)} callback
 576      */
 577     searchInContent: function(query, caseSensitive, isRegex, callback)
 578     {
 579         /**
 580          * @this {WebInspector.SnippetContentProvider}
 581          */
 582         function performSearch()
 583         {
 584             callback(WebInspector.ContentProvider.performSearchInContent(this._snippet.content, query, caseSensitive, isRegex));
 585         }
 586
 587         // searchInContent should call back later.
 588         window.setTimeout(performSearch.bind(this), 0);
 589     }
 590 }
 591
 592 /**
 593  * @constructor
 594  * @extends {WebInspector.ContentProviderBasedProjectDelegate}
 595  * @param {!WebInspector.Workspace} workspace
 596  * @param {!WebInspector.ScriptSnippetModel} model
 597  * @param {string} id
 598  */
 599 WebInspector.SnippetsProjectDelegate = function(workspace, model, id)
 600 {
 601     WebInspector.ContentProviderBasedProjectDelegate.call(this, workspace, id, WebInspector.projectTypes.Snippets);
 602     this._model = model;
 603 }
 604
 605 WebInspector.SnippetsProjectDelegate.prototype = {
 606     /**
 607      * @param {string} name
 608      * @param {!WebInspector.ContentProvider} contentProvider
 609      * @return {string}
 610      */
 611     addSnippet: function(name, contentProvider)
 612     {
 613         return this.addContentProvider("", name, name, name, contentProvider);
 614     },
 615
 616     /**
 617      * @override
 618      * @return {boolean}
 619      */
 620     canSetFileContent: function()
 621     {
 622         return true;
 623     },
 624
 625     /**
 626      * @override
 627      * @param {string} path
 628      * @param {string} newContent
 629      * @param {function(?string)} callback
 630      */
 631     setFileContent: function(path, newContent, callback)
 632     {
 633         this._model._setScriptSnippetContent(path, newContent);
 634         callback("");
 635     },
 636
 637     /**
 638      * @override
 639      * @return {boolean}
 640      */
 641     canRename: function()
 642     {
 643         return true;
 644     },
 645
 646     /**
 647      * @override
 648      * @param {string} path
 649      * @param {string} newName
 650      * @param {function(boolean, string=)} callback
 651      */
 652     performRename: function(path, newName, callback)
 653     {
 654         this._model.renameScriptSnippet(path, newName, callback);
 655     },
 656
 657     /**
 658      * @override
 659      * @param {string} path
 660      * @param {?string} name
 661      * @param {string} content
 662      * @param {function(?string)} callback
 663      */
 664     createFile: function(path, name, content, callback)
 665     {
 666         var filePath = this._model.createScriptSnippet(content);
 667         callback(filePath);
 668     },
 669
 670     /**
 671      * @override
 672      * @param {string} path
 673      */
 674     deleteFile: function(path)
 675     {
 676         this._model.deleteScriptSnippet(path);
 677     },
 678
 679     __proto__: WebInspector.ContentProviderBasedProjectDelegate.prototype
 680 }
 681
 682 /**
 683  * @type {!WebInspector.ScriptSnippetModel}
 684  */
 685 WebInspector.scriptSnippetModel = new WebInspector.ScriptSnippetModel(WebInspector.workspace);