[Devtools] Moved DataGridNode's .parent property to proper getter/setter

third_party/WebKit/Source/devtools/front_end/data_grid/DataGrid.js

 /*
  * Copyright (C) 2008 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
  *        notice, this list of conditions and the following disclaimer in the
@@ skipping 786 matching lines @@
       while (nextSelectedNode && !nextSelectedNode.selectable)
         nextSelectedNode = nextSelectedNode.traverseNextNode(true);
       handled = nextSelectedNode ? true : false;
     } else if (event.key === 'ArrowLeft') {
       if (this.selectedNode.expanded) {
         if (event.altKey)
           this.selectedNode.collapseRecursively();
         else
           this.selectedNode.collapse();
         handled = true;
-      } else if (this.selectedNode.parent && !this.selectedNode.parent._isRoot) {
+      } else if (this.selectedNode.parent() && !this.selectedNode.parent()._isRoot) {
         handled = true;
-        if (this.selectedNode.parent.selectable) {
-          nextSelectedNode = this.selectedNode.parent;
+        if (this.selectedNode.parent().selectable) {
+          nextSelectedNode = this.selectedNode.parent();
           handled = nextSelectedNode ? true : false;
-        } else if (this.selectedNode.parent) {
-          this.selectedNode.parent.collapse();
+        } else if (this.selectedNode.parent()) {
+          this.selectedNode.parent().collapse();
         }
       }
     } else if (event.key === 'ArrowRight') {
       if (!this.selectedNode.revealed) {
         this.selectedNode.reveal();
         handled = true;
       } else if (this.selectedNode.hasChildren()) {
         handled = true;
         if (this.selectedNode.expanded) {
           nextSelectedNode = this.selectedNode.children[0];
@@ skipping 25 matching lines @@
       event.consume(true);
   }
 
   /**
    * @param {?NODE_TYPE} root
    * @param {boolean} onlyAffectsSubtree
    */
   updateSelectionBeforeRemoval(root, onlyAffectsSubtree) {
     var ancestor = this.selectedNode;
     while (ancestor && ancestor !== root)
-      ancestor = ancestor.parent;
+      ancestor = ancestor.parent();
     // Selection is not in the subtree being deleted.
     if (!ancestor)
       return;
 
     var nextSelectedNode;
     // Skip subtree being deleted when looking for the next selectable node.
-    for (ancestor = root; ancestor && !ancestor.nextSibling; ancestor = ancestor.parent) {
+    for (ancestor = root; ancestor && !ancestor.nextSibling; ancestor = ancestor.parent()) {
     }
     if (ancestor)
       nextSelectedNode = ancestor.nextSibling;
     while (nextSelectedNode && !nextSelectedNode.selectable)
       nextSelectedNode = nextSelectedNode.traverseNextNode(true);
 
     if (!nextSelectedNode || nextSelectedNode.isCreationNode) {
       nextSelectedNode = root.traversePreviousNode(true);
       while (nextSelectedNode && !nextSelectedNode.selectable)
         nextSelectedNode = nextSelectedNode.traversePreviousNode(true);
@@ skipping 373 matching lines @@
     this._shouldRefreshChildren = true;
     /** @type {!Object.<string, *>} */
     this._data = data || {};
     /** @type {boolean} */
     this._hasChildren = hasChildren || false;
     /** @type {!Array.<!NODE_TYPE>} */
     this.children = [];
     /** @type {?DataGrid.DataGrid} */
     this.dataGrid = null;
     /** @type {?NODE_TYPE} */
-    this.parent = null;
+    this._parent = null;
     /** @type {?NODE_TYPE} */
     this.previousSibling = null;
     /** @type {?NODE_TYPE} */
     this.nextSibling = null;
     /** @type {number} */
     this.disclosureToggleWidth = 10;
 
     /** @type {boolean} */
     this.selectable = true;
 
@@ skipping 55 matching lines @@
    */
   createCells(element) {
     element.removeChildren();
     var columnsArray = this.dataGrid._visibleColumnsArray;
     for (var i = 0; i < columnsArray.length; ++i)
       element.appendChild(this.createCell(columnsArray[i].id));
     element.appendChild(this._createTDWithClass('corner'));
   }
 
   /**
+   * @param {?NODE_TYPE} parentNode
+   */
+  setParent(parentNode) {
+    delete this._depth;
+    this._parent = parentNode;

[luoe, 2017/03/06 16:56:40]

Do we need to recalculate depth of this node's grand/children as well?

[allada, 2017/03/06 18:18:32]

Done.

+  }
+
+  /**
+   * @return {?NODE_TYPE}
+   */
+  parent() {
+    return this._parent;
+  }
+
+  /**
    * @return {!Object.<string, *>}
    */
   get data() {
     return this._data;
   }
 
   /**
    * @param {!Object.<string, *>} x
    */
   set data(x) {
     this._data = x || {};
     this.refresh();
   }
 
   /**
    * @return {boolean}
    */
   get revealed() {
     if (this._revealed !== undefined)
       return this._revealed;
 
-    var currentAncestor = this.parent;
+    var currentAncestor = this.parent();
     while (currentAncestor && !currentAncestor._isRoot) {
       if (!currentAncestor.expanded) {
         this._revealed = false;
         return false;
       }
 
-      currentAncestor = currentAncestor.parent;
+      currentAncestor = currentAncestor.parent();
     }
 
     this._revealed = true;
     return true;
   }
 
   /**
    * @param {boolean} x
    */
   set revealed(x) {
@@ skipping 76 matching lines @@
     this._element.classList.toggle('parent', this._hasChildren);
     this._element.classList.toggle('expanded', this._hasChildren && this.expanded);
   }
 
   /**
    * @return {number}
    */
   get depth() {
     if (this._depth !== undefined)
       return this._depth;
-    if (this.parent && !this.parent._isRoot)
-      this._depth = this.parent.depth + 1;
+    if (this.parent() && !this.parent()._isRoot)
+      this._depth = this.parent().depth + 1;
     else
       this._depth = 0;
     return this._depth;
   }
 
   /**
    * @return {number}
    */
   get leftPadding() {
     return this.depth * this.dataGrid.indentWidth;
@@ skipping 123 matching lines @@
     this.insertChild(child, this.children.length);
   }
 
   /**
    * @param {!NODE_TYPE} child
    * @param {number} index
    */
   insertChild(child, index) {
     if (!child)
       throw 'insertChild: Node can\'t be undefined or null.';
-    if (child.parent === this) {
+    if (child.parent() === this) {
       var currentIndex = this.children.indexOf(child);
       if (currentIndex < 0)
         console.assert(false, 'Inconsistent DataGrid state');
       if (currentIndex === index)
         return;
       if (currentIndex < index)
         --index;
     }
 
     child.remove();
 
     this.children.splice(index, 0, child);
     this.setHasChildren(true);
 
-    child.parent = this;
+    child.setParent(this);
     child.dataGrid = this.dataGrid;
     child.recalculateSiblings(index);
 
     child._depth = undefined;

[luoe, 2017/03/06 16:56:40]

No longer need this since setParent deletes it?

     child._revealed = undefined;
     child._attached = false;
     child._shouldRefreshChildren = true;
 
     var current = child.children[0];
     while (current) {
       current.dataGrid = this.dataGrid;
       current._depth = undefined;
       current._revealed = undefined;
       current._attached = false;
       current._shouldRefreshChildren = true;
       current = current.traverseNextNode(false, child, true);
     }
 
     if (this.expanded)
       child._attach();
     if (!this.revealed)
       child.revealed = false;
   }
 
   remove() {
-    if (this.parent)
-      this.parent.removeChild(this);
+    if (this.parent())
+      this.parent().removeChild(this);
   }
 
   /**
    * @param {!NODE_TYPE} child
    */
   removeChild(child) {
     if (!child)
       throw 'removeChild: Node can\'t be undefined or null.';
-    if (child.parent !== this)
+    if (child.parent() !== this)
       throw 'removeChild: Node is not a child of this node.';
 
     if (this.dataGrid)
       this.dataGrid.updateSelectionBeforeRemoval(child, false);
     child._detach();
 
     this.children.remove(child, true);
 
     if (child.previousSibling)
       child.previousSibling.nextSibling = child.nextSibling;
     if (child.nextSibling)
       child.nextSibling.previousSibling = child.previousSibling;
 
     child.dataGrid = null;
-    child.parent = null;
+    child.setParent(null);
     child.nextSibling = null;
     child.previousSibling = null;
 
     if (this.children.length <= 0)
       this.setHasChildren(false);
   }
 
   removeChildren() {
     if (this.dataGrid)
       this.dataGrid.updateSelectionBeforeRemoval(this, true);
     for (var i = 0; i < this.children.length; ++i) {
       var child = this.children[i];
       child._detach();
       child.dataGrid = null;
-      child.parent = null;
+      child.setParent(null);
       child.nextSibling = null;
       child.previousSibling = null;
     }
 
     this.children = [];
     this.setHasChildren(false);
   }
 
   /**
    * @param {number} myIndex
    */
   recalculateSiblings(myIndex) {
-    if (!this.parent)
+    if (!this.parent())
       return;
 
-    var previousChild = this.parent.children[myIndex - 1] || null;
+    var previousChild = this.parent().children[myIndex - 1] || null;
     if (previousChild)
       previousChild.nextSibling = this;
     this.previousSibling = previousChild;
 
-    var nextChild = this.parent.children[myIndex + 1] || null;
+    var nextChild = this.parent().children[myIndex + 1] || null;
     if (nextChild)
       nextChild.previousSibling = this;
     this.nextSibling = nextChild;
   }
 
   collapse() {
     if (this._isRoot)
       return;
     if (this._element)
       this._element.classList.remove('expanded');
@@ skipping 55 matching lines @@
     var item = this;
     while (item) {
       item.expand();
       item = item.traverseNextNode(false, this);
     }
   }
 
   reveal() {
     if (this._isRoot)
       return;
-    var currentAncestor = this.parent;
+    var currentAncestor = this.parent();
     while (currentAncestor && !currentAncestor._isRoot) {
       if (!currentAncestor.expanded)
         currentAncestor.expand();
-      currentAncestor = currentAncestor.parent;
+      currentAncestor = currentAncestor.parent();
     }
 
     this.element().scrollIntoViewIfNeeded(false);
   }
 
   /**
    * @param {boolean=} supressSelectedEvent
    */
   select(supressSelectedEvent) {
     if (!this.dataGrid || !this.selectable || this.selected)
@@ skipping 59 matching lines @@
 
     if (this === stayWithin)
       return null;
 
     node = (!skipHidden || this.revealed) ? this.nextSibling : null;
     if (node)
       return node;
 
     node = this;
     while (node && !node._isRoot && !((!skipHidden || node.revealed) ? node.nextSibling : null) &&
-           node.parent !== stayWithin) {
+           node.parent() !== stayWithin) {
       if (info)
         info.depthChange -= 1;
-      node = node.parent;
+      node = node.parent();
     }
 
     if (!node)
       return null;
 
     return (!skipHidden || node.revealed) ? node.nextSibling : null;
   }
 
   /**
    * @param {boolean} skipHidden
    * @param {boolean=} dontPopulate
    * @return {?NODE_TYPE}
    */
   traversePreviousNode(skipHidden, dontPopulate) {
     var node = (!skipHidden || this.revealed) ? this.previousSibling : null;
     if (!dontPopulate && node && node._hasChildren)
       node.populate();
 
     while (node &&
            ((!skipHidden || (node.revealed && node.expanded)) ? node.children[node.children.length - 1] : null)) {
       if (!dontPopulate && node._hasChildren)
         node.populate();
       node = ((!skipHidden || (node.revealed && node.expanded)) ? node.children[node.children.length - 1] : null);
     }
 
     if (node)
       return node;
 
-    if (!this.parent || this.parent._isRoot)
+    if (!this.parent() || this.parent()._isRoot)
       return null;
 
-    return this.parent;
+    return this.parent();
   }
 
   /**
    * @param {!Event} event
    * @return {boolean}
    */
   isEventWithinDisclosureTriangle(event) {
     if (!this._hasChildren)
       return false;
     var cell = event.target.enclosingNodeOrSelfWithNodeName('td');
@@ skipping 35 matching lines @@
     this.wasDetached();
   }
 
   wasDetached() {
   }
 
   savePosition() {
     if (this._savedPosition)
       return;
 
-    if (!this.parent)
+    if (!this.parent())
       throw 'savePosition: Node must have a parent.';
-    this._savedPosition = {parent: this.parent, index: this.parent.children.indexOf(this)};
+    this._savedPosition = {parent: this.parent(), index: this.parent().children.indexOf(this)};
   }
 
   restorePosition() {
     if (!this._savedPosition)
       return;
 
-    if (this.parent !== this._savedPosition.parent)
-      this._savedPosition.parent.insertChild(this, this._savedPosition.index);
+    if (this.parent() !== this._savedPosition.parent())
+      this._savedPosition.parent().insertChild(this, this._savedPosition.index);
 
     this._savedPosition = null;
   }
 };
 
 /**
  * @unrestricted
  * @extends {DataGrid.DataGridNode<!NODE_TYPE>}
  * @template NODE_TYPE
  */
@@ skipping 54 matching lines @@
   /**
    * @override
    */
   detachChildWidgets() {
     super.detachChildWidgets();
     for (var dataGrid of this._dataGrids)
       this.element.removeChild(dataGrid.element);
     this._dataGrids = [];
   }
 };