DevTools: Code fixes for the Closure compiler roll

Source/devtools/front_end/common/DOMExtension.js

 /*
  * Copyright (C) 2007 Apple Inc.  All rights reserved.
  * 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 17 matching lines @@
  *
  * Contains diff method based on Javascript Diff Algorithm By John Resig
  * http://ejohn.org/files/jsdiff.js (released under the MIT license).
  */
 
 /**
  * @param {number} offset
  * @param {string} stopCharacters
  * @param {!Node} stayWithinNode
  * @param {string=} direction
+ * @return {!Range}
  */
 Node.prototype.rangeOfWord = function(offset, stopCharacters, stayWithinNode, direction)
 {
     var startNode;
     var startOffset = 0;
     var endNode;
     var endOffset = 0;
 
     if (!stayWithinNode)
         stayWithinNode = this;
@@ skipping 68 matching lines @@
         endOffset = offset;
     }
 
     var result = this.ownerDocument.createRange();
     result.setStart(startNode, startOffset);
     result.setEnd(endNode, endOffset);
 
     return result;
 }
 
+/**
+ * @param {!Node=} stayWithin
+ * @return {?Node}
+ */
 Node.prototype.traverseNextTextNode = function(stayWithin)
 {
     var node = this.traverseNextNode(stayWithin);
     if (!node)
-        return;
+        return null;
 
     while (node && node.nodeType !== Node.TEXT_NODE)
         node = node.traverseNextNode(stayWithin);
 
     return node;
 }
 
+/**
+ * @param {number} offset
+ * @return {!{container: !Node, offset: number}}
+ */
 Node.prototype.rangeBoundaryForOffset = function(offset)
 {
     var node = this.traverseNextTextNode(this);
     while (node && offset > node.nodeValue.length) {
         offset -= node.nodeValue.length;
         node = node.traverseNextTextNode(this);
     }
     if (!node)
         return { container: this, offset: 0 };
     return { container: node, offset: offset };
@@ skipping 21 matching lines @@
         this.style.setProperty("left", (shift.x + x) + "px");
     else
         this.style.removeProperty("left");
 
     if (typeof y === "number")
         this.style.setProperty("top", (shift.y + y) + "px");
     else
         this.style.removeProperty("top");
 }
 
+/**
+ * @return {boolean}
+ */
 Element.prototype.isScrolledToBottom = function()
 {
     // This code works only for 0-width border.
     // Both clientHeight and scrollHeight are rounded to integer values, so we tolerate
     // one pixel error.
     return Math.abs(this.scrollTop + this.clientHeight - this.scrollHeight) <= 1;
 }
 
 /**
  * @param {!Node} fromNode
@@ skipping 29 matching lines @@
         throw new Error("Minimum size is greater than preferred.");
 }
 
 /**
  * @param {?Constraints} constraints
  * @return {boolean}
  */
 Constraints.prototype.isEqual = function(constraints)
 {
     return !!constraints && this.minimum.isEqual(constraints.minimum) && this.preferred.isEqual(constraints.preferred);
-};
+}
 
 /**
  * @param {!Constraints|number} value
  * @return {!Constraints}
  */
 Constraints.prototype.widthToMax = function(value)
 {
     if (typeof value === "number")
         return new Constraints(this.minimum.widthToMax(value), this.preferred.widthToMax(value));
     return new Constraints(this.minimum.widthToMax(value.minimum), this.preferred.widthToMax(value.preferred));
-};
+}
 
 /**
  * @param {!Constraints|number} value
  * @return {!Constraints}
  */
 Constraints.prototype.addWidth = function(value)
 {
     if (typeof value === "number")
         return new Constraints(this.minimum.addWidth(value), this.preferred.addWidth(value));
     return new Constraints(this.minimum.addWidth(value.minimum), this.preferred.addWidth(value.preferred));
-};
+}
 
 /**
  * @param {!Constraints|number} value
  * @return {!Constraints}
  */
 Constraints.prototype.heightToMax = function(value)
 {
     if (typeof value === "number")
         return new Constraints(this.minimum.heightToMax(value), this.preferred.heightToMax(value));
     return new Constraints(this.minimum.heightToMax(value.minimum), this.preferred.heightToMax(value.preferred));
-};
+}
 
 /**
  * @param {!Constraints|number} value
  * @return {!Constraints}
  */
 Constraints.prototype.addHeight = function(value)
 {
     if (typeof value === "number")
         return new Constraints(this.minimum.addHeight(value), this.preferred.addHeight(value));
     return new Constraints(this.minimum.addHeight(value.minimum), this.preferred.addHeight(value.preferred));
-};
+}
 
 /**
  * @param {?Element=} containerElement
  * @return {!Size}
  */
 Element.prototype.measurePreferredSize = function(containerElement)
 {
     containerElement = containerElement || document.body;
     containerElement.appendChild(this);
     this.positionAt(0, 0);
@@ skipping 72 matching lines @@
     for (var i = 0; i < children.length; ++i)
         this.appendChild(children[i]);
 }
 
 Element.prototype.setChildren = function(children)
 {
     this.removeChildren();
     this.appendChildren(children);
 }
 
