DevTools: make paint profiler target-aware

Source/devtools/front_end/sdk/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 64 matching lines @@
         this._enabled = false;
         this._layerTree = null;
         LayerTreeAgent.disable();
     },
 
     enable: function()
     {
         if (this._enabled)
             return;
         this._enabled = true;
-        this._layerTree = new WebInspector.AgentLayerTree(this.target());
+        this._layerTree = new WebInspector.AgentLayerTree(this.target().weakReference());
         this._lastPaintRectByLayerId = {};
         LayerTreeAgent.enable();
     },
 
     /**
      * @param {!WebInspector.LayerTreeBase} layerTree
      */
     setLayerTree: function(layerTree)
     {
         this.disable();
@@ skipping 60 matching lines @@
             return;
         this.disable();
         this.enable();
     },
 
     __proto__: WebInspector.SDKObject.prototype
 }
 
 /**
   * @constructor
-  * @extends {WebInspector.SDKObject}
-  * @param {!WebInspector.Target} target
+  * @param {!WeakReference.<!WebInspector.Target>} weakTarget
   */
-WebInspector.LayerTreeBase = function(target)
+WebInspector.LayerTreeBase = function(weakTarget)
 {
-    WebInspector.SDKObject.call(this, target);
+    this._weakTarget = weakTarget;
     this._layersById = {};
     this._backendNodeIdToNodeId = {};
     this._reset();
 }
 
 WebInspector.LayerTreeBase.prototype = {
     _reset: function()
     {
         this._root = null;
         this._contentRoot = null;
@@ skipping 38 matching lines @@
     {
         return this._layersById[id] || null;
     },
 
     /**
      * @param {!Array.<number>} requestedNodeIds
      * @param {function()} callback
      */
     _resolveBackendNodeIds: function(requestedNodeIds, callback)
     {
-        if (!requestedNodeIds.length) {
+        var target = this._weakTarget.get();
+        if (!requestedNodeIds.length || !target) {
             callback();
             return;
         }
 
-        this.target().domModel.pushNodesByBackendIdsToFrontend(requestedNodeIds, populateBackendNodeIdMap.bind(this));
+        target.domModel.pushNodesByBackendIdsToFrontend(requestedNodeIds, populateBackendNodeIdMap.bind(this));
 
         /**
          * @this {WebInspector.LayerTreeBase}
          * @param {?Array.<number>} nodeIds
          */
         function populateBackendNodeIdMap(nodeIds)
         {
             if (nodeIds) {
                 for (var i = 0; i < requestedNodeIds.length; ++i) {
                     var nodeId = nodeIds[i];
@@ skipping 14 matching lines @@
     },
 
     /**
      * @return {!Object | undefined}
      */
     viewportSize: function()
     {
         return this._viewportSize;
     },
 
-    __proto__: WebInspector.SDKObject.prototype
+    /**
+     * @param {number} id
+     * @return {?WebInspector.DOMNode}
+     */
+    _nodeForId: function(id)
+    {
+        var target = this._weakTarget.get();
+        return target ? target.domModel.nodeForId(id) : null;
+    }
 };
 
 /**
   * @constructor
   * @extends {WebInspector.LayerTreeBase}
-  * @param {!WebInspector.Target} target
+  * @param {!WeakReference.<!WebInspector.Target>} weakTarget
   */
-WebInspector.TracingLayerTree = function(target)
+WebInspector.TracingLayerTree = function(weakTarget)
 {
-    WebInspector.LayerTreeBase.call(this, target);
+    WebInspector.LayerTreeBase.call(this, weakTarget);
 }
 
 WebInspector.TracingLayerTree.prototype = {
     /**
      * @param {!WebInspector.TracingLayerPayload} root
      * @param {!function()} callback
      */
     setLayers: function(root, callback)
     {
         var idsToResolve = [];
@@ skipping 23 matching lines @@
         var layer = /** @type {?WebInspector.TracingLayer} */ (oldLayersById[payload.layer_id]);
         if (layer)
             layer._reset(payload);
         else
             layer = new WebInspector.TracingLayer(payload);
         this._layersById[payload.layer_id] = layer;
         if (!this._contentRoot && payload.draws_content)
             this._contentRoot = layer;
 
         if (payload.owner_node && this._backendNodeIdToNodeId[payload.owner_node])
-            layer._setNode(this.target().domModel.nodeForId(this._backendNodeIdToNodeId[payload.owner_node]));
+            layer._setNode(this._nodeForId(this._backendNodeIdToNodeId[payload.owner_node]));
 
         for (var i = 0; payload.children && i < payload.children.length; ++i)
             layer.addChild(this._innerSetLayers(oldLayersById, payload.children[i]));
         return layer;
     },
 
     /**
      * @param {!Array.<number>} nodeIdsToResolve
      * @param {!Object} seenNodeIds
      * @param {!WebInspector.TracingLayerPayload} payload
      */
     _extractNodeIdsToResolve: function(nodeIdsToResolve, seenNodeIds, payload)
     {
         var backendNodeId = payload.owner_node;
-        if (backendNodeId && !seenNodeIds[backendNodeId] && !(this._backendNodeIdToNodeId[backendNodeId] && this.target().domModel.nodeForId(backendNodeId))) {
+        if (backendNodeId && !seenNodeIds[backendNodeId] && !(this._backendNodeIdToNodeId[backendNodeId] && this._nodeForId(backendNodeId))) {
             seenNodeIds[backendNodeId] = true;
             nodeIdsToResolve.push(backendNodeId);
         }
         for (var i = 0; payload.children && i < payload.children.length; ++i)
             this._extractNodeIdsToResolve(nodeIdsToResolve, seenNodeIds, payload.children[i]);
     },
 
     __proto__: WebInspector.LayerTreeBase.prototype
 }
 
 /**
   * @constructor
+  * @param {!WeakReference.<!WebInspector.Target>} weakTarget
   * @extends {WebInspector.LayerTreeBase}
   */
-WebInspector.AgentLayerTree = function(target)
+WebInspector.AgentLayerTree = function(weakTarget)
 {
-    WebInspector.LayerTreeBase.call(this, target);
+    WebInspector.LayerTreeBase.call(this, weakTarget);
 }
 
 WebInspector.AgentLayerTree.prototype = {
     /**
      * @param {?Array.<!LayerTreeAgent.Layer>} payload
      * @param {function()} callback
      */
     setLayers: function(payload, callback)
     {
         if (!payload) {
             onBackendNodeIdsResolved.call(this);
             return;
         }
 
         var idsToResolve = {};
         var requestedIds = [];
         for (var i = 0; i < payload.length; ++i) {
             var backendNodeId = payload[i].backendNodeId;
             if (!backendNodeId || idsToResolve[backendNodeId] ||
-                (this._backendNodeIdToNodeId[backendNodeId] && this.target().domModel.nodeForId(this._backendNodeIdToNodeId[backendNodeId]))) {
+                (this._backendNodeIdToNodeId[backendNodeId] && this._nodeForId(this._backendNodeIdToNodeId[backendNodeId]))) {
                 continue;
             }
             idsToResolve[backendNodeId] = true;
             requestedIds.push(backendNodeId);
         }
         this._resolveBackendNodeIds(requestedIds, onBackendNodeIdsResolved.bind(this));
 
         /**
          * @this {WebInspector.AgentLayerTree}
          */
@@ skipping 14 matching lines @@
         if (!layers)
             return;
         var oldLayersById = this._layersById;
         this._layersById = {};
         for (var i = 0; i < layers.length; ++i) {
             var layerId = layers[i].layerId;
             var layer = oldLayersById[layerId];
             if (layer)
                 layer._reset(layers[i]);
             else
-                layer = new WebInspector.AgentLayer(layers[i]);
+                layer = new WebInspector.AgentLayer(this._weakTarget, layers[i]);
             this._layersById[layerId] = layer;
             if (layers[i].backendNodeId) {
-                layer._setNode(this.target().domModel.nodeForId(this._backendNodeIdToNodeId[layers[i].backendNodeId]));
+                layer._setNode(this._nodeForId(this._backendNodeIdToNodeId[layers[i].backendNodeId]));
                 if (!this._contentRoot)
                     this._contentRoot = layer;
             }
             var parentId = layer.parentId();
             if (parentId) {
                 var parent = this._layersById[parentId];
                 if (!parent)
                     console.assert(parent, "missing parent " + parentId + " for layer " + layerId);
                 parent.addChild(layer);
             } else {
@@ skipping 119 matching lines @@
 
     /**
      * @param {function(!WebInspector.PaintProfilerSnapshot=)} callback
      */
     requestSnapshot: function(callback) { },
 }
 
 /**
  * @constructor
  * @implements {WebInspector.Layer}
+ * @param {!WeakReference.<!WebInspector.Target>} weakTarget
  * @param {!LayerTreeAgent.Layer} layerPayload
  */
-WebInspector.AgentLayer = function(layerPayload)
+WebInspector.AgentLayer = function(weakTarget, layerPayload)
 {
+    this._weakTarget = weakTarget;
     this._reset(layerPayload);
 }
 
 WebInspector.AgentLayer.prototype = {
     /**
      * @return {string}
      */
     id: function()
     {
         return this._layerPayload.layerId;
@@ skipping 169 matching lines @@
     {
         var wrappedCallback = InspectorBackend.wrapClientCallback(callback, "LayerTreeAgent.reasonsForCompositingLayer(): ", undefined, []);
         LayerTreeAgent.compositingReasons(this.id(), wrappedCallback);
     },
 
     /**
      * @param {function(!WebInspector.PaintProfilerSnapshot=)} callback
      */
     requestSnapshot: function(callback)
     {
-        var wrappedCallback = InspectorBackend.wrapClientCallback(callback, "LayerTreeAgent.makeSnapshot(): ", WebInspector.PaintProfilerSnapshot);
+        var wrappedCallback = InspectorBackend.wrapClientCallback(callback, "LayerTreeAgent.makeSnapshot(): ", WebInspector.PaintProfilerSnapshot.bind(null, this._weakTarget));
         LayerTreeAgent.makeSnapshot(this.id(), wrappedCallback);
     },
 
     /**
      * @param {!DOMAgent.Rect} rect
      */
     _didPaint: function(rect)
     {
         this._lastPaintRect = rect;
         this._paintCount = this.paintCount() + 1;
@@ skipping 317 matching lines @@
      */
     requestSnapshot: function(callback)
     {
         var wrappedCallback = InspectorBackend.wrapClientCallback(callback, "LayerTreeAgent.makeSnapshot(): ", WebInspector.PaintProfilerSnapshot);
         LayerTreeAgent.makeSnapshot(this.id(), wrappedCallback);
     }
 }
 
 /**
  * @constructor
- * @param {!WebInspector.Target} target
+ * @param {!WeakReference.<!WebInspector.Target>} weakTarget
  */
-WebInspector.DeferredLayerTree = function(target)
+WebInspector.DeferredLayerTree = function(weakTarget)
 {
-    this._target = target;
+    this._weakTarget = weakTarget;
 }
 
 WebInspector.DeferredLayerTree.prototype = {
     /**
      * @param {function(!WebInspector.LayerTreeBase)} callback
      */
     resolve: function(callback) { },
 
     /**
-     * @return {!WebInspector.Target}
+     * @return {!WeakReference.<!WebInspector.Target>}
      */
-    target: function()
+    weakTarget: function()
     {
-        return this._target;
+        return this._weakTarget;
     }
 };
 
 /**
  * @constructor
  * @extends {WebInspector.DeferredLayerTree}
- * @param {!WebInspector.Target} target
+ * @param {!WeakReference.<!WebInspector.Target>} weakTarget
  * @param {!Array.<!LayerTreeAgent.Layer>} layers
  */
-WebInspector.DeferredAgentLayerTree = function(target, layers)
+WebInspector.DeferredAgentLayerTree = function(weakTarget, layers)
 {
-    WebInspector.DeferredLayerTree.call(this, target);
+    WebInspector.DeferredLayerTree.call(this, weakTarget);
     this._layers = layers;
 }
 
 WebInspector.DeferredAgentLayerTree.prototype = {
     /**
      * @param {function(!WebInspector.LayerTreeBase)} callback
      */
     resolve: function(callback)
     {
-        var result = new WebInspector.AgentLayerTree(this._target);
+        var result = new WebInspector.AgentLayerTree(this._weakTarget);
         result.setLayers(this._layers, callback.bind(null, result));
     },
 
     __proto__: WebInspector.DeferredLayerTree.prototype
 };
 
 /**
  * @constructor
  * @extends {WebInspector.DeferredLayerTree}
- * @param {!WebInspector.Target} target
+ * @param {!WeakReference.<!WebInspector.Target>} weakTarget
  * @param {!WebInspector.TracingLayerPayload} root
  * @param {!Object} viewportSize
  */
-WebInspector.DeferredTracingLayerTree = function(target, root, viewportSize)
+WebInspector.DeferredTracingLayerTree = function(weakTarget, root, viewportSize)
 {
-    WebInspector.DeferredLayerTree.call(this, target);
+    WebInspector.DeferredLayerTree.call(this, weakTarget);
     this._root = root;
     this._viewportSize = viewportSize;
 }
 
 WebInspector.DeferredTracingLayerTree.prototype = {
     /**
      * @param {function(!WebInspector.LayerTreeBase)} callback
      */
     resolve: function(callback)
     {
-        var result = new WebInspector.TracingLayerTree(this._target);
+        var result = new WebInspector.TracingLayerTree(this._weakTarget);
         result.setViewportSize(this._viewportSize);
         result.setLayers(this._root, callback.bind(null, result));
     },
 
     __proto__: WebInspector.DeferredLayerTree.prototype
 };
 
 /**
  * @constructor
  * @implements {LayerTreeAgent.Dispatcher}
@@ skipping 15 matching lines @@
 
     /**
      * @param {!LayerTreeAgent.LayerId} layerId
      * @param {!DOMAgent.Rect} clipRect
      */
     layerPainted: function(layerId, clipRect)
     {
         this._layerTreeModel._layerPainted(layerId, clipRect);
     }
 }