cc: Make LayerTreeImpl dump layer list to FrameViewer and Devtools

third_party/WebKit/Source/devtools/front_end/timeline_model/LayerTreeModel.js

 /*
  * Copyright (C) 2013 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 176 matching lines @@
     /** @type Map<number, ?WebInspector.DOMNode> */
     this._backendNodeIdToNode = new Map();
     this._reset();
 }
 
 WebInspector.LayerTreeBase.prototype = {
     _reset: function()
     {
         this._root = null;
         this._contentRoot = null;
+        this._layers = null;
     },
 
     /**
      * @return {?WebInspector.Target}
      */
     target: function()
     {
         return this._target;
     },
 
     /**
      * @return {?WebInspector.Layer}
      */
     root: function()
     {
         return this._root;
     },
 
     /**
      * @return {?WebInspector.Layer}
      */
     contentRoot: function()
     {
         return this._contentRoot;
     },
 
     /**
+     * @return {!Array.<!WebInspector.Layer>}
+     */
+    layers: function()
+    {
+        return this._layers;
+    },
+
+    /**
      * @param {function(!WebInspector.Layer)} callback
      * @param {?WebInspector.Layer=} root
      * @return {boolean}
      */
     forEachLayer: function(callback, root)
     {
         if (!root) {
             root = this.root();
             if (!root)
                 return false;
@@ skipping 71 matching lines @@
 WebInspector.TracingLayerTree = function(target)
 {
     WebInspector.LayerTreeBase.call(this, target);
     /** @type {!Map.<string, !WebInspector.TracingLayerTile>} */
     this._tileById = new Map();
 }
 
 WebInspector.TracingLayerTree.prototype = {
     /**
      * @param {!WebInspector.TracingLayerPayload} root
+     * @param {?Array.<!WebInspector.TracingLayerPayload>} layers
      * @param {function()} callback
      */
-    setLayers: function(root, callback)
+    setLayers: function(root, layers, callback)
     {
         var idsToResolve = new Set();
-        this._extractNodeIdsToResolve(idsToResolve, {}, root);
+        if (root) {
+            // This is a legacy code path for compatibility, as cc is removing
+            // layer tree hierarchy, this code will eventually be removed.
+            this._extractNodeIdsToResolve(idsToResolve, {}, root);
+        } else {
+            for (var i = 0; i < layers.length; ++i)
+                this._extractNodeIdsToResolve(idsToResolve, {}, layers[i]);
+        }
         this._resolveBackendNodeIds(idsToResolve, onBackendNodeIdsResolved.bind(this));
 
         /**
          * @this {WebInspector.TracingLayerTree}
          */
         function onBackendNodeIdsResolved()
         {
             var oldLayersById = this._layersById;
             this._layersById = {};
             this._contentRoot = null;
-            this._root = this._innerSetLayers(oldLayersById, root);
+            if (root) {
+                this._root = this._innerSetLayers(oldLayersById, root);
+            } else {
+                this._layers = layers.map(this._innerSetLayers.bind(this, oldLayersById));
+                this._root = this._contentRoot;
+                for (var i = 0; i < this._layers.length; ++i) {
+                    if (this._layers[i].id() !== this._contentRoot.id()) {
+                        this._contentRoot.addChild(this._layers[i]);
+                    }
+                }
+            }
             callback();
         }
     },
 
     /**
      * @param {!Array.<!WebInspector.TracingLayerTile>} tiles
      */
     setTiles: function(tiles)
     {
         this._tileById = new Map();
@@ skipping 931 matching lines @@
 WebInspector.LayerTreeModel.fromTarget = function(target)
 {
     if (!target.isPage())
         return null;
 
     var model = /** @type {?WebInspector.LayerTreeModel} */ (target.model(WebInspector.LayerTreeModel));
     if (!model)
         model = new WebInspector.LayerTreeModel(target);
     return model;
 }