+/**
+ * @return {boolean}
+ */
 Element.prototype.isInsertionCaretInside = function()
 {
     var selection = window.getSelection();
     if (!selection.rangeCount || !selection.isCollapsed)
         return false;
     var selectionRange = selection.getRangeAt(0);
     return selectionRange.startContainer.isSelfOrDescendant(this);
 }
 
 /**
  * @param {string} elementName
  * @param {string=} className
+ * @return {!Element}
  */
 Document.prototype.createElementWithClass = function(elementName, className)
 {
     var element = this.createElement(elementName);
     if (className)
         element.className = className;
     return element;
 }
 
 /**
  * @param {string} elementName
  * @param {string=} className
+ * @return {!Element}
  */
 Element.prototype.createChild = function(elementName, className)
 {
     var element = this.ownerDocument.createElementWithClass(elementName, className);
     this.appendChild(element);
     return element;
 }
 
 DocumentFragment.prototype.createChild = Element.prototype.createChild;
 
 /**
  * @param {string} text
+ * @return {!Text}
  */
 Element.prototype.createTextChild = function(text)
 {
     var element = this.ownerDocument.createTextNode(text);
     this.appendChild(element);
     return element;
 }
 
 DocumentFragment.prototype.createTextChild = Element.prototype.createTextChild;
 
 /**
  * @return {number}
  */
 Element.prototype.totalOffsetLeft = function()
 {
     return this.totalOffset().left;
 }
 
 /**
  * @return {number}
  */
 Element.prototype.totalOffsetTop = function()
 {
     return this.totalOffset().top;
 
 }
 
+/**
+ * @return {!{left: number, top: number}}
+ */
 Element.prototype.totalOffset = function()
 {
     var rect = this.getBoundingClientRect();
     return { left: rect.left, top: rect.top };
 }
 
+/**
+ * @return {!{left: number, top: number}}
+ */
 Element.prototype.scrollOffset = function()
 {
     var curLeft = 0;
     var curTop = 0;
     for (var element = this; element; element = element.scrollParent) {
         curLeft += element.scrollLeft;
         curTop += element.scrollTop;
     }
     return { left: curLeft, top: curTop };
 }
