DevTools: Remove redundant dependency on target from TimelineFrameModel

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 31 matching lines @@
 */
 WebInspector.TracingLayerPayload;
 
 /**
   * @constructor
   * @extends {WebInspector.SDKObject}
   */
 WebInspector.LayerTreeModel = function(target)
 {
     WebInspector.SDKObject.call(this, target);
-    InspectorBackend.registerLayerTreeDispatcher(new WebInspector.LayerTreeDispatcher(this));
+    target.registerLayerTreeDispatcher(new WebInspector.LayerTreeDispatcher(this));
     target.domModel.addEventListener(WebInspector.DOMModel.Events.DocumentUpdated, this._onDocumentUpdated, this);
     /** @type {?WebInspector.LayerTreeBase} */
     this._layerTree = null;
 }
 
 WebInspector.LayerTreeModel.Events = {
     LayerTreeChanged: "LayerTreeChanged",
     LayerPainted: "LayerPainted",
 }
 
 WebInspector.LayerTreeModel.ScrollRectType = {
     NonFastScrollable: {name: "NonFastScrollable", description: "Non fast scrollable"},
     TouchEventHandler: {name: "TouchEventHandler", description: "Touch event handler"},
     WheelEventHandler: {name: "WheelEventHandler", description: "Wheel event handler"},
     RepaintsOnScroll: {name: "RepaintsOnScroll", description: "Repaints on scroll"}
 }
 
 WebInspector.LayerTreeModel.prototype = {
     disable: function()
     {
         if (!this._enabled)
             return;
         this._enabled = false;
         this._layerTree = null;
-        LayerTreeAgent.disable();
+        this.target().layerTreeAgent().disable();
     },
 
     enable: function()
     {
         if (this._enabled)
             return;
         this._enabled = true;
-        this._layerTree = new WebInspector.AgentLayerTree(this.target().weakReference());
+        this._layerTree = new WebInspector.AgentLayerTree(this.target());
         this._lastPaintRectByLayerId = {};
-        LayerTreeAgent.enable();
+        this.target().layerTreeAgent().enable();
     },
 
     /**
      * @param {!WebInspector.LayerTreeBase} layerTree
      */
     setLayerTree: function(layerTree)
     {
         this.disable();
         this._layerTree = layerTree;
         this.dispatchEventToListeners(WebInspector.LayerTreeModel.Events.LayerTreeChanged);
@@ skipping 58 matching lines @@
             return;
         this.disable();
         this.enable();
     },
 
     __proto__: WebInspector.SDKObject.prototype
 }
 
 /**
   * @constructor
-  * @param {!WeakReference.<!WebInspector.Target>} weakTarget
+  * @param {?WebInspector.Target} target
   */
