DevTools: [Persistence] validate persistence binding.

third_party/WebKit/Source/devtools/front_end/persistence/Persistence.js

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 /**
  * @unrestricted
  */
 Persistence.Persistence = class extends Common.Object {
   /**
    * @param {!Workspace.Workspace} workspace
    * @param {!Bindings.BreakpointManager} breakpointManager
    * @param {!Workspace.FileSystemMapping} fileSystemMapping
    */
   constructor(workspace, breakpointManager, fileSystemMapping) {
     super();
     this._workspace = workspace;
     this._breakpointManager = breakpointManager;
     /** @type {!Map<string, number>} */
     this._filePathPrefixesToBindingCount = new Map();
 
     if (Runtime.experiments.isEnabled('persistence2')) {
       var linkDecorator = new Persistence.PersistenceUtils.LinkDecorator(this);
       Components.Linkifier.setLinkDecorator(linkDecorator);
       this._mapping =
-          new Persistence.Automapping(workspace, this._onBindingCreated.bind(this), this._onBindingRemoved.bind(this));
+          new Persistence.Automapping(workspace, this._validateBinding.bind(this), this._onBindingRemoved.bind(this));
     } else {
       this._mapping = new Persistence.DefaultMapping(
-          workspace, fileSystemMapping, this._onBindingCreated.bind(this), this._onBindingRemoved.bind(this));
+          workspace, fileSystemMapping, this._validateBinding.bind(this), this._onBindingRemoved.bind(this));
     }
   }
 
   /**
    * @param {!Persistence.PersistenceBinding} binding
    */
