DevTools: [JSDoc] Avoid partial arg list annotations in code except "profiler" module

Source/devtools/front_end/elements/ElementsTreeOutline.js

 /*
  * Copyright (C) 2007, 2008 Apple Inc.  All rights reserved.
  * Copyright (C) 2008 Matt Lilek <webkit@mattlilek.com>
  * 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
@@ skipping 816 matching lines @@
             return null;
         if (descendantCount === 1)
             return WebInspector.UIString("%d descendant with forced state", descendantCount);
         return WebInspector.UIString("%d descendants with forced state", descendantCount);
     }
 }
 
 /**
  * @constructor
  * @extends {TreeElement}
+ * @param {!WebInspector.DOMNode} node
  * @param {boolean=} elementCloseTag
  */
 WebInspector.ElementsTreeElement = function(node, elementCloseTag)
 {
     // The title will be updated in onattach.
     TreeElement.call(this, "", node);
     this._node = node;
 
     this._elementCloseTag = elementCloseTag;
     this._updateHasChildren();
@@ skipping 205 matching lines @@
      * @param {boolean=} fullRefresh
      */
     updateChildren: function(fullRefresh)
     {
         if (this._elementCloseTag)
             return;
         this._node.getChildNodes(this._updateChildren.bind(this, fullRefresh));
     },
 
     /**
+     * @param {!WebInspector.DOMNode} child
+     * @param {number} index
      * @param {boolean=} closingTag
      * @return {!WebInspector.ElementsTreeElement}
      */
     insertChildElement: function(child, index, closingTag)
     {
         var newElement = new WebInspector.ElementsTreeElement(child, closingTag);
         newElement.selectable = this.treeOutline._selectEnabled;
         this.insertChild(newElement, index);
         return newElement;
     },
@@ skipping 589 matching lines @@
         }
 
         tagNameElement.addEventListener('keyup', keyupListener, false);
 
         var config = new WebInspector.InplaceEditor.Config(editingComitted.bind(this), editingCancelled.bind(this), tagName);
         this._editing = WebInspector.InplaceEditor.startEditing(tagNameElement, config);
         window.getSelection().setBaseAndExtent(tagNameElement, 0, tagNameElement, 1);
         return true;
     },
 
+    /**
+     * @param {function(string, string)} commitCallback
+     * @param {?Protocol.Error} error
+     * @param {string} initialValue
+     */
     _startEditingAsHTML: function(commitCallback, error, initialValue)
     {
         if (error)
             return;
         if (this._editing)
             return;
 
         function consume(event)
         {
             if (event.eventPhase === Event.AT_TARGET)
@@ skipping 463 matching lines @@
     /**
      * @param {function(string, string, string, boolean=, string=)=} linkify
      */
     _nodeTitleInfo: function(linkify)
     {
         var node = this._node;
         var info = {titleDOM: document.createDocumentFragment(), hasChildren: this.hasChildren};
 
         switch (node.nodeType()) {
             case Node.ATTRIBUTE_NODE:
-                this._buildAttributeDOM(info.titleDOM, node.name, node.value, true);
+                this._buildAttributeDOM(info.titleDOM, /** @type {string} */ (node.name), /** @type {string} */ (node.value), true);
                 break;
 
             case Node.ELEMENT_NODE:
-                if (node.pseudoType()) {
-                    this._buildPseudoElementDOM(info.titleDOM, node.pseudoType());
+                var pseudoType = node.pseudoType();
+                if (pseudoType) {
+                    this._buildPseudoElementDOM(info.titleDOM, pseudoType);
                     info.hasChildren = false;
                     break;
                 }
 
                 var tagName = node.nodeNameInCorrectCase();
                 if (this._elementCloseTag) {
                     this._buildTagDOM(info.titleDOM, tagName, true, true);
                     info.hasChildren = false;
                     break;
                 }
@@ skipping 109 matching lines @@
 
     remove: function()
     {
         if (this._node.pseudoType())
             return;
         var parentElement = this.parent;
         if (!parentElement)
             return;
 
         var self = this;
-        function removeNodeCallback(error, removedNodeId)
+        function removeNodeCallback(error)
         {
             if (error)
                 return;
 
             parentElement.removeChild(self);
             parentElement._adjustCollapsedRange();
         }
 
         if (!this._node.parentNode || this._node.parentNode.nodeType() === Node.DOCUMENT_NODE)
             return;
         this._node.removeNode(removeNodeCallback);
     },
 
     _editAsHTML: function()
     {
         var node = this._node;
         if (node.pseudoType())
             return;
 
         var treeOutline = this.treeOutline;
         var parentNode = node.parentNode;
         var index = node.index;
         var wasExpanded = this.expanded;
 
-        function selectNode(error, nodeId)
+        /**
+         * @param {?Protocol.Error} error
+         */
+        function selectNode(error)
         {
             if (error)
                 return;
 
             // Select it and expand if necessary. We force tree update so that it processes dom events and is up to date.
             treeOutline._updateModifiedNodes();
 
             var newNode = parentNode ? parentNode.children()[index] || parentNode : null;
             if (!newNode)
                 return;
 
             treeOutline.selectDOMNode(newNode, true);
 
             if (wasExpanded) {
                 var newTreeItem = treeOutline.findTreeElement(newNode);
                 if (newTreeItem)
                     newTreeItem.expand();
             }
         }
 
+        /**
+         * @param {string} initialValue
+         * @param {string} value
+         */
         function commitChange(initialValue, value)
         {
             if (initialValue !== value)
                 node.setOuterHTML(value, selectNode);
-            else
-                return;
         }
 
         node.getOuterHTML(this._startEditingAsHTML.bind(this, commitChange));
     },
 
     _copyHTML: function()
     {
         this._node.copyNode();
     },
 
@@ skipping 49 matching lines @@
             }
 
             if (object)
                 object.callFunction(scrollIntoView);
         }
 
         this._node.resolveToObject("", scrollIntoViewCallback);
     },
 
     /**
-     * @return {!Array.<!WebInspector.DOMModel>}
+     * @return {!Array.<!WebInspector.DOMNode>}
      */
     _visibleShadowRoots: function()
     {
         var roots = this._node.shadowRoots();
         if (roots.length && !WebInspector.settings.showUAShadowDOM.get()) {
             roots = roots.filter(function(root) {
                 return root.shadowRootType() === WebInspector.DOMNode.ShadowRootTypes.Author;
             });
         }
         return roots;
@@ skipping 246 matching lines @@
         var treeOutline = new WebInspector.ElementsTreeOutline(node.target(), false, false);
         treeOutline.rootDOMNode = node;
         treeOutline.element.classList.add("outline-disclosure");
         if (!treeOutline.children[0].hasChildren)
             treeOutline.element.classList.add("single-node");
         treeOutline.setVisible(true);
         treeOutline.element.treeElementForTest = treeOutline.children[0];
         return treeOutline.element;
     }
 }