DevTools: migrate treeoutline from hasChildren to is/setExpandable().

Source/devtools/front_end/ui/treeoutline.js

 /*
  * Copyright (C) 2007 Apple 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.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 211 matching lines @@
                     while (nextSelectedElement && !nextSelectedElement.selectable)
                         nextSelectedElement = nextSelectedElement.parent;
                     handled = nextSelectedElement ? true : false;
                 } else if (this.selectedTreeElement.parent)
                     this.selectedTreeElement.parent.collapse();
             }
         } else if (event.keyIdentifier === "Right") {
             if (!this.selectedTreeElement.revealed()) {
                 this.selectedTreeElement.reveal();
                 handled = true;
-            } else if (this.selectedTreeElement.hasChildren) {
+            } else if (this.selectedTreeElement._expandable) {
                 handled = true;
                 if (this.selectedTreeElement.expanded) {
                     nextSelectedElement = this.selectedTreeElement.firstChild();
                     while (nextSelectedElement && !nextSelectedElement.selectable)
                         nextSelectedElement = nextSelectedElement.nextSibling;
                     handled = nextSelectedElement ? true : false;
                 } else {
                     if (event.altKey)
                         this.selectedTreeElement.expandRecursively();
                     else
@@ skipping 38 matching lines @@
     this._renderSelection = true;
 }
 
 TreeOutlineInShadow.prototype = {
     __proto__: TreeOutline.prototype
 }
 
 /**
  * @constructor
  * @param {(string|!Node)=} title
- * @param {boolean=} hasChildren
+ * @param {boolean=} expandable
  */
