Sync: Support nodes with implicit permanent folders: Node Browser and out-of-order loading from DB

chrome/browser/resources/sync_internals/sync_node_browser.js

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // require: cr.js
 // require: cr/ui.js
 // require: cr/ui/tree.js
 
 (function() {
   /**
    * A helper function to determine if a node is the root of its type.
    *
    * @param {!Object} node The node to check.
    */
   var isTypeRootNode = function(node) {
     return node.PARENT_ID == 'r' && node.UNIQUE_SERVER_TAG != '';
-  }
+  };
 
   /**
    * A helper function to determine if a node is a child of the given parent.
    *
-   * @param {string} parentId The ID of the parent.
+   * @param {!Object} parent node.
    * @param {!Object} node The node to check.
    */
-  var isChildOf = function(parentId, node) {
-    return node.PARENT_ID == parentId;
-  }
+  var isChildOf = function(parentNode, node) {
+    if (node.PARENT_ID != '') {
+      return node.PARENT_ID == parentNode.ID;
+    }
+    else {
+      return node.modelType == parentNode.modelType;
+    }
+  };
 
   /**
    * A helper function to sort sync nodes.
    *
    * Sorts by position index if possible, falls back to sorting by name, and
    * finally sorting by METAHANDLE.
    *
    * If this proves to be slow and expensive, we should experiment with moving
    * this functionality to C++ instead.
    */
   var nodeComparator = function(nodeA, nodeB) {
     if (nodeA.hasOwnProperty('positionIndex') &&
         nodeB.hasOwnProperty('positionIndex')) {
       return nodeA.positionIndex - nodeB.positionIndex;
     } else if (nodeA.NON_UNIQUE_NAME != nodeB.NON_UNIQUE_NAME) {
       return nodeA.NON_UNIQUE_NAME.localeCompare(nodeB.NON_UNIQUE_NAME);
     } else {
       return nodeA.METAHANDLE - nodeB.METAHANDLE;
     }
-  }
+  };
 
   /**
    * Updates the node detail view with the details for the given node.
    * @param {!Object} node The struct representing the node we want to display.
    */
   function updateNodeDetailView(node) {
     var nodeDetailsView = $('node-details');
     nodeDetailsView.hidden = false;
     jstProcess(new JsEvalContext(node.entry_), nodeDetailsView);
   }
@@ skipping 41 matching lines @@
      */
     handleExpand_: function(event) {
       var treeItem = this;
 
       if (treeItem.expanded_) {
         return;
       }
       treeItem.expanded_ = true;
 
       var children = treeItem.tree.allNodes.filter(
-          isChildOf.bind(undefined, treeItem.entry_.ID));
+          isChildOf.bind(undefined, treeItem.entry_));
       children.sort(nodeComparator);
 
       children.forEach(function(node) {
         treeItem.add(new SyncNodeTreeItem(node));
       });
     },
   };
 
   /**
    * Creates a new sync node tree.  Technically, it's a forest since it each
@@ skipping 85 matching lines @@
     // Automatically trigger a refresh the first time this tab is selected.
     $('sync-browser-tab').addEventListener('selectedChange', function f(e) {
       if (this.selected) {
         $('sync-browser-tab').removeEventListener('selectedChange', f);
         refresh();
       }
     });
   });
 
 })();