-  _onBindingCreated(binding) {
-    if (binding.network.isDirty()) {
-      Common.console.log(
-          Common.UIString('%s can not be persisted to file system due to unsaved changes.', binding.network.name()));
+  _validateBinding(binding) {
+    if (!Runtime.experiments.isEnabled('persistenceValidation') || binding.network.contentType().isFromSourceMap()) {
+      this._establishBinding(binding);
       return;
     }
-    if (binding.fileSystem.isDirty())
-      binding.network.setWorkingCopy(binding.fileSystem.workingCopy());
 
+    Promise.all([binding.network.requestContent(), binding.fileSystem.requestContent()]).then(onContents.bind(this));
+
+    /**
+     * @this {Persistence.Persistence}
+     */
+    function onContents() {
+      if (binding._removed)
+        return;
+
+      var fileSystemContent = binding.fileSystem.workingCopy();
+      var networkContent = binding.network.workingCopy();
+      var target = Bindings.NetworkProject.targetForUISourceCode(binding.network);
+      var isValid = false;
+      if (target.isNodeJS()) {
+        var rewrappedNetworkContent = Persistence.Persistence._rewrapNodeJSContent(
+            binding, binding.fileSystem, fileSystemContent, networkContent);
+        isValid = (fileSystemContent === rewrappedNetworkContent);
+      } else {
+        // Trim trailing whitespaces because V8 adds trailing newline.
+        isValid = (fileSystemContent.trimRight() === networkContent.trimRight());
+      }
+
+      if (isValid)
+        this._establishBinding(binding);
+      else
+        this._prevalidationFailedForTest(binding);
+    }
+  }
+
+  /**
+   * @param {!Persistence.PersistenceBinding} binding
+   */
+  _prevalidationFailedForTest(binding) {
+  }
+
+  /**
+   * @param {!Persistence.PersistenceBinding} binding
+   */
+  _establishBinding(binding) {
     binding.network[Persistence.Persistence._binding] = binding;
     binding.fileSystem[Persistence.Persistence._binding] = binding;
 
     binding.fileSystem.forceLoadOnCheckContent();
 
     binding.network.addEventListener(
         Workspace.UISourceCode.Events.WorkingCopyCommitted, this._onWorkingCopyCommitted, this);
     binding.fileSystem.addEventListener(
         Workspace.UISourceCode.Events.WorkingCopyCommitted, this._onWorkingCopyCommitted, this);
     binding.network.addEventListener(
         Workspace.UISourceCode.Events.WorkingCopyChanged, this._onWorkingCopyChanged, this);
     binding.fileSystem.addEventListener(
         Workspace.UISourceCode.Events.WorkingCopyChanged, this._onWorkingCopyChanged, this);
 
     this._addFilePathBindingPrefixes(binding.fileSystem.url());
 
     this._moveBreakpoints(binding.fileSystem, binding.network);
     this.dispatchEventToListeners(Persistence.Persistence.Events.BindingCreated, binding);
   }
 
   /**
    * @param {!Persistence.PersistenceBinding} binding
    */
   _onBindingRemoved(binding) {
+    binding._removed = true;
+    if (!binding.network[Persistence.Persistence._binding] || !binding.fileSystem[Persistence.Persistence._binding])

[dgozman, 2016/12/08 22:38:53]

if (binding.network[Persistence.Persistence._binding] !== binding || )
  return;
console.assert(they are equal)

[lushnikov, 2016/12/08 23:02:24]

Done.

+      return;
+
     binding.network[Persistence.Persistence._binding] = null;
     binding.fileSystem[Persistence.Persistence._binding] = null;
 
     binding.network.removeEventListener(
         Workspace.UISourceCode.Events.WorkingCopyCommitted, this._onWorkingCopyCommitted, this);
     binding.fileSystem.removeEventListener(
         Workspace.UISourceCode.Events.WorkingCopyCommitted, this._onWorkingCopyCommitted, this);
     binding.network.removeEventListener(
         Workspace.UISourceCode.Events.WorkingCopyChanged, this._onWorkingCopyChanged, this);
     binding.fileSystem.removeEventListener(
@@ skipping 11 matching lines @@
   _onWorkingCopyChanged(event) {
     var uiSourceCode = /** @type {!Workspace.UISourceCode} */ (event.target);
     var binding = uiSourceCode[Persistence.Persistence._binding];
     if (!binding || binding[Persistence.Persistence._muteWorkingCopy])
       return;
     var other = binding.network === uiSourceCode ? binding.fileSystem : binding.network;
     var target = Bindings.NetworkProject.targetForUISourceCode(binding.network);
     if (target.isNodeJS()) {
       var newContent = uiSourceCode.workingCopy();
       other.requestContent().then(() => {
-        var nodeJSContent = this._rewrapNodeJSContent(binding, other, other.workingCopy(), newContent);
+        var nodeJSContent =
+            Persistence.Persistence._rewrapNodeJSContent(binding, other, other.workingCopy(), newContent);
         setWorkingCopy.call(this, () => nodeJSContent);
       });
       return;
     }
 
     setWorkingCopy.call(this, () => uiSourceCode.workingCopy());
 
     /**
      * @param {function():string} workingCopyGetter
      * @this {Persistence.Persistence}
@@ skipping 12 matching lines @@
   _onWorkingCopyCommitted(event) {
     var uiSourceCode = /** @type {!Workspace.UISourceCode} */ (event.target);
     var binding = uiSourceCode[Persistence.Persistence._binding];
     if (!binding || binding[Persistence.Persistence._muteCommit])
       return;
     var newContent = /** @type {string} */ (event.data.content);
     var other = binding.network === uiSourceCode ? binding.fileSystem : binding.network;
     var target = Bindings.NetworkProject.targetForUISourceCode(binding.network);
     if (target.isNodeJS()) {
       other.requestContent().then(currentContent => {
-        var nodeJSContent = this._rewrapNodeJSContent(binding, other, currentContent, newContent);
+        var nodeJSContent = Persistence.Persistence._rewrapNodeJSContent(binding, other, currentContent, newContent);
         setContent.call(this, nodeJSContent);
       });
       return;
     }
     setContent.call(this, newContent);
 
     /**
      * @param {string} newContent
      * @this {Persistence.Persistence}
      */
     function setContent(newContent) {
       binding[Persistence.Persistence._muteCommit] = true;
       other.addRevision(newContent);
       binding[Persistence.Persistence._muteCommit] = false;
       this._contentSyncedForTest();
     }
   }
 
   /**
    * @param {!Persistence.PersistenceBinding} binding
    * @param {!Workspace.UISourceCode} uiSourceCode
    * @param {string} currentContent
    * @param {string} newContent
    * @return {string}
    */
-  _rewrapNodeJSContent(binding, uiSourceCode, currentContent, newContent) {
+  static _rewrapNodeJSContent(binding, uiSourceCode, currentContent, newContent) {
     if (uiSourceCode === binding.fileSystem) {
       if (newContent.startsWith(Persistence.Persistence._NodePrefix) &&
           newContent.endsWith(Persistence.Persistence._NodeSuffix)) {
         newContent = newContent.substring(
             Persistence.Persistence._NodePrefix.length, newContent.length - Persistence.Persistence._NodeSuffix.length);
       }
       if (currentContent.startsWith(Persistence.Persistence._NodeShebang))
         newContent = Persistence.Persistence._NodeShebang + newContent;
     } else {
       if (newContent.startsWith(Persistence.Persistence._NodeShebang))
@@ skipping 115 matching lines @@
 Persistence.PersistenceBinding = class {
   /**
    * @param {!Workspace.UISourceCode} network
    * @param {!Workspace.UISourceCode} fileSystem
    * @param {boolean} exactMatch
    */
   constructor(network, fileSystem, exactMatch) {
     this.network = network;
     this.fileSystem = fileSystem;
     this.exactMatch = exactMatch;
+    this._removed = false;
   }
 };
 
 /** @type {!Persistence.Persistence} */
 Persistence.persistence;