DevTools: wrap DebuggerAgent.Location with DebuggerModel.Location.

Source/devtools/front_end/ConsoleViewMessage.js

 /*
  * Copyright (C) 2011 Google Inc.  All rights reserved.
  * Copyright (C) 2007, 2008 Apple Inc.  All rights reserved.
  * Copyright (C) 2009 Joseph Pecoraro
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
@@ skipping 12 matching lines @@
  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 /**
  * @constructor
+ * @extends {WebInspector.TargetAware}
  * @param {!WebInspector.Target} target
  * @param {!WebInspector.ConsoleMessage} consoleMessage
  * @param {?WebInspector.Linkifier} linkifier
  */
 WebInspector.ConsoleViewMessage = function(target, consoleMessage, linkifier)
 {
+    WebInspector.TargetAware.call(this, target);
     this._message = consoleMessage;
     this._linkifier = linkifier;
-    this._target = target;
     this._repeatCount = 1;
 
     /** @type {!Array.<!WebInspector.DataGrid>} */
     this._dataGrids = [];
     /** @type {!Map.<!WebInspector.DataGrid, ?Element>} */
     this._dataGridParents = new Map();
 
     this._customFormatters = {
         "object": this._formatParameterAsObject,
         "array":  this._formatParameterAsArray,
@@ skipping 164 matching lines @@
      */
     _linkifyLocation: function(url, lineNumber, columnNumber)
     {
         console.assert(this._linkifier);
         if (!this._linkifier)
             return null;
         // FIXME(62725): stack trace line/column numbers are one-based.
         lineNumber = lineNumber ? lineNumber - 1 : 0;
         columnNumber = columnNumber ? columnNumber - 1 : 0;
         if (this._message.source === WebInspector.ConsoleMessage.MessageSource.CSS) {
-            var headerIds = WebInspector.cssModel.styleSheetIdsForURL(url);
-            var cssLocation = new WebInspector.CSSLocation(url, lineNumber, columnNumber);
+            var headerIds = this.target().cssModel.styleSheetIdsForURL(url);
+            var cssLocation = new WebInspector.CSSLocation(this.target(), url, lineNumber, columnNumber);
             return this._linkifier.linkifyCSSLocation(headerIds[0] || null, cssLocation, "console-message-url");
         }
 
         return this._linkifier.linkifyLocation(url, lineNumber, columnNumber, "console-message-url");
     },
 
     /**
      * @param {!ConsoleAgent.CallFrame} callFrame
      * @return {?Element}
      */
     _linkifyCallFrame: function(callFrame)
     {
         console.assert(this._linkifier);
         if (!this._linkifier)
             return null;
         // FIXME(62725): stack trace line/column numbers are one-based.
         var lineNumber = callFrame.lineNumber ? callFrame.lineNumber - 1 : 0;
         var columnNumber = callFrame.columnNumber ? callFrame.columnNumber - 1 : 0;
-        var rawLocation = new WebInspector.DebuggerModel.Location(callFrame.scriptId, lineNumber, columnNumber);
+        var rawLocation = new WebInspector.DebuggerModel.Location(this.target(), callFrame.scriptId, lineNumber, columnNumber);
         return this._linkifier.linkifyRawLocation(rawLocation, "console-message-url");
     },
 
     /**
      * @param {?Array.<!ConsoleAgent.CallFrame>} stackTrace
      * @return {?ConsoleAgent.CallFrame}
      */
     _callFrameAnchorFromStackTrace: function(stackTrace)
     {
         if (!stackTrace || !stackTrace.length)
             return null;
         var callFrame = stackTrace[0].scriptId ? stackTrace[0] : null;
         if (!WebInspector.experimentsSettings.frameworksDebuggingSupport.isEnabled())
             return callFrame;
         if (!WebInspector.settings.skipStackFramesSwitch.get())
             return callFrame;
         var regex = WebInspector.settings.skipStackFramesPattern.asRegExp();
         if (!regex)
             return callFrame;
         for (var i = 0; i < stackTrace.length; ++i) {
-            var script = this._target.debuggerModel.scriptForId(stackTrace[i].scriptId);
+            var script = this.target().debuggerModel.scriptForId(stackTrace[i].scriptId);
             if (!script || !regex.test(script.sourceURL))
                 return stackTrace[i].scriptId ? stackTrace[i] : null;
         }
         return callFrame;
     },
 
     /**
      * @return {boolean}
      */
     isErrorOrWarning: function()
     {
         return (this._message.level === WebInspector.ConsoleMessage.MessageLevel.Warning || this._message.level === WebInspector.ConsoleMessage.MessageLevel.Error);
     },
 
     _format: function(parameters)
     {
         // This node is used like a Builder. Values are continually appended onto it.
         var formattedResult = document.createElement("span");
         if (!parameters.length)
             return formattedResult;
 
         // Formatting code below assumes that parameters are all wrappers whereas frontend console
         // API allows passing arbitrary values as messages (strings, numbers, etc.). Wrap them here.
         for (var i = 0; i < parameters.length; ++i) {
             // FIXME: Only pass runtime wrappers here.
             if (parameters[i] instanceof WebInspector.RemoteObject)
                 continue;
 
             if (typeof parameters[i] === "object")
-                parameters[i] = this._target.runtimeModel.createRemoteObject(parameters[i], this._target);
+                parameters[i] = this.target().runtimeModel.createRemoteObject(parameters[i]);
             else
-                parameters[i] = this._target.runtimeModel.createRemoteObjectFromPrimitiveValue(parameters[i]);
+                parameters[i] = this.target().runtimeModel.createRemoteObjectFromPrimitiveValue(parameters[i]);
         }
 
         // There can be string log and string eval result. We distinguish between them based on message type.
         var shouldFormatMessage = WebInspector.RemoteObject.type(parameters[0]) === "string" && this._message.type !== WebInspector.ConsoleMessage.MessageType.Result;
 
         // Multiple parameters with the first being a format string. Save unused substitutions.
         if (shouldFormatMessage) {
             // Multiple parameters with the first being a format string. Save unused substitutions.
             var result = this._formatWithSubstitutionString(parameters[0].description, parameters.slice(1), formattedResult);
             parameters = result.unusedSubstitutions;
@@ skipping 181 matching lines @@
          * @this {WebInspector.ConsoleViewMessage}
          */
         function printNode(nodeId)
         {
             if (!nodeId) {
                 // Sometimes DOM is loaded after the sync message is being formatted, so we get no
                 // nodeId here. So we fall back to object formatting here.
                 this._formatParameterAsObject(object, elem, false);
                 return;
             }
-            var node = this._target.domModel.nodeForId(nodeId);
+            var node = this.target().domModel.nodeForId(nodeId);
             var renderer = WebInspector.moduleManager.instance(WebInspector.Renderer, node);
             if (renderer)
                 elem.appendChild(renderer.render(node));
             else
                 console.error("No renderer for node found");
         }
         object.pushNodeToFrontend(printNode.bind(this));
     },
 
     /**
@@ skipping 557 matching lines @@
                 levelString = "Info";
                 break;
         }
 
         return sourceString + " " + typeString + " " + levelString + ": " + this.formattedMessage().textContent + "\n" + this._message.url + " line " + this._message.line;
     },
 
     get text()
     {
         return this._message.messageText;
-    }
+    },
+
+    __proto__: WebInspector.TargetAware.prototype
 }