Web Inspector: more robust treeoutline.findTreeElement
authorcommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 5 Dec 2012 17:45:56 +0000 (17:45 +0000)
committercommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 5 Dec 2012 17:45:56 +0000 (17:45 +0000)
https://bugs.webkit.org/show_bug.cgi?id=103911

Patch by John J. Barton <johnjbarton@chromium.org> on 2012-12-05
Reviewed by Vsevolod Vlasov.

Non-recursive algorithm to populate the treeoutline given an DOMNode
as representedObject. Walk up the parents from the desired object
until we find one that is currently represented in the treeoutline
cache. Then walk down, putting children in the cache until we get
to the desired object again.
With Pavel Feldeman <pfeldman@chromium.org>

No new tests, refactoring, no new function

       * inspector/front-end/treeoutline.js:
(TreeOutline.prototype.findTreeElement):

git-svn-id: http://svn.webkit.org/repository/webkit/trunk@136706 268f45cc-cd09-0410-ab3c-d52691b4dbfc

Source/WebCore/ChangeLog
Source/WebCore/inspector/front-end/treeoutline.js

index 97c8b09..202c037 100644 (file)
@@ -1,3 +1,22 @@
+2012-12-05  John J. Barton  <johnjbarton@chromium.org>
+
+        Web Inspector: more robust treeoutline.findTreeElement
+        https://bugs.webkit.org/show_bug.cgi?id=103911
+
+        Reviewed by Vsevolod Vlasov.
+
+        Non-recursive algorithm to populate the treeoutline given an DOMNode
+        as representedObject. Walk up the parents from the desired object
+        until we find one that is currently represented in the treeoutline 
+        cache. Then walk down, putting children in the cache until we get 
+        to the desired object again. 
+        With Pavel Feldeman <pfeldman@chromium.org>
+
+        No new tests, refactoring, no new function
+
+       * inspector/front-end/treeoutline.js:
+        (TreeOutline.prototype.findTreeElement):
+
 2012-12-05  Alexander Shalamov  <alexander.shalamov@intel.com>
 
         [EFL][GTK] List value response headers are not handled in RespourceResponse (libsoup specific)
 2012-12-05  Alexander Shalamov  <alexander.shalamov@intel.com>
 
         [EFL][GTK] List value response headers are not handled in RespourceResponse (libsoup specific)
index 9c52d5c..10d7f33 100644 (file)
@@ -245,43 +245,22 @@ TreeOutline.prototype.findTreeElement = function(representedObject, isAncestor,
     if (cachedElement)
         return cachedElement;
 
     if (cachedElement)
         return cachedElement;
 
-    // The representedObject isn't known, so we start at the top of the tree and work down to find the first
-    // tree element that represents representedObject or one of its ancestors.
-    var item;
-    var found = false;
-    for (var i = 0; i < this.children.length; ++i) {
-        item = this.children[i];
-        if (item.representedObject === representedObject || isAncestor(item.representedObject, representedObject)) {
-            found = true;
-            break;
-        }
-    }
-
-    if (!found)
-        return null;
-
-    // Make sure the item that we found is connected to the root of the tree.
-    // Build up a list of representedObject's ancestors that aren't already in our tree.
+    // Walk up the parent pointers from the desired representedObject 
     var ancestors = [];
     var ancestors = [];
-    var currentObject = representedObject;
-    while (currentObject) {
-        ancestors.unshift(currentObject);
-        if (currentObject === item.representedObject)
+    for (var currentObject = getParent(representedObject); currentObject;  currentObject = getParent(currentObject)) {
+        ancestors.push(currentObject);
+        if (this.getCachedTreeElement(currentObject))  // stop climbing as soon as we hit
             break;
             break;
-        currentObject = getParent(currentObject);
     }
     }
+        
+    if (!currentObject)
+        return null;
 
 
-    // For each of those ancestors we populate them to fill in the tree.
-    for (var i = 0; i < ancestors.length; ++i) {
-        // Make sure we don't call findTreeElement with the same representedObject
-        // again, to prevent infinite recursion.
-        if (ancestors[i] === representedObject)
-            continue;
-        // FIXME: we could do something faster than findTreeElement since we will know the next
-        // ancestor exists in the tree.
-        item = this.findTreeElement(ancestors[i], isAncestor, getParent);
-        if (item)
-            item.onpopulate();
+    // Walk down to populate each ancestor's children, to fill in the tree and the cache.
+    for (var i = ancestors.length - 1; i >= 0; --i) {
+        var treeElement = this.getCachedTreeElement(ancestors[i]);
+        if (treeElement)
+            treeElement.onpopulate();  // fill the cache with the children of treeElement
     }
 
     return this.getCachedTreeElement(representedObject);
     }
 
     return this.getCachedTreeElement(representedObject);