DevTools: use target-based model accessors only.

Source/devtools/front_end/profiler/CanvasProfileView.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 477 matching lines @@
         data[0] = index + 1;
         data[1] = callViewElement;
         data[2] = "";
         if (call.sourceURL) {
             // FIXME(62725): stack trace line/column numbers are one-based.
             var lineNumber = Math.max(0, call.lineNumber - 1) || 0;
             var columnNumber = Math.max(0, call.columnNumber - 1) || 0;
             data[2] = this._linkifier.linkifyScriptLocation(this._profile.target(), null, call.sourceURL, lineNumber, columnNumber);
         }
 
+        var node = new WebInspector.DataGridNode(data);
+        node.index = index;
+        node.selectable = true;
+        node.call = call;
+
         callViewElement.createChild("span", "canvas-function-name").textContent = call.functionName || "context." + call.property;
+        var target = this._profile.target();
+        if (!target)
+            return node;
 
         if (call.arguments) {
             callViewElement.createTextChild("(");
             for (var i = 0, n = call.arguments.length; i < n; ++i) {
                 var argument = /** @type {!CanvasAgent.CallArgument} */ (call.arguments[i]);
                 if (i)
                     callViewElement.createTextChild(", ");
-                var element = WebInspector.CanvasProfileDataGridHelper.createCallArgumentElement(argument);
+                var element = WebInspector.CanvasProfileDataGridHelper.createCallArgumentElement(target, argument);
                 element.__argumentIndex = i;
                 callViewElement.appendChild(element);
             }
             callViewElement.createTextChild(")");
         } else if (call.value) {
             callViewElement.createTextChild(" = ");
-            callViewElement.appendChild(WebInspector.CanvasProfileDataGridHelper.createCallArgumentElement(call.value));
+            callViewElement.appendChild(WebInspector.CanvasProfileDataGridHelper.createCallArgumentElement(target, call.value));
         }
 
         if (call.result) {
             callViewElement.createTextChild(" => ");
-            callViewElement.appendChild(WebInspector.CanvasProfileDataGridHelper.createCallArgumentElement(call.result));
+            callViewElement.appendChild(WebInspector.CanvasProfileDataGridHelper.createCallArgumentElement(target, call.result));
         }
 
-        var node = new WebInspector.DataGridNode(data);
-        node.index = index;
-        node.selectable = true;
-        node.call = call;
         return node;
     },
 
     /**
      * @param {!Element} element
      * @param {!Event} event
      * @return {!Element|!AnchorBox|undefined}
      */
     _popoverAnchor: function(element, event)
     {
@@ skipping 21 matching lines @@
                 return;
 
             this._popoverAnchorElement = argumentElement.cloneNode(true);
             this._popoverAnchorElement.classList.add("canvas-popover-anchor");
             this._popoverAnchorElement.classList.add("source-frame-eval-expression");
             argumentElement.parentElement.appendChild(this._popoverAnchorElement);
 
             var diffLeft = this._popoverAnchorElement.boxInWindow().x - argumentElement.boxInWindow().x;
             this._popoverAnchorElement.style.left = this._popoverAnchorElement.offsetLeft - diffLeft + "px";
 
-            showCallback(WebInspector.runtimeModel.createRemoteObject(result), false, this._popoverAnchorElement);
+            showCallback(this._profile.target().runtimeModel.createRemoteObject(result), false, this._popoverAnchorElement);
         }
 
         var evalResult = argumentElement.__evalResult;
         if (evalResult)
             showObjectPopover.call(this, null, evalResult);
         else {
             var dataGridNode = this._logGrid.dataGridNodeFromNode(argumentElement);
             if (!dataGridNode || typeof dataGridNode.index !== "number") {
                 this._popoverHelper.hidePopover();
                 return;
@@ skipping 561 matching lines @@
             this._updateCapturingStatus();
         }
         this._traceLogPlayer.getTraceLog(0, 0, didReceiveTraceLog.bind(this));
     },
 
     __proto__: WebInspector.ProfileHeader.prototype
 }
 
 WebInspector.CanvasProfileDataGridHelper = {
     /**
+     * @param {!WebInspector.Target} target
      * @param {!CanvasAgent.CallArgument} callArgument
      * @return {!Element}
      */
-    createCallArgumentElement: function(callArgument)
+    createCallArgumentElement: function(target, callArgument)
     {
         if (callArgument.enumName)
-            return WebInspector.CanvasProfileDataGridHelper.createEnumValueElement(callArgument.enumName, +callArgument.description);
+            return WebInspector.CanvasProfileDataGridHelper.createEnumValueElement(target, callArgument.enumName, +callArgument.description);
         var element = createElement("span");
         element.className = "canvas-call-argument";
         var description = callArgument.description;
         if (callArgument.type === "string") {
             const maxStringLength = 150;
             element.createTextChild("\"");
             element.createChild("span", "canvas-formatted-string").textContent = description.trimMiddle(maxStringLength);
             element.createTextChild("\"");
             element.__suppressPopover = (description.length <= maxStringLength && !/[\r\n]/.test(description));
             if (!element.__suppressPopover)
-                element.__evalResult = WebInspector.runtimeModel.createRemoteObjectFromPrimitiveValue(description);
+                element.__evalResult = target.runtimeModel.createRemoteObjectFromPrimitiveValue(description);
         } else {
             var type = callArgument.subtype || callArgument.type;
             if (type) {
                 element.classList.add("canvas-formatted-" + type);
                 if (["null", "undefined", "boolean", "number"].indexOf(type) >= 0)
                     element.__suppressPopover = true;
             }
             element.textContent = description;
             if (callArgument.remoteObject)
-                element.__evalResult = WebInspector.runtimeModel.createRemoteObject(callArgument.remoteObject);
+                element.__evalResult = target.runtimeModel.createRemoteObject(callArgument.remoteObject);
         }
         if (callArgument.resourceId) {
             element.classList.add("canvas-formatted-resource");
             element.__resourceId = callArgument.resourceId;
         }
         return element;
     },
 
     /**
+     * @param {!WebInspector.Target} target
      * @param {string} enumName
      * @param {number} enumValue
      * @return {!Element}
      */
-    createEnumValueElement: function(enumName, enumValue)
+    createEnumValueElement: function(target, enumName, enumValue)
     {
         var element = createElement("span");
         element.className = "canvas-call-argument canvas-formatted-number";
         element.textContent = enumName;
-        element.__evalResult = WebInspector.runtimeModel.createRemoteObjectFromPrimitiveValue(enumValue);
+        element.__evalResult = target.runtimeModel.createRemoteObjectFromPrimitiveValue(enumValue);
         return element;
     }
 }
 
 /**
  * @extends {WebInspector.SDKObject}
  * @constructor
  * @param {!WebInspector.Target} target
  * @param {!CanvasAgent.TraceLogId} traceLogId
  */
@@ skipping 111 matching lines @@
     },
 
     clearResourceStates: function()
     {
         this._currentResourceStates = {};
         this.dispatchEventToListeners(WebInspector.CanvasTraceLogPlayerProxy.Events.CanvasReplayStateChanged);
     },
 
     __proto__: WebInspector.SDKObject.prototype
 }