-function TreeElement(title, hasChildren)
+function TreeElement(title, expandable)
 {
     /** @type {?TreeOutline} */
     this.treeOutline = null;
     this.parent = null;
     this.previousSibling = null;
     this.nextSibling = null;
 
     this._listItemNode = createElement("li");
     this._listItemNode.treeElement = this;
     if (title)
         this.title = title;
     if (typeof title === "string")
         this.tooltip = title;
     this._listItemNode.addEventListener("mousedown", this._handleMouseDown.bind(this), false);
     this._listItemNode.addEventListener("selectstart", this._treeElementSelectStart.bind(this), false);
     this._listItemNode.addEventListener("click", this._treeElementToggled.bind(this), false);
     this._listItemNode.addEventListener("dblclick", this._handleDoubleClick.bind(this), false);
 
     this._childrenListNode = createElement("ol");
     this._childrenListNode.parentTreeElement = this;
     this._childrenListNode.classList.add("children");
 
     this._hidden = false;
     this._selectable = true;
     this.expanded = false;
     this.selected = false;
-    this.hasChildren = hasChildren || false;
+    this.setExpandable(expandable || false);
 }
 
 /** @const */
 TreeElement._ArrowToggleWidth = 10;
 
 TreeElement.prototype = {
     /**
      * @param {?TreeElement} ancestor
      * @return {boolean}
      */
@@ skipping 112 matching lines @@
         var nextChild = this._children[index];
         if (nextChild) {
             nextChild.previousSibling = child;
             child.nextSibling = nextChild;
         } else {
             child.nextSibling = null;
         }
 
         this._children.splice(index, 0, child);
 
-        this.hasChildren = true;
+        this.setExpandable(true);
         child.parent = this;
 
         if (this.treeOutline)
             this.treeOutline._bindTreeElement(child);
         for (var current = child.firstChild(); this.treeOutline && current; current = current.traverseNextTreeElement(false, child, true))
             this.treeOutline._bindTreeElement(current);
         child.onattach();
         child._ensureSelection();
         if (this.treeOutline)
             this.treeOutline.dispatchEventToListeners(TreeOutline.Events.ElementAttached, child);
@@ skipping 122 matching lines @@
      * @param {string} x
      */
     set tooltip(x)
     {
         if (x)
             this._listItemNode.setAttribute("title", x);
         else
             this._listItemNode.removeAttribute("title");
     },
 
-    get hasChildren()
+    /**
+     * @return {boolean}
+     */
+    isExpandable: function()
     {
-        return this._hasChildren;
+        return this._expandable;
     },
 
     /**
-     * Used inside subclasses.
-     *
-     * @param {boolean} hasChildren
+     * @param {boolean} expandable
      */
-    setHasChildren: function(hasChildren)
+    setExpandable: function(expandable)
     {
-        this.hasChildren = hasChildren;
-    },
-
-    set hasChildren(x)
-    {
-        if (this._hasChildren === x)
+        if (this._expandable === expandable)
             return;
 
-        this._hasChildren = x;
+        this._expandable = expandable;
 
-        this._listItemNode.classList.toggle("parent", x);
-        if (!x)
+        this._listItemNode.classList.toggle("parent", expandable);
+        if (!expandable)
             this.collapse();
     },
 
     get hidden()
     {
         return this._hidden;
     },
 
     set hidden(x)
     {
@@ skipping 95 matching lines @@
      */
     _handleDoubleClick: function(event)
     {
         var element = event.currentTarget;
         if (!element || element.treeElement !== this)
             return;
 
         var handled = this.ondblclick(event);
         if (handled)
             return;
-        if (this.hasChildren && !this.expanded)
+        if (this._expandable && !this.expanded)
             this.expand();
     },
 
     _detach: function()
     {
         this._listItemNode.remove();
         this._childrenListNode.remove();
     },
 
     collapse: function()
@@ skipping 13 matching lines @@
         var item = this;
         while (item) {
             if (item.expanded)
                 item.collapse();
             item = item.traverseNextTreeElement(false, this, true);
         }
     },
 
     expand: function()
     {
-        if (!this.hasChildren || (this.expanded && this._children))
+        if (!this._expandable || (this.expanded && this._children))
             return;
 
         // Set this before onpopulate. Since onpopulate can add elements, this makes
         // sure the expanded flag is true before calling those functions. This prevents the possibility
         // of an infinite loop if onpopulate were to call expand.
 
         this.expanded = true;
 
-        if (!this._children) {
-            this._children = [];
-            this.onpopulate();
-        }
-
+        this._populateIfNeeded();
         this._listItemNode.classList.add("expanded");
         this._childrenListNode.classList.add("expanded");
 
         this.onexpand();
         if (this.treeOutline)
             this.treeOutline.dispatchEventToListeners(TreeOutline.Events.ElementExpanded, this);
     },
 
     /**
      * @param {number=} maxDepth
@@ skipping 99 matching lines @@
     deselect: function(supressOnDeselect)
     {
         if (!this.treeOutline || this.treeOutline.selectedTreeElement !== this || !this.selected)
             return;
 
         this.selected = false;
         this.treeOutline.selectedTreeElement = null;
         this._listItemNode.classList.remove("selected");
     },
 
+    _populateIfNeeded: function()
+    {
+        if (this._expandable && !this._children) {
+            this._children = [];
+            this.onpopulate();
+        }
+    },
+
     onpopulate: function()
     {
         // Overridden by subclasses.
     },
 
     /**
      * @return {boolean}
      */
     onenter: function()
     {
@@ skipping 60 matching lines @@
 
     /**
      * @param {boolean} skipUnrevealed
      * @param {?TreeElement=} stayWithin
      * @param {boolean=} dontPopulate
      * @param {!Object=} info
      * @return {?TreeElement}
      */
     traverseNextTreeElement: function(skipUnrevealed, stayWithin, dontPopulate, info)
     {
-        if (!dontPopulate && this.hasChildren)
-            this.onpopulate();
+        if (!dontPopulate)
+            this._populateIfNeeded();
 
         if (info)
             info.depthChange = 0;
 
         var element = skipUnrevealed ? (this.revealed() ? this.firstChild() : null) : this.firstChild();
         if (element && (!skipUnrevealed || (skipUnrevealed && this.expanded))) {
             if (info)
                 info.depthChange = 1;
             return element;
         }
@@ skipping 19 matching lines @@
     },
 
     /**
      * @param {boolean} skipUnrevealed
      * @param {boolean=} dontPopulate
      * @return {?TreeElement}
      */
     traversePreviousTreeElement: function(skipUnrevealed, dontPopulate)
     {
         var element = skipUnrevealed ? (this.revealed() ? this.previousSibling : null) : this.previousSibling;
-        if (!dontPopulate && element && element.hasChildren)
-            element.onpopulate();
+        if (!dontPopulate && element)
+            element._populateIfNeeded();
 
         while (element && (skipUnrevealed ? (element.revealed() && element.expanded ? element.lastChild() : null) : element.lastChild())) {
-            if (!dontPopulate && element.hasChildren)
-                element.onpopulate();
+            if (!dontPopulate)
+                element._populateIfNeeded();
             element = (skipUnrevealed ? (element.revealed() && element.expanded ? element.lastChild() : null) : element.lastChild());
         }
 
         if (element)
             return element;
 
         if (!this.parent || this.parent.root)
             return null;
 
         return this.parent;
     },
 
     /**
      * @return {boolean}
      */
     isEventWithinDisclosureTriangle: function(event)
     {
         // FIXME: We should not use getComputedStyle(). For that we need to get rid of using ::before for disclosure triangle. (http://webk.it/74446)
         var paddingLeftValue = window.getComputedStyle(this._listItemNode).paddingLeft;
         console.assert(paddingLeftValue.endsWith("px"));
         var computedLeftPadding = parseFloat(paddingLeftValue);
         var left = this._listItemNode.totalOffsetLeft() + computedLeftPadding;
-        return event.pageX >= left && event.pageX <= left + TreeElement._ArrowToggleWidth && this.hasChildren;
+        return event.pageX >= left && event.pageX <= left + TreeElement._ArrowToggleWidth && this._expandable;
     }
 }