-WebInspector.LayerTreeBase = function(weakTarget)
+WebInspector.LayerTreeBase = function(target)
 {
-    this._weakTarget = weakTarget;
+    this._target = target;
     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)
     {
-        var target = this._weakTarget.get();
-        if (!requestedNodeIds.length || !target) {
+        if (!requestedNodeIds.length || !this._target) {
             callback();
             return;
         }
 
-        target.domModel.pushNodesByBackendIdsToFrontend(requestedNodeIds, populateBackendNodeIdMap.bind(this));
+        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 20 matching lines @@
     {
         return this._viewportSize;
     },
 
     /**
      * @param {number} id
      * @return {?WebInspector.DOMNode}
      */
     _nodeForId: function(id)
     {
-        var target = this._weakTarget.get();
-        return target ? target.domModel.nodeForId(id) : null;
+        return this._target ? this._target.domModel.nodeForId(id) : null;
     }
 };
 
 /**
   * @constructor
   * @extends {WebInspector.LayerTreeBase}
-  * @param {!WeakReference.<!WebInspector.Target>} weakTarget
+  * @param {?WebInspector.Target} target
   */
-WebInspector.TracingLayerTree = function(weakTarget)
+WebInspector.TracingLayerTree = function(target)
 {
-    WebInspector.LayerTreeBase.call(this, weakTarget);
+    WebInspector.LayerTreeBase.call(this, target);
 }
 
 WebInspector.TracingLayerTree.prototype = {
     /**
      * @param {!WebInspector.TracingLayerPayload} root
      * @param {!function()} callback
      */
     setLayers: function(root, callback)
     {
         var idsToResolve = [];
@@ skipping 51 matching lines @@
         }
         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
+  * @param {?WebInspector.Target} target
   * @extends {WebInspector.LayerTreeBase}
   */
-WebInspector.AgentLayerTree = function(weakTarget)
+WebInspector.AgentLayerTree = function(target)
 {
-    WebInspector.LayerTreeBase.call(this, weakTarget);
+    WebInspector.LayerTreeBase.call(this, target);
 }
 
 WebInspector.AgentLayerTree.prototype = {
     /**
      * @param {?Array.<!LayerTreeAgent.Layer>} payload
      * @param {function()} callback
      */
     setLayers: function(payload, callback)
     {
         if (!payload) {
@@ skipping 34 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(this._weakTarget, layers[i]);
+                layer = new WebInspector.AgentLayer(this._target, layers[i]);
             this._layersById[layerId] = layer;
             if (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)
@@ skipping 122 matching lines @@
 
     /**
      * @param {function(!WebInspector.PaintProfilerSnapshot=)} callback
      */
     requestSnapshot: function(callback) { },
 }
 
 /**
  * @constructor
  * @implements {WebInspector.Layer}
- * @param {!WeakReference.<!WebInspector.Target>} weakTarget
+ * @param {?WebInspector.Target} target
  * @param {!LayerTreeAgent.Layer} layerPayload
  */
-WebInspector.AgentLayer = function(weakTarget, layerPayload)
+WebInspector.AgentLayer = function(target, layerPayload)
 {
-    this._weakTarget = weakTarget;
+    this._target = target;
     this._reset(layerPayload);
 }
 
 WebInspector.AgentLayer.prototype = {
     /**
      * @return {string}
      */
     id: function()
     {
         return this._layerPayload.layerId;
@@ skipping 160 matching lines @@
     scrollRects: function()
     {
         return this._scrollRects;
     },
 
     /**
      * @param {function(!Array.<string>)} callback
      */
     requestCompositingReasons: function(callback)
     {
+        if (!this._target)

[caseq, 2014/07/17 14:41:18]

We normally invoke callbacks if we fail early (passing [] to callback upon error
is ok here)

[sergeyv, 2014/07/17 15:09:22]

Done.

+            return;
+
         var wrappedCallback = InspectorBackend.wrapClientCallback(callback, "LayerTreeAgent.reasonsForCompositingLayer(): ", undefined, []);
-        LayerTreeAgent.compositingReasons(this.id(), wrappedCallback);
+        this._target.layerTreeAgent().compositingReasons(this.id(), wrappedCallback);
     },
 
     /**
      * @param {function(!WebInspector.PaintProfilerSnapshot=)} callback
      */
     requestSnapshot: function(callback)
     {
-        var wrappedCallback = InspectorBackend.wrapClientCallback(callback, "LayerTreeAgent.makeSnapshot(): ", WebInspector.PaintProfilerSnapshot.bind(null, this._weakTarget));
-        LayerTreeAgent.makeSnapshot(this.id(), wrappedCallback);
+        if (!this._target)

[caseq, 2014/07/17 14:41:18]

ditto.

[sergeyv, 2014/07/17 15:09:22]

Done.

+            return;
+
+        var wrappedCallback = InspectorBackend.wrapClientCallback(callback, "LayerTreeAgent.makeSnapshot(): ", WebInspector.PaintProfilerSnapshot.bind(null, this._target));
+        this._target.layerTreeAgent().makeSnapshot(this.id(), wrappedCallback);
     },
 
     /**
      * @param {!DOMAgent.Rect} rect
      */
     _didPaint: function(rect)
     {
         this._lastPaintRect = rect;
         this._paintCount = this.paintCount() + 1;
         this._image = null;
@@ skipping 316 matching lines @@
      */
     requestSnapshot: function(callback)
     {
         var wrappedCallback = InspectorBackend.wrapClientCallback(callback, "LayerTreeAgent.makeSnapshot(): ", WebInspector.PaintProfilerSnapshot);
         LayerTreeAgent.makeSnapshot(this.id(), wrappedCallback);
     }
 }
 
 /**
  * @constructor
- * @param {!WeakReference.<!WebInspector.Target>} weakTarget
+ * @param {?WebInspector.Target} target
  */
-WebInspector.DeferredLayerTree = function(weakTarget)
+WebInspector.DeferredLayerTree = function(target)
 {
-    this._weakTarget = weakTarget;
+    this._target = target;
 }
 
 WebInspector.DeferredLayerTree.prototype = {
     /**
      * @param {function(!WebInspector.LayerTreeBase)} callback
      */
     resolve: function(callback) { },
 
     /**
-     * @return {!WeakReference.<!WebInspector.Target>}
+     * @return {?WebInspector.Target}
      */
-    weakTarget: function()
+    target: function()
     {
-        return this._weakTarget;
+        return this._target;
     }
 };
 
 /**
  * @constructor
  * @extends {WebInspector.DeferredLayerTree}
- * @param {!WeakReference.<!WebInspector.Target>} weakTarget
+ * @param {?WebInspector.Target} target
  * @param {!Array.<!LayerTreeAgent.Layer>} layers
  */
-WebInspector.DeferredAgentLayerTree = function(weakTarget, layers)
+WebInspector.DeferredAgentLayerTree = function(target, layers)
 {
-    WebInspector.DeferredLayerTree.call(this, weakTarget);
+    WebInspector.DeferredLayerTree.call(this, target);
     this._layers = layers;
 }
 
 WebInspector.DeferredAgentLayerTree.prototype = {
     /**
      * @param {function(!WebInspector.LayerTreeBase)} callback
      */
     resolve: function(callback)
     {
-        var result = new WebInspector.AgentLayerTree(this._weakTarget);
+        var result = new WebInspector.AgentLayerTree(this._target);
         result.setLayers(this._layers, callback.bind(null, result));
     },
 
     __proto__: WebInspector.DeferredLayerTree.prototype
 };
 
 /**
  * @constructor
  * @extends {WebInspector.DeferredLayerTree}
- * @param {!WeakReference.<!WebInspector.Target>} weakTarget
+ * @param {?WebInspector.Target} target
  * @param {!WebInspector.TracingLayerPayload} root
  * @param {!Object} viewportSize
  */
-WebInspector.DeferredTracingLayerTree = function(weakTarget, root, viewportSize)
+WebInspector.DeferredTracingLayerTree = function(target, root, viewportSize)
 {
-    WebInspector.DeferredLayerTree.call(this, weakTarget);
+    WebInspector.DeferredLayerTree.call(this, target);
     this._root = root;
     this._viewportSize = viewportSize;
 }
 
 WebInspector.DeferredTracingLayerTree.prototype = {
     /**
      * @param {function(!WebInspector.LayerTreeBase)} callback
      */
     resolve: function(callback)
     {
-        var result = new WebInspector.TracingLayerTree(this._weakTarget);
+        var result = new WebInspector.TracingLayerTree(this._target);
         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);
     }
 }