@@ skipping 14 matching lines @@
 }
 
 /**
  * @param {!AnchorBox} box
  * @return {!AnchorBox}
  */
 AnchorBox.prototype.relativeTo = function(box)
 {
     return new AnchorBox(
         this.x - box.x, this.y - box.y, this.width, this.height);
-};
+}
 
 /**
  * @param {!Element} element
  * @return {!AnchorBox}
  */
 AnchorBox.prototype.relativeToElement = function(element)
 {
     return this.relativeTo(element.boxInWindow(element.ownerDocument.defaultView));
-};
+}
 
 /**
  * @param {?AnchorBox} anchorBox
  * @return {boolean}
  */
 AnchorBox.prototype.equals = function(anchorBox)
 {
     return !!anchorBox && this.x === anchorBox.x && this.y === anchorBox.y && this.width === anchorBox.width && this.height === anchorBox.height;
-};
+}
 
 /**
  * @param {!Window} targetWindow
  * @return {!AnchorBox}
  */
 Element.prototype.offsetRelativeToWindow = function(targetWindow)
 {
     var elementOffset = new AnchorBox();
     var curElement = this;
     var curWindow = this.ownerDocument.defaultView;
@@ skipping 57 matching lines @@
  * @param {boolean=} preventDefault
  */
 Event.prototype.consume = function(preventDefault)
 {
     this.stopImmediatePropagation();
     if (preventDefault)
         this.preventDefault();
     this.handled = true;
 }
 
+/**
+ * @param {number=} start
+ * @param {number=} end
+ * @return {!Text}
+ */
 Text.prototype.select = function(start, end)
 {
     start = start || 0;
     end = end || this.textContent.length;
 
     if (start < 0)
         start = end + start;
 
     var selection = this.ownerDocument.defaultView.getSelection();
     selection.removeAllRanges();
     var range = this.ownerDocument.createRange();
     range.setStart(this, start);
     range.setEnd(this, end);
     selection.addRange(range);
     return this;
 }
 
+/**
+ * @return {?number}
+ */
 Element.prototype.selectionLeftOffset = function()
 {
     // Calculate selection offset relative to the current element.
 
     var selection = window.getSelection();
     if (!selection.containsNode(this, true))
         return null;
 
     var leftOffset = selection.anchorOffset;
     var node = selection.anchorNode;
 
     while (node !== this) {
         while (node.previousSibling) {
             node = node.previousSibling;
             leftOffset += node.textContent.length;
         }
         node = node.parentNode;
     }
 
     return leftOffset;
 }
 
-Node.prototype.isAncestor = function(node)
+/**
+ * @param {?Node|?EventTarget} target

[aandrey, 2014/06/17 20:58:36]

this should not be called for EventTarget as it has no notion of ancestor at all

[apavlov, 2014/06/18 07:55:13]

ElementsPanel.js:1233
if (this.element.isAncestor(event.target))

Should we first check that it's a Node? :) I'll add a cast there instead.

+ * @return {boolean}
+ */
+Node.prototype.isAncestor = function(target)
 {
-    if (!node)
+    if (!target)
         return false;
 
+    var node = /** @type {!Node} */ (target);
     var currentNode = node.parentNode;
     while (currentNode) {
         if (this === currentNode)
             return true;
         currentNode = currentNode.parentNode;
     }
     return false;
 }
 
+/**
+ * @param {?Node} descendant
+ * @return {boolean}
+ */
 Node.prototype.isDescendant = function(descendant)
 {
     return !!descendant && descendant.isAncestor(this);
 }
 
+/**
+ * @param {?Node} node
+ * @return {boolean}
+ */
 Node.prototype.isSelfOrAncestor = function(node)
 {
     return !!node && (node === this || this.isAncestor(node));
 }
 
+/**
+ * @param {?Node} node
+ * @return {boolean}
+ */
 Node.prototype.isSelfOrDescendant = function(node)
 {
     return !!node && (node === this || this.isDescendant(node));
 }
 
+/**
+ * @param {!Node=} stayWithin
+ * @return {?Node}
+ */
 Node.prototype.traverseNextNode = function(stayWithin)
 {
     var node = this.firstChild;
     if (node)
         return node;
 
     if (stayWithin && this === stayWithin)
         return null;
 
     node = this.nextSibling;
     if (node)
         return node;
 
     node = this;
     while (node && !node.nextSibling && (!stayWithin || !node.parentNode || node.parentNode !== stayWithin))
         node = node.parentNode;
     if (!node)
         return null;
 
     return node.nextSibling;
 }
 
+/**
+ * @param {!Node=} stayWithin
+ * @return {?Node}
+ */
 Node.prototype.traversePreviousNode = function(stayWithin)
 {
     if (stayWithin && this === stayWithin)
         return null;
     var node = this.previousSibling;
     while (node && node.lastChild)
         node = node.lastChild;
     if (node)
         return node;
     return this.parentNode;
@@ skipping 25 matching lines @@
  */
 function isEnterKey(event) {
     // Check if in IME.
     return event.keyCode !== 229 && event.keyIdentifier === "Enter";
 }
 
 function consumeEvent(e)
 {
     e.consume();
 }