Merge 92764 - Web Inspector: [REGRESSION] Editor lost after committing a CSS property value for i...

Source/WebCore/inspector/front-end/StylesSidebarPane.js

 /*
  * Copyright (C) 2007 Apple Inc.  All rights reserved.
  * Copyright (C) 2009 Joseph Pecoraro
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 220 matching lines @@
             node = null;
 
         if (node)
             this.node = node;
         else
             node = this.node;
 
         this._innerUpdate(refresh, null);
     },
 
-    _innerUpdate: function(refresh, editedSection)
+    _innerUpdate: function(refresh, editedSection, userCallback)
     {
         var node = this.node;
         if (!node) {
             this._sectionsContainer.removeChildren();
             this._computedStylePane.bodyElement.removeChildren();
             this.sections = {};
+            if (userCallback)
+                userCallback();
             return;
         }
 
         function stylesCallback(styles)
         {
             if (this.node === node && styles)
                 this._rebuildUpdate(node, styles);
+            if (userCallback)
+                userCallback();
         }
 
         function computedStyleCallback(computedStyle)
         {
             if (this.node === node && computedStyle)
                 this._refreshUpdate(node, computedStyle, editedSection);
+            if (userCallback)
+                userCallback();
         }
 
         if (refresh)
             WebInspector.cssModel.getComputedStyleAsync(node.id, computedStyleCallback.bind(this));
         else
             WebInspector.cssModel.getStylesAsync(node.id, this._forcedPseudoClasses, stylesCallback.bind(this));
     },
 
     _styleSheetChanged: function()
     {
@@ skipping 1333 matching lines @@
             // Avoid having longhands under an invalid shorthand.
             this.hasChildren = false;
             this.listItemElement.addStyleClass("not-parsed-ok");
         }
         if (this.property.inactive)
             this.listItemElement.addStyleClass("inactive");
 
         this.tooltip = this.property.propertyText;
     },
 
-    _updateAll: function()
+    _updatePane: function(userCallback)
     {
-        if (!this.treeOutline)
-            return;
-        if (this.treeOutline.section && this.treeOutline.section.pane)
-            this.treeOutline.section.pane._innerUpdate(true, this.treeOutline.section);
-        else if (this.treeOutline.section)
-            this.treeOutline.section.update(true);
-        else
-            this.updateTitle(); // FIXME: this will not show new properties. But we don't hit this case yet.
+        if (this.treeOutline && this.treeOutline.section && this.treeOutline.section.pane)
+            this.treeOutline.section.pane._innerUpdate(true, this.treeOutline.section, userCallback);
+        else  {
+            if (userCallback)
+                userCallback();
+        }
     },
 
     toggleEnabled: function(event)
     {
         var disabled = !event.target.checked;
 
         function callback(newStyle)
         {
             if (!newStyle)
                 return;
 
             this.style = newStyle;
             this._styleRule.style = newStyle;
 
             if (this.treeOutline.section && this.treeOutline.section.pane)
                 this.treeOutline.section.pane.dispatchEventToListeners("style property toggled");
 
-            this._updateAll();
+            this._updatePane();
         }
 
         this.property.setDisabled(disabled, callback.bind(this));
     },
 
     updateState: function()
     {
         if (!this.listItemElement)
             return;
 
@@ skipping 421 matching lines @@
 
     _hasBeenModifiedIncrementally: function()
     {
         // New properties applied via up/down have an originalPropertyText and will be deleted later
         // on, if cancelled, when the empty string gets applied as their style text.
         return typeof this.originalPropertyText === "string";
     },
 
     applyStyleText: function(styleText, updateInterface, majorChange, isRevert)
     {
+        function userOperationFinishedCallback(parentPane, updateInterface)
+        {
+            if (updateInterface)
+                delete parentPane._userOperation;
+        }
+
         // Leave a way to cancel editing after incremental changes.
         if (!isRevert && !updateInterface && !this._hasBeenModifiedIncrementally()) {
             // Remember the rule's original CSS text on [Page](Up|Down), so it can be restored
             // if the editing is canceled.
             this.originalPropertyText = this.property.propertyText;
         }
 
         var section = this.treeOutline.section;
         var elementsPanel = WebInspector.panels.elements;
         styleText = styleText.replace(/\s/g, " ").trim(); // Replace   with whitespace.
         var styleTextLength = styleText.length;
         if (!styleTextLength && updateInterface && !isRevert && this._newProperty && !this._hasBeenModifiedIncrementally()) {
             // The user deleted everything and never applied a new property value via Up/Down scrolling, so remove the tree element and update.
             this.parent.removeChild(this);
             section.afterUpdate();
             return;
         }
 
         var currentNode = this._parentPane.node;
-        this._parentPane._userOperation = true;
+        if (updateInterface)
+            this._parentPane._userOperation = true;
 
-        function callback(originalPropertyText, newStyle)
+        function callback(userCallback, originalPropertyText, newStyle)
         {
-            delete this._parentPane._userOperation;
             if (!newStyle) {
                 if (updateInterface) {
                     // It did not apply, cancel editing.
                     this._revertStyleUponEditingCanceled(originalPropertyText);
                 }
+                userCallback();
                 return;
             }
 
             this.style = newStyle;
             this.property = newStyle.propertyAt(this.property.index);
             this._styleRule.style = this.style;
 
             if (section && section.pane)
                 section.pane.dispatchEventToListeners("style edited");
 
-            if (updateInterface && currentNode === section.pane.node)
-                this._updateAll();
+            if (updateInterface && currentNode === section.pane.node) {
+                this._updatePane(userCallback);
+                return;
+            }
+
+            userCallback();
         }
 
         // Append a ";" if the new text does not end in ";".
         // FIXME: this does not handle trailing comments.
         if (styleText.length && !/;\s*$/.test(styleText))
             styleText += ";";
-        this.property.setText(styleText, majorChange, callback.bind(this, this.originalPropertyText));
+        this.property.setText(styleText, majorChange, callback.bind(this, userOperationFinishedCallback.bind(null, this._parentPane, updateInterface), this.originalPropertyText));
     }
 }
 
 WebInspector.StylePropertyTreeElement.prototype.__proto__ = TreeElement.prototype;
 
 WebInspector.StylesSidebarPane.CSSPropertyPrompt = function(element, cssCompletions)
 {
     WebInspector.TextPrompt.call(this, element, this._buildPropertyCompletions.bind(this), WebInspector.StylesSidebarPane.StyleValueDelimiters, true);
     this._cssCompletions = cssCompletions;
 }
@@ skipping 59 matching lines @@
             return completionsReadyCallback(results);
         }
 
         results = this._cssCompletions.startsWith(prefix);
         if (results)
             completionsReadyCallback(results);
     }
 }
 
 WebInspector.StylesSidebarPane.CSSPropertyPrompt.prototype.__proto__ = WebInspector.TextPrompt.prototype;