DevTools: [JSDoc] Fix injected scripts JSDoc and related code

Source/core/inspector/InjectedScriptCanvasModuleSource.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 241 matching lines @@
 
 /**
  * @constructor
  * @implements {StackTrace}
  * @param {number=} stackTraceLimit
  * @param {Function=} topMostFunctionToIgnore
  * @see http://code.google.com/p/v8/wiki/JavaScriptStackTraceApi
  */
 function StackTraceV8(stackTraceLimit, topMostFunctionToIgnore)
 {
-    StackTrace.call(this);
-
     var oldPrepareStackTrace = Error.prepareStackTrace;
     var oldStackTraceLimit = Error.stackTraceLimit;
     if (typeof stackTraceLimit === "number")
         Error.stackTraceLimit = stackTraceLimit;
 
     /**
      * @param {Object} error
      * @param {!Array.<CallSite>} structuredStackTrace
      * @return {!Array.<{sourceURL: string, lineNumber: number, columnNumber: number}>}
      */
@@ skipping 18 matching lines @@
 
 StackTraceV8.prototype = {
     /**
      * @override
      * @param {number} index
      * @return {{sourceURL: string, lineNumber: number, columnNumber: number}|undefined}
      */
     callFrame: function(index)
     {
         return this._stackTrace[index];
-    },
-
-    __proto__: StackTrace.prototype
+    }
 }
 
 /**
  * @constructor
  * @template T
  */
 function Cache()
 {
     this.reset();
 }
