DevTools: Diff subsystem

third_party/WebKit/Source/devtools/front_end/source_frame/SourceCodeDiff.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
  */
 SourceFrame.SourceCodeDiff = class {
   /**
-   * @param {!Promise<?string>} diffBaseline
+   * @param {!Workspace.UISourceCode} uiSourceCode
    * @param {!TextEditor.CodeMirrorTextEditor} textEditor
    */
-  constructor(diffBaseline, textEditor) {
+  constructor(uiSourceCode, textEditor) {
     this._textEditor = textEditor;
     this._decorations = [];
     this._textEditor.installGutter(SourceFrame.SourceCodeDiff.DiffGutterType, true);
-    this._diffBaseline = diffBaseline;
+    this._uiSourceCode = uiSourceCode;
+    WorkspaceDiff.workspaceDiff().subscribeToDiffChange(this._uiSourceCode, this._update, this);
     /** @type {!Array<!TextEditor.TextEditorPositionHandle>}*/
     this._animatedLines = [];
-  }
 
-  updateDiffMarkersWhenPossible() {
-    if (this._updateTimeout)
-      clearTimeout(this._updateTimeout);
-    this._updateTimeout =
-        setTimeout(this.updateDiffMarkersImmediately.bind(this), SourceFrame.SourceCodeDiff.UpdateTimeout);
-  }
-
-  updateDiffMarkersImmediately() {
-    if (this._updateTimeout)
-      clearTimeout(this._updateTimeout);
-    this._updateTimeout = null;
-    this._diffBaseline.then(this._innerUpdate.bind(this));
+    this._update();
   }
 
   /**
    * @param {?string} oldContent
    * @param {?string} newContent
    */
   highlightModifiedLines(oldContent, newContent) {
     if (typeof oldContent !== 'string' || typeof newContent !== 'string')
       return;
 
-    var diff = this._computeDiff(oldContent, newContent);
+    var diff = this._computeDiff(Diff.Diff.lineDiff(oldContent.split('\n'), newContent.split('\n')));
     var changedLines = [];
     for (var i = 0; i < diff.length; ++i) {
       var diffEntry = diff[i];
       if (diffEntry.type === SourceFrame.SourceCodeDiff.GutterDecorationType.Delete)
         continue;
       for (var lineNumber = diffEntry.from; lineNumber < diffEntry.to; ++lineNumber) {
         var position = this._textEditor.textEditorPositionHandle(lineNumber, 0);
         if (position)
           changedLines.push(position);
       }
@@ skipping 43 matching lines @@
 
     function operation() {
       for (var decoration of removed)
         decoration.remove();
       for (var decoration of added)
         decoration.install();
     }
   }
 
   /**
-   * @param {string} baseline
-   * @param {string} current
+   * @param {!Diff.Diff.DiffArray} diff
    * @return {!Array<!{type: !SourceFrame.SourceCodeDiff.GutterDecorationType, from: number, to: number}>}
    */
-  _computeDiff(baseline, current) {
-    var diff = Diff.Diff.lineDiff(baseline.split('\n'), current.split('\n'));
+  _computeDiff(diff) {
     var result = [];
     var hasAdded = false;
     var hasRemoved = false;
     var blockStartLineNumber = 0;
     var currentLineNumber = 0;
     var isInsideBlock = false;
     for (var i = 0; i < diff.length; ++i) {
       var token = diff[i];
       if (token[0] === Diff.Diff.Operation.Equal) {
         if (isInsideBlock)
@@ skipping 35 matching lines @@
         type = SourceFrame.SourceCodeDiff.GutterDecorationType.Delete;
         from -= 1;
       }
       result.push({type: type, from: from, to: to});
       isInsideBlock = false;
       hasAdded = false;
       hasRemoved = false;
     }
   }
 
+  _update() {
+    WorkspaceDiff.workspaceDiff().requestDiff(this._uiSourceCode).then(this._innerUpdate.bind(this));

[lushnikov, 2017/03/10 01:17:04]

let's pass this from the outside

+  }
+
   /**
-   * @param {?string} baseline
+   * @param {!Diff.Diff.DiffArray} lineDiff
    */
-  _innerUpdate(baseline) {
-    var current = this._textEditor.text();
-    if (typeof baseline !== 'string') {
-      this._updateDecorations(this._decorations, [] /* added */);
-      this._decorations = [];
-      return;
-    }
-
-    var diff = this._computeDiff(baseline, current);
-
+  _innerUpdate(lineDiff) {
     /** @type {!Map<number, !SourceFrame.SourceCodeDiff.GutterDecoration>} */
     var oldDecorations = new Map();
     for (var i = 0; i < this._decorations.length; ++i) {
       var decoration = this._decorations[i];
       var lineNumber = decoration.lineNumber();
       if (lineNumber === -1)
         continue;
       oldDecorations.set(lineNumber, decoration);
     }
 
+    var diff = this._computeDiff(lineDiff);
+
     /** @type {!Map<number, !{lineNumber: number, type: !SourceFrame.SourceCodeDiff.GutterDecorationType}>} */
     var newDecorations = new Map();
     for (var i = 0; i < diff.length; ++i) {
       var diffEntry = diff[i];
       for (var lineNumber = diffEntry.from; lineNumber < diffEntry.to; ++lineNumber)
         newDecorations.set(lineNumber, {lineNumber: lineNumber, type: diffEntry.type});
     }
 
     var decorationDiff = oldDecorations.diff(newDecorations, (e1, e2) => e1.type === e2.type);
     var addedDecorations = decorationDiff.added.map(
         entry => new SourceFrame.SourceCodeDiff.GutterDecoration(this._textEditor, entry.lineNumber, entry.type));
 
     this._decorations = decorationDiff.equal.concat(addedDecorations);
     this._updateDecorations(decorationDiff.removed, addedDecorations);
     this._decorationsSetForTest(newDecorations);
   }
 
   /**
    * @param {!Map<number, !{lineNumber: number, type: !SourceFrame.SourceCodeDiff.GutterDecorationType}>} decorations
    */
   _decorationsSetForTest(decorations) {
   }
+
+  dispose() {
+    WorkspaceDiff.workspaceDiff().unsubscribeToDiffChange(this._uiSourceCode, this._update, this);
+  }
 };
 
-/** @type {number} */
-SourceFrame.SourceCodeDiff.UpdateTimeout = 200;
-
 /** @type {string} */
 SourceFrame.SourceCodeDiff.DiffGutterType = 'CodeMirror-gutter-diff';
 
 /** @enum {symbol} */
 SourceFrame.SourceCodeDiff.GutterDecorationType = {
   Insert: Symbol('Insert'),
   Delete: Symbol('Delete'),
   Modify: Symbol('Modify'),
 };
 
@@ skipping 40 matching lines @@
   }
 
   remove() {
     var location = this._position.resolve();
     if (!location)
       return;
     this._textEditor.setGutterDecoration(location.lineNumber, SourceFrame.SourceCodeDiff.DiffGutterType, null);
     this._textEditor.toggleLineClass(location.lineNumber, this._className, false);
   }
 };