[DevTools] Host paint profiles in PaintProfilerModel

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

 // Copyright 2016 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.
 /** @typedef {!{
         bounds: {height: number, width: number},
         children: Array.<!TimelineModel.TracingLayerPayload>,
         layer_id: number,
         position: Array.<number>,
         scroll_offset: Array.<number>,
         layer_quad: Array.<number>,
@@ skipping 19 matching lines @@
  * @unrestricted
  */
 TimelineModel.TracingLayerTree = class extends SDK.LayerTreeBase {
   /**
    * @param {?SDK.Target} target
    */
   constructor(target) {
     super(target);
     /** @type {!Map.<string, !TimelineModel.TracingLayerTile>} */
     this._tileById = new Map();
+    this._paintProfilerModel = target && target.model(SDK.PaintProfilerModel);
   }
 
   /**
    * @param {?TimelineModel.TracingLayerPayload} root
    * @param {?Array<!TimelineModel.TracingLayerPayload>} layers
    * @param {!Array<!TimelineModel.LayerPaintEvent>} paints
    * @param {function()} callback
    */
   setLayers(root, layers, paints, callback) {
     var idsToResolve = new Set();
@@ skipping 72 matching lines @@
   /**
    * @param {!Object<(string|number), !SDK.Layer>} oldLayersById
    * @param {!TimelineModel.TracingLayerPayload} payload
    * @return {!TimelineModel.TracingLayer}
    */
   _innerSetLayers(oldLayersById, payload) {
     var layer = /** @type {?TimelineModel.TracingLayer} */ (oldLayersById[payload.layer_id]);
     if (layer)
       layer._reset(payload);
     else
-      layer = new TimelineModel.TracingLayer(this.target(), payload);
+      layer = new TimelineModel.TracingLayer(this._paintProfilerModel, payload);
     this._layersById[payload.layer_id] = layer;
     if (payload.owner_node)
       layer._setNode(this.backendNodeIdToNode().get(payload.owner_node) || null);
     if (!this.contentRoot() && layer.drawsContent())
       this.setContentRoot(layer);
     for (var i = 0; payload.children && i < payload.children.length; ++i)
       layer.addChild(this._innerSetLayers(oldLayersById, payload.children[i]));
     return layer;
   }
 
@@ skipping 10 matching lines @@
       this._extractNodeIdsToResolve(nodeIdsToResolve, seenNodeIds, payload.children[i]);
   }
 };
 
 /**
  * @implements {SDK.Layer}
  * @unrestricted
  */
 TimelineModel.TracingLayer = class {
   /**
+   * @param {?SDK.PaintProfilerModel} paintProfilerModel
    * @param {!TimelineModel.TracingLayerPayload} payload
-   * @param {?SDK.Target} target
    */
-  constructor(target, payload) {
-    this._target = target;
+  constructor(paintProfilerModel, payload) {
+    this._paintProfilerModel = paintProfilerModel;
     this._reset(payload);
   }
 
   /**
    * @param {!TimelineModel.TracingLayerPayload} payload
    */
   _reset(payload) {
     /** @type {?SDK.DOMNode} */
     this._node = null;
     this._layerId = String(payload.layer_id);
@@ skipping 202 matching lines @@
 
   /**
    * @param {!Array<number>} targetRect
    * @return {!Promise<?SDK.SnapshotWithRect>}
    */
   _pictureForRect(targetRect) {
     return Promise.all(this._paints.map(paint => paint.picturePromise())).then(pictures => {
       var fragments =
           pictures.filter(picture => picture && rectsOverlap(picture.rect, targetRect))
               .map(picture => ({x: picture.rect[0], y: picture.rect[1], picture: picture.serializedPicture}));
-      if (!fragments.length || !this._target)
+      if (!fragments.length || !this._paintProfilerModel)
         return null;
       var x0 = fragments.reduce((min, item) => Math.min(min, item.x), Infinity);
       var y0 = fragments.reduce((min, item) => Math.min(min, item.y), Infinity);
       // Rect is in layer content coordinates, make it relative to picture by offsetting to the top left corner.
       var rect = {x: targetRect[0] - x0, y: targetRect[1] - y0, width: targetRect[2], height: targetRect[3]};
-      return SDK.PaintProfilerSnapshot.loadFromFragments(this._target, fragments)
-          .then(snapshot => snapshot ? {rect: rect, snapshot: snapshot} : null);
+      return this._paintProfilerModel.loadSnapshotFromFragments(fragments).then(
+          snapshot => snapshot ? {rect: rect, snapshot: snapshot} : null);
     });
 
     /**
      * @param {number} a1
      * @param {number} a2
      * @param {number} b1
      * @param {number} b2
      * @return {boolean}
      */
     function segmentsOverlap(a1, a2, b1, b2) {
@@ skipping 60 matching lines @@
   }
 
   /**
    * @override
    * @return {boolean}
    */
   drawsContent() {
     return this._drawsContent;
   }
 };