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 22 matching lines @@
  * @param {Window} inspectedWindow
  * @param {number} injectedScriptId
  * @param {!InjectedScript} injectedScript
  */
 (function (InjectedScriptHost, inspectedWindow, injectedScriptId, injectedScript) {
 
 var TypeUtils = {
     /**
      * http://www.khronos.org/registry/typedarray/specs/latest/#7
      * @const
-     * @type {!Array.<function(new:ArrayBufferView, (ArrayBuffer|ArrayBufferView), number=, number=)>}
+     * @type {!Array.<function(new:ArrayBufferView, (!ArrayBuffer|!ArrayBufferView), number=, number=)>}
      */
     _typedArrayClasses: (function(typeNames) {
         var result = [];
         for (var i = 0, n = typeNames.length; i < n; ++i) {
             if (inspectedWindow[typeNames[i]])
                 result.push(inspectedWindow[typeNames[i]]);
         }
         return result;
     })(["Int8Array", "Uint8Array", "Uint8ClampedArray", "Int16Array", "Uint16Array", "Int32Array", "Uint32Array", "Float32Array", "Float64Array"]),
 
     /**
      * @const
      * @type {!Array.<string>}
      */
     _supportedPropertyPrefixes: ["webkit"],
 
     /**
      * @param {*} array
-     * @return {function(new:ArrayBufferView, (ArrayBuffer|ArrayBufferView), number=, number=)|null}
+     * @return {function(new:ArrayBufferView, (!ArrayBuffer|!ArrayBufferView), number=, number=)|null}
      */
     typedArrayClass: function(array)
     {
         var classes = TypeUtils._typedArrayClasses;
         for (var i = 0, n = classes.length; i < n; ++i) {
             if (array instanceof classes[i])
                 return classes[i];
         }
         return null;
     },
@@ skipping 12 matching lines @@
             return obj;
 
         // Handle Array and ArrayBuffer instances.
         if (typeof obj.slice === "function") {
             console.assert(obj instanceof Array || obj instanceof ArrayBuffer);
             return obj.slice(0);
         }
 
         var typedArrayClass = TypeUtils.typedArrayClass(obj);
         if (typedArrayClass)
-            return new typedArrayClass(/** @type {ArrayBufferView} */ (obj));
+            return new typedArrayClass(/** @type {!ArrayBufferView} */ (obj));
 
         if (obj instanceof HTMLImageElement) {
-            var img = /** @type {HTMLImageElement} */ (obj);
+            var img = /** @type {!HTMLImageElement} */ (obj);
             // Special case for Images with Blob URIs: cloneNode will fail if the Blob URI has already been revoked.
             // FIXME: Maybe this is a bug in WebKit core?
             if (/^blob:/.test(img.src))
                 return TypeUtils.cloneIntoCanvas(img);
             return img.cloneNode(true);
         }
 
         if (obj instanceof HTMLCanvasElement)
             return TypeUtils.cloneIntoCanvas(obj);
 
@@ skipping 15 matching lines @@
             var valueType = typeof value;
             if (valueType !== "object" && valueType !== "function")
                 return value;
         }
 
         console.error("ASSERT_NOT_REACHED: failed to clone object: ", obj);
         return obj;
     },
 
     /**
-     * @param {HTMLImageElement|HTMLCanvasElement|HTMLVideoElement} obj
+     * @param {!HTMLImageElement|!HTMLCanvasElement|!HTMLVideoElement} obj
      * @param {number=} width
      * @param {number=} height
-     * @return {HTMLCanvasElement}
+     * @return {!HTMLCanvasElement}
      */
     cloneIntoCanvas: function(obj, width, height)
     {
-        var canvas = /** @type {HTMLCanvasElement} */ (inspectedWindow.document.createElement("canvas"));
+        var canvas = /** @type {!HTMLCanvasElement} */ (inspectedWindow.document.createElement("canvas"));
         canvas.width = width || +obj.width;
         canvas.height = height || +obj.height;
-        var context = /** @type {CanvasRenderingContext2D} */ (Resource.wrappedObject(canvas.getContext("2d")));
+        var context = /** @type {!CanvasRenderingContext2D} */ (Resource.wrappedObject(canvas.getContext("2d")));
         context.drawImage(obj, 0, 0);
         return canvas;
     },
 
     /**
-     * @param {Object=} obj
-     * @return {Object}
+     * @param {?Object=} obj
+     * @return {?Object}
      */
     cloneObject: function(obj)
     {
         if (!obj)
             return null;
         var result = {};
         for (var key in obj)
             result[key] = obj[key];
         return result;
     },
@@ skipping 34 matching lines @@
      * @param {string} property
      * @param {!Object} obj
      * @return {boolean}
      */
     isEnumPropertyName: function(property, obj)
     {
         return (/^[A-Z][A-Z0-9_]+$/.test(property) && typeof obj[property] === "number");
     },
 
     /**
-     * @return {CanvasRenderingContext2D}
+     * @return {!CanvasRenderingContext2D}
      */
     _dummyCanvas2dContext: function()
     {
         var context = TypeUtils._dummyCanvas2dContextInstance;
         if (!context) {
-            var canvas = /** @type {HTMLCanvasElement} */ (inspectedWindow.document.createElement("canvas"));
-            context = /** @type {CanvasRenderingContext2D} */ (Resource.wrappedObject(canvas.getContext("2d")));
+            var canvas = /** @type {!HTMLCanvasElement} */ (inspectedWindow.document.createElement("canvas"));
+            context = /** @type {!CanvasRenderingContext2D} */ (Resource.wrappedObject(canvas.getContext("2d")));
             TypeUtils._dummyCanvas2dContextInstance = context;
         }
         return context;
     }
 }
 
