DevTools: Add Closure docs and clean up UISourceCode

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._name = parsedURL.lastPathComponent;
       if (parsedURL.queryParams)
         this._name += '?' + parsedURL.queryParams;
     } else {
       this._origin = '';
       this._parentURL = '';
       this._name = url;
     }
 
     this._contentType = contentType;
-    /** @type {?function(?string)} */
-    this._requestContentCallback = null;
     /** @type {?Promise<?string>} */
     this._requestContentPromise = null;
     /** @type {!Multimap<string, !Workspace.UISourceCode.LineMarker>} */
     this._decorations = new Multimap();
 
     /** @type {!Array.<!Workspace.Revision>} */
     this.history = [];
 
     /** @type {!Array<!Workspace.UISourceCode.Message>} */
     this._messages = [];
+
+    this._contentLoaded = false;

[einbinder, 2016/12/19 21:34:16]

Make things explicit. Never undefined.

+    /** @type {?string} */
+    this._content = null;
+    this._forceLoadOnCheckContent = false;
+    this._checkingContent = false;
+    /** @type {?string} */
+    this._lastAcceptedContent = null;
+    /** @type {?string} */
+    this._workingCopy = null;
+    /** @type {?function() : string} */
+    this._workingCopyGetter = null;
   }
 
   /**
    * @return {!Promise<?Workspace.UISourceCodeMetadata>}
    */
   requestMetadata() {
     return this._project.requestMetadata(this);
   }
 
   /**
@@ skipping 122 matching lines @@
    */
   project() {
     return this._project;
   }
 
   /**
    * @override
    * @return {!Promise<?string>}
    */
   requestContent() {
-    if (this._content || this._contentLoaded)

[einbinder, 2016/12/19 21:34:16]

Just return the same loading promise. Makes things simpler.

-      return Promise.resolve(this._content);
-    var promise = this._requestContentPromise;
-    if (!promise) {
-      promise = new Promise(fulfill => this._requestContentCallback = fulfill);
-      this._requestContentPromise = promise;
-      this._project.requestFileContent(this, this._fireContentAvailable.bind(this));
+    if (!this._requestContentPromise) {
+      var fulfill;
+      this._requestContentPromise = new Promise(x => fulfill = x);
+      this._project.requestFileContent(this, content => {
+        this._contentLoaded = true;
+        this._content = content;
+        fulfill(content);
+      });
     }
-    return promise;
+    return this._requestContentPromise;
   }
 
   checkContentUpdated() {
     if (!this._contentLoaded && !this._forceLoadOnCheckContent)
       return;
 
     if (!this._project.canSetFileContent() || this._checkingContent)
       return;
 
     this._checkingContent = true;
     this._project.requestFileContent(this, contentLoaded.bind(this));
 
     /**
      * @param {?string} updatedContent
      * @this {Workspace.UISourceCode}
      */
     function contentLoaded(updatedContent) {
       this._checkingContent = false;
       if (updatedContent === null) {
         var workingCopy = this.workingCopy();
         this._contentCommitted('', false);
         this.setWorkingCopy(workingCopy);
         return;
       }
-      if (typeof this._lastAcceptedContent === 'string' && this._lastAcceptedContent === updatedContent)
+      if (this._lastAcceptedContent === updatedContent)
         return;
 
       if (this._content === updatedContent) {
-        delete this._lastAcceptedContent;
+        this._lastAcceptedContent = null;
         return;
       }
 
       if (!this.isDirty() || this._workingCopy === updatedContent) {
         this._contentCommitted(updatedContent, false);
         return;
       }
 
       var shouldUpdate =
           window.confirm(Common.UIString('This file was changed externally. Would you like to reload it?'));
@@ skipping 29 matching lines @@
       Workspace.fileManager.close(this._url);
     }
     this._contentCommitted(content, true);
   }
 
   /**
    * @param {string} content
    * @param {boolean} committedByUser
    */
   _contentCommitted(content, committedByUser) {
-    delete this._lastAcceptedContent;
+    this._lastAcceptedContent = null;
     this._content = content;
     this._contentLoaded = true;
+    this._requestContentPromise = Promise.resolve(/** @type {?string} */ (content));

[einbinder, 2016/12/19 21:34:16]

Closure gets confused with {?string} and {string}.

[lushnikov, 2016/12/19 23:32:13]

let's clean the promise here to not do unnecessary work

[einbinder, 2016/12/19 23:48:49]

Done.

 
     var lastRevision = this.history.length ? this.history[this.history.length - 1] : null;
     if (!lastRevision || lastRevision._content !== this._content) {
       var revision = new Workspace.Revision(this, this._content, new Date());
       this.history.push(revision);
     }
 
     this._innerResetWorkingCopy();
     this.dispatchEventToListeners(
         Workspace.UISourceCode.Events.WorkingCopyCommitted, {uiSourceCode: this, content: content});
@@ skipping 65 matching lines @@
     Host.userMetrics.actionTaken(Host.UserMetrics.Action.RevisionApplied);
     this.requestOriginalContent().then(revert.bind(this));
   }
 
   /**
    * @return {string}
    */
   workingCopy() {
     if (this._workingCopyGetter) {
       this._workingCopy = this._workingCopyGetter();
-      delete this._workingCopyGetter;
+      this._workingCopyGetter = null;
     }
     if (this.isDirty())
-      return this._workingCopy;
-    return this._content;
+      return /** @type {string} */ (this._workingCopy);

[einbinder, 2016/12/19 21:34:16]

we know that workingCopyGetter is null, and it is dirty, so workingCopy must be
non-null.

+    return this._content || '';
   }
 
   resetWorkingCopy() {
     this._innerResetWorkingCopy();
     this._workingCopyChanged();
   }
 
   _innerResetWorkingCopy() {
-    delete this._workingCopy;
-    delete this._workingCopyGetter;
+    this._workingCopy = null;
+    this._workingCopyGetter = null;
   }
 
   /**
    * @param {string} newWorkingCopy
    */
   setWorkingCopy(newWorkingCopy) {
     this._workingCopy = newWorkingCopy;
-    delete this._workingCopyGetter;
+    this._workingCopyGetter = null;
     this._workingCopyChanged();
   }
 
+  /**
+  * @param {function(): string } workingCopyGetter
+  */

[einbinder, 2016/12/19 21:34:16]

Typing!

   setWorkingCopyGetter(workingCopyGetter) {
     this._workingCopyGetter = workingCopyGetter;
     this._workingCopyChanged();
   }
 
   _workingCopyChanged() {
     this._removeAllMessages();
     this.dispatchEventToListeners(Workspace.UISourceCode.Events.WorkingCopyChanged, this);
     this._project.workspace().dispatchEventToListeners(
         Workspace.Workspace.Events.WorkingCopyChanged, {uiSourceCode: this});
   }
 
   removeWorkingCopyGetter() {
     if (!this._workingCopyGetter)
       return;
     this._workingCopy = this._workingCopyGetter();
-    delete this._workingCopyGetter;
+    this._workingCopyGetter = null;
   }
 
   commitWorkingCopy() {
     if (this.isDirty())
       this._commitContent(this.workingCopy());
   }
 
   /**
    * @return {boolean}
    */
   isDirty() {
-    return typeof this._workingCopy !== 'undefined' || typeof this._workingCopyGetter !== 'undefined';
+    return this._workingCopy !== null || this._workingCopyGetter !== null;
   }
 
   /**
    * @return {string}
    */
   extension() {
     return Common.ParsedURL.extractExtension(this._name);
   }
 
   /**
@@ skipping 22 matching lines @@
 
     /**
      * @param {string} content
      */
     function doSearch(content) {
       callback(Common.ContentProvider.performSearchInContent(content, query, caseSensitive, isRegex));
     }
   }
 
   /**
-   * @param {?string} content
-   */
-  _fireContentAvailable(content) {

[einbinder, 2016/12/19 21:34:16]

This gets inlined.

-    this._contentLoaded = true;
-    this._content = content;
-
-    var callback = this._requestContentCallback;
-    this._requestContentCallback = null;
-    this._requestContentPromise = null;
-
-    callback.call(null, content);
-  }
-
-  /**
    * @return {boolean}
    */
   contentLoaded() {
     return this._contentLoaded;
   }
 
   /**
    * @param {number} lineNumber
    * @param {number=} columnNumber
    * @return {!Workspace.UILocation}
@@ skipping 392 matching lines @@
 Workspace.UISourceCodeMetadata = class {
   /**
    * @param {?Date} modificationTime
    * @param {?number} contentSize
    */
   constructor(modificationTime, contentSize) {
     this.modificationTime = modificationTime;
     this.contentSize = contentSize;
   }
 };