DevTools: introduce persistence/ module

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

 /*
  * Copyright (C) 2011 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 38 matching lines @@
     this._contentType = contentType;
     /** @type {?function(?string)} */
     this._requestContentCallback = null;
     /** @type {?Promise<?string>} */
     this._requestContentPromise = null;
     /** @type {!Map<string, !Map<number, !WebInspector.UISourceCode.LineMarker>>} */
     this._lineDecorations = new Map();
 
     /** @type {!Array.<!WebInspector.Revision>} */
     this.history = [];
-    this._hasUnsavedCommittedChanges = false;
 
     /** @type {!Array<!WebInspector.UISourceCode.Message>} */
     this._messages = [];
 }
 
 /** @enum {symbol} */
 WebInspector.UISourceCode.Events = {
     WorkingCopyChanged: Symbol("WorkingCopyChanged"),
     WorkingCopyCommitted: Symbol("WorkingCopyCommitted"),
     TitleChanged: Symbol("TitleChanged"),
@@ skipping 215 matching lines @@
         this._project.requestFileContent(this, contentLoaded.bind(this));
 
         /**
          * @param {?string} updatedContent
          * @this {WebInspector.UISourceCode}
          */
         function contentLoaded(updatedContent)
         {
             if (updatedContent === null) {
                 var workingCopy = this.workingCopy();
-                this._contentCommitted("", true, false);
+                this._contentCommitted("", false);
                 this.setWorkingCopy(workingCopy);
                 this._terminateContentCheck();
                 return;
             }
             if (typeof this._lastAcceptedContent === "string" && this._lastAcceptedContent === updatedContent) {
                 this._terminateContentCheck();
                 return;
             }
 
             if (this._content === updatedContent) {
                 delete this._lastAcceptedContent;
                 this._terminateContentCheck();
                 return;
             }
 
             if (!this.isDirty() || this._workingCopy === updatedContent) {
-                this._contentCommitted(updatedContent, true, false);
+                this._contentCommitted(updatedContent, false);
                 this._terminateContentCheck();
                 return;
             }
 
             var shouldUpdate = window.confirm(WebInspector.UIString("This file was changed externally. Would you like to reload it?"));
             if (shouldUpdate)
-                this._contentCommitted(updatedContent, true, false);
+                this._contentCommitted(updatedContent, false);
             else
                 this._lastAcceptedContent = updatedContent;
             this._terminateContentCheck();
         }
     },
 
     forceLoadOnCheckContent: function()
     {
         this._forceLoadOnCheckContent = true;
     },
 
     /**
      * @return {!Promise<?string>}
      */
     requestOriginalContent: function()
     {
         var callback;
         var promise = new Promise(fulfill => callback = fulfill);
         this._project.requestFileContent(this, callback);
         return promise;
     },
 
     /**
      * @param {string} content
      */
     _commitContent: function(content)
     {
-        var wasPersisted = false;
         if (this._project.canSetFileContent()) {
             this._project.setFileContent(this, content, function() { });
-            wasPersisted = true;
-        } else if (this._project.workspace().hasResourceContentTrackingExtensions()) {
-            wasPersisted = true;
         } else if (this._url && WebInspector.fileManager.isURLSaved(this._url)) {
             WebInspector.fileManager.save(this._url, content, false, function() { });
             WebInspector.fileManager.close(this._url);
-            wasPersisted = true;
         }
-        this._contentCommitted(content, wasPersisted, true);
+        this._contentCommitted(content, true);
     },
 
     /**
      * @param {string} content
-     * @param {boolean} wasPersisted
      * @param {boolean} committedByUser
      */
-    _contentCommitted: function(content, wasPersisted, committedByUser)
+    _contentCommitted: function(content, committedByUser)
     {
         delete this._lastAcceptedContent;
         this._content = content;
         this._contentLoaded = true;
 
         var lastRevision = this.history.length ? this.history[this.history.length - 1] : null;
         if (!lastRevision || lastRevision._content !== this._content) {
             var revision = new WebInspector.Revision(this, this._content, new Date());
             this.history.push(revision);
         }
 
         this._innerResetWorkingCopy();
-        this._hasUnsavedCommittedChanges = !wasPersisted;
-        this.dispatchEventToListeners(WebInspector.UISourceCode.Events.WorkingCopyCommitted);
+        this.dispatchEventToListeners(WebInspector.UISourceCode.Events.WorkingCopyCommitted, { content: content });
         this._project.workspace().dispatchEventToListeners(WebInspector.Workspace.Events.WorkingCopyCommitted, { uiSourceCode: this, content: content });
         if (committedByUser)
             this._project.workspace().dispatchEventToListeners(WebInspector.Workspace.Events.WorkingCopyCommittedByUser, { uiSourceCode: this, content: content });
     },
 
     saveAs: function()
     {
         WebInspector.fileManager.save(this._url, this.workingCopy(), true, callback.bind(this));
         WebInspector.fileManager.close(this._url);
 
         /**
          * @param {boolean} accepted
          * @this {WebInspector.UISourceCode}
          */
         function callback(accepted)
         {
             if (accepted)
-                this._contentCommitted(this.workingCopy(), true, true);
+                this._contentCommitted(this.workingCopy(), true);
         }
     },
 
     /**
-     * @return {boolean}
-     */
-    hasUnsavedCommittedChanges: function()
-    {
-        return this._hasUnsavedCommittedChanges;
-    },
-
-    /**
      * @param {string} content
      */
     addRevision: function(content)
     {
         this._commitContent(content);
     },
 
     /**
      * @return {!Promise}
      */
@@ skipping 551 matching lines @@
     },
 
     /**
      * @return {*}
      */
     data: function()
     {
         return this._data;
     }
 }