-/** @typedef {{name:string, valueIsEnum:(boolean|undefined), value:*, values:(!Array.<TypeUtils.InternalResourceStateDescriptor>|undefined), isArray:(boolean|undefined)}} */
+/** @typedef {{name:string, valueIsEnum:(boolean|undefined), value:*, values:(!Array.<!TypeUtils.InternalResourceStateDescriptor>|undefined), isArray:(boolean|undefined)}} */
 TypeUtils.InternalResourceStateDescriptor;
 
 /**
  * @interface
  */
 function StackTrace()
 {
 }
 
 StackTrace.prototype = {
     /**
      * @param {number} index
      * @return {{sourceURL: string, lineNumber: number, columnNumber: number}|undefined}
      */
     callFrame: function(index)
     {
     }
 }
 
 /**
  * @param {number=} stackTraceLimit
- * @param {Function=} topMostFunctionToIgnore
- * @return {StackTrace}
+ * @param {?Function=} topMostFunctionToIgnore
+ * @return {?StackTrace}
  */
 StackTrace.create = function(stackTraceLimit, topMostFunctionToIgnore)
 {
     if (typeof Error.captureStackTrace === "function")
         return new StackTraceV8(stackTraceLimit, topMostFunctionToIgnore || arguments.callee);
     // FIXME: Support JSC, and maybe other browsers.
     return null;
 }
 
 /**
  * @constructor
  * @implements {StackTrace}
  * @param {number=} stackTraceLimit
- * @param {Function=} topMostFunctionToIgnore
+ * @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
+     * @param {!Object} error
+     * @param {!Array.<!CallSite>} structuredStackTrace
      * @return {!Array.<{sourceURL: string, lineNumber: number, columnNumber: number}>}
      */
     Error.prepareStackTrace = function(error, structuredStackTrace)
     {
         return structuredStackTrace.map(function(callSite) {
             return {
                 sourceURL: callSite.getFileName(),
                 lineNumber: callSite.getLineNumber(),
                 columnNumber: callSite.getColumnNumber()
             };
@@ skipping 10 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 40 matching lines @@
     put: function(key, item)
     {
         if (!this.has(key))
             ++this._size;
         this._items[key] = item;
     }
 }
 
 /**
  * @constructor
- * @param {Resource|Object} thisObject
+ * @param {?Resource|!Object} thisObject
  * @param {string} functionName
- * @param {!Array|Arguments} args
- * @param {Resource|*=} result
- * @param {StackTrace=} stackTrace
+ * @param {!Array|!Arguments} args
+ * @param {!Resource|*=} result
+ * @param {?StackTrace=} stackTrace
  */
 function Call(thisObject, functionName, args, result, stackTrace)
 {
     this._thisObject = thisObject;
     this._functionName = functionName;
     this._args = Array.prototype.slice.call(args, 0);
     this._result = result;
     this._stackTrace = stackTrace || null;
 
     if (!this._functionName)
         console.assert(this._args.length === 2 && typeof this._args[0] === "string");
 }
 
 Call.prototype = {
     /**
-     * @return {Resource}
+     * @return {?Resource}
      */
     resource: function()
     {
         return Resource.forObject(this._thisObject);
     },
 
     /**
      * @return {string}
      */
     functionName: function()
@@ skipping 19 matching lines @@
 
     /**
      * @return {*}
      */
     result: function()
     {
         return this._result;
     },
 
     /**
-     * @return {StackTrace}
+     * @return {?StackTrace}
      */
     stackTrace: function()
     {
         return this._stackTrace;
     },
 
     /**
-     * @param {StackTrace} stackTrace
+     * @param {?StackTrace} stackTrace
      */
     setStackTrace: function(stackTrace)
     {
         this._stackTrace = stackTrace;
     },
 
     /**
      * @param {*} result
      */
     setResult: function(result)
     {
         this._result = result;
     },
 
     /**
      * @param {string} name
-     * @param {Object} attachment
+     * @param {?Object} attachment
      */
     setAttachment: function(name, attachment)
     {
         if (attachment) {
-            /** @type {Object.<string, Object>} */
+            /** @type {?Object.<string, !Object>|undefined} */
             this._attachments = this._attachments || Object.create(null);
             this._attachments[name] = attachment;
-        } else if (this._attachments)
+        } else if (this._attachments) {
             delete this._attachments[name];
+        }
     },
 
     /**
      * @param {string} name
-     * @return {Object}
+     * @return {?Object}
      */
     attachment: function(name)
     {
-        return this._attachments && this._attachments[name];
+        return this._attachments ? (this._attachments[name] || null) : null;
     },
 
     freeze: function()
     {
         if (this._freezed)
             return;
         this._freezed = true;
         for (var i = 0, n = this._args.length; i < n; ++i) {
             // FIXME: freeze the Resources also!
             if (!Resource.forObject(this._args[i]))
                 this._args[i] = TypeUtils.clone(this._args[i]);
         }
     },
 
     /**
-     * @param {!Cache.<ReplayableResource>} cache
+     * @param {!Cache.<!ReplayableResource>} cache
      * @return {!ReplayableCall}
      */
     toReplayable: function(cache)
     {
         this.freeze();
-        var thisObject = /** @type {ReplayableResource} */ (Resource.toReplayable(this._thisObject, cache));
+        var thisObject = /** @type {!ReplayableResource} */ (Resource.toReplayable(this._thisObject, cache));
         var result = Resource.toReplayable(this._result, cache);
         var args = this._args.map(function(obj) {
             return Resource.toReplayable(obj, cache);
         });
         var attachments = TypeUtils.cloneObject(this._attachments);
         return new ReplayableCall(thisObject, this._functionName, args, result, this._stackTrace, attachments);
     },
 
     /**
      * @param {!ReplayableCall} replayableCall
-     * @param {!Cache.<Resource>} cache
+     * @param {!Cache.<!Resource>} cache
      * @return {!Call}
      */
     replay: function(replayableCall, cache)
     {
         var replayableResult = replayableCall.result();
         if (replayableResult instanceof ReplayableResource && !cache.has(replayableResult.id())) {
             var resource = replayableResult.replay(cache);
             console.assert(resource.calls().length > 0, "Expected create* call for the Resource");
             return resource.calls()[0];
         }
@@ skipping 18 matching lines @@
             }
         }
     
         this._thisObject = replayObject;
         this._functionName = replayableCall.functionName();
         this._args = replayArgs;
         this._result = replayResult;
         this._stackTrace = replayableCall.stackTrace();
         this._freezed = true;
         var attachments = replayableCall.attachments();
-        if (attachments)
-            this._attachments = TypeUtils.cloneObject(attachments);
+        this._attachments = attachments ? TypeUtils.cloneObject(attachments) : null;
         return this;
     }
 }
 
 /**
  * @constructor
- * @param {ReplayableResource} thisObject
+ * @param {!ReplayableResource} thisObject
  * @param {string} functionName
- * @param {!Array.<ReplayableResource|*>} args
- * @param {ReplayableResource|*} result
- * @param {StackTrace} stackTrace
- * @param {Object.<string, Object>} attachments
+ * @param {!Array.<!ReplayableResource|*>} args
+ * @param {!ReplayableResource|*} result
+ * @param {?StackTrace} stackTrace
+ * @param {?Object.<string, !Object>} attachments
  */
 function ReplayableCall(thisObject, functionName, args, result, stackTrace, attachments)
 {
     this._thisObject = thisObject;
     this._functionName = functionName;
     this._args = args;
     this._result = result;
     this._stackTrace = stackTrace;
     if (attachments)
         this._attachments = attachments;
 }
 
 ReplayableCall.prototype = {
     /**
-     * @return {ReplayableResource}
+     * @return {!ReplayableResource}
      */
     replayableResource: function()
     {
         return this._thisObject;
     },
 
     /**
      * @return {string}
      */
     functionName: function()
@@ skipping 21 matching lines @@
     /**
      * @return {*}
      */
     propertyValue: function()
     {
         console.assert(this.isPropertySetter());
         return this._args[1];
     },
 
     /**
-     * @return {!Array.<ReplayableResource|*>}
+     * @return {!Array.<!ReplayableResource|*>}
      */
     args: function()
     {
         return this._args;
     },
 
     /**
-     * @return {ReplayableResource|*}
+     * @return {!ReplayableResource|*}
      */
     result: function()
     {
         return this._result;
     },
 
     /**
-     * @return {StackTrace}
+     * @return {?StackTrace}
      */
     stackTrace: function()
     {
         return this._stackTrace;
     },
 
     /**
-     * @return {Object.<string, Object>}
+     * @return {?Object.<string, !Object>}
      */
     attachments: function()
     {
         return this._attachments;
     },
 
     /**
      * @param {string} name
-     * @return {Object}
+     * @return {!Object}
      */
     attachment: function(name)
     {
         return this._attachments && this._attachments[name];
     },
 
     /**
-     * @param {!Cache.<Resource>} cache
+     * @param {!Cache.<!Resource>} cache
      * @return {!Call}
      */
     replay: function(cache)
     {
         var call = /** @type {!Call} */ (Object.create(Call.prototype));
         return call.replay(this, cache);
     }
 }
 
 /**
  * @constructor
  * @param {!Object} wrappedObject
  * @param {string} name
  */
 function Resource(wrappedObject, name)
 {
     /** @type {number} */
     this._id = ++Resource._uniqueId;
     /** @type {string} */
     this._name = name || "Resource";
     /** @type {number} */
     this._kindId = Resource._uniqueKindIds[this._name] = (Resource._uniqueKindIds[this._name] || 0) + 1;
-    /** @type {ResourceTrackingManager} */
+    /** @type {?ResourceTrackingManager} */
     this._resourceManager = null;
-    /** @type {!Array.<Call>} */
+    /** @type {!Array.<!Call>} */
     this._calls = [];
     /**
      * This is to prevent GC from collecting associated resources.
      * Otherwise, for example in WebGL, subsequent calls to gl.getParameter()
      * may return a recently created instance that is no longer bound to a
      * Resource object (thus, no history to replay it later).
      *
-     * @type {!Object.<string, Resource>}
+     * @type {!Object.<string, !Resource>}
      */
     this._boundResources = Object.create(null);
     this.setWrappedObject(wrappedObject);
 }
 
 /**
  * @type {number}
  */
 Resource._uniqueId = 0;
 
 /**
  * @type {!Object.<string, number>}
  */
 Resource._uniqueKindIds = {};
 
 /**
  * @param {*} obj
- * @return {Resource}
+ * @return {?Resource}
  */
 Resource.forObject = function(obj)
 {
     if (!obj)
         return null;
     if (obj instanceof Resource)
         return obj;
     if (typeof obj === "object")
         return obj["__resourceObject"];
     return null;
 }
 
 /**
- * @param {Resource|*} obj
+ * @param {!Resource|*} obj
  * @return {*}
  */
 Resource.wrappedObject = function(obj)
 {
     var resource = Resource.forObject(obj);
     return resource ? resource.wrappedObject() : obj;
 }
 
 /**
- * @param {Resource|*} obj
- * @param {!Cache.<ReplayableResource>} cache
- * @return {ReplayableResource|*}
+ * @param {!Resource|*} obj
+ * @param {!Cache.<!ReplayableResource>} cache
+ * @return {!ReplayableResource|*}
  */
 Resource.toReplayable = function(obj, cache)
 {
     var resource = Resource.forObject(obj);
     return resource ? resource.toReplayable(cache) : obj;
 }
 
 Resource.prototype = {
     /**
      * @return {number}
@@ skipping 13 matching lines @@
 
     /**
      * @return {string}
      */
     description: function()
     {
         return this._name + "@" + this._kindId;
     },
 
     /**
-     * @return {Object}
+     * @return {!Object}
      */
     wrappedObject: function()
     {
         return this._wrappedObject;
     },
 
     /**
      * @param {!Object} value
      */
     setWrappedObject: function(value)
     {
         console.assert(value, "wrappedObject should not be NULL");
         console.assert(!(value instanceof Resource), "Binding a Resource object to another Resource object?");
         this._wrappedObject = value;
         this._bindObjectToResource(value);
     },
 
     /**
-     * @return {Object}
+     * @return {!Object}
      */
     proxyObject: function()
     {
         if (!this._proxyObject)
             this._proxyObject = this._wrapObject();
         return this._proxyObject;
     },
 
     /**
-     * @return {ResourceTrackingManager}
+     * @return {?ResourceTrackingManager}
      */
     manager: function()
     {
         return this._resourceManager;
     },
 
     /**
-     * @param {ResourceTrackingManager} value
+     * @param {!ResourceTrackingManager} value
      */
     setManager: function(value)
     {
         this._resourceManager = value;
     },
 
     /**
      * @return {!Array.<!Call>}
      */
     calls: function()
     {
         return this._calls;
     },
 
     /**
-     * @return {ContextResource}
+     * @return {?ContextResource}
      */
     contextResource: function()
     {
         if (this instanceof ContextResource)
-            return /** @type {ContextResource} */ (this);
+            return /** @type {!ContextResource} */ (this);
 
         if (this._calculatingContextResource)
             return null;
 
         this._calculatingContextResource = true;
         var result = null;
         for (var i = 0, n = this._calls.length; i < n; ++i) {
             result = this._calls[i].resource().contextResource();
             if (result)
                 break;
         }
         delete this._calculatingContextResource;
         console.assert(result, "Failed to find context resource for " + this._name + "@" + this._kindId);
         return result;
     },
 
     /**
-     * @return {!Array.<TypeUtils.InternalResourceStateDescriptor>}
+     * @return {!Array.<!TypeUtils.InternalResourceStateDescriptor>}
      */
     currentState: function()
     {
         var result = [];
         var proxyObject = this.proxyObject();
         if (!proxyObject)
             return result;
         var statePropertyNames = this._proxyStatePropertyNames || [];
         for (var i = 0, n = statePropertyNames.length; i < n; ++i) {
             var pname = statePropertyNames[i];
             result.push({ name: pname, value: proxyObject[pname] });
         }
         result.push({ name: "context", value: this.contextResource() });
         return result;
     },
 
     /**
      * @return {string}
      */
     toDataURL: function()
     {
         return "";
     },
 
     /**
-     * @param {!Cache.<ReplayableResource>} cache
+     * @param {!Cache.<!ReplayableResource>} cache
      * @return {!ReplayableResource}
      */
     toReplayable: function(cache)
     {
         var result = cache.get(this._id);
         if (result)
             return result;
         var data = {
             id: this._id,
             name: this._name,
             kindId: this._kindId
         };
         result = new ReplayableResource(this, data);
         cache.put(this._id, result); // Put into the cache early to avoid loops.
         data.calls = this._calls.map(function(call) {
             return call.toReplayable(cache);
         });
         this._populateReplayableData(data, cache);
         var contextResource = this.contextResource();
         if (contextResource !== this)
             data.contextResource = Resource.toReplayable(contextResource, cache);
         return result;
     },
 
     /**
      * @param {!Object} data
-     * @param {!Cache.<ReplayableResource>} cache
+     * @param {!Cache.<!ReplayableResource>} cache
      */
     _populateReplayableData: function(data, cache)
     {
         // Do nothing. Should be overridden by subclasses.
     },
 
     /**
      * @param {!Object} data
-     * @param {!Cache.<Resource>} cache
+     * @param {!Cache.<!Resource>} cache
      * @return {!Resource}
      */
     replay: function(data, cache)
     {
         var resource = cache.get(data.id);
         if (resource)
             return resource;
         this._id = data.id;
         this._name = data.name;
         this._kindId = data.kindId;
         this._resourceManager = null;
         this._calls = [];
         this._boundResources = Object.create(null);
         this._wrappedObject = null;
         cache.put(data.id, this); // Put into the cache early to avoid loops.
         this._doReplayCalls(data, cache);
         console.assert(this._wrappedObject, "Resource should be reconstructed!");
         return this;
     },
 
     /**
      * @param {!Object} data
-     * @param {!Cache.<Resource>} cache
+     * @param {!Cache.<!Resource>} cache
      */
     _doReplayCalls: function(data, cache)
     {
         for (var i = 0, n = data.calls.length; i < n; ++i)
             this._calls.push(data.calls[i].replay(cache));
     },
 
     /**
      * @param {!Call} call
      */
@@ skipping 31 matching lines @@
     _registerBoundResource: function(key, obj)
     {
         var resource = Resource.forObject(obj);
         if (resource)
             this._boundResources[key] = resource;
         else
             delete this._boundResources[key];
     },
 
     /**
-     * @return {Object}
+     * @return {?Object}
      */
     _wrapObject: function()
     {
         var wrappedObject = this.wrappedObject();
         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 95 matching lines @@
             var args = [propertyName, value];
             manager.captureArguments(resource, args);
             originalObject[propertyName] = Resource.wrappedObject(value);
             var stackTrace = StackTrace.create(1, arguments.callee);
             var call = new Call(resource, "", args, undefined, stackTrace);
             manager.captureCall(call);
         };
     },
 
     /**
-     * @return {!Object.<string, Function>}
+     * @return {!Object.<string, !Function>}
      */
     _customWrapFunctions: function()
     {
         return Object.create(null); // May be overridden by subclasses.
     }
 }
 
 /**
  * @constructor
- * @param {Object} originalObject
- * @param {Function} originalFunction
+ * @param {!Object} originalObject
+ * @param {!Function} originalFunction
  * @param {string} functionName
- * @param {!Array|Arguments} args
+ * @param {!Array|!Arguments} args
  */
 Resource.WrapFunction = function(originalObject, originalFunction, functionName, args)
 {
     this._originalObject = originalObject;
     this._originalFunction = originalFunction;
     this._functionName = functionName;
     this._args = args;
     this._resource = Resource.forObject(originalObject);
     console.assert(this._resource, "Expected a wrapped call on a Resource object.");
 }