@@ skipping 665 matching lines @@
         if (!wrappedObject)
             return null;
         var proxy = Object.create(wrappedObject.__proto__); // In order to emulate "instanceof".
 
         var customWrapFunctions = this._customWrapFunctions();
         /** @type {!Array.<string>} */
         this._proxyStatePropertyNames = [];
 
         /**
          * @param {string} property
+         * @this {Resource}
          */
         function processProperty(property)
         {
             if (typeof wrappedObject[property] === "function") {
                 var customWrapFunction = customWrapFunctions[property];
                 if (customWrapFunction)
                     proxy[property] = this._wrapCustomFunction(this, wrappedObject, wrappedObject[property], property, customWrapFunction);
                 else
                     proxy[property] = this._wrapFunction(this, wrappedObject, wrappedObject[property], property);
             } else if (TypeUtils.isEnumPropertyName(property, wrappedObject)) {
@@ skipping 161 matching lines @@
     }
 }
 
 /**
  * @param {function(new:Resource, !Object, string)} resourceConstructor
  * @param {string} resourceName
  * @return {function(this:Resource.WrapFunction)}
  */
 Resource.WrapFunction.resourceFactoryMethod = function(resourceConstructor, resourceName)
 {
-    /** @this Resource.WrapFunction */
+    /** @this {Resource.WrapFunction} */
     return function()
     {
         var wrappedObject = /** @type {Object} */ (this.result());
         if (!wrappedObject)
             return;
         var resource = new resourceConstructor(wrappedObject, resourceName);
         var manager = this._resource.manager();
         if (manager)
             manager.registerResource(resource);
         this.overrideResult(resource.proxyObject());
@@ skipping 98 matching lines @@
     /**
      * @override
      * @return {!Object.<string, Function>}
      */
     _customWrapFunctions: function()
     {
         var wrapFunctions = Object.create(null);
         var wrappedObject = this.wrappedObject();
         if (wrappedObject) {
             for (var property in wrappedObject) {
-                /** @this Resource.WrapFunction */
+                /** @this {Resource.WrapFunction} */
                 wrapFunctions[property] = function()
                 {
                     this._resource.pushCall(this.call());
                 }
             }
         }
         return wrapFunctions;
     },
 
     __proto__: Resource.prototype
@@ skipping 1644 matching lines @@
             stateModifyingWrapFunction("compressedTexSubImage2D");
             stateModifyingWrapFunction("copyTexImage2D", WebGLTextureResource.prototype.pushCall_copyTexImage2D);
             stateModifyingWrapFunction("copyTexSubImage2D", WebGLTextureResource.prototype.pushCall_copyTexImage2D);
             stateModifyingWrapFunction("generateMipmap");
             stateModifyingWrapFunction("texImage2D");
             stateModifyingWrapFunction("texSubImage2D");
             stateModifyingWrapFunction("texParameterf", WebGLTextureResource.prototype.pushCall_texParameter);
             stateModifyingWrapFunction("texParameteri", WebGLTextureResource.prototype.pushCall_texParameter);
             stateModifyingWrapFunction("renderbufferStorage");
 
-            /** @this Resource.WrapFunction */
+            /** @this {Resource.WrapFunction} */
             wrapFunctions["getError"] = function()
             {
                 var gl = /** @type {WebGLRenderingContext} */ (this._originalObject);
                 var error = this.result();
                 if (error !== gl.NO_ERROR)
                     this._resource.clearError(error);
                 else {
                     error = this._resource.nextError();
                     if (error !== gl.NO_ERROR)
                         this.overrideResult(error);
                 }
             }
 
             /**
              * @param {string} name
-             * @this Resource.WrapFunction
+             * @this {Resource.WrapFunction}
              */
             wrapFunctions["getExtension"] = function(name)
             {
                 this._resource.registerWebGLExtension(name, this.result());
             }
 
             //
             // Register bound WebGL resources.
             //
 
             /**
              * @param {WebGLProgram} program
              * @param {WebGLShader} shader
-             * @this Resource.WrapFunction
+             * @this {Resource.WrapFunction}
              */
             wrapFunctions["attachShader"] = function(program, shader)
             {
                 var resource = this._resource.currentBinding(program);
                 if (resource) {
                     resource.pushCall(this.call());
                     var shaderResource = /** @type {WebGLShaderResource} */ (Resource.forObject(shader));
                     if (shaderResource) {
                         var shaderType = shaderResource.type();
                         resource._registerBoundResource("__attachShader_" + shaderType, shaderResource);
                     }
                 }
             }
             /**
              * @param {number} target
              * @param {number} attachment
              * @param {number} objectTarget
              * @param {WebGLRenderbuffer|WebGLTexture} obj
-             * @this Resource.WrapFunction
+             * @this {Resource.WrapFunction}
              */
             wrapFunctions["framebufferRenderbuffer"] = wrapFunctions["framebufferTexture2D"] = function(target, attachment, objectTarget, obj)
             {
                 var resource = this._resource.currentBinding(target);
                 if (resource) {
                     resource.pushCall(this.call());
                     resource._registerBoundResource("__framebufferAttachmentObjectName", obj);
                 }
             }
             /**
              * @param {number} target
              * @param {Object} obj
-             * @this Resource.WrapFunction
+             * @this {Resource.WrapFunction}
              */
             wrapFunctions["bindBuffer"] = wrapFunctions["bindFramebuffer"] = wrapFunctions["bindRenderbuffer"] = function(target, obj)
             {
                 this._resource.currentBinding(target); // To call WebGLBoundResource.prototype.pushBinding().
                 this._resource._registerBoundResource("__bindBuffer_" + target, obj);
             }
             /**
              * @param {number} target
              * @param {WebGLTexture} obj
-             * @this Resource.WrapFunction
+             * @this {Resource.WrapFunction}
              */
             wrapFunctions["bindTexture"] = function(target, obj)
             {
                 this._resource.currentBinding(target); // To call WebGLBoundResource.prototype.pushBinding().
                 var gl = /** @type {WebGLRenderingContext} */ (this._originalObject);
                 var currentTextureBinding = /** @type {number} */ (gl.getParameter(gl.ACTIVE_TEXTURE));
                 this._resource._registerBoundResource("__bindTexture_" + target + "_" + currentTextureBinding, obj);
             }
             /**
              * @param {WebGLProgram} program
-             * @this Resource.WrapFunction
+             * @this {Resource.WrapFunction}
              */
             wrapFunctions["useProgram"] = function(program)
             {
                 this._resource._registerBoundResource("__useProgram", program);
             }
             /**
              * @param {number} index
-             * @this Resource.WrapFunction
+             * @this {Resource.WrapFunction}
              */
             wrapFunctions["vertexAttribPointer"] = function(index)
             {
                 var gl = /** @type {WebGLRenderingContext} */ (this._originalObject);
                 this._resource._registerBoundResource("__vertexAttribPointer_" + index, gl.getParameter(gl.ARRAY_BUFFER_BINDING));
             }
 
             WebGLRenderingContextResource._wrapFunctions = wrapFunctions;
         }
 
         /**
          * @param {string} methodName
          * @param {function(this:Resource, !Call)=} pushCallFunc
          */
         function stateModifyingWrapFunction(methodName, pushCallFunc)
         {
             if (pushCallFunc) {
                 /**
                  * @param {Object|number} target
-                 * @this Resource.WrapFunction
+                 * @this {Resource.WrapFunction}
                  */
                 wrapFunctions[methodName] = function(target)
                 {
                     var resource = this._resource.currentBinding(target);
                     if (resource)
                         pushCallFunc.call(resource, this.call());
                 }
             } else {
                 /**
                  * @param {Object|number} target
-                 * @this Resource.WrapFunction
+                 * @this {Resource.WrapFunction}
                  */
                 wrapFunctions[methodName] = function(target)
                 {
                     var resource = this._resource.currentBinding(target);
                     if (resource)
                         resource.pushCall(this.call());
                 }
             }
         }
 
@@ skipping 402 matching lines @@
             CanvasRenderingContext2DResource._wrapFunctions = wrapFunctions;
         }
 
         /**
          * @param {string} methodName
          * @param {function(this:Resource, !Call)=} func
          */
         function stateModifyingWrapFunction(methodName, func)
         {
             if (func) {
-                /** @this Resource.WrapFunction */
+                /** @this {Resource.WrapFunction} */
                 wrapFunctions[methodName] = function()
                 {
                     func.call(this._resource, this.call());
                 }
             } else {
-                /** @this Resource.WrapFunction */
+                /** @this {Resource.WrapFunction} */
                 wrapFunctions[methodName] = function()
                 {
                     this._resource.pushCall(this.call());
                 }
             }
         }
 
         return wrapFunctions;
     },
 
@@ skipping 640 matching lines @@
         };
     },
 
     /**
      * @param {number} stepNum
      */
     _replayCallArguments: function(stepNum)
     {
         /**
          * @param {*} obj
+         * @this {TraceLogPlayer}
          */
         function replayIfNotCreatedInThisTraceLog(obj)
         {
             if (!(obj instanceof ReplayableResource))
                 return;
             var replayableResource = /** @type {!ReplayableResource} */ (obj);
             if (!this._traceLog.createdInThisTraceLog(replayableResource.id()))
                 replayableResource.replay(this._replayWorldCache)
         }
         var replayableCalls = this._traceLog.replayableCalls();
@@ skipping 400 matching lines @@
     _parseStringId: function(stringId)
     {
         return InjectedScriptHost.evaluate("(" + stringId + ")");
     }
 }
 
 var injectedCanvasModule = new InjectedCanvasModule();
 return injectedCanvasModule;
 
 })