DevTools: introduce WebInspector.Throttler

Source/devtools/front_end/sdk/StylesSourceMapping.js

 /*
  * Copyright (C) 2012 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 305 matching lines @@
  * @constructor
  * @param {!WebInspector.UISourceCode} uiSourceCode
  * @param {!WebInspector.StylesSourceMapping} mapping
  */
 WebInspector.StyleFile = function(uiSourceCode, mapping)
 {
     this._uiSourceCode = uiSourceCode;
     this._mapping = mapping;
     this._uiSourceCode.addEventListener(WebInspector.UISourceCode.Events.WorkingCopyChanged, this._workingCopyChanged, this);
     this._uiSourceCode.addEventListener(WebInspector.UISourceCode.Events.WorkingCopyCommitted, this._workingCopyCommitted, this);
+    this._commitThrottler = new WebInspector.Throttler(WebInspector.StyleFile.updateTimeout);

[vsevik, 2014/06/09 12:32:58]

We have (at least used to have) a test that overrides this timeout. You might
need to fix it.

[lushnikov, 2014/06/09 13:07:26]

All tests successfully pass.

 }
 
 WebInspector.StyleFile.updateTimeout = 200;
 
 /**
  * @enum {string}
  */
 WebInspector.StyleFile.PendingChangeType = {
     Major: "Major",
     Minor: "Minor"
 }
 
 WebInspector.StyleFile.prototype = {
     /**
      * @param {!WebInspector.Event} event
      */
     _workingCopyCommitted: function(event)
     {
         if (this._isAddingRevision)
             return;
 
         this._pendingChangeType = WebInspector.StyleFile.PendingChangeType.Major;

[vsevik, 2014/06/09 12:32:58]

I believe it should be enough to set this._isMajorChangePending to true here and
reset it in this._commitIncrementalEdit. All usages of this._pendingChangeType
would be redundant then.

[lushnikov, 2014/06/09 13:07:26]

Indeed. Fixed this.

-        this._maybeProcessChange();
+        this._commitThrottler.schedule(this._commitIncrementalEdit.bind(this), true);
     },
 
     /**
      * @param {!WebInspector.Event} event
      */
     _workingCopyChanged: function(event)
     {
         if (this._isAddingRevision)
             return;
-
         if (this._pendingChangeType === WebInspector.StyleFile.PendingChangeType.Major)
             return;
+
         this._pendingChangeType = WebInspector.StyleFile.PendingChangeType.Minor;
-        this._maybeProcessChange();
-    },
-
-    _maybeProcessChange: function()
-    {
-        if (this._isSettingContent)
-            return;
-        if (!this._pendingChangeType)
-            return;
-
-        if (this._pendingChangeType === WebInspector.StyleFile.PendingChangeType.Major) {
-            this._clearIncrementalUpdateTimer();
-            delete this._pendingChangeType;
-            this._commitIncrementalEdit(true);
-            return;
-        }
-
-        if (this._incrementalUpdateTimer)
-            return;
-        this._incrementalUpdateTimer = setTimeout(this._commitIncrementalEdit.bind(this, false), WebInspector.StyleFile.updateTimeout);
+        this._commitThrottler.schedule(this._commitIncrementalEdit.bind(this), false);
     },
 
     /**
-     * @param {boolean} majorChange
+     * @param {!WebInspector.Throttler.FinishCallback} finishCallback
      */
-    _commitIncrementalEdit: function(majorChange)
+    _commitIncrementalEdit: function(finishCallback)
     {
-        this._clearIncrementalUpdateTimer();
+        var majorChange = this._pendingChangeType === WebInspector.StyleFile.PendingChangeType.Major;

[dgozman, 2014/06/09 07:01:51]

I still think, that binding such values as parameters of throttled function is
much safer: you don't have to guarantee that |this.something| will have the
right value at the time on invocation.
Since the whole throttler stuff is hard to test, there may be bugs which you
will not catch immediately.

[vsevik, 2014/06/09 12:32:58]

We can not bind pending change type.

[lushnikov, 2014/06/09 13:07:26]

It's tempting, but we can't.

+        this._mapping._setStyleContent(this._uiSourceCode, this._uiSourceCode.workingCopy(), majorChange, this._styleContentSet.bind(this, finishCallback));
         delete this._pendingChangeType;
-        this._isSettingContent = true;
-        this._mapping._setStyleContent(this._uiSourceCode, this._uiSourceCode.workingCopy(), majorChange, this._styleContentSet.bind(this));
     },
 
     /**
+     * @param {!WebInspector.Throttler.FinishCallback} finishCallback
      * @param {?string} error
      */
-    _styleContentSet: function(error)
+    _styleContentSet: function(finishCallback, error)
     {
         if (error)
             this._mapping._cssModel.target().consoleModel.showErrorMessage(error);
-        delete this._isSettingContent;
-        this._maybeProcessChange();
-    },
-
-    _clearIncrementalUpdateTimer: function()
-    {
-        if (!this._incrementalUpdateTimer)
-            return;
-        clearTimeout(this._incrementalUpdateTimer);
-        delete this._incrementalUpdateTimer;
+        finishCallback();
     },
 
     /**
      * @param {string} content
      */
     addRevision: function(content)
     {
         this._isAddingRevision = true;
         this._uiSourceCode.addRevision(content);
         delete this._isAddingRevision;
     },
 
     dispose: function()
     {
         this._uiSourceCode.removeEventListener(WebInspector.UISourceCode.Events.WorkingCopyCommitted, this._workingCopyCommitted, this);
         this._uiSourceCode.removeEventListener(WebInspector.UISourceCode.Events.WorkingCopyChanged, this._workingCopyChanged, this);
     }
 }