@@ skipping 32 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());
+        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());
         resource.pushCall(this.call());
     }
 }
@@ skipping 36 matching lines @@
 
     /**
      * @return {!ReplayableResource}
      */
     contextResource: function()
     {
         return this._data.contextResource || this;
     },
 
     /**
-     * @param {!Cache.<Resource>} cache
+     * @param {!Cache.<!Resource>} cache
      * @return {!Resource}
      */
     replay: function(cache)
     {
         var result = /** @type {!Resource} */ (Object.create(this._proto));
         result = result.replay(this._data, cache)
         console.assert(result.__proto__ === this._proto, "Wrong type of a replay result");
         return result;
     }
 }
 
 /**
- * @param {ReplayableResource|*} obj
- * @param {!Cache.<Resource>} cache
+ * @param {!ReplayableResource|*} obj
+ * @param {!Cache.<!Resource>} cache
  * @return {*}
  */
 ReplayableResource.replay = function(obj, cache)
 {
     return (obj instanceof ReplayableResource) ? obj.replay(cache).wrappedObject() : obj;
 }
 
 /**
  * @constructor
  * @extends {Resource}
@@ skipping 16 matching lines @@
  * @param {string} name
  */
 function LogEverythingResource(wrappedObject, name)
 {
     Resource.call(this, wrappedObject, name);
 }
 
 LogEverythingResource.prototype = {
     /**
      * @override
-     * @return {!Object.<string, Function>}
+     * @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 13 matching lines @@
 {
     Resource.call(this, wrappedObject, name);
     /** @type {!Object.<string, *>} */
     this._state = {};
 }
 
 WebGLBoundResource.prototype = {
     /**
      * @override
      * @param {!Object} data
-     * @param {!Cache.<ReplayableResource>} cache
+     * @param {!Cache.<!ReplayableResource>} cache
      */
     _populateReplayableData: function(data, cache)
     {
         var state = this._state;
         data.state = {};
         Object.keys(state).forEach(function(parameter) {
             data.state[parameter] = Resource.toReplayable(state[parameter], cache);
         });
     },
 
     /**
      * @override
      * @param {!Object} data
-     * @param {!Cache.<Resource>} cache
+     * @param {!Cache.<!Resource>} cache
      */
     _doReplayCalls: function(data, cache)
     {
         var gl = this._replayContextResource(data, cache).wrappedObject();
 
-        /** @type {!Object.<string, Array.<string>>} */
+        /** @type {!Object.<string, !Array.<string>>} */
         var bindingsData = {
             TEXTURE_2D: ["bindTexture", "TEXTURE_BINDING_2D"],
             TEXTURE_CUBE_MAP: ["bindTexture", "TEXTURE_BINDING_CUBE_MAP"],
             ARRAY_BUFFER: ["bindBuffer", "ARRAY_BUFFER_BINDING"],
             ELEMENT_ARRAY_BUFFER: ["bindBuffer", "ELEMENT_ARRAY_BUFFER_BINDING"],
             FRAMEBUFFER: ["bindFramebuffer", "FRAMEBUFFER_BINDING"],
             RENDERBUFFER: ["bindRenderbuffer", "RENDERBUFFER_BINDING"]
         };
         var originalBindings = {};
         Object.keys(bindingsData).forEach(function(bindingTarget) {
             var bindingParameter = bindingsData[bindingTarget][1];
             originalBindings[bindingTarget] = gl.getParameter(gl[bindingParameter]);
         });
 
         var state = {};
         Object.keys(data.state).forEach(function(parameter) {
             state[parameter] = ReplayableResource.replay(data.state[parameter], cache);
         });
         this._state = state;
         Resource.prototype._doReplayCalls.call(this, data, cache);
 
         Object.keys(bindingsData).forEach(function(bindingTarget) {
             var bindMethodName = bindingsData[bindingTarget][0];
             gl[bindMethodName].call(gl, gl[bindingTarget], originalBindings[bindingTarget]);
         });
     },
 
     /**
      * @param {!Object} data
-     * @param {!Cache.<Resource>} cache
-     * @return {WebGLRenderingContextResource}
+     * @param {!Cache.<!Resource>} cache
+     * @return {?WebGLRenderingContextResource}
      */
     _replayContextResource: function(data, cache)
     {
-        var calls = /** @type {!Array.<ReplayableCall>} */ (data.calls);
+        var calls = /** @type {!Array.<!ReplayableCall>} */ (data.calls);
         for (var i = 0, n = calls.length; i < n; ++i) {
             var resource = ReplayableResource.replay(calls[i].replayableResource(), cache);
             var contextResource = WebGLRenderingContextResource.forObject(resource);
             if (contextResource)
                 return contextResource;
         }
         return null;
     },
 
     /**
@@ skipping 18 matching lines @@
  * @param {string} name
  */
 function WebGLTextureResource(wrappedObject, name)
 {
     WebGLBoundResource.call(this, wrappedObject, name);
 }
 
 WebGLTextureResource.prototype = {
     /**
      * @override (overrides @return type)
-     * @return {WebGLTexture}
+     * @return {!WebGLTexture}
      */
     wrappedObject: function()
     {
         return this._wrappedObject;
     },
 
     /**
      * @override
-     * @return {!Array.<TypeUtils.InternalResourceStateDescriptor>}
+     * @return {!Array.<!TypeUtils.InternalResourceStateDescriptor>}
      */
     currentState: function()
     {
         var result = [];
         var glResource = WebGLRenderingContextResource.forObject(this);
         var gl = glResource.wrappedObject();
         var texture = this.wrappedObject();
         if (!gl || !texture)
             return result;
         result.push({ name: "isTexture", value: gl.isTexture(texture) });
@@ skipping 10 matching lines @@
             break;
         case gl.TEXTURE_CUBE_MAP:
             bindingParameter = gl.TEXTURE_BINDING_CUBE_MAP;
             break;
         default:
             console.error("ASSERT_NOT_REACHED: unknown texture target " + target);
             return result;
         }
         result.push({ name: "target", value: target, valueIsEnum: true });
 
-        var oldTexture = /** @type {WebGLTexture} */ (gl.getParameter(bindingParameter));
+        var oldTexture = /** @type {!WebGLTexture} */ (gl.getParameter(bindingParameter));
         if (oldTexture !== texture)
             gl.bindTexture(target, texture);
 
         var textureParameters = [
             "TEXTURE_MAG_FILTER",
             "TEXTURE_MIN_FILTER",
             "TEXTURE_WRAP_S",
             "TEXTURE_WRAP_T",
             "TEXTURE_MAX_ANISOTROPY_EXT" // EXT_texture_filter_anisotropic extension
         ];
         glResource.queryStateValues(gl.getTexParameter, target, textureParameters, result);
 
         if (oldTexture !== texture)
             gl.bindTexture(target, oldTexture);
         return result;
     },
 
     /**
      * @override
      * @param {!Object} data
-     * @param {!Cache.<Resource>} cache
+     * @param {!Cache.<!Resource>} cache
      */
     _doReplayCalls: function(data, cache)
     {
         var gl = this._replayContextResource(data, cache).wrappedObject();
 
         var state = {};
         WebGLRenderingContextResource.PixelStoreParameters.forEach(function(parameter) {
             state[parameter] = gl.getParameter(gl[parameter]);
         });
 
@@ skipping 42 matching lines @@
 
     /**
      * Handles: copyTexImage2D, copyTexSubImage2D
      * copyTexImage2D and copyTexSubImage2D define a texture image with pixels from the current framebuffer.
      * @param {!Call} call
      */
     pushCall_copyTexImage2D: function(call)
     {
         var glResource = WebGLRenderingContextResource.forObject(call.resource());
         var gl = glResource.wrappedObject();
-        var framebufferResource = /** @type {WebGLFramebufferResource} */ (glResource.currentBinding(gl.FRAMEBUFFER));
+        var framebufferResource = /** @type {!WebGLFramebufferResource} */ (glResource.currentBinding(gl.FRAMEBUFFER));
         if (framebufferResource)
             this.pushCall(new Call(glResource, "bindFramebuffer", [gl.FRAMEBUFFER, framebufferResource]));
         else {
             // FIXME: Implement this case.
             console.error("ASSERT_NOT_REACHED: Could not properly process a gl." + call.functionName() + " call while the DRAWING BUFFER is bound.");
         }
         this.pushCall(call);
     },
 
     __proto__: WebGLBoundResource.prototype
 }
 
 /**
  * @constructor
  * @extends {Resource}
  * @param {!Object} wrappedObject
  * @param {string} name
  */
 function WebGLProgramResource(wrappedObject, name)
 {
     Resource.call(this, wrappedObject, name);
 }
 
 WebGLProgramResource.prototype = {
     /**
      * @override (overrides @return type)
-     * @return {WebGLProgram}
+     * @return {!WebGLProgram}
      */
     wrappedObject: function()
     {
         return this._wrappedObject;
     },
 
     /**
      * @override
-     * @return {!Array.<TypeUtils.InternalResourceStateDescriptor>}
+     * @return {!Array.<!TypeUtils.InternalResourceStateDescriptor>}
      */
     currentState: function()
     {
         /**
          * @param {!Object} obj
-         * @param {!Array.<TypeUtils.InternalResourceStateDescriptor>} output
+         * @param {!Array.<!TypeUtils.InternalResourceStateDescriptor>} output
          */
         function convertToStateDescriptors(obj, output)
         {
             for (var pname in obj)
                 output.push({ name: pname, value: obj[pname], valueIsEnum: (pname === "type") });
         }
 
         var result = [];
         var program = this.wrappedObject();
         if (!program)
@@ skipping 73 matching lines @@
             if (includeAllInfo)
                 item.size = activeInfo.size;
             uniforms.push(item);
         }
         return uniforms;
     },
 
     /**
      * @override
      * @param {!Object} data
-     * @param {!Cache.<ReplayableResource>} cache
+     * @param {!Cache.<!ReplayableResource>} cache
      */
     _populateReplayableData: function(data, cache)
     {
         var glResource = WebGLRenderingContextResource.forObject(this);
         var originalErrors = glResource.getAllErrors();
         data.uniforms = this._activeUniforms();
         glResource.restoreErrors(originalErrors);
     },
 
     /**
      * @override
      * @param {!Object} data
-     * @param {!Cache.<Resource>} cache
+     * @param {!Cache.<!Resource>} cache
      */
     _doReplayCalls: function(data, cache)
     {
         Resource.prototype._doReplayCalls.call(this, data, cache);
         var gl = WebGLRenderingContextResource.forObject(this).wrappedObject();
         var program = this.wrappedObject();
 
-        var originalProgram = /** @type {WebGLProgram} */ (gl.getParameter(gl.CURRENT_PROGRAM));
+        var originalProgram = /** @type {!WebGLProgram} */ (gl.getParameter(gl.CURRENT_PROGRAM));
         var currentProgram = originalProgram;
         
         data.uniforms.forEach(function(uniform) {
             var uniformLocation = gl.getUniformLocation(program, uniform.name);
             if (!uniformLocation)
                 return;
             if (currentProgram !== program) {
                 currentProgram = program;
                 gl.useProgram(program);
             }
             var methodName = this._uniformMethodNameByType(gl, uniform.type);
             if (methodName.indexOf("Matrix") === -1)
                 gl[methodName].call(gl, uniformLocation, uniform.value);
             else
                 gl[methodName].call(gl, uniformLocation, false, uniform.value);
         }.bind(this));
 
         if (currentProgram !== originalProgram)
             gl.useProgram(originalProgram);
     },
 
     /**
-     * @param {WebGLRenderingContext} gl
+     * @param {!WebGLRenderingContext} gl
      * @param {number} type
      * @return {string}
      */
     _uniformMethodNameByType: function(gl, type)
     {
         var uniformMethodNames = WebGLProgramResource._uniformMethodNames;
         if (!uniformMethodNames) {
             uniformMethodNames = {};
             uniformMethodNames[gl.FLOAT] = "uniform1f";
             uniformMethodNames[gl.FLOAT_VEC2] = "uniform2fv";
@@ skipping 39 matching lines @@
  * @param {string} name
  */
 function WebGLShaderResource(wrappedObject, name)
 {
     Resource.call(this, wrappedObject, name);
 }
 
 WebGLShaderResource.prototype = {
     /**
      * @override (overrides @return type)
-     * @return {WebGLShader}
+     * @return {!WebGLShader}
      */
     wrappedObject: function()
     {
         return this._wrappedObject;
     },
 
     /**
      * @return {number}
      */
     type: function()
     {
         var call = this._calls[0];
         if (call && call.functionName() === "createShader")
             return call.args()[0];
         console.error("ASSERT_NOT_REACHED: Failed to restore shader type from the log.", call);
         return 0;
     },
 
     /**
      * @override
-     * @return {!Array.<TypeUtils.InternalResourceStateDescriptor>}
+     * @return {!Array.<!TypeUtils.InternalResourceStateDescriptor>}
      */
     currentState: function()
     {
         var result = [];
         var shader = this.wrappedObject();
         if (!shader)
             return result;
         var glResource = WebGLRenderingContextResource.forObject(this);
         var gl = glResource.wrappedObject();
         var shaderParameters = ["SHADER_TYPE", "DELETE_STATUS", "COMPILE_STATUS"];
@@ skipping 35 matching lines @@
  * @param {string} name
  */
 function WebGLBufferResource(wrappedObject, name)
 {
     WebGLBoundResource.call(this, wrappedObject, name);
 }
 
 WebGLBufferResource.prototype = {
     /**
      * @override (overrides @return type)
-     * @return {WebGLBuffer}
+     * @return {!WebGLBuffer}
      */
     wrappedObject: function()
     {
         return this._wrappedObject;
     },
 
     /**
      * @return {?ArrayBufferView}
      */
     cachedBufferData: function()
     {
         /**
          * Creates a view to a given buffer, does NOT copy the buffer.
          * @param {!ArrayBuffer|!ArrayBufferView} buffer
          * @return {!Uint8Array}
          */
         function createUint8ArrayBufferView(buffer)
         {
             return buffer instanceof ArrayBuffer ? new Uint8Array(buffer) : new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
         }
 
         if (!this._cachedBufferData) {
             for (var i = this._calls.length - 1; i >= 0; --i) {
                 var call = this._calls[i];
                 if (call.functionName() === "bufferData") {
-                    var sizeOrData = /** @type {number|ArrayBuffer|ArrayBufferView} */ (call.args()[1]);
+                    var sizeOrData = /** @type {number|!ArrayBuffer|!ArrayBufferView} */ (call.args()[1]);
                     if (typeof sizeOrData === "number")
                         this._cachedBufferData = new ArrayBuffer(sizeOrData);
                     else
                         this._cachedBufferData = sizeOrData;
                     this._lastBufferSubDataIndex = i + 1;
                     break;
                 }
             }
             if (!this._cachedBufferData)
                 return null;
@@ skipping 29 matching lines @@
 
         if (this._cachedBufferData instanceof ArrayBuffer) {
             // If we failed to guess the data type yet, use Uint8Array.
             return new Uint8Array(this._cachedBufferData);
         }
         return this._cachedBufferData;
     },
 
     /**
      * @override
-     * @return {!Array.<TypeUtils.InternalResourceStateDescriptor>}
+     * @return {!Array.<!TypeUtils.InternalResourceStateDescriptor>}
      */
     currentState: function()
     {
         var result = [];
         var glResource = WebGLRenderingContextResource.forObject(this);
         var gl = glResource.wrappedObject();
         var buffer = this.wrappedObject();
         if (!gl || !buffer)
             return result;
         result.push({ name: "isBuffer", value: gl.isBuffer(buffer) });
@@ skipping 10 matching lines @@
             break;
         case gl.ELEMENT_ARRAY_BUFFER:
             bindingParameter = gl.ELEMENT_ARRAY_BUFFER_BINDING;
             break;
         default:
             console.error("ASSERT_NOT_REACHED: unknown buffer target " + target);
             return result;
         }
         result.push({ name: "target", value: target, valueIsEnum: true });
 
-        var oldBuffer = /** @type {WebGLBuffer} */ (gl.getParameter(bindingParameter));
+        var oldBuffer = /** @type {!WebGLBuffer} */ (gl.getParameter(bindingParameter));
         if (oldBuffer !== buffer)
             gl.bindBuffer(target, buffer);
 
         var bufferParameters = ["BUFFER_SIZE", "BUFFER_USAGE"];
         glResource.queryStateValues(gl.getBufferParameter, target, bufferParameters, result);
 
         if (oldBuffer !== buffer)
             gl.bindBuffer(target, oldBuffer);
 
         try {
@@ skipping 37 matching lines @@
  * @param {string} name
  */
 function WebGLFramebufferResource(wrappedObject, name)
 {
     WebGLBoundResource.call(this, wrappedObject, name);
 }
 
 WebGLFramebufferResource.prototype = {
     /**
      * @override (overrides @return type)
-     * @return {WebGLFramebuffer}
+     * @return {!WebGLFramebuffer}
      */
     wrappedObject: function()
     {
         return this._wrappedObject;
     },
 
     /**
      * @override
-     * @return {!Array.<TypeUtils.InternalResourceStateDescriptor>}
+     * @return {!Array.<!TypeUtils.InternalResourceStateDescriptor>}
      */
     currentState: function()
     {
         var result = [];
         var framebuffer = this.wrappedObject();
         if (!framebuffer)
             return result;
         var gl = WebGLRenderingContextResource.forObject(this).wrappedObject();
 
-        var oldFramebuffer = /** @type {WebGLFramebuffer} */ (gl.getParameter(gl.FRAMEBUFFER_BINDING));
+        var oldFramebuffer = /** @type {!WebGLFramebuffer} */ (gl.getParameter(gl.FRAMEBUFFER_BINDING));
         if (oldFramebuffer !== framebuffer)
             gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
 
         var attachmentParameters = ["COLOR_ATTACHMENT0", "DEPTH_ATTACHMENT", "STENCIL_ATTACHMENT"];
         var framebufferParameters = ["FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE", "FRAMEBUFFER_ATTACHMENT_OBJECT_NAME", "FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL", "FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE"];
         for (var i = 0, attachment; attachment = attachmentParameters[i]; ++i) {
             var values = [];
             for (var j = 0, pname; pname = framebufferParameters[j]; ++j) {
                 var value = gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl[attachment], gl[pname]);
                 value = Resource.forObject(value) || value;
@@ skipping 29 matching lines @@
  * @param {string} name
  */
 function WebGLRenderbufferResource(wrappedObject, name)
 {
     WebGLBoundResource.call(this, wrappedObject, name);
 }
 
 WebGLRenderbufferResource.prototype = {
     /**
      * @override (overrides @return type)
-     * @return {WebGLRenderbuffer}
+     * @return {!WebGLRenderbuffer}
      */
     wrappedObject: function()
     {
         return this._wrappedObject;
     },
 
     /**
      * @override
-     * @return {!Array.<TypeUtils.InternalResourceStateDescriptor>}
+     * @return {!Array.<!TypeUtils.InternalResourceStateDescriptor>}
      */
     currentState: function()
     {
         var result = [];
         var renderbuffer = this.wrappedObject();
         if (!renderbuffer)
             return result;
         var glResource = WebGLRenderingContextResource.forObject(this);
         var gl = glResource.wrappedObject();
 
-        var oldRenderbuffer = /** @type {WebGLRenderbuffer} */ (gl.getParameter(gl.RENDERBUFFER_BINDING));
+        var oldRenderbuffer = /** @type {!WebGLRenderbuffer} */ (gl.getParameter(gl.RENDERBUFFER_BINDING));
         if (oldRenderbuffer !== renderbuffer)
             gl.bindRenderbuffer(gl.RENDERBUFFER, renderbuffer);
 
         var renderbufferParameters = ["RENDERBUFFER_WIDTH", "RENDERBUFFER_HEIGHT", "RENDERBUFFER_INTERNAL_FORMAT", "RENDERBUFFER_RED_SIZE", "RENDERBUFFER_GREEN_SIZE", "RENDERBUFFER_BLUE_SIZE", "RENDERBUFFER_ALPHA_SIZE", "RENDERBUFFER_DEPTH_SIZE", "RENDERBUFFER_STENCIL_SIZE"];
         glResource.queryStateValues(gl.getRenderbufferParameter, gl.RENDERBUFFER, renderbufferParameters, result);
         result.push({ name: "isRenderbuffer", value: gl.isRenderbuffer(renderbuffer) });
         result.push({ name: "context", value: this.contextResource() });
 
         if (oldRenderbuffer !== renderbuffer)
             gl.bindRenderbuffer(gl.RENDERBUFFER, oldRenderbuffer);
@@ skipping 20 matching lines @@
  * @param {string} name
  */
 function WebGLUniformLocationResource(wrappedObject, name)
 {
     Resource.call(this, wrappedObject, name);
 }
 
 WebGLUniformLocationResource.prototype = {
     /**
      * @override (overrides @return type)
-     * @return {WebGLUniformLocation}
+     * @return {!WebGLUniformLocation}
      */
     wrappedObject: function()
     {
         return this._wrappedObject;
     },
 
     /**
-     * @return {WebGLProgramResource}
+     * @return {?WebGLProgramResource}
      */
     program: function()
     {
         var call = this._calls[0];
         if (call && call.functionName() === "getUniformLocation")
-            return /** @type {WebGLProgramResource} */ (Resource.forObject(call.args()[0]));
+            return /** @type {!WebGLProgramResource} */ (Resource.forObject(call.args()[0]));
         console.error("ASSERT_NOT_REACHED: Failed to restore WebGLUniformLocation from the log.", call);
         return null;
     },
 
     /**
      * @return {string}
      */
     name: function()
     {
         var call = this._calls[0];
         if (call && call.functionName() === "getUniformLocation")
             return call.args()[1];
         console.error("ASSERT_NOT_REACHED: Failed to restore WebGLUniformLocation from the log.", call);
         return "";
     },
 
     /**
      * @override
-     * @return {!Array.<TypeUtils.InternalResourceStateDescriptor>}
+     * @return {!Array.<!TypeUtils.InternalResourceStateDescriptor>}
      */
     currentState: function()
     {
         var result = [];
         var location = this.wrappedObject();
         if (!location)
             return result;
         var programResource = this.program();
         var program = programResource && programResource.wrappedObject();
         if (!program)
@@ skipping 25 matching lines @@
             result.push({ name: "type", value: this._type, valueIsEnum: true });
         if (typeof this._size === "number")
             result.push({ name: "size", value: this._size });
 
         return result;
     },
 
     /**
      * @override
      * @param {!Object} data
-     * @param {!Cache.<ReplayableResource>} cache
+     * @param {!Cache.<!ReplayableResource>} cache
      */
     _populateReplayableData: function(data, cache)
     {
         data.type = this._type;
         data.size = this._size;
     },
 
     /**
      * @override
      * @param {!Object} data
-     * @param {!Cache.<Resource>} cache
+     * @param {!Cache.<!Resource>} cache
      */
     _doReplayCalls: function(data, cache)
     {
         this._type = data.type;
         this._size = data.size;
         Resource.prototype._doReplayCalls.call(this, data, cache);
     },
 
     __proto__: Resource.prototype
 }
 
 /**
  * @constructor
  * @extends {ContextResource}
  * @param {!WebGLRenderingContext} glContext
  */
 function WebGLRenderingContextResource(glContext)
 {
     ContextResource.call(this, glContext, "WebGLRenderingContext");
-    /** @type {Object.<number, boolean>} */
+    /** @type {?Object.<number, boolean>} */
     this._customErrors = null;
     /** @type {!Object.<string, string>} */
     this._extensions = {};
     /** @type {!Object.<string, number>} */
     this._extensionEnums = {};
 }
 
 /**
  * @const
  * @type {!Array.<string>}
@@ skipping 130 matching lines @@
  * @type {!Object.<string, boolean>}
  */
 WebGLRenderingContextResource.DrawingMethods = TypeUtils.createPrefixedPropertyNamesSet([
     "clear",
     "drawArrays",
     "drawElements"
 ]);
 
 /**
  * @param {*} obj
- * @return {WebGLRenderingContextResource}
+ * @return {?WebGLRenderingContextResource}
  */
 WebGLRenderingContextResource.forObject = function(obj)
 {
     var resource = Resource.forObject(obj);
     if (!resource)
         return null;
     resource = resource.contextResource();
     return (resource instanceof WebGLRenderingContextResource) ? resource : null;
 }
 
 WebGLRenderingContextResource.prototype = {
     /**
      * @override (overrides @return type)
-     * @return {WebGLRenderingContext}
+     * @return {!WebGLRenderingContext}
      */
     wrappedObject: function()
     {
         return this._wrappedObject;
     },
 
     /**
      * @override
      * @return {string}
      */
     toDataURL: function()
     {
         return this.wrappedObject().canvas.toDataURL();
     },
 
     /**
-     * @return {Array.<number>}
+     * @return {!Array.<number>}
      */
     getAllErrors: function()
     {
         var errors = [];
         var gl = this.wrappedObject();
         if (gl) {
             while (true) {
                 var error = gl.getError();
                 if (error === gl.NO_ERROR)
                     break;
                 this.clearError(error);
                 errors.push(error);
             }
         }
         if (this._customErrors) {
             for (var key in this._customErrors) {
                 var error = Number(key);
                 errors.push(error);
             }
             delete this._customErrors;
         }
         return errors;
     },
 
     /**
-     * @param {Array.<number>} errors
+     * @param {!Array.<number>} errors
      */
     restoreErrors: function(errors)
     {
         var gl = this.wrappedObject();
         if (gl) {
             var wasError = false;
             while (gl.getError() !== gl.NO_ERROR)
                 wasError = true;
             console.assert(!wasError, "Error(s) while capturing current WebGL state.");
         }
@@ skipping 27 matching lines @@
                 return error;
             }
         }
         delete this._customErrors;
         var gl = this.wrappedObject();
         return gl ? gl.NO_ERROR : 0;
     },
 
     /**
      * @param {string} name
-     * @param {Object} obj
+     * @param {?Object} obj
      */
     registerWebGLExtension: function(name, obj)
     {
         // FIXME: Wrap OES_vertex_array_object extension.
         var lowerName = name.toLowerCase();
         if (obj && !this._extensions[lowerName]) {
             this._extensions[lowerName] = name;
             for (var property in obj) {
                 if (TypeUtils.isEnumPropertyName(property, obj))
                     this._extensionEnums[property] = /** @type {number} */ (obj[property]);
@@ skipping 10 matching lines @@
         if (typeof this._extensionEnums[name] === "number")
             return this._extensionEnums[name];
         var gl = this.wrappedObject();
         return (typeof gl[name] === "number" ? gl[name] : undefined);
     },
 
     /**
      * @param {function(this:WebGLRenderingContext, T, number):*} func
      * @param {T} targetOrWebGLObject
      * @param {!Array.<string>} pnames
-     * @param {!Array.<TypeUtils.InternalResourceStateDescriptor>} output
+     * @param {!Array.<!TypeUtils.InternalResourceStateDescriptor>} output
      * @template T
      */
     queryStateValues: function(func, targetOrWebGLObject, pnames, output)
     {
         var gl = this.wrappedObject();
         for (var i = 0, pname; pname = pnames[i]; ++i) {
             var enumValue = this._enumValueForName(pname);
             if (typeof enumValue !== "number")
                 continue;
             var value = func.call(gl, targetOrWebGLObject, enumValue);
             value = Resource.forObject(value) || value;
             output.push({ name: pname, value: value, valueIsEnum: WebGLRenderingContextResource.GetResultIsEnum[pname] });
         }
     },
 
     /**
      * @override
-     * @return {!Array.<TypeUtils.InternalResourceStateDescriptor>}
+     * @return {!Array.<!TypeUtils.InternalResourceStateDescriptor>}
      */
     currentState: function()
     {
         /**
          * @param {!Object} obj
-         * @param {!Array.<TypeUtils.InternalResourceStateDescriptor>} output
+         * @param {!Array.<!TypeUtils.InternalResourceStateDescriptor>} output
          */
         function convertToStateDescriptors(obj, output)
         {
             for (var pname in obj)
                 output.push({ name: pname, value: obj[pname], valueIsEnum: WebGLRenderingContextResource.GetResultIsEnum[pname] });
         }
 
         var gl = this.wrappedObject();
         var glState = this._internalCurrentState(null);
 
@@ skipping 36 matching lines @@
             var value = gl.getExtension(pname);
             value = Resource.forObject(value) || value;
             enabledExtensions.push({ name: pname, value: value });
         }
         result.push({ name: "ENABLED_EXTENSIONS", values: enabledExtensions, isArray: true });
 
         return result;
     },
 
     /**
-     * @param {?Cache.<ReplayableResource>} cache
+     * @param {?Cache.<!ReplayableResource>} cache
      * @return {!Object.<string, *>}
      */
     _internalCurrentState: function(cache)
     {
         /**
-         * @param {Resource|*} obj
-         * @return {Resource|ReplayableResource|*}
+         * @param {!Resource|*} obj
+         * @return {!Resource|!ReplayableResource|*}
          */
         function maybeToReplayable(obj)
         {
             return cache ? Resource.toReplayable(obj, cache) : (Resource.forObject(obj) || obj);
         }
 
         var gl = this.wrappedObject();
         var originalErrors = this.getAllErrors();
 
         // Take a full GL state snapshot.
@@ skipping 46 matching lines @@
         glState.TEXTURE_UNITS = textureUnits;
         gl.activeTexture(savedActiveTexture);
 
         this.restoreErrors(originalErrors);
         return glState;
     },
 
     /**
      * @override
      * @param {!Object} data
-     * @param {!Cache.<ReplayableResource>} cache
+     * @param {!Cache.<!ReplayableResource>} cache
      */
     _populateReplayableData: function(data, cache)
     {
         var gl = this.wrappedObject();
         data.originalCanvas = gl.canvas;
         data.originalContextAttributes = gl.getContextAttributes();
         data.extensions = TypeUtils.cloneObject(this._extensions);
         data.extensionEnums = TypeUtils.cloneObject(this._extensionEnums);
         data.glState = this._internalCurrentState(cache);
     },
 
     /**
      * @override
      * @param {!Object} data
-     * @param {!Cache.<Resource>} cache
+     * @param {!Cache.<!Resource>} cache
      */
     _doReplayCalls: function(data, cache)
     {
         this._customErrors = null;
         this._extensions = TypeUtils.cloneObject(data.extensions) || {};
         this._extensionEnums = TypeUtils.cloneObject(data.extensionEnums) || {};
 
         var canvas = data.originalCanvas.cloneNode(true);
         var replayContext = null;
         var contextIds = ["experimental-webgl", "webkit-3d", "3d"];
         for (var i = 0, contextId; contextId = contextIds[i]; ++i) {
             replayContext = canvas.getContext(contextId, data.originalContextAttributes);
             if (replayContext)
                 break;
         }
 
         console.assert(replayContext, "Failed to create a WebGLRenderingContext for the replay.");
 
         var gl = /** @type {!WebGLRenderingContext} */ (Resource.wrappedObject(replayContext));
         this.setWrappedObject(gl);
 
         // Enable corresponding WebGL extensions.
         for (var name in this._extensions)
             gl.getExtension(name);
 
         var glState = data.glState;
-        gl.bindFramebuffer(gl.FRAMEBUFFER, /** @type {WebGLFramebuffer} */ (ReplayableResource.replay(glState.FRAMEBUFFER_BINDING, cache)));
-        gl.bindRenderbuffer(gl.RENDERBUFFER, /** @type {WebGLRenderbuffer} */ (ReplayableResource.replay(glState.RENDERBUFFER_BINDING, cache)));
+        gl.bindFramebuffer(gl.FRAMEBUFFER, /** @type {!WebGLFramebuffer} */ (ReplayableResource.replay(glState.FRAMEBUFFER_BINDING, cache)));
+        gl.bindRenderbuffer(gl.RENDERBUFFER, /** @type {!WebGLRenderbuffer} */ (ReplayableResource.replay(glState.RENDERBUFFER_BINDING, cache)));
 
         // Enable or disable server-side GL capabilities.
         WebGLRenderingContextResource.GLCapabilities.forEach(function(parameter) {
             console.assert(parameter in glState);
             if (glState[parameter])
                 gl.enable(gl[parameter]);
             else
                 gl.disable(gl[parameter]);
         });
 
@@ skipping 25 matching lines @@
         gl.stencilFuncSeparate(gl.FRONT, glState.STENCIL_FUNC, glState.STENCIL_REF, glState.STENCIL_VALUE_MASK);
         gl.stencilFuncSeparate(gl.BACK, glState.STENCIL_BACK_FUNC, glState.STENCIL_BACK_REF, glState.STENCIL_BACK_VALUE_MASK);
         gl.stencilOpSeparate(gl.FRONT, glState.STENCIL_FAIL, glState.STENCIL_PASS_DEPTH_FAIL, glState.STENCIL_PASS_DEPTH_PASS);
         gl.stencilOpSeparate(gl.BACK, glState.STENCIL_BACK_FAIL, glState.STENCIL_BACK_PASS_DEPTH_FAIL, glState.STENCIL_BACK_PASS_DEPTH_PASS);
         gl.stencilMaskSeparate(gl.FRONT, glState.STENCIL_WRITEMASK);
         gl.stencilMaskSeparate(gl.BACK, glState.STENCIL_BACK_WRITEMASK);
 
         gl.scissor(glState.SCISSOR_BOX[0], glState.SCISSOR_BOX[1], glState.SCISSOR_BOX[2], glState.SCISSOR_BOX[3]);
         gl.viewport(glState.VIEWPORT[0], glState.VIEWPORT[1], glState.VIEWPORT[2], glState.VIEWPORT[3]);
 
-        gl.useProgram(/** @type {WebGLProgram} */ (ReplayableResource.replay(glState.CURRENT_PROGRAM, cache)));
+        gl.useProgram(/** @type {!WebGLProgram} */ (ReplayableResource.replay(glState.CURRENT_PROGRAM, cache)));
 
         // VERTEX_ATTRIB_ARRAYS
         var maxVertexAttribs = /** @type {number} */ (gl.getParameter(gl.MAX_VERTEX_ATTRIBS));
         for (var i = 0; i < maxVertexAttribs; ++i) {
             var state = glState.VERTEX_ATTRIB_ARRAYS[i] || {};
             if (state.VERTEX_ATTRIB_ARRAY_ENABLED)
                 gl.enableVertexAttribArray(i);
             else
                 gl.disableVertexAttribArray(i);
             if (state.CURRENT_VERTEX_ATTRIB)
                 gl.vertexAttrib4fv(i, state.CURRENT_VERTEX_ATTRIB);
-            var buffer = /** @type {WebGLBuffer} */ (ReplayableResource.replay(state.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, cache));
+            var buffer = /** @type {!WebGLBuffer} */ (ReplayableResource.replay(state.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, cache));
             if (buffer) {
                 gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
                 gl.vertexAttribPointer(i, state.VERTEX_ATTRIB_ARRAY_SIZE, state.VERTEX_ATTRIB_ARRAY_TYPE, state.VERTEX_ATTRIB_ARRAY_NORMALIZED, state.VERTEX_ATTRIB_ARRAY_STRIDE, state.VERTEX_ATTRIB_ARRAY_POINTER);
             }
         }
-        gl.bindBuffer(gl.ARRAY_BUFFER, /** @type {WebGLBuffer} */ (ReplayableResource.replay(glState.ARRAY_BUFFER_BINDING, cache)));
-        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, /** @type {WebGLBuffer} */ (ReplayableResource.replay(glState.ELEMENT_ARRAY_BUFFER_BINDING, cache)));
+        gl.bindBuffer(gl.ARRAY_BUFFER, /** @type {!WebGLBuffer} */ (ReplayableResource.replay(glState.ARRAY_BUFFER_BINDING, cache)));
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, /** @type {!WebGLBuffer} */ (ReplayableResource.replay(glState.ELEMENT_ARRAY_BUFFER_BINDING, cache)));
 
         // TEXTURE_UNITS
         var maxTextureImageUnits = /** @type {number} */ (gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS));
         for (var i = 0; i < maxTextureImageUnits; ++i) {
             gl.activeTexture(gl.TEXTURE0 + i);
             var state = glState.TEXTURE_UNITS[i] || {};
-            gl.bindTexture(gl.TEXTURE_2D, /** @type {WebGLTexture} */ (ReplayableResource.replay(state.TEXTURE_2D, cache)));
-            gl.bindTexture(gl.TEXTURE_CUBE_MAP, /** @type {WebGLTexture} */ (ReplayableResource.replay(state.TEXTURE_CUBE_MAP, cache)));
+            gl.bindTexture(gl.TEXTURE_2D, /** @type {!WebGLTexture} */ (ReplayableResource.replay(state.TEXTURE_2D, cache)));
+            gl.bindTexture(gl.TEXTURE_CUBE_MAP, /** @type {!WebGLTexture} */ (ReplayableResource.replay(state.TEXTURE_CUBE_MAP, cache)));
         }
         gl.activeTexture(glState.ACTIVE_TEXTURE);
 
         ContextResource.prototype._doReplayCalls.call(this, data, cache);
     },
 
     /**
-     * @param {Object|number} target
-     * @return {Resource}
+     * @param {!Object|number} target
+     * @return {?Resource}
      */
     currentBinding: function(target)
     {
         var resource = Resource.forObject(target);
         if (resource)
             return resource;
         var gl = this.wrappedObject();
         var bindingParameter;
         var bindMethodName;
         target = +target; // Explicitly convert to a number.
@@ skipping 52 matching lines @@
         case "bindBuffer":
         case "bindFramebuffer":
         case "bindRenderbuffer":
         case "bindTexture":
             // Update BINDING state for Resources in the replay world.
             var resource = Resource.forObject(args[1]);
             if (resource)
                 resource.pushBinding(args[0], functionName);
             break;
         case "getExtension":
-            this.registerWebGLExtension(args[0], /** @type {Object} */ (call.result()));
+            this.registerWebGLExtension(args[0], /** @type {!Object} */ (call.result()));
             break;
         case "bufferData":
-            var resource = /** @type {WebGLBufferResource} */ (this.currentBinding(args[0]));
+            var resource = /** @type {!WebGLBufferResource} */ (this.currentBinding(args[0]));
             if (resource)
                 resource.pushCall_bufferData(call);
             break;
         case "bufferSubData":
-            var resource = /** @type {WebGLBufferResource} */ (this.currentBinding(args[0]));
+            var resource = /** @type {!WebGLBufferResource} */ (this.currentBinding(args[0]));
             if (resource)
                 resource.pushCall_bufferSubData(call);
             break;
         }
     },
 
     /**
      * @override
-     * @return {!Object.<string, Function>}
+     * @return {!Object.<string, !Function>}
      */
     _customWrapFunctions: function()
     {
         var wrapFunctions = WebGLRenderingContextResource._wrapFunctions;
         if (!wrapFunctions) {
             wrapFunctions = Object.create(null);
 
             wrapFunctions["createBuffer"] = Resource.WrapFunction.resourceFactoryMethod(WebGLBufferResource, "WebGLBuffer");
             wrapFunctions["createShader"] = Resource.WrapFunction.resourceFactoryMethod(WebGLShaderResource, "WebGLShader");
             wrapFunctions["createProgram"] = Resource.WrapFunction.resourceFactoryMethod(WebGLProgramResource, "WebGLProgram");
@@ skipping 13 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 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
+             * @param {!WebGLProgram} program
+             * @param {!WebGLShader} shader
+             * @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));
+                    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
+             * @param {!WebGLRenderbuffer|!WebGLTexture} obj
+             * @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
+             * @param {!Object} obj
+             * @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
+             * @param {!WebGLTexture} obj
+             * @this {Resource.WrapFunction}
              */
             wrapFunctions["bindTexture"] = function(target, obj)
             {
                 this._resource.currentBinding(target); // To call WebGLBoundResource.prototype.pushBinding().
-                var gl = /** @type {WebGLRenderingContext} */ (this._originalObject);
+                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
+             * @param {!WebGLProgram} program
+             * @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);
+                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
+                 * @param {!Object|number} target
+                 * @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
+                 * @param {!Object|number} target
+                 * @this {Resource.WrapFunction}
                  */
                 wrapFunctions[methodName] = function(target)
                 {
                     var resource = this._resource.currentBinding(target);
                     if (resource)
                         resource.pushCall(this.call());
                 }
             }
         }
 
@@ skipping 87 matching lines @@
     "putImageData",
     "putImageDataHD",
     "stroke",
     "strokeRect",
     "strokeText"
 ]);
 
 CanvasRenderingContext2DResource.prototype = {
     /**
      * @override (overrides @return type)
-     * @return {CanvasRenderingContext2D}
+     * @return {!CanvasRenderingContext2D}
      */
     wrappedObject: function()
     {
         return this._wrappedObject;
     },
 
     /**
      * @override
      * @return {string}
      */
     toDataURL: function()
     {
         return this.wrappedObject().canvas.toDataURL();
     },
 
     /**
      * @override
-     * @return {!Array.<TypeUtils.InternalResourceStateDescriptor>}
+     * @return {!Array.<!TypeUtils.InternalResourceStateDescriptor>}
      */
     currentState: function()
     {
         var result = [];
         var state = this._internalCurrentState(null);
         for (var pname in state)
             result.push({ name: pname, value: state[pname] });
         result.push({ name: "context", value: this.contextResource() });
         return result;
     },
 
     /**
-     * @param {?Cache.<ReplayableResource>} cache
+     * @param {?Cache.<!ReplayableResource>} cache
      * @return {!Object.<string, *>}
      */
     _internalCurrentState: function(cache)
     {
         /**
-         * @param {Resource|*} obj
-         * @return {Resource|ReplayableResource|*}
+         * @param {!Resource|*} obj
+         * @return {!Resource|!ReplayableResource|*}
          */
         function maybeToReplayable(obj)
         {
             return cache ? Resource.toReplayable(obj, cache) : (Resource.forObject(obj) || obj);
         }
 
         var ctx = this.wrappedObject();
         var state = Object.create(null);
         CanvasRenderingContext2DResource.AttributeProperties.forEach(function(attribute) {
             if (attribute in ctx)
                 state[attribute] = maybeToReplayable(ctx[attribute]);
         });
         if (ctx.getLineDash)
             state.lineDash = ctx.getLineDash();
         return state;
     },
 
     /**
-     * @param {Object.<string, *>} state
-     * @param {!Cache.<Resource>} cache
+     * @param {?Object.<string, *>} state
+     * @param {!Cache.<!Resource>} cache
      */
     _applyAttributesState: function(state, cache)
     {
         if (!state)
             return;
         var ctx = this.wrappedObject();
         for (var attribute in state) {
             if (attribute === "lineDash") {
                 if (ctx.setLineDash)
-                    ctx.setLineDash(/** @type {Array.<number>} */ (state[attribute]));
+                    ctx.setLineDash(/** @type {!Array.<number>} */ (state[attribute]));
             } else
                 ctx[attribute] = ReplayableResource.replay(state[attribute], cache);
         }
     },
 
     /**
      * @override
      * @param {!Object} data
-     * @param {!Cache.<ReplayableResource>} cache
+     * @param {!Cache.<!ReplayableResource>} cache
      */
     _populateReplayableData: function(data, cache)
     {
         var ctx = this.wrappedObject();
         // FIXME: Convert resources in the state (CanvasGradient, CanvasPattern) to Replayable.
         data.currentAttributes = this._internalCurrentState(null);
-        data.originalCanvasCloned = TypeUtils.cloneIntoCanvas(ctx.canvas);
+        data.originalCanvasCloned = TypeUtils.cloneIntoCanvas(/** @type {!HTMLCanvasElement} */ (ctx.canvas));
         if (ctx.getContextAttributes)
             data.originalContextAttributes = ctx.getContextAttributes();
     },
 
     /**
      * @override
      * @param {!Object} data
-     * @param {!Cache.<Resource>} cache
+     * @param {!Cache.<!Resource>} cache
      */
     _doReplayCalls: function(data, cache)
     {
         var canvas = TypeUtils.cloneIntoCanvas(data.originalCanvasCloned);
         var ctx = /** @type {!CanvasRenderingContext2D} */ (Resource.wrappedObject(canvas.getContext("2d", data.originalContextAttributes)));
         this.setWrappedObject(ctx);
 
         for (var i = 0, n = data.calls.length; i < n; ++i) {
-            var replayableCall = /** @type {ReplayableCall} */ (data.calls[i]);
+            var replayableCall = /** @type {!ReplayableCall} */ (data.calls[i]);
             if (replayableCall.functionName() === "save")
                 this._applyAttributesState(replayableCall.attachment("canvas2dAttributesState"), cache);
             this._calls.push(replayableCall.replay(cache));
         }
         this._applyAttributesState(data.currentAttributes, cache);
     },
 
     /**
      * @param {!Call} call
      */
@@ skipping 162 matching lines @@
                 this._calls[newIndex++] = call;
         }
         if (newIndex >= toIndex)
             return false;
         this._calls.splice(newIndex, toIndex - newIndex);
         return true;
     },
 
     /**
      * @override
-     * @return {!Object.<string, Function>}
+     * @return {!Object.<string, !Function>}
      */
     _customWrapFunctions: function()
     {
         var wrapFunctions = CanvasRenderingContext2DResource._wrapFunctions;
         if (!wrapFunctions) {
             wrapFunctions = Object.create(null);
 
             wrapFunctions["createLinearGradient"] = Resource.WrapFunction.resourceFactoryMethod(LogEverythingResource, "CanvasGradient");
             wrapFunctions["createRadialGradient"] = Resource.WrapFunction.resourceFactoryMethod(LogEverythingResource, "CanvasGradient");
             wrapFunctions["createPattern"] = Resource.WrapFunction.resourceFactoryMethod(LogEverythingResource, "CanvasPattern");
@@ skipping 10 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 48 matching lines @@
                 description: value.description(),
                 resourceId: CallFormatter.makeStringResourceId(value.id())
             };
         }
 
         var remoteObject = injectedScript.wrapObject(value, objectGroup || "", true, false);
         var description = remoteObject.description || ("" + value);
 
         var result = {
             description: description,
-            type: /** @type {CanvasAgent.CallArgumentType} */ (remoteObject.type)
+            type: /** @type {!CanvasAgent.CallArgumentType} */ (remoteObject.type)
         };
         if (remoteObject.subtype)
-            result.subtype = /** @type {CanvasAgent.CallArgumentSubtype} */ (remoteObject.subtype);
+            result.subtype = /** @type {!CanvasAgent.CallArgumentSubtype} */ (remoteObject.subtype);
         if (remoteObject.objectId) {
             if (objectGroup)
                 result.remoteObject = remoteObject;
             else
                 injectedScript.releaseObject(remoteObject.objectId);
         }
         return result;
     },
 
     /**
      * @param {string} name
      * @return {?string}
      */
     enumValueForName: function(name)
     {
         return null;
     },
 
     /**
      * @param {number} value
-     * @param {Array.<string>=} options
+     * @param {!Array.<string>=} options
      * @return {?string}
      */
     enumNameForValue: function(value, options)
     {
         return null;
     },
 
     /**
-     * @param {!Array.<TypeUtils.InternalResourceStateDescriptor>} descriptors
+     * @param {!Array.<!TypeUtils.InternalResourceStateDescriptor>} descriptors
      * @param {string=} objectGroup
      * @return {!Array.<!CanvasAgent.ResourceStateDescriptor>}
      */
     formatResourceStateDescriptors: function(descriptors, objectGroup)
     {
         var result = [];
         for (var i = 0, n = descriptors.length; i < n; ++i) {
             var d = descriptors[i];
             var item;
             if (d.values)
@@ skipping 41 matching lines @@
     var formatter = CallFormatter._formatters[resource.name()];
     if (!formatter) {
         var contextResource = resource.contextResource();
         formatter = (contextResource && CallFormatter._formatters[contextResource.name()]) || new CallFormatter();
     }
     return formatter;
 }
 
 /**
  * @param {number} resourceId
- * @return {CanvasAgent.ResourceId}
+ * @return {!CanvasAgent.ResourceId}
  */
 CallFormatter.makeStringResourceId = function(resourceId)
 {
     return "{\"injectedScriptId\":" + injectedScriptId + ",\"resourceId\":" + resourceId + "}";
 }
 
 /**
  * @constructor
  * @extends {CallFormatter}
  * @param {!Object.<string, boolean>} drawingMethodNames
@@ skipping 111 matching lines @@
     {
         this._initialize();
         if (name in this._enumNameToValue)
             return "" + this._enumNameToValue[name];
         return null;
     },
 
     /**
      * @override
      * @param {number} value
-     * @param {Array.<string>=} options
+     * @param {!Array.<string>=} options
      * @return {?string}
      */
     enumNameForValue: function(value, options)
     {
         this._initialize();
         options = options || [];
         for (var i = 0, n = options.length; i < n; ++i) {
             if (this._enumNameToValue[options[i]] === value)
                 return options[i];
         }
         var names = this._enumValueToNames[value];
         if (!names || names.length !== 1)
             return null;
         return names[0];
     },
 
     /**
      * @param {!ReplayableCall} replayableCall
-     * @return {Object}
+     * @return {?Object}
      */
     _findEnumsInfo: function(replayableCall)
     {
         function findMaxArgumentIndex(enumsInfo)
         {
             var result = -1;
             var enumArgsIndexes = enumsInfo["enum"] || [];
             for (var i = 0, n = enumArgsIndexes.length; i < n; ++i)
                 result = Math.max(result, enumArgsIndexes[i]);
             var bitfieldArgsIndexes = enumsInfo["bitfield"] || [];
@@ skipping 12 matching lines @@
                 continue;
             // To resolve ambiguity (see texImage2D, texSubImage2D) choose description with max argument indexes.
             if (!result || findMaxArgumentIndex(result) < maxArgumentIndex)
                 result = enumsInfo;
         }
         return result;
     },
 
     /**
      * @param {?CanvasAgent.CallArgument|undefined} callArgument
-     * @param {Array.<string>=} options
+     * @param {!Array.<string>=} options
      */
     _formatEnumValue: function(callArgument, options)
     {
         if (!callArgument || isNaN(callArgument.description))
             return;
         this._initialize();
         var value = +callArgument.description;
         var enumName = this.enumNameForValue(value, options);
         if (enumName)
             callArgument.enumName = enumName;
     },
 
     /**
      * @param {?CanvasAgent.CallArgument|undefined} callArgument
-     * @param {Array.<string>=} options
+     * @param {!Array.<string>=} options
      */
     _formatEnumBitmaskValue: function(callArgument, options)
     {
         if (!callArgument || isNaN(callArgument.description))
             return;
         this._initialize();
         var value = +callArgument.description;
         options = options || [];
         /** @type {!Array.<string>} */
         var result = [];
@@ skipping 23 matching lines @@
     {
         if (this._enumNameToValue)
             return;
 
         /** @type {!Object.<string, number>} */
         this._enumNameToValue = Object.create(null);
         /** @type {!Object.<number, !Array.<string>>} */
         this._enumValueToNames = Object.create(null);
 
         /**
-         * @param {Object} obj
+         * @param {?Object} obj
          * @this WebGLCallFormatter
          */
         function iterateWebGLEnums(obj)
         {
             if (!obj)
                 return;
             for (var property in obj) {
                 if (TypeUtils.isEnumPropertyName(property, obj)) {
                     var value = /** @type {number} */ (obj[property]);
                     this._enumNameToValue[property] = value;
@@ skipping 42 matching lines @@
                 var common = commonSubstring(names);
                 if (common)
                     this._enumValueToNames[value] = [common];
                 else
                     this._enumValueToNames[value] = names.sort();
             }
         }
     },
 
     /**
-     * @return {WebGLRenderingContext}
+     * @return {?WebGLRenderingContext}
      */
     _createUninstrumentedWebGLRenderingContext: function()
     {
-        var canvas = /** @type {HTMLCanvasElement} */ (inspectedWindow.document.createElement("canvas"));
+        var canvas = /** @type {!HTMLCanvasElement} */ (inspectedWindow.document.createElement("canvas"));
         var contextIds = ["experimental-webgl", "webkit-3d", "3d"];
         for (var i = 0, contextId; contextId = contextIds[i]; ++i) {
             var context = canvas.getContext(contextId);
             if (context)
-                return /** @type {WebGLRenderingContext} */ (Resource.wrappedObject(context));
+                return /** @type {!WebGLRenderingContext} */ (Resource.wrappedObject(context));
         }
         return null;
     },
 
     __proto__: CallFormatter.prototype
 }
 
 CallFormatter.register("CanvasRenderingContext2D", new CallFormatter(CanvasRenderingContext2DResource.DrawingMethods));
 CallFormatter.register("WebGLRenderingContext", new WebGLCallFormatter(WebGLRenderingContextResource.DrawingMethods));
 
 /**
  * @constructor
  */
 function TraceLog()
 {
     /** @type {!Array.<!ReplayableCall>} */
     this._replayableCalls = [];
-    /** @type {!Cache.<ReplayableResource>} */
+    /** @type {!Cache.<!ReplayableResource>} */
     this._replayablesCache = new Cache();
     /** @type {!Object.<number, boolean>} */
     this._frameEndCallIndexes = {};
     /** @type {!Object.<number, boolean>} */
     this._resourcesCreatedInThisTraceLog = {};
 }
 
 TraceLog.prototype = {
     /**
      * @return {number}
      */
     size: function()
     {
         return this._replayableCalls.length;
     },
 
     /**
      * @return {!Array.<!ReplayableCall>}
      */
     replayableCalls: function()
     {
         return this._replayableCalls;
     },
 
     /**
      * @param {number} id
-     * @return {ReplayableResource|undefined}
+     * @return {!ReplayableResource|undefined}
      */
     replayableResource: function(id)
     {
         return this._replayablesCache.get(id);
     },
 
     /**
      * @param {number} resourceId
      * @return {boolean}
      */
@@ skipping 41 matching lines @@
 /**
  * @constructor
  * @param {!TraceLog} traceLog
  */
 function TraceLogPlayer(traceLog)
 {
     /** @type {!TraceLog} */
     this._traceLog = traceLog;
     /** @type {number} */
     this._nextReplayStep = 0;
-    /** @type {!Cache.<Resource>} */
+    /** @type {!Cache.<!Resource>} */
     this._replayWorldCache = new Cache();
 }
 
 TraceLogPlayer.prototype = {
     /**
      * @return {!TraceLog}
      */
     traceLog: function()
     {
         return this._traceLog;
     },
 
     /**
      * @param {number} id
-     * @return {Resource|undefined}
+     * @return {!Resource|undefined}
      */
     replayWorldResource: function(id)
     {
         return this._replayWorldCache.get(id);
     },
 
     /**
      * @return {number}
      */
     nextReplayStep: function()
@@ skipping 39 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 18 matching lines @@
 ResourceTrackingManager.prototype = {
     /**
      * @return {boolean}
      */
     capturing: function()
     {
         return this._capturing;
     },
 
     /**
-     * @return {TraceLog}
+     * @return {?TraceLog}
      */
     lastTraceLog: function()
     {
         return this._lastTraceLog;
     },
 
     /**
      * @param {!Resource} resource
      */
     registerResource: function(resource)
     {
         resource.setManager(this);
     },
 
     startCapturing: function()
     {
         if (!this._capturing)
             this._lastTraceLog = new TraceLog();
         this._capturing = true;
         this._stopCapturingOnFrameEnd = false;
     },
 
     /**
-     * @param {TraceLog=} traceLog
+     * @param {!TraceLog=} traceLog
      */
     stopCapturing: function(traceLog)
     {
         if (traceLog && this._lastTraceLog !== traceLog)
             return;
         this._capturing = false;
         this._stopCapturingOnFrameEnd = false;
         if (this._lastTraceLog)
             this._lastTraceLog.addFrameEndMark();
     },
@@ skipping 10 matching lines @@
 
     captureFrame: function()
     {
         this._lastTraceLog = new TraceLog();
         this._capturing = true;
         this._stopCapturingOnFrameEnd = true;
     },
 
     /**
      * @param {!Resource} resource
-     * @param {Array|Arguments} args
+     * @param {!Array|!Arguments} args
      */
     captureArguments: function(resource, args)
     {
         if (!this._capturing)
             return;
         this._lastTraceLog.captureResource(resource);
         for (var i = 0, n = args.length; i < n; ++i) {
             var res = Resource.forObject(args[i]);
             if (res)
                 this._lastTraceLog.captureResource(res);
@@ skipping 22 matching lines @@
 
 /**
  * @constructor
  */
 var InjectedCanvasModule = function()
 {
     /** @type {!ResourceTrackingManager} */
     this._manager = new ResourceTrackingManager();
     /** @type {number} */
     this._lastTraceLogId = 0;
-    /** @type {!Object.<string, TraceLog>} */
+    /** @type {!Object.<string, !TraceLog>} */
     this._traceLogs = {};
-    /** @type {!Object.<string, TraceLogPlayer>} */
+    /** @type {!Object.<string, !TraceLogPlayer>} */
     this._traceLogPlayers = {};
 }
 
 InjectedCanvasModule.prototype = {
     /**
      * @param {!WebGLRenderingContext} glContext
-     * @return {Object}
+     * @return {!Object}
      */
     wrapWebGLContext: function(glContext)
     {
         var resource = Resource.forObject(glContext) || new WebGLRenderingContextResource(glContext);
         this._manager.registerResource(resource);
         return resource.proxyObject();
     },
 
     /**
      * @param {!CanvasRenderingContext2D} context
-     * @return {Object}
+     * @return {!Object}
      */
     wrapCanvas2DContext: function(context)
     {
         var resource = Resource.forObject(context) || new CanvasRenderingContext2DResource(context);
         this._manager.registerResource(resource);
         return resource.proxyObject();
     },
 
     /**
-     * @return {CanvasAgent.TraceLogId}
+     * @return {!CanvasAgent.TraceLogId}
      */
     captureFrame: function()
     {
         return this._callStartCapturingFunction(this._manager.captureFrame);
     },
 
     /**
-     * @return {CanvasAgent.TraceLogId}
+     * @return {!CanvasAgent.TraceLogId}
      */
     startCapturing: function()
     {
         return this._callStartCapturingFunction(this._manager.startCapturing);
     },
 
     markFrameEnd: function()
     {
         this._manager.markFrameEnd();
     },
 
     /**
      * @param {function(this:ResourceTrackingManager)} func
-     * @return {CanvasAgent.TraceLogId}
+     * @return {!CanvasAgent.TraceLogId}
      */
     _callStartCapturingFunction: function(func)
     {
         var oldTraceLog = this._manager.lastTraceLog();
         func.call(this._manager);
-        var traceLog = this._manager.lastTraceLog();
+        var traceLog = /** @type {!TraceLog} */ (this._manager.lastTraceLog());
         if (traceLog === oldTraceLog) {
             for (var id in this._traceLogs) {
                 if (this._traceLogs[id] === traceLog)
                     return id;
             }
         }
         var id = this._makeTraceLogId();
         this._traceLogs[id] = traceLog;
         return id;
     },
 
     /**
-     * @param {CanvasAgent.TraceLogId} id
+     * @param {!CanvasAgent.TraceLogId} id
      */
     stopCapturing: function(id)
     {
         var traceLog = this._traceLogs[id];
         if (traceLog)
             this._manager.stopCapturing(traceLog);
     },
 
     /**
-     * @param {CanvasAgent.TraceLogId} id
+     * @param {!CanvasAgent.TraceLogId} id
      */
     dropTraceLog: function(id)
     {
         var traceLog = this._traceLogs[id];
         if (traceLog)
             this._manager.dropTraceLog(traceLog);
         delete this._traceLogs[id];
         delete this._traceLogPlayers[id];
         injectedScript.releaseObjectGroup(id);
     },
 
     /**
-     * @param {CanvasAgent.TraceLogId} id
+     * @param {!CanvasAgent.TraceLogId} id
      * @param {number=} startOffset
      * @param {number=} maxLength
      * @return {!CanvasAgent.TraceLog|string}
      */
     traceLog: function(id, startOffset, maxLength)
     {
         var traceLog = this._traceLogs[id];
         if (!traceLog)
             return "Error: Trace log with the given ID not found.";
 
@@ skipping 37 matching lines @@
             result.calls.push(item);
             if (!contextIds[item.contextId]) {
                 contextIds[item.contextId] = true;
                 result.contexts.push(CallFormatter.forResource(resource).formatValue(contextResource));
             }
         }
         return result;
     },
 
     /**
-     * @param {CanvasAgent.TraceLogId} traceLogId
+     * @param {!CanvasAgent.TraceLogId} traceLogId
      * @param {number} stepNo
      * @return {{resourceState: !CanvasAgent.ResourceState, replayTime: number}|string}
      */
     replayTraceLog: function(traceLogId, stepNo)
     {
         var traceLog = this._traceLogs[traceLogId];
         if (!traceLog)
             return "Error: Trace log with the given ID not found.";
         this._traceLogPlayers[traceLogId] = this._traceLogPlayers[traceLogId] || new TraceLogPlayer(traceLog);
         injectedScript.releaseObjectGroup(traceLogId);
 
         var replayResult = this._traceLogPlayers[traceLogId].stepTo(stepNo);
         var resource = replayResult.lastCall.resource();
         var dataURL = resource.toDataURL();
         if (!dataURL) {
             resource = resource.contextResource();
             dataURL = resource.toDataURL();
         }
         return {
             resourceState: this._makeResourceState(resource.id(), traceLogId, resource, dataURL),
             replayTime: replayResult.replayTime
         };
     },
 
     /**
-     * @param {CanvasAgent.TraceLogId} traceLogId
-     * @param {CanvasAgent.ResourceId} stringResourceId
+     * @param {!CanvasAgent.TraceLogId} traceLogId
+     * @param {!CanvasAgent.ResourceId} stringResourceId
      * @return {!CanvasAgent.ResourceState|string}
      */
     resourceState: function(traceLogId, stringResourceId)
     {
         var traceLog = this._traceLogs[traceLogId];
         if (!traceLog)
             return "Error: Trace log with the given ID not found.";
 
         var parsedStringId1 = this._parseStringId(traceLogId);
         var parsedStringId2 = this._parseStringId(stringResourceId);
         if (parsedStringId1.injectedScriptId !== parsedStringId2.injectedScriptId)
             return "Error: Both IDs must point to the same injected script.";
 
         var resourceId = parsedStringId2.resourceId;
         if (!resourceId)
             return "Error: Wrong resource ID: " + stringResourceId;
 
         var traceLogPlayer = this._traceLogPlayers[traceLogId];
         var resource = traceLogPlayer && traceLogPlayer.replayWorldResource(resourceId);
         return this._makeResourceState(resourceId, traceLogId, resource);
     },
 
     /**
-     * @param {CanvasAgent.TraceLogId} traceLogId
+     * @param {!CanvasAgent.TraceLogId} traceLogId
      * @param {number} callIndex
      * @param {number} argumentIndex
      * @param {string} objectGroup
      * @return {{result:(!RuntimeAgent.RemoteObject|undefined), resourceState:(!CanvasAgent.ResourceState|undefined)}|string}
      */
     evaluateTraceLogCallArgument: function(traceLogId, callIndex, argumentIndex, objectGroup)
     {
         var traceLog = this._traceLogs[traceLogId];
         if (!traceLog)
             return "Error: Trace log with the given ID not found.";
@@ skipping 19 matching lines @@
             var resource = traceLogPlayer && traceLogPlayer.replayWorldResource(value.id());
             var resourceState = this._makeResourceState(value.id(), traceLogId, resource);
             return { resourceState: resourceState };
         }
 
         var remoteObject = injectedScript.wrapObject(value, objectGroup, true, false);
         return { result: remoteObject };
     },
 
     /**
-     * @return {CanvasAgent.TraceLogId}
+     * @return {!CanvasAgent.TraceLogId}
      */
     _makeTraceLogId: function()
     {
         return "{\"injectedScriptId\":" + injectedScriptId + ",\"traceLogId\":" + (++this._lastTraceLogId) + "}";
     },
 
     /**
      * @param {number} resourceId
-     * @param {CanvasAgent.TraceLogId} traceLogId
-     * @param {Resource|undefined} resource
+     * @param {!CanvasAgent.TraceLogId} traceLogId
+     * @param {?Resource=} resource
      * @param {string=} overrideImageURL
      * @return {!CanvasAgent.ResourceState}
      */
     _makeResourceState: function(resourceId, traceLogId, resource, overrideImageURL)
     {
         var result = {
             id: CallFormatter.makeStringResourceId(resourceId),
             traceLogId: traceLogId
         };
         if (resource) {
@@ skipping 10 matching lines @@
     _parseStringId: function(stringId)
     {
         return InjectedScriptHost.evaluate("(" + stringId + ")");
     }
 }
 
 var injectedCanvasModule = new InjectedCanvasModule();
 return injectedCanvasModule;
 
 })