From 7c8094835cf5727a15120270f3dc4d5a51d29a04 Mon Sep 17 00:00:00 2001 From: James Wright Date: Mon, 31 Aug 2020 17:02:45 -0700 Subject: [PATCH] RELNOTES[INC]: Tighten strictness in Closure Library function in goog.provide files. PiperOrigin-RevId: 329407787 --- closure/goog/color/alpha.js | 25 +++++++++ closure/goog/color/color.js | 42 ++++++++++++++- closure/goog/debug/devcss/devcss.js | 10 +++- closure/goog/debug/devcss/devcssrunner.js | 5 +- .../goog/dom/animationframe/animationframe.js | 5 ++ closure/goog/dom/animationframe/polyfill.js | 8 ++- closure/goog/fx/css3/fx.js | 3 ++ closure/goog/fx/css3/transition.js | 7 +++ closure/goog/i18n/uchar/localnamefetcher.js | 2 + closure/goog/i18n/uchar/remotenamefetcher.js | 9 ++++ .../labs/events/nondisposableeventtarget.js | 15 ++++++ closure/goog/labs/events/touch.js | 2 +- closure/goog/labs/mock/mock.js | 47 ++++++++++++++++- closure/goog/labs/mock/timeoutmode.js | 1 + closure/goog/proto/proto.js | 1 + closure/goog/proto/serializer.js | 2 + closure/goog/testing/proto2/proto2.js | 3 ++ closure/goog/testing/storage/fakemechanism.js | 5 ++ closure/goog/testing/style/layoutasserts.js | 14 +++++ closure/goog/testing/style/style.js | 4 ++ closure/goog/timer/timer.js | 19 ++++++- closure/goog/window/window.js | 4 ++ .../closure/goog/mochikit/async/deferred.js | 52 +++++++++++++++++-- .../goog/mochikit/async/deferredlist.js | 15 +++--- 24 files changed, 281 insertions(+), 19 deletions(-) diff --git a/closure/goog/color/alpha.js b/closure/goog/color/alpha.js index 5fd1bd63d9..0e931006ff 100644 --- a/closure/goog/color/alpha.js +++ b/closure/goog/color/alpha.js @@ -22,6 +22,7 @@ goog.require('goog.color'); * containing the type of color format passed in ('hex', 'rgb', 'named'). */ goog.color.alpha.parse = function(str) { + 'use strict'; var result = {}; str = String(str); @@ -56,6 +57,7 @@ goog.color.alpha.parse = function(str) { * styles. */ goog.color.alpha.hexToRgbaStyle = function(hexColor) { + 'use strict'; return goog.color.alpha.rgbaStyle_(goog.color.alpha.hexToRgba(hexColor)); }; @@ -71,6 +73,7 @@ goog.color.alpha.hexToRgbaStyle = function(hexColor) { * @private */ goog.color.alpha.extractColor_ = function(colorWithAlpha, startIdx, endIdx) { + 'use strict'; if (goog.color.alpha.isValidAlphaHexColor_(colorWithAlpha)) { var fullColor = goog.color.prependHashIfNecessaryHelper(colorWithAlpha); var normalizedColor = goog.color.alpha.normalizeAlphaHex_(fullColor); @@ -88,6 +91,7 @@ goog.color.alpha.extractColor_ = function(colorWithAlpha, startIdx, endIdx) { * @return {string} The hex color where the alpha part has been stripped off. */ goog.color.alpha.extractHexColor = function(colorWithAlpha) { + 'use strict'; return goog.color.alpha.extractColor_(colorWithAlpha, 0, 7); }; @@ -99,6 +103,7 @@ goog.color.alpha.extractHexColor = function(colorWithAlpha) { * @return {string} The two-character alpha from the given color. */ goog.color.alpha.extractAlpha = function(colorWithAlpha) { + 'use strict'; return goog.color.alpha.extractColor_(colorWithAlpha, 7, 9); }; @@ -119,6 +124,7 @@ goog.color.alpha.hexQuadrupletRe_ = /#(.)(.)(.)(.)/; * @private */ goog.color.alpha.normalizeAlphaHex_ = function(hexColor) { + 'use strict'; if (!goog.color.alpha.isValidAlphaHexColor_(hexColor)) { throw new Error('\'' + hexColor + '\' is not a valid alpha hex color'); } @@ -138,6 +144,7 @@ goog.color.alpha.normalizeAlphaHex_ = function(hexColor) { * and 255, and a is a value between 0 and 1. */ goog.color.alpha.hexToRgba = function(hexColor) { + 'use strict'; // TODO(user): Enhance code sharing with goog.color, for example by // adding a goog.color.genericHexToRgb method. hexColor = goog.color.alpha.normalizeAlphaHex_(hexColor); @@ -159,6 +166,7 @@ goog.color.alpha.hexToRgba = function(hexColor) { * @return {string} hex representation of the color. */ goog.color.alpha.rgbaToHex = function(r, g, b, a) { + 'use strict'; var intAlpha = Math.floor(a * 255); if (isNaN(intAlpha) || intAlpha < 0 || intAlpha > 255) { // TODO(user): The CSS spec says the value should be clamped. @@ -180,6 +188,7 @@ goog.color.alpha.rgbaToHex = function(r, g, b, a) { * @return {string} hex representation of the color. */ goog.color.alpha.hslaToHex = function(h, s, l, a) { + 'use strict'; var intAlpha = Math.floor(a * 255); if (isNaN(intAlpha) || intAlpha < 0 || intAlpha > 255) { // TODO(user): The CSS spec says the value should be clamped. @@ -199,6 +208,7 @@ goog.color.alpha.hslaToHex = function(h, s, l, a) { * @return {string} hex representation of the color. */ goog.color.alpha.rgbaArrayToHex = function(rgba) { + 'use strict'; return goog.color.alpha.rgbaToHex(rgba[0], rgba[1], rgba[2], rgba[3]); }; @@ -212,6 +222,7 @@ goog.color.alpha.rgbaArrayToHex = function(rgba) { * @return {string} An 'rgba(r,g,b,a)' string ready for use in a CSS rule. */ goog.color.alpha.rgbaToRgbaStyle = function(r, g, b, a) { + 'use strict'; if (isNaN(r) || r < 0 || r > 255 || isNaN(g) || g < 0 || g > 255 || isNaN(b) || b < 0 || b > 255 || isNaN(a) || a < 0 || a > 1) { throw new Error( @@ -229,6 +240,7 @@ goog.color.alpha.rgbaToRgbaStyle = function(r, g, b, a) { * @return {string} An 'rgba(r,g,b,a)' string ready for use in a CSS rule. */ goog.color.alpha.rgbaArrayToRgbaStyle = function(rgba) { + 'use strict'; return goog.color.alpha.rgbaToRgbaStyle(rgba[0], rgba[1], rgba[2], rgba[3]); }; @@ -240,6 +252,7 @@ goog.color.alpha.rgbaArrayToRgbaStyle = function(rgba) { * @return {string} hex representation of the color, such as '#af457eff'. */ goog.color.alpha.hslaArrayToHex = function(hsla) { + 'use strict'; return goog.color.alpha.hslaToHex(hsla[0], hsla[1], hsla[2], hsla[3]); }; @@ -251,6 +264,7 @@ goog.color.alpha.hslaArrayToHex = function(hsla) { * @return {string} An 'rgba(r,g,b,a)' string ready for use in a CSS rule. */ goog.color.alpha.hslaArrayToRgbaStyle = function(hsla) { + 'use strict'; return goog.color.alpha.hslaToRgbaStyle(hsla[0], hsla[1], hsla[2], hsla[3]); }; @@ -265,6 +279,7 @@ goog.color.alpha.hslaArrayToRgbaStyle = function(hsla) { * styles. */ goog.color.alpha.hslaToRgbaStyle = function(h, s, l, a) { + 'use strict'; return goog.color.alpha.rgbaStyle_(goog.color.alpha.hslaToRgba(h, s, l, a)); }; @@ -279,6 +294,7 @@ goog.color.alpha.hslaToRgbaStyle = function(h, s, l, a) { * are integers in [0, 255] and a is a float in [0, 1]. */ goog.color.alpha.hslaToRgba = function(h, s, l, a) { + 'use strict'; return goog.color.hslToRgb(h, s / 100, l / 100).concat(a); }; @@ -294,6 +310,7 @@ goog.color.alpha.hslaToRgba = function(h, s, l, a) { * [0, 360] and s, l and a in [0, 1]. */ goog.color.alpha.rgbaToHsla = function(r, g, b, a) { + 'use strict'; return goog.color.rgbToHsl(r, g, b).concat(a); }; @@ -306,6 +323,7 @@ goog.color.alpha.rgbaToHsla = function(r, g, b, a) { * [0, 360] and s, l and a in [0, 1]. */ goog.color.alpha.rgbaArrayToHsla = function(rgba) { + 'use strict'; return goog.color.alpha.rgbaToHsla(rgba[0], rgba[1], rgba[2], rgba[3]); }; @@ -327,6 +345,7 @@ goog.color.alpha.validAlphaHexColorRe_ = /^#(?:[0-9a-f]{4}){1,2}$/i; */ // TODO(user): Support percentages when goog.color also supports them. goog.color.alpha.isValidAlphaHexColor_ = function(str) { + 'use strict'; return goog.color.alpha.validAlphaHexColorRe_.test(str); }; @@ -348,6 +367,7 @@ goog.color.alpha.normalizedAlphaHexColorRe_ = /^#[0-9a-f]{8}$/; * @private */ goog.color.alpha.isNormalizedAlphaHexColor_ = function(str) { + 'use strict'; return goog.color.alpha.normalizedAlphaHexColorRe_.test(str); }; @@ -405,6 +425,7 @@ goog.color.alpha.hslaColorRe_ = new RegExp( * @private */ goog.color.alpha.isValidRgbaColor_ = function(str) { + 'use strict'; // Each component is separate (rather than using a repeater) so we can // capture the match. Also, we explicitly set each component to be either 0, // or start with a non-zero, to prevent octal numbers from slipping through. @@ -433,6 +454,7 @@ goog.color.alpha.isValidRgbaColor_ = function(str) { * @private */ goog.color.alpha.isValidHslaColor_ = function(str) { + 'use strict'; // Each component is separate (rather than using a repeater) so we can // capture the match. Also, we explicitly set each component to be either 0, // or start with a non-zero, to prevent octal numbers from slipping through. @@ -461,6 +483,7 @@ goog.color.alpha.isValidHslaColor_ = function(str) { * @private */ goog.color.alpha.rgbaStyle_ = function(rgba) { + 'use strict'; var roundedRgba = rgba.slice(0); roundedRgba[3] = Math.round(rgba[3] * 1000) / 1000; return 'rgba(' + roundedRgba.join(',') + ')'; @@ -476,6 +499,7 @@ goog.color.alpha.rgbaStyle_ = function(rgba) { * @return {string} hex representation of the color. */ goog.color.alpha.hsvaToHex = function(h, s, v, a) { + 'use strict'; var alpha = Math.floor(a * 255); return goog.color.hsvArrayToHex([h, s, v]) + goog.color.prependZeroIfNecessaryHelper(alpha.toString(16)); @@ -489,5 +513,6 @@ goog.color.alpha.hsvaToHex = function(h, s, v, a) { * @return {string} hex representation of the color. */ goog.color.alpha.hsvaArrayToHex = function(hsva) { + 'use strict'; return goog.color.alpha.hsvaToHex(hsva[0], hsva[1], hsva[2], hsva[3]); }; diff --git a/closure/goog/color/color.js b/closure/goog/color/color.js index 06777a3de6..7abb846f28 100644 --- a/closure/goog/color/color.js +++ b/closure/goog/color/color.js @@ -54,6 +54,7 @@ goog.color.Hsl; * of color format passed in ('hex', 'rgb', 'named'). */ goog.color.parse = function(str) { + 'use strict'; var result = {}; str = String(str); @@ -88,6 +89,7 @@ goog.color.parse = function(str) { * @return {boolean} True if str is in a format that can be parsed to a color. */ goog.color.isValidColor = function(str) { + 'use strict'; var maybeHex = goog.color.prependHashIfNecessaryHelper(str); return !!( goog.color.isValidHexColor_(maybeHex) || @@ -104,6 +106,7 @@ goog.color.isValidColor = function(str) { * @return {!goog.color.Rgb} rgb representation of the color. */ goog.color.parseRgb = function(str) { + 'use strict'; var rgb = goog.color.isValidRgbColor_(str); if (!rgb.length) { throw Error(str + ' is not a valid RGB color'); @@ -119,6 +122,7 @@ goog.color.parseRgb = function(str) { * styles. */ goog.color.hexToRgbStyle = function(hexColor) { + 'use strict'; return goog.color.rgbStyle_(goog.color.hexToRgb(hexColor)); }; @@ -138,6 +142,7 @@ goog.color.hexTripletRe_ = /#(.)(.)(.)/; * literals. */ goog.color.normalizeHex = function(hexColor) { + 'use strict'; if (!goog.color.isValidHexColor_(hexColor)) { throw Error("'" + hexColor + "' is not a valid hex color"); } @@ -154,6 +159,7 @@ goog.color.normalizeHex = function(hexColor) { * @return {!goog.color.Rgb} rgb representation of the color. */ goog.color.hexToRgb = function(hexColor) { + 'use strict'; hexColor = goog.color.normalizeHex(hexColor); var rgb = parseInt(hexColor.substr(1), 16); var r = rgb >> 16; @@ -172,6 +178,7 @@ goog.color.hexToRgb = function(hexColor) { * @return {string} hex representation of the color. */ goog.color.rgbToHex = function(r, g, b) { + 'use strict'; r = Number(r); g = Number(g); b = Number(b); @@ -192,6 +199,7 @@ goog.color.rgbToHex = function(r, g, b) { * @return {string} hex representation of the color. */ goog.color.rgbArrayToHex = function(rgb) { + 'use strict'; return goog.color.rgbToHex(rgb[0], rgb[1], rgb[2]); }; @@ -205,6 +213,7 @@ goog.color.rgbArrayToHex = function(rgb) { * @return {!goog.color.Hsl} hsl representation of the color. */ goog.color.rgbToHsl = function(r, g, b) { + 'use strict'; // First must normalize r, g, b to be between 0 and 1. var normR = r / 255; var normG = g / 255; @@ -246,6 +255,7 @@ goog.color.rgbToHsl = function(r, g, b) { * @return {!goog.color.Hsl} hsl representation of the color. */ goog.color.rgbArrayToHsl = function(rgb) { + 'use strict'; return goog.color.rgbToHsl(rgb[0], rgb[1], rgb[2]); }; @@ -259,6 +269,7 @@ goog.color.rgbArrayToHsl = function(rgb) { * @private */ goog.color.hueToRgb_ = function(v1, v2, vH) { + 'use strict'; if (vH < 0) { vH += 1; } else if (vH > 1) { @@ -284,6 +295,7 @@ goog.color.hueToRgb_ = function(v1, v2, vH) { * @return {!goog.color.Rgb} rgb representation of the color. */ goog.color.hslToRgb = function(h, s, l) { + 'use strict'; var r = 0; var g = 0; var b = 0; @@ -315,6 +327,7 @@ goog.color.hslToRgb = function(h, s, l) { * @return {!goog.color.Rgb} rgb representation of the color. */ goog.color.hslArrayToRgb = function(hsl) { + 'use strict'; return goog.color.hslToRgb(hsl[0], hsl[1], hsl[2]); }; @@ -335,6 +348,7 @@ goog.color.validHexColorRe_ = /^#(?:[0-9a-f]{3}){1,2}$/i; * @private */ goog.color.isValidHexColor_ = function(str) { + 'use strict'; return goog.color.validHexColorRe_.test(str); }; @@ -359,6 +373,7 @@ goog.color.rgbColorRe_ = * @private */ goog.color.isValidRgbColor_ = function(str) { + 'use strict'; // Each component is separate (rather than using a repeater) so we can // capture the match. Also, we explicitly set each component to be either 0, // or start with a non-zero, to prevent octal numbers from slipping through. @@ -383,6 +398,7 @@ goog.color.isValidRgbColor_ = function(str) { * otherwise the same value that was passed in. */ goog.color.prependZeroIfNecessaryHelper = function(hex) { + 'use strict'; return hex.length == 1 ? '0' + hex : hex; }; @@ -395,6 +411,7 @@ goog.color.prependZeroIfNecessaryHelper = function(hex) { * already have one. */ goog.color.prependHashIfNecessaryHelper = function(str) { + 'use strict'; return str.charAt(0) == '#' ? str : '#' + str; }; @@ -407,6 +424,7 @@ goog.color.prependHashIfNecessaryHelper = function(str) { * @private */ goog.color.rgbStyle_ = function(rgb) { + 'use strict'; return 'rgb(' + rgb.join(',') + ')'; }; @@ -420,6 +438,7 @@ goog.color.rgbStyle_ = function(rgb) { * @return {!goog.color.Rgb} rgb representation of the color. */ goog.color.hsvToRgb = function(h, s, brightness) { + 'use strict'; var red = 0; var green = 0; var blue = 0; @@ -480,7 +499,7 @@ goog.color.hsvToRgb = function(h, s, brightness) { * @return {!goog.color.Hsv} hsv representation of the color. */ goog.color.rgbToHsv = function(red, green, blue) { - + 'use strict'; var max = Math.max(Math.max(red, green), blue); var min = Math.min(Math.min(red, green), blue); var hue; @@ -519,6 +538,7 @@ goog.color.rgbToHsv = function(red, green, blue) { * @return {!goog.color.Hsv} hsv representation of the color. */ goog.color.rgbArrayToHsv = function(rgb) { + 'use strict'; return goog.color.rgbToHsv(rgb[0], rgb[1], rgb[2]); }; @@ -529,6 +549,7 @@ goog.color.rgbArrayToHsv = function(rgb) { * @return {!goog.color.Rgb} rgb representation of the color. */ goog.color.hsvArrayToRgb = function(hsv) { + 'use strict'; return goog.color.hsvToRgb(hsv[0], hsv[1], hsv[2]); }; @@ -539,6 +560,7 @@ goog.color.hsvArrayToRgb = function(hsv) { * @return {!goog.color.Hsl} hsl representation of the color. */ goog.color.hexToHsl = function(hex) { + 'use strict'; var rgb = goog.color.hexToRgb(hex); return goog.color.rgbToHsl(rgb[0], rgb[1], rgb[2]); }; @@ -552,6 +574,7 @@ goog.color.hexToHsl = function(hex) { * @return {string} hex representation of the color. */ goog.color.hslToHex = function(h, s, l) { + 'use strict'; return goog.color.rgbArrayToHex(goog.color.hslToRgb(h, s, l)); }; @@ -562,6 +585,7 @@ goog.color.hslToHex = function(h, s, l) { * @return {string} hex representation of the color. */ goog.color.hslArrayToHex = function(hsl) { + 'use strict'; return goog.color.rgbArrayToHex(goog.color.hslToRgb(hsl[0], hsl[1], hsl[2])); }; @@ -572,6 +596,7 @@ goog.color.hslArrayToHex = function(hsl) { * @return {!goog.color.Hsv} hsv representation of the color. */ goog.color.hexToHsv = function(hex) { + 'use strict'; return goog.color.rgbArrayToHsv(goog.color.hexToRgb(hex)); }; @@ -584,6 +609,7 @@ goog.color.hexToHsv = function(hex) { * @return {string} hex representation of the color. */ goog.color.hsvToHex = function(h, s, v) { + 'use strict'; return goog.color.rgbArrayToHex(goog.color.hsvToRgb(h, s, v)); }; @@ -594,6 +620,7 @@ goog.color.hsvToHex = function(h, s, v) { * @return {string} hex representation of the color. */ goog.color.hsvArrayToHex = function(hsv) { + 'use strict'; return goog.color.hsvToHex(hsv[0], hsv[1], hsv[2]); }; @@ -610,6 +637,7 @@ goog.color.hsvArrayToHex = function(hsv) { * @return {number} Distance between the two colors, in the range [0, 1]. */ goog.color.hslDistance = function(hsl1, hsl2) { + 'use strict'; var sl1, sl2; if (hsl1[2] <= 0.5) { sl1 = hsl1[1] * hsl1[2]; @@ -642,6 +670,7 @@ goog.color.hslDistance = function(hsl1, hsl2) { * @return {!goog.color.Rgb} Combined color represented in rgb. */ goog.color.blend = function(rgb1, rgb2, factor) { + 'use strict'; factor = goog.math.clamp(factor, 0, 1); return [ @@ -661,6 +690,7 @@ goog.color.blend = function(rgb1, rgb2, factor) { * @return {!goog.color.Rgb} Combined rgb color. */ goog.color.darken = function(rgb, factor) { + 'use strict'; var black = [0, 0, 0]; return goog.color.blend(black, rgb, factor); }; @@ -675,6 +705,7 @@ goog.color.darken = function(rgb, factor) { * @return {!goog.color.Rgb} Combined rgb color. */ goog.color.lighten = function(rgb, factor) { + 'use strict'; var white = [255, 255, 255]; return goog.color.blend(white, rgb, factor); }; @@ -690,6 +721,7 @@ goog.color.lighten = function(rgb, factor) { * @return {!goog.color.Rgb} Highest-contrast color represented by an array.. */ goog.color.highContrast = function(prime, suggestions) { + 'use strict'; var suggestionsWithDiff = []; for (var i = 0; i < suggestions.length; i++) { suggestionsWithDiff.push({ @@ -698,7 +730,10 @@ goog.color.highContrast = function(prime, suggestions) { goog.color.colorDiff_(suggestions[i], prime) }); } - suggestionsWithDiff.sort(function(a, b) { return b.diff - a.diff; }); + suggestionsWithDiff.sort(function(a, b) { + 'use strict'; + return b.diff - a.diff; + }); return suggestionsWithDiff[0].color; }; @@ -712,6 +747,7 @@ goog.color.highContrast = function(prime, suggestions) { * @private */ goog.color.yiqBrightness_ = function(rgb) { + 'use strict'; return Math.round((rgb[0] * 299 + rgb[1] * 587 + rgb[2] * 114) / 1000); }; @@ -725,6 +761,7 @@ goog.color.yiqBrightness_ = function(rgb) { * @private */ goog.color.yiqBrightnessDiff_ = function(rgb1, rgb2) { + 'use strict'; return Math.abs( goog.color.yiqBrightness_(rgb1) - goog.color.yiqBrightness_(rgb2)); }; @@ -739,6 +776,7 @@ goog.color.yiqBrightnessDiff_ = function(rgb1, rgb2) { * @private */ goog.color.colorDiff_ = function(rgb1, rgb2) { + 'use strict'; return Math.abs(rgb1[0] - rgb2[0]) + Math.abs(rgb1[1] - rgb2[1]) + Math.abs(rgb1[2] - rgb2[2]); }; diff --git a/closure/goog/debug/devcss/devcss.js b/closure/goog/debug/devcss/devcss.js index bacd33e965..ea7c792663 100644 --- a/closure/goog/debug/devcss/devcss.js +++ b/closure/goog/debug/devcss/devcss.js @@ -37,6 +37,7 @@ goog.require('goog.userAgent'); * @final */ goog.debug.DevCss = function(opt_userAgent, opt_userAgentVersion) { + 'use strict'; if (!opt_userAgent) { // Walks through the known goog.userAgents. if (goog.userAgent.IE) { @@ -113,6 +114,7 @@ goog.debug.DevCss = function(opt_userAgent, opt_userAgentVersion) { */ goog.debug.DevCss.prototype.activateBrowserSpecificCssRules = function( opt_enableIe6ReadyHandler) { + 'use strict'; var enableIe6EventHandler = (opt_enableIe6ReadyHandler !== undefined) ? opt_enableIe6ReadyHandler : true; @@ -183,6 +185,7 @@ goog.debug.DevCss.CssToken_ = { * @private */ goog.debug.DevCss.prototype.generateUserAgentTokens_ = function() { + 'use strict'; this.userAgentTokens_.ANY = goog.debug.DevCss.CssToken_.USERAGENT + goog.debug.DevCss.CssToken_.SEPARATOR + this.userAgent_; this.userAgentTokens_.EQUALS = @@ -211,6 +214,7 @@ goog.debug.DevCss.prototype.generateUserAgentTokens_ = function() { */ goog.debug.DevCss.prototype.getVersionNumberFromSelectorText_ = function( selectorText, userAgentToken) { + 'use strict'; var regex = new RegExp(userAgentToken + '([\\d\\.]+)'); var matches = regex.exec(selectorText); if (matches && matches.length == 2) { @@ -231,6 +235,7 @@ goog.debug.DevCss.prototype.getVersionNumberFromSelectorText_ = function( */ goog.debug.DevCss.prototype.getRuleVersionAndCompare_ = function( cssRule, token) { + 'use strict'; if (!cssRule.selectorText || !cssRule.selectorText.match(token)) { return; } @@ -256,7 +261,7 @@ goog.debug.DevCss.prototype.getRuleVersionAndCompare_ = function( */ goog.debug.DevCss.prototype.replaceBrowserSpecificClassNames_ = function( cssRule) { - + 'use strict'; // If we don't match the browser token, we can stop now. if (!cssRule.selectorText || !cssRule.selectorText.match(this.userAgentTokens_.ANY)) { @@ -351,6 +356,7 @@ goog.debug.DevCss.prototype.replaceBrowserSpecificClassNames_ = function( * @private */ goog.debug.DevCss.prototype.replaceIe6CombinedSelectors_ = function(cssRule) { + 'use strict'; // This match only ever works in IE because other UA's won't have our // IE6_SELECTOR_TEXT in the cssText property. if (cssRule.style && cssRule.style.cssText && @@ -379,6 +385,7 @@ goog.debug.DevCss.prototype.replaceIe6CombinedSelectors_ = function(cssRule) { * @private */ goog.debug.DevCss.prototype.getIe6CombinedSelectorText_ = function(cssText) { + 'use strict'; var regex = new RegExp( goog.debug.DevCss.CssToken_.IE6_SELECTOR_TEXT + '\\s*:\\s*\\"([^\\"]+)\\"', @@ -413,6 +420,7 @@ goog.debug.DevCss.prototype.getIe6CombinedSelectorText_ = function(cssText) { * @private */ goog.debug.DevCss.prototype.addIe6CombinedClassNames_ = function() { + 'use strict'; if (!this.ie6CombinedMatches_.length) { return; } diff --git a/closure/goog/debug/devcss/devcssrunner.js b/closure/goog/debug/devcss/devcssrunner.js index a7f508ce14..b6d2e72f5b 100644 --- a/closure/goog/debug/devcss/devcssrunner.js +++ b/closure/goog/debug/devcss/devcssrunner.js @@ -13,6 +13,7 @@ goog.provide('goog.debug.devCssRunner'); goog.require('goog.debug.DevCss'); (function() { - var devCssInstance = new goog.debug.DevCss(); - devCssInstance.activateBrowserSpecificCssRules(); +'use strict'; +var devCssInstance = new goog.debug.DevCss(); +devCssInstance.activateBrowserSpecificCssRules(); })(); diff --git a/closure/goog/dom/animationframe/animationframe.js b/closure/goog/dom/animationframe/animationframe.js index ee16c9abb3..436c79a81e 100644 --- a/closure/goog/dom/animationframe/animationframe.js +++ b/closure/goog/dom/animationframe/animationframe.js @@ -150,6 +150,7 @@ goog.dom.animationFrame.running_ = false; * @template THIS */ goog.dom.animationFrame.createTask = function(spec, opt_context) { + 'use strict'; var id = goog.dom.animationFrame.taskId_++; var measureTask = {id: id, fn: spec.measure, context: opt_context}; var mutateTask = {id: id, fn: spec.mutate, context: opt_context}; @@ -163,6 +164,7 @@ goog.dom.animationFrame.createTask = function(spec, opt_context) { }; return function() { + 'use strict'; // Save args and state. if (arguments.length > 0) { // The state argument goes last. That is kinda horrible but compatible @@ -198,6 +200,7 @@ goog.dom.animationFrame.createTask = function(spec, opt_context) { * @private */ goog.dom.animationFrame.runTasks_ = function() { + 'use strict'; goog.dom.animationFrame.running_ = true; goog.dom.animationFrame.requestedFrame_ = false; var tasksArray = goog.dom.animationFrame @@ -248,6 +251,7 @@ goog.dom.animationFrame.runTasks_ = function() { * additional frame. */ goog.dom.animationFrame.isRunning = function() { + 'use strict'; return goog.dom.animationFrame.running_; }; @@ -258,6 +262,7 @@ goog.dom.animationFrame.isRunning = function() { * @private */ goog.dom.animationFrame.requestAnimationFrame_ = function() { + 'use strict'; if (goog.dom.animationFrame.requestedFrame_) { return; } diff --git a/closure/goog/dom/animationframe/polyfill.js b/closure/goog/dom/animationframe/polyfill.js index b30f7f5a2b..7da0e39137 100644 --- a/closure/goog/dom/animationframe/polyfill.js +++ b/closure/goog/dom/animationframe/polyfill.js @@ -24,6 +24,7 @@ goog.dom.animationFrame.polyfill.ENABLED = * Installs the requestAnimationFrame (and cancelAnimationFrame) polyfill. */ goog.dom.animationFrame.polyfill.install = function() { + 'use strict'; if (goog.dom.animationFrame.polyfill.ENABLED) { const vendors = ['ms', 'moz', 'webkit', 'o']; let v; @@ -38,16 +39,21 @@ goog.dom.animationFrame.polyfill.install = function() { if (!goog.global.requestAnimationFrame) { let lastTime = 0; goog.global.requestAnimationFrame = function(callback) { + 'use strict'; const currTime = new Date().getTime(); const timeToCall = Math.max(0, 16 - (currTime - lastTime)); lastTime = currTime + timeToCall; return goog.global.setTimeout(function() { + 'use strict'; callback(currTime + timeToCall); }, timeToCall); }; if (!goog.global.cancelAnimationFrame) { - goog.global.cancelAnimationFrame = function(id) { clearTimeout(id); }; + goog.global.cancelAnimationFrame = function(id) { + 'use strict'; + clearTimeout(id); + }; } } } diff --git a/closure/goog/fx/css3/fx.js b/closure/goog/fx/css3/fx.js index 45ff61df4d..907b9fd36a 100644 --- a/closure/goog/fx/css3/fx.js +++ b/closure/goog/fx/css3/fx.js @@ -25,6 +25,7 @@ goog.require('goog.fx.css3.Transition'); */ goog.fx.css3.fade = function( element, duration, timing, startOpacity, endOpacity) { + 'use strict'; return new goog.fx.css3.Transition( element, duration, {'opacity': startOpacity}, {'opacity': endOpacity}, {property: 'opacity', duration: duration, timing: timing, delay: 0}); @@ -38,6 +39,7 @@ goog.fx.css3.fade = function( * @return {!goog.fx.css3.Transition} The transition object. */ goog.fx.css3.fadeIn = function(element, duration) { + 'use strict'; return goog.fx.css3.fade(element, duration, 'ease-out', 0, 1); }; @@ -49,5 +51,6 @@ goog.fx.css3.fadeIn = function(element, duration) { * @return {!goog.fx.css3.Transition} The transition object. */ goog.fx.css3.fadeOut = function(element, duration) { + 'use strict'; return goog.fx.css3.fade(element, duration, 'ease-in', 1, 0); }; diff --git a/closure/goog/fx/css3/transition.js b/closure/goog/fx/css3/transition.js index ce9014249f..2780d9c9bb 100644 --- a/closure/goog/fx/css3/transition.js +++ b/closure/goog/fx/css3/transition.js @@ -63,6 +63,7 @@ goog.require('goog.style.transition'); */ goog.fx.css3.Transition = function( element, duration, initialStyle, finalStyle, transitions) { + 'use strict'; goog.fx.css3.Transition.base(this, 'constructor'); /** @@ -106,6 +107,7 @@ goog.inherits(goog.fx.css3.Transition, goog.fx.TransitionBase); /** @override */ goog.fx.css3.Transition.prototype.play = function() { + 'use strict'; if (this.isPlaying()) { return false; } @@ -134,6 +136,7 @@ goog.fx.css3.Transition.prototype.play = function() { * @private */ goog.fx.css3.Transition.prototype.play_ = function() { + 'use strict'; // This measurement of the DOM element causes the browser to recalculate its // initial state before the transition starts. goog.style.getSize(this.element_); @@ -146,6 +149,7 @@ goog.fx.css3.Transition.prototype.play_ = function() { /** @override */ goog.fx.css3.Transition.prototype.stop = function() { + 'use strict'; if (!this.isPlaying()) return; this.stop_(true); @@ -158,6 +162,7 @@ goog.fx.css3.Transition.prototype.stop = function() { * @private */ goog.fx.css3.Transition.prototype.stop_ = function(stopped) { + 'use strict'; goog.style.transition.removeAll(this.element_); // Clear the timer. @@ -180,6 +185,7 @@ goog.fx.css3.Transition.prototype.stop_ = function(stopped) { /** @override */ goog.fx.css3.Transition.prototype.disposeInternal = function() { + 'use strict'; this.stop(); goog.fx.css3.Transition.base(this, 'disposeInternal'); }; @@ -190,5 +196,6 @@ goog.fx.css3.Transition.prototype.disposeInternal = function() { * @override */ goog.fx.css3.Transition.prototype.pause = function() { + 'use strict'; goog.asserts.assert(false, 'Css3 transitions does not support pause action.'); }; diff --git a/closure/goog/i18n/uchar/localnamefetcher.js b/closure/goog/i18n/uchar/localnamefetcher.js index d2dbf3a38c..f0d2a49b82 100644 --- a/closure/goog/i18n/uchar/localnamefetcher.js +++ b/closure/goog/i18n/uchar/localnamefetcher.js @@ -48,6 +48,7 @@ goog.i18n.uChar.LocalNameFetcher.prototype.prefetch = function(character) {}; /** @override */ goog.i18n.uChar.LocalNameFetcher.prototype.getName = function( character, callback) { + 'use strict'; var localName = goog.i18n.uCharNames.toName(character); if (!localName) { goog.log.warning( @@ -61,5 +62,6 @@ goog.i18n.uChar.LocalNameFetcher.prototype.getName = function( /** @override */ goog.i18n.uChar.LocalNameFetcher.prototype.isNameAvailable = function( character) { + 'use strict'; return !!goog.i18n.uCharNames.toName(character); }; diff --git a/closure/goog/i18n/uchar/remotenamefetcher.js b/closure/goog/i18n/uchar/remotenamefetcher.js index 822aa9a893..5e01faa82b 100644 --- a/closure/goog/i18n/uchar/remotenamefetcher.js +++ b/closure/goog/i18n/uchar/remotenamefetcher.js @@ -46,6 +46,7 @@ goog.require('goog.net.XhrIo'); * @final */ goog.i18n.uChar.RemoteNameFetcher = function(dataSourceUri) { + 'use strict'; goog.i18n.uChar.RemoteNameFetcher.base(this, 'constructor'); /** @@ -113,6 +114,7 @@ goog.i18n.uChar.RemoteNameFetcher.logger_ = /** @override */ goog.i18n.uChar.RemoteNameFetcher.prototype.disposeInternal = function() { + 'use strict'; goog.i18n.uChar.RemoteNameFetcher.base(this, 'disposeInternal'); this.prefetchXhrIo_.dispose(); this.getNameXhrIo_.dispose(); @@ -121,6 +123,7 @@ goog.i18n.uChar.RemoteNameFetcher.prototype.disposeInternal = function() { /** @override */ goog.i18n.uChar.RemoteNameFetcher.prototype.prefetch = function(characters) { + 'use strict'; // Abort the current request if there is one if (this.prefetchXhrIo_.isActive()) { goog.log.info( @@ -149,6 +152,7 @@ goog.i18n.uChar.RemoteNameFetcher.prototype.prefetch = function(characters) { * @private */ goog.i18n.uChar.RemoteNameFetcher.prototype.prefetchCallback_ = function() { + 'use strict'; this.processResponse_(this.prefetchXhrIo_); }; @@ -156,6 +160,7 @@ goog.i18n.uChar.RemoteNameFetcher.prototype.prefetchCallback_ = function() { /** @override */ goog.i18n.uChar.RemoteNameFetcher.prototype.getName = function( character, callback) { + 'use strict'; var codepoint = goog.i18n.uChar.toCharCode(character).toString(16); if (this.charNames_.has(codepoint)) { @@ -199,6 +204,7 @@ goog.i18n.uChar.RemoteNameFetcher.prototype.getName = function( */ goog.i18n.uChar.RemoteNameFetcher.prototype.getNameCallback_ = function( codepoint, callback) { + 'use strict'; this.processResponse_(this.getNameXhrIo_); var name = this.charNames_.has(codepoint) ? this.charNames_.get(codepoint) : null; @@ -213,6 +219,7 @@ goog.i18n.uChar.RemoteNameFetcher.prototype.getNameCallback_ = function( * @private */ goog.i18n.uChar.RemoteNameFetcher.prototype.processResponse_ = function(xhrIo) { + 'use strict'; if (!xhrIo.isSuccess()) { goog.log.error( goog.i18n.uChar.RemoteNameFetcher.logger_, @@ -263,6 +270,7 @@ goog.i18n.uChar.RemoteNameFetcher.RequestType_ = { */ goog.i18n.uChar.RemoteNameFetcher.prototype.fetch_ = function( requestType, requestInput, xhrIo) { + 'use strict'; var url = new goog.Uri(this.dataSourceUri_); url.setParameterValue(requestType, requestInput); url.setParameterValue('p', 'name'); @@ -275,5 +283,6 @@ goog.i18n.uChar.RemoteNameFetcher.prototype.fetch_ = function( /** @override */ goog.i18n.uChar.RemoteNameFetcher.prototype.isNameAvailable = function( character) { + 'use strict'; return true; }; diff --git a/closure/goog/labs/events/nondisposableeventtarget.js b/closure/goog/labs/events/nondisposableeventtarget.js index ded0173f77..33b9dff10d 100644 --- a/closure/goog/labs/events/nondisposableeventtarget.js +++ b/closure/goog/labs/events/nondisposableeventtarget.js @@ -59,6 +59,7 @@ goog.require('goog.object'); * @final */ goog.labs.events.NonDisposableEventTarget = function() { + 'use strict'; /** * Maps of event type to an array of listeners. * @private {!goog.events.ListenerMap} @@ -88,6 +89,7 @@ goog.labs.events.NonDisposableEventTarget.prototype.parentEventTarget_ = null; /** @override */ goog.labs.events.NonDisposableEventTarget.prototype.getParentEventTarget = function() { + 'use strict'; return this.parentEventTarget_; }; @@ -99,6 +101,7 @@ goog.labs.events.NonDisposableEventTarget.prototype.getParentEventTarget = */ goog.labs.events.NonDisposableEventTarget.prototype.setParentEventTarget = function(parent) { + 'use strict'; this.parentEventTarget_ = parent; }; @@ -106,6 +109,7 @@ goog.labs.events.NonDisposableEventTarget.prototype.setParentEventTarget = /** @override */ goog.labs.events.NonDisposableEventTarget.prototype.dispatchEvent = function( e) { + 'use strict'; this.assertInitialized_(); var ancestorsTree, ancestor = this.getParentEventTarget(); if (ancestor) { @@ -128,6 +132,7 @@ goog.labs.events.NonDisposableEventTarget.prototype.dispatchEvent = function( /** @override */ goog.labs.events.NonDisposableEventTarget.prototype.listen = function( type, listener, opt_useCapture, opt_listenerScope) { + 'use strict'; this.assertInitialized_(); return this.eventTargetListeners_.add( String(type), listener, false /* callOnce */, opt_useCapture, @@ -138,6 +143,7 @@ goog.labs.events.NonDisposableEventTarget.prototype.listen = function( /** @override */ goog.labs.events.NonDisposableEventTarget.prototype.listenOnce = function( type, listener, opt_useCapture, opt_listenerScope) { + 'use strict'; return this.eventTargetListeners_.add( String(type), listener, true /* callOnce */, opt_useCapture, opt_listenerScope); @@ -147,6 +153,7 @@ goog.labs.events.NonDisposableEventTarget.prototype.listenOnce = function( /** @override */ goog.labs.events.NonDisposableEventTarget.prototype.unlisten = function( type, listener, opt_useCapture, opt_listenerScope) { + 'use strict'; return this.eventTargetListeners_.remove( String(type), listener, opt_useCapture, opt_listenerScope); }; @@ -155,6 +162,7 @@ goog.labs.events.NonDisposableEventTarget.prototype.unlisten = function( /** @override */ goog.labs.events.NonDisposableEventTarget.prototype.unlistenByKey = function( key) { + 'use strict'; return this.eventTargetListeners_.removeByKey(key); }; @@ -162,6 +170,7 @@ goog.labs.events.NonDisposableEventTarget.prototype.unlistenByKey = function( /** @override */ goog.labs.events.NonDisposableEventTarget.prototype.removeAllListeners = function(opt_type) { + 'use strict'; return this.eventTargetListeners_.removeAll(opt_type); }; @@ -169,6 +178,7 @@ goog.labs.events.NonDisposableEventTarget.prototype.removeAllListeners = /** @override */ goog.labs.events.NonDisposableEventTarget.prototype.fireListeners = function( type, capture, eventObject) { + 'use strict'; // TODO(chrishenry): Original code avoids array creation when there // is no listener, so we do the same. If this optimization turns // out to be not required, we can replace this with @@ -201,6 +211,7 @@ goog.labs.events.NonDisposableEventTarget.prototype.fireListeners = function( /** @override */ goog.labs.events.NonDisposableEventTarget.prototype.getListeners = function( type, capture) { + 'use strict'; return this.eventTargetListeners_.getListeners(String(type), capture); }; @@ -208,6 +219,7 @@ goog.labs.events.NonDisposableEventTarget.prototype.getListeners = function( /** @override */ goog.labs.events.NonDisposableEventTarget.prototype.getListener = function( type, listener, capture, opt_listenerScope) { + 'use strict'; return this.eventTargetListeners_.getListener( String(type), listener, capture, opt_listenerScope); }; @@ -216,6 +228,7 @@ goog.labs.events.NonDisposableEventTarget.prototype.getListener = function( /** @override */ goog.labs.events.NonDisposableEventTarget.prototype.hasListener = function( opt_type, opt_capture) { + 'use strict'; var id = (opt_type !== undefined) ? String(opt_type) : undefined; return this.eventTargetListeners_.hasListener(id, opt_capture); }; @@ -227,6 +240,7 @@ goog.labs.events.NonDisposableEventTarget.prototype.hasListener = function( */ goog.labs.events.NonDisposableEventTarget.prototype.assertInitialized_ = function() { + 'use strict'; goog.asserts.assert( this.eventTargetListeners_, 'Event target is not initialized. Did you call the superclass ' + @@ -251,6 +265,7 @@ goog.labs.events.NonDisposableEventTarget.prototype.assertInitialized_ = */ goog.labs.events.NonDisposableEventTarget.dispatchEventInternal_ = function( target, e, opt_ancestorsTree) { + 'use strict'; var type = e.type || /** @type {string} */ (e); // If accepting a string or object, create a custom event object so that diff --git a/closure/goog/labs/events/touch.js b/closure/goog/labs/events/touch.js index 6a1161507f..e3ab840255 100644 --- a/closure/goog/labs/events/touch.js +++ b/closure/goog/labs/events/touch.js @@ -39,7 +39,7 @@ goog.labs.events.touch.TouchData; * @return {!goog.labs.events.touch.TouchData} */ goog.labs.events.touch.getTouchData = function(e) { - + 'use strict'; var source = e; goog.asserts.assert( goog.string.startsWith(e.type, 'touch') || diff --git a/closure/goog/labs/mock/mock.js b/closure/goog/labs/mock/mock.js index 0df9c67e18..c3940fc73e 100644 --- a/closure/goog/labs/mock/mock.js +++ b/closure/goog/labs/mock/mock.js @@ -44,6 +44,7 @@ goog.setTestOnly('goog.labs.mock'); * @return {!Object} The mocked object. */ goog.labs.mock.mock = function(objectOrClass) { + 'use strict'; // Go over properties of 'objectOrClass' and create a MockManager to // be used for stubbing out calls to methods. var mockObjectManager = new goog.labs.mock.MockObjectManager_(objectOrClass); @@ -60,6 +61,7 @@ goog.labs.mock.mock = function(objectOrClass) { * @return {!Function} The mocked function. */ goog.labs.mock.mockFunction = function(func) { + 'use strict'; var mockFuncManager = new goog.labs.mock.MockFunctionManager_(func); var mockedFunction = mockFuncManager.getMockedItem(); goog.asserts.assertFunction(mockedFunction); @@ -75,6 +77,7 @@ goog.labs.mock.mockFunction = function(func) { * @template T */ goog.labs.mock.mockConstructor = function(ctor) { + 'use strict'; var mockCtor = goog.labs.mock.mockFunction(ctor); // Copy class members from the real constructor to the mock. Do not copy @@ -97,6 +100,7 @@ goog.labs.mock.mockConstructor = function(ctor) { * @return {!Object} The spy object. */ goog.labs.mock.spy = function(obj) { + 'use strict'; // Go over properties of 'obj' and create a MockSpyManager_ to // be used for spying on calls to methods. var mockSpyManager = new goog.labs.mock.MockSpyManager_(obj); @@ -116,6 +120,7 @@ goog.labs.mock.spy = function(obj) { * @suppress {strictMissingProperties} Part of the go/strict_warnings_migration */ goog.labs.mock.verify = function(obj, opt_verificationMode) { + 'use strict'; var mode = opt_verificationMode || goog.labs.mock.verification.atLeast(1); obj.$verificationModeSetter(mode); @@ -157,6 +162,7 @@ goog.labs.mock.waitAndVerify = function(obj, ...verificationOrTimeoutModes) { * @return {string} The function name. */ goog.labs.mock.getFunctionName_ = function(func) { + 'use strict'; var funcName = goog.debug.getFunctionName(func); if (funcName == '' || funcName == '[Anonymous]') { funcName = '#anonymous' + goog.labs.mock.getUid(func); @@ -173,8 +179,10 @@ goog.labs.mock.getFunctionName_ = function(func) { * @return {string} The string representation of the method call. */ goog.labs.mock.formatMethodCall_ = function(methodName, opt_args) { + 'use strict'; opt_args = opt_args || []; opt_args = goog.array.map(opt_args, function(arg) { + 'use strict'; if (goog.isFunction(arg)) { var funcName = goog.labs.mock.getFunctionName_(arg); return ''; @@ -207,6 +215,7 @@ goog.labs.mock.uid_ = []; * @return {number} an unique id for the object. */ goog.labs.mock.getUid = function(obj) { + 'use strict'; var index = goog.array.indexOf(goog.labs.mock.uid_, obj); if (index == -1) { index = goog.labs.mock.uid_.length; @@ -226,12 +235,15 @@ goog.labs.mock.getUid = function(obj) { * @return {string} The string representation of the object. */ goog.labs.mock.formatValue_ = function(obj, opt_id) { + 'use strict'; var id = (opt_id !== undefined) ? opt_id : true; var previous = []; var output = []; var helper = function(obj) { + 'use strict'; var indentMultiline = function(output) { + 'use strict'; return output.replace(/\n/g, '\n'); }; @@ -300,6 +312,7 @@ goog.labs.mock.formatValue_ = function(obj, opt_id) { */ goog.labs.mock.VerificationError = function( recordedCalls, methodName, verificationMode, args) { + 'use strict'; var msg = goog.labs.mock.VerificationError.getVerificationErrorMsg_( recordedCalls, methodName, verificationMode, args); goog.labs.mock.VerificationError.base(this, 'constructor', msg); @@ -325,6 +338,7 @@ goog.labs.mock.VerificationError.prototype.name = 'VerificationError'; */ goog.labs.mock.TimeoutError = function( recordedCalls, methodName, verificationMode, args) { + 'use strict'; var msg = goog.labs.mock.TimeoutError.getTimeoutErrorMsg_( recordedCalls, methodName, verificationMode, args); goog.labs.mock.TimeoutError.base(this, 'constructor', msg); @@ -361,8 +375,9 @@ goog.labs.mock.PROTOTYPE_FIELDS_ = [ */ goog.labs.mock.VerificationError.getVerificationErrorMsg_ = function( recordedCalls, methodName, verificationMode, args) { - + 'use strict'; recordedCalls = goog.array.filter(recordedCalls, function(binding) { + 'use strict'; return binding.getMethodName() == methodName; }); @@ -395,6 +410,7 @@ goog.labs.mock.VerificationError.getVerificationErrorMsg_ = function( */ goog.labs.mock.TimeoutError.getTimeoutErrorMsg_ = function( recordedCalls, methodName, verificationMode, args) { + 'use strict'; var verificationErrorMsg = goog.labs.mock.VerificationError.getVerificationErrorMsg_( recordedCalls, methodName, verificationMode, args); @@ -417,6 +433,7 @@ goog.labs.mock.TimeoutError.getTimeoutErrorMsg_ = function( * @private */ goog.labs.mock.MockManager_ = function() { + 'use strict'; /** * Proxies the methods for the mocked object or class to execute the stubs. * @type {!Object} @@ -482,6 +499,7 @@ goog.labs.mock.MockManager_ = function() { */ goog.labs.mock.MockManager_.prototype.setVerificationMode_ = function( verificationMode) { + 'use strict'; this.verificationMode_ = verificationMode; }; @@ -493,6 +511,7 @@ goog.labs.mock.MockManager_.prototype.setVerificationMode_ = function( * @private */ goog.labs.mock.MockManager_.prototype.setTimeoutMode_ = function(timeoutMode) { + 'use strict'; this.timeoutMode_ = timeoutMode; }; @@ -507,6 +526,7 @@ goog.labs.mock.MockManager_.prototype.setTimeoutMode_ = function(timeoutMode) { */ goog.labs.mock.MockManager_.prototype.handleMockCall_ = function( methodName, var_args) { + 'use strict'; var args = goog.array.slice(arguments, 1); return new goog.labs.mock.StubBinderImpl_(this, methodName, args); }; @@ -519,6 +539,7 @@ goog.labs.mock.MockManager_.prototype.handleMockCall_ = function( * @return {!Object|!Function} The mock object. */ goog.labs.mock.MockManager_.prototype.getMockedItem = function() { + 'use strict'; return this.mockedItem; }; @@ -534,6 +555,7 @@ goog.labs.mock.MockManager_.prototype.getMockedItem = function() { */ goog.labs.mock.MockManager_.prototype.addBinding = function( methodName, args, func) { + 'use strict'; var binding = new goog.labs.mock.MethodBinding_(methodName, args, func); var sequentialStubsArray = [binding]; goog.array.insertAt(this.methodBindings, sequentialStubsArray, 0); @@ -557,7 +579,9 @@ goog.labs.mock.MockManager_.prototype.addBinding = function( */ goog.labs.mock.MockManager_.prototype.getNextBinding = function( methodName, args) { + 'use strict'; var bindings = goog.array.find(this.methodBindings, function(bindingArray) { + 'use strict'; return bindingArray[0].matches( methodName, args, false /* isVerification */); }); @@ -582,6 +606,7 @@ goog.labs.mock.MockManager_.prototype.getNextBinding = function( * @protected */ goog.labs.mock.MockManager_.prototype.getExecutor = function(methodName, args) { + 'use strict'; return this.getNextBinding(methodName, args); }; @@ -597,6 +622,7 @@ goog.labs.mock.MockManager_.prototype.getExecutor = function(methodName, args) { */ goog.labs.mock.MockManager_.prototype.executeStub = function( methodName, var_args) { + 'use strict'; var args = goog.array.slice(arguments, 1); var callRecord = this.recordCall_(methodName, args); @@ -623,6 +649,7 @@ goog.labs.mock.MockManager_.prototype.executeStub = function( * @private */ goog.labs.mock.MockManager_.prototype.recordCall_ = function(methodName, args) { + 'use strict'; var callRecord = new goog.labs.mock.MethodBinding_(methodName, args, goog.nullFunction); @@ -640,8 +667,10 @@ goog.labs.mock.MockManager_.prototype.recordCall_ = function(methodName, args) { */ goog.labs.mock.MockManager_.prototype.verifyInvocation = function( methodName, var_args) { + 'use strict'; var args = goog.array.slice(arguments, 1); var count = goog.array.count(this.callRecords_, function(binding) { + 'use strict'; return binding.matches(methodName, args, true /* isVerification */); }); @@ -719,6 +748,7 @@ goog.labs.mock.MockManager_.prototype.waitForCall = function( * go/strict_warnings_migration */ goog.labs.mock.MockObjectManager_ = function(objOrClass) { + 'use strict'; goog.labs.mock.MockObjectManager_.base(this, 'constructor'); /** @@ -828,6 +858,7 @@ goog.inherits(goog.labs.mock.MockObjectManager_, goog.labs.mock.MockManager_); * @private */ goog.labs.mock.MockSpyManager_ = function(obj) { + 'use strict'; goog.labs.mock.MockSpyManager_.base(this, 'constructor', obj); }; goog.inherits( @@ -844,6 +875,7 @@ goog.inherits( */ goog.labs.mock.MockSpyManager_.prototype.getNextBinding = function( methodName, args) { + 'use strict'; var stub = goog.labs.mock.MockSpyManager_.base( this, 'getNextBinding', methodName, args); @@ -869,6 +901,7 @@ goog.labs.mock.MockSpyManager_.prototype.getNextBinding = function( * go/strict_warnings_migration */ goog.labs.mock.MockFunctionManager_ = function(func) { + 'use strict'; goog.labs.mock.MockFunctionManager_.base(this, 'constructor'); this.func_ = func; @@ -918,9 +951,11 @@ goog.inherits(goog.labs.mock.MockFunctionManager_, goog.labs.mock.MockManager_); */ goog.labs.mock.MockFunctionManager_.prototype.useMockedFunctionName_ = function( nextFunc) { + 'use strict'; var mockFunctionManager = this; // Avoid using 'this' because this function may be called with 'new'. return function(var_args) { + 'use strict'; var args = goog.array.clone(arguments); var name = '#mockFor<' + goog.labs.mock.getFunctionName_(mockFunctionManager.func_) + '>'; @@ -980,6 +1015,7 @@ goog.labs.mock.StubBinder.prototype.thenReturn = goog.abstractMethod; * @private @constructor @struct @final */ goog.labs.mock.StubBinderImpl_ = function(mockManager, name, args) { + 'use strict'; /** * The mock manager instance. * @type {!goog.labs.mock.MockManager_} @@ -1014,6 +1050,7 @@ goog.labs.mock.StubBinderImpl_ = function(mockManager, name, args) { * @override */ goog.labs.mock.StubBinderImpl_.prototype.then = function(func) { + 'use strict'; if (this.sequentialStubsArray_.length) { this.sequentialStubsArray_.push( new goog.labs.mock.MethodBinding_(this.name_, this.args_, func)); @@ -1029,6 +1066,7 @@ goog.labs.mock.StubBinderImpl_.prototype.then = function(func) { * @override */ goog.labs.mock.StubBinderImpl_.prototype.thenReturn = function(value) { + 'use strict'; return this.then(goog.functions.constant(value)); }; @@ -1061,6 +1099,7 @@ goog.labs.mock.StubBinderImpl_.prototype.thenReturn = function(value) { * go/strict_warnings_migration */ goog.labs.mock.when = function(mockObject) { + 'use strict'; goog.asserts.assert(mockObject.$stubBinder, 'Stub binder cannot be null!'); return mockObject.$stubBinder; }; @@ -1079,6 +1118,7 @@ goog.labs.mock.when = function(mockObject) { * @private */ goog.labs.mock.MethodBinding_ = function(methodName, args, stub) { + 'use strict'; /** * The name of the method being stubbed. * @type {?string} @@ -1106,6 +1146,7 @@ goog.labs.mock.MethodBinding_ = function(methodName, args, stub) { * @return {!Function} The stub to be executed. */ goog.labs.mock.MethodBinding_.prototype.getStub = function() { + 'use strict'; return this.stub_; }; @@ -1116,6 +1157,7 @@ goog.labs.mock.MethodBinding_.prototype.getStub = function() { * as a method call. */ goog.labs.mock.MethodBinding_.prototype.toString = function() { + 'use strict'; return goog.labs.mock.formatMethodCall_(this.methodName_ || '', this.args_); }; @@ -1124,6 +1166,7 @@ goog.labs.mock.MethodBinding_.prototype.toString = function() { * @return {string} The method name for this binding. */ goog.labs.mock.MethodBinding_.prototype.getMethodName = function() { + 'use strict'; return this.methodName_ || ''; }; @@ -1140,6 +1183,7 @@ goog.labs.mock.MethodBinding_.prototype.getMethodName = function() { */ goog.labs.mock.MethodBinding_.prototype.matches = function( methodName, args, isVerification) { + 'use strict'; var specs = isVerification ? args : this.args_; var calls = isVerification ? this.args_ : args; @@ -1147,6 +1191,7 @@ goog.labs.mock.MethodBinding_.prototype.matches = function( // objects. return this.methodName_ == methodName && goog.array.equals(calls, specs, function(arg, spec) { + 'use strict'; // Duck-type to see if this is an object that implements the // goog.labs.testing.Matcher interface. if (spec && goog.isFunction(spec.matches)) { diff --git a/closure/goog/labs/mock/timeoutmode.js b/closure/goog/labs/mock/timeoutmode.js index 1f99c6b709..243707ee48 100644 --- a/closure/goog/labs/mock/timeoutmode.js +++ b/closure/goog/labs/mock/timeoutmode.js @@ -38,5 +38,6 @@ goog.labs.mock.timeout.TimeoutMode = class TimeoutMode { * @return {!goog.labs.mock.timeout.TimeoutMode} */ goog.labs.mock.timeout.timeout = function(duration) { + 'use strict'; return new goog.labs.mock.timeout.TimeoutMode(duration); }; diff --git a/closure/goog/proto/proto.js b/closure/goog/proto/proto.js index fdebaaa20f..a55b3665ab 100644 --- a/closure/goog/proto/proto.js +++ b/closure/goog/proto/proto.js @@ -28,6 +28,7 @@ goog.proto.serializer_ = null; * @return {string} The serialized protocol buffer string. */ goog.proto.serialize = function(object) { + 'use strict'; if (!goog.proto.serializer_) { goog.proto.serializer_ = new goog.proto.Serializer; } diff --git a/closure/goog/proto/serializer.js b/closure/goog/proto/serializer.js index 67e1351869..e7f26df0fb 100644 --- a/closure/goog/proto/serializer.js +++ b/closure/goog/proto/serializer.js @@ -27,6 +27,7 @@ goog.require('goog.string'); * @final */ goog.proto.Serializer = function() { + 'use strict'; goog.json.Serializer.call(this); }; goog.inherits(goog.proto.Serializer, goog.json.Serializer); @@ -40,6 +41,7 @@ goog.inherits(goog.proto.Serializer, goog.json.Serializer); * @override */ goog.proto.Serializer.prototype.serializeArray = function(arr, sb) { + 'use strict'; var l = arr.length; sb.push('['); var emptySlots = 0; diff --git a/closure/goog/testing/proto2/proto2.js b/closure/goog/testing/proto2/proto2.js index 12682aea59..acd907035f 100644 --- a/closure/goog/testing/proto2/proto2.js +++ b/closure/goog/testing/proto2/proto2.js @@ -26,6 +26,7 @@ goog.require('goog.testing.asserts'); * @private */ goog.testing.proto2.findDifferences_ = function(expected, actual, path) { + 'use strict'; var fields = expected.getDescriptor().getFields(); for (var i = 0; i < fields.length; i++) { var field = fields[i]; @@ -101,6 +102,7 @@ goog.testing.proto2.findDifferences_ = function(expected, actual, path) { */ goog.testing.proto2.assertEquals = function( expected, actual, opt_failureMessage) { + 'use strict'; var failureSummary = opt_failureMessage || ''; if (!(expected instanceof goog.proto2.Message) || !(actual instanceof goog.proto2.Message)) { @@ -130,6 +132,7 @@ goog.testing.proto2.assertEquals = function( * @template MessageType */ goog.testing.proto2.fromObject = function(messageCtor, json) { + 'use strict'; var serializer = new goog.proto2.ObjectSerializer( goog.proto2.ObjectSerializer.KeyOption.NAME); var message = new messageCtor; diff --git a/closure/goog/testing/storage/fakemechanism.js b/closure/goog/testing/storage/fakemechanism.js index 13fdbaf6e8..7a7d9b9233 100644 --- a/closure/goog/testing/storage/fakemechanism.js +++ b/closure/goog/testing/storage/fakemechanism.js @@ -24,6 +24,7 @@ goog.require('goog.structs.Map'); * @final */ goog.testing.storage.FakeMechanism = function() { + 'use strict'; /** * @type {goog.structs.Map} * @private @@ -37,12 +38,14 @@ goog.inherits( /** @override */ goog.testing.storage.FakeMechanism.prototype.set = function(key, value) { + 'use strict'; this.storage_.set(key, value); }; /** @override */ goog.testing.storage.FakeMechanism.prototype.get = function(key) { + 'use strict'; return /** @type {?string} */ ( this.storage_.get(key, null /* default value */)); }; @@ -50,11 +53,13 @@ goog.testing.storage.FakeMechanism.prototype.get = function(key) { /** @override */ goog.testing.storage.FakeMechanism.prototype.remove = function(key) { + 'use strict'; this.storage_.remove(key); }; /** @override */ goog.testing.storage.FakeMechanism.prototype.__iterator__ = function(opt_keys) { + 'use strict'; return this.storage_.__iterator__(opt_keys); }; diff --git a/closure/goog/testing/style/layoutasserts.js b/closure/goog/testing/style/layoutasserts.js index 4d76af1b9b..c2559102b0 100644 --- a/closure/goog/testing/style/layoutasserts.js +++ b/closure/goog/testing/style/layoutasserts.js @@ -26,6 +26,7 @@ goog.require('goog.testing.style'); * @param {Element=} opt_b The element when a comment string is present. */ var assertIsVisible = function(a, opt_b) { + 'use strict'; _validateArguments(1, arguments); var element = nonCommentArg(1, 1, arguments); @@ -42,6 +43,7 @@ var assertIsVisible = function(a, opt_b) { * @param {Element=} opt_b The element when a comment string is present. */ var assertNotVisible = function(a, opt_b) { + 'use strict'; _validateArguments(1, arguments); var element = nonCommentArg(1, 1, arguments); if (!element) { @@ -63,6 +65,7 @@ var assertNotVisible = function(a, opt_b) { * @param {Element=} opt_c The second element if comment string is present. */ var assertIntersect = function(a, b, opt_c) { + 'use strict'; _validateArguments(2, arguments); var element = nonCommentArg(1, 2, arguments); var otherElement = nonCommentArg(2, 2, arguments); @@ -82,6 +85,7 @@ var assertIntersect = function(a, b, opt_c) { * @param {Element=} opt_c The second element if comment string is present. */ var assertNoIntersect = function(a, b, opt_c) { + 'use strict'; _validateArguments(2, arguments); var element = nonCommentArg(1, 2, arguments); var otherElement = nonCommentArg(2, 2, arguments); @@ -101,6 +105,7 @@ var assertNoIntersect = function(a, b, opt_c) { * @param {Element=} opt_c The second element if comment string is present. */ var assertWidth = function(a, b, opt_c) { + 'use strict'; _validateArguments(2, arguments); var element = nonCommentArg(1, 2, arguments); var width = nonCommentArg(2, 2, arguments); @@ -126,6 +131,7 @@ var assertWidth = function(a, b, opt_c) { * @param {number=} opt_d The tolerance if comment string is present. */ var assertWidthWithinTolerance = function(a, b, c, opt_d) { + 'use strict'; _validateArguments(3, arguments); var element = nonCommentArg(1, 3, arguments); var width = nonCommentArg(2, 3, arguments); @@ -150,6 +156,7 @@ var assertWidthWithinTolerance = function(a, b, c, opt_d) { * @param {Element=} opt_c The second element if comment string is present. */ var assertHeight = function(a, b, opt_c) { + 'use strict'; _validateArguments(2, arguments); var element = nonCommentArg(1, 2, arguments); var height = nonCommentArg(2, 2, arguments); @@ -175,6 +182,7 @@ var assertHeight = function(a, b, opt_c) { * @param {number=} opt_d The tolerance if comment string is present. */ var assertHeightWithinTolerance = function(a, b, c, opt_d) { + 'use strict'; _validateArguments(3, arguments); var element = nonCommentArg(1, 3, arguments); var height = nonCommentArg(2, 3, arguments); @@ -199,6 +207,7 @@ var assertHeightWithinTolerance = function(a, b, c, opt_d) { * @param {Element=} opt_c The second element if comment string is present. */ var assertIsLeftOf = function(a, b, opt_c) { + 'use strict'; _validateArguments(2, arguments); var element = nonCommentArg(1, 2, arguments); var otherElement = nonCommentArg(2, 2, arguments); @@ -219,6 +228,7 @@ var assertIsLeftOf = function(a, b, opt_c) { * @param {Element=} opt_c The second element if comment string is present. */ var assertIsStrictlyLeftOf = function(a, b, opt_c) { + 'use strict'; _validateArguments(2, arguments); var element = nonCommentArg(1, 2, arguments); var otherElement = nonCommentArg(2, 2, arguments); @@ -240,6 +250,7 @@ var assertIsStrictlyLeftOf = function(a, b, opt_c) { * @param {Element=} opt_c The second element if comment string is present. */ var assertIsAbove = function(a, b, opt_c) { + 'use strict'; _validateArguments(2, arguments); var element = nonCommentArg(1, 2, arguments); var otherElement = nonCommentArg(2, 2, arguments); @@ -260,6 +271,7 @@ var assertIsAbove = function(a, b, opt_c) { * @param {Element=} opt_c The second element if comment string is present. */ var assertIsStrictlyAbove = function(a, b, opt_c) { + 'use strict'; _validateArguments(2, arguments); var element = nonCommentArg(1, 2, arguments); var otherElement = nonCommentArg(2, 2, arguments); @@ -282,6 +294,7 @@ var assertIsStrictlyAbove = function(a, b, opt_c) { * @param {Element=} opt_c The second element if comment string is present. */ var assertContained = function(a, b, opt_c) { + 'use strict'; _validateArguments(2, arguments); var element = nonCommentArg(1, 2, arguments); var otherElement = nonCommentArg(2, 2, arguments); @@ -305,5 +318,6 @@ var assertContained = function(a, b, opt_c) { */ goog.testing.style.layoutasserts.isWithinThreshold_ = function( val1, val2, threshold) { + 'use strict'; return Math.abs(val1 - val2) <= threshold; }; diff --git a/closure/goog/testing/style/style.js b/closure/goog/testing/style/style.js index d30065faad..425c5c42ff 100644 --- a/closure/goog/testing/style/style.js +++ b/closure/goog/testing/style/style.js @@ -26,6 +26,7 @@ goog.require('goog.style'); * intersect. */ goog.testing.style.intersects = function(element, otherElement) { + 'use strict'; var elementRect = goog.style.getBounds(element); var otherElementRect = goog.style.getBounds(otherElement); return goog.math.Rect.intersects(elementRect, otherElementRect); @@ -38,6 +39,7 @@ goog.testing.style.intersects = function(element, otherElement) { * @return {boolean} Whether the element has visible dimensions. */ goog.testing.style.hasVisibleDimensions = function(element) { + 'use strict'; var elSize = goog.style.getSize(element); var shortest = elSize.getShortest(); if (shortest <= 0) { @@ -55,6 +57,7 @@ goog.testing.style.hasVisibleDimensions = function(element) { * @return {boolean} Whether the CSS style of the element renders it visible. */ goog.testing.style.isVisible = function(element) { + 'use strict'; if (!goog.dom.isInDocument(element)) { return false; } @@ -69,6 +72,7 @@ goog.testing.style.isVisible = function(element) { * @return {boolean} Whether the element is on the screen. */ goog.testing.style.isOnScreen = function(el) { + 'use strict'; var doc = goog.dom.getDomHelper(el).getDocument(); var viewport = goog.style.getVisibleRectForElement(doc.body); var viewportRect = goog.math.Rect.createFromBox(viewport); diff --git a/closure/goog/timer/timer.js b/closure/goog/timer/timer.js index b4ec441529..64b640a1c9 100644 --- a/closure/goog/timer/timer.js +++ b/closure/goog/timer/timer.js @@ -30,6 +30,7 @@ goog.requireType('goog.Thenable'); * @extends {goog.events.EventTarget} */ goog.Timer = function(opt_interval, opt_timerObject) { + 'use strict'; goog.events.EventTarget.call(this); /** @@ -133,6 +134,7 @@ goog.Timer.prototype.timer_ = null; * @return {number} interval Number of ms between ticks. */ goog.Timer.prototype.getInterval = function() { + 'use strict'; return this.interval_; }; @@ -142,6 +144,7 @@ goog.Timer.prototype.getInterval = function() { * @param {number} interval Number of ms between ticks. */ goog.Timer.prototype.setInterval = function(interval) { + 'use strict'; this.interval_ = interval; if (this.timer_ && this.enabled) { // Stop and then start the timer to reset the interval. @@ -158,6 +161,7 @@ goog.Timer.prototype.setInterval = function(interval) { * @private */ goog.Timer.prototype.tick_ = function() { + 'use strict'; if (this.enabled) { var elapsed = goog.now() - this.last_; if (elapsed > 0 && elapsed < this.interval_ * goog.Timer.intervalScale) { @@ -189,6 +193,7 @@ goog.Timer.prototype.tick_ = function() { * Dispatches the TICK event. This is its own method so subclasses can override. */ goog.Timer.prototype.dispatchTick = function() { + 'use strict'; this.dispatchEvent(goog.Timer.TICK); }; @@ -197,6 +202,7 @@ goog.Timer.prototype.dispatchTick = function() { * Starts the timer. */ goog.Timer.prototype.start = function() { + 'use strict'; this.enabled = true; // If there is no interval already registered, start it now @@ -223,6 +229,7 @@ goog.Timer.prototype.start = function() { * Stops the timer. */ goog.Timer.prototype.stop = function() { + 'use strict'; this.enabled = false; if (this.timer_) { this.timerObject_.clearTimeout(this.timer_); @@ -233,6 +240,7 @@ goog.Timer.prototype.stop = function() { /** @override */ goog.Timer.prototype.disposeInternal = function() { + 'use strict'; goog.Timer.superClass_.disposeInternal.call(this); this.stop(); delete this.timerObject_; @@ -261,6 +269,7 @@ goog.Timer.TICK = 'tick'; * @template SCOPE */ goog.Timer.callOnce = function(listener, opt_delay, opt_handler) { + 'use strict'; if (goog.isFunction(listener)) { if (opt_handler) { listener = goog.bind(listener, opt_handler); @@ -288,6 +297,7 @@ goog.Timer.callOnce = function(listener, opt_delay, opt_handler) { * @param {?number} timerId A timer ID. */ goog.Timer.clear = function(timerId) { + 'use strict'; goog.Timer.defaultTimerObject.clearTimeout(timerId); }; @@ -301,16 +311,21 @@ goog.Timer.clear = function(timerId) { * @template RESULT */ goog.Timer.promise = function(delay, opt_result) { + 'use strict'; var timerKey = null; return new goog .Promise(function(resolve, reject) { - timerKey = - goog.Timer.callOnce(function() { resolve(opt_result); }, delay); + 'use strict'; + timerKey = goog.Timer.callOnce(function() { + 'use strict'; + resolve(opt_result); + }, delay); if (timerKey == goog.Timer.INVALID_TIMEOUT_ID_) { reject(new Error('Failed to schedule timer.')); } }) .thenCatch(function(error) { + 'use strict'; // Clear the timer. The most likely reason is "cancel" signal. goog.Timer.clear(timerKey); throw error; diff --git a/closure/goog/window/window.js b/closure/goog/window/window.js index be71dd81a8..66cd7afeb3 100644 --- a/closure/goog/window/window.js +++ b/closure/goog/window/window.js @@ -50,6 +50,7 @@ goog.window.DEFAULT_POPUP_TARGET = 'google_popup'; * @private */ goog.window.createFakeWindow_ = function() { + 'use strict'; return /** @type {!Window} */ ({}); }; @@ -93,6 +94,7 @@ goog.window.createFakeWindow_ = function() { * a cross-origin window has been opened. */ goog.window.open = function(linkRef, opt_options, opt_parentWin) { + 'use strict'; if (!opt_options) { opt_options = {}; } @@ -275,6 +277,7 @@ goog.window.open = function(linkRef, opt_options, opt_parentWin) { * opened. */ goog.window.openBlank = function(opt_message, opt_options, opt_parentWin) { + 'use strict'; // Open up a window with the loading message and nothing else. // This will be interpreted as HTML content type with a missing doctype // and html/body tags, but is otherwise acceptable. @@ -327,6 +330,7 @@ goog.window.openBlank = function(opt_message, opt_options, opt_parentWin) { * @return {boolean} true if the window was not popped up, false if it was. */ goog.window.popup = function(linkRef, opt_options) { + 'use strict'; if (!opt_options) { opt_options = {}; } diff --git a/third_party/closure/goog/mochikit/async/deferred.js b/third_party/closure/goog/mochikit/async/deferred.js index 626fc7da76..a57f9f75ce 100644 --- a/third_party/closure/goog/mochikit/async/deferred.js +++ b/third_party/closure/goog/mochikit/async/deferred.js @@ -74,6 +74,7 @@ goog.require('goog.debug.Error'); * @template VALUE */ goog.async.Deferred = function(opt_onCancelFunction, opt_defaultScope) { + 'use strict'; /** * Entries in the sequence are arrays containing a callback, an errback, and * an optional scope. The callback or errback in an entry may be null. @@ -226,6 +227,7 @@ goog.async.Deferred.LONG_STACK_TRACES = * effect on a branch without opt_propagateCancel set to true. */ goog.async.Deferred.prototype.cancel = function(opt_deepCancel) { + 'use strict'; if (!this.hasFired()) { if (this.parent_) { // Get rid of the parent reference before potentially running the parent's @@ -262,6 +264,7 @@ goog.async.Deferred.prototype.cancel = function(opt_deepCancel) { * @private */ goog.async.Deferred.prototype.branchCancel_ = function() { + 'use strict'; this.branches_--; if (this.branches_ <= 0) { this.cancel(); @@ -278,6 +281,7 @@ goog.async.Deferred.prototype.branchCancel_ = function() { * @private */ goog.async.Deferred.prototype.continue_ = function(isSuccess, res) { + 'use strict'; this.blocked_ = false; this.updateResult_(isSuccess, res); }; @@ -292,6 +296,7 @@ goog.async.Deferred.prototype.continue_ = function(isSuccess, res) { * @private */ goog.async.Deferred.prototype.updateResult_ = function(isSuccess, res) { + 'use strict'; this.fired_ = true; this.result_ = res; this.hadError_ = !isSuccess; @@ -306,6 +311,7 @@ goog.async.Deferred.prototype.updateResult_ = function(isSuccess, res) { * @throws {Error} If this has already been fired. */ goog.async.Deferred.prototype.check_ = function() { + 'use strict'; if (this.hasFired()) { if (!this.silentlyCanceled_) { throw new goog.async.Deferred.AlreadyCalledError(this); @@ -321,6 +327,7 @@ goog.async.Deferred.prototype.check_ = function() { * @param {VALUE=} opt_result The starting result. */ goog.async.Deferred.prototype.callback = function(opt_result) { + 'use strict'; this.check_(); this.assertNotDeferred_(opt_result); this.updateResult_(true /* isSuccess */, opt_result); @@ -333,6 +340,7 @@ goog.async.Deferred.prototype.callback = function(opt_result) { * @param {*=} opt_result The starting error. */ goog.async.Deferred.prototype.errback = function(opt_result) { + 'use strict'; this.check_(); this.assertNotDeferred_(opt_result); this.makeStackTraceLong_(opt_result); @@ -357,6 +365,7 @@ goog.async.Deferred.unhandledErrorHandler_ = (e) => { * will fail with `throw`. */ goog.async.Deferred.setUnhandledErrorHandler = function(handler) { + 'use strict'; goog.async.Deferred.unhandledErrorHandler_ = handler; }; @@ -370,6 +379,7 @@ goog.async.Deferred.setUnhandledErrorHandler = function(handler) { * @suppress {missingProperties} error.stack */ goog.async.Deferred.prototype.makeStackTraceLong_ = function(error) { + 'use strict'; if (!goog.async.Deferred.LONG_STACK_TRACES) { return; } @@ -390,6 +400,7 @@ goog.async.Deferred.prototype.makeStackTraceLong_ = function(error) { * @private */ goog.async.Deferred.prototype.assertNotDeferred_ = function(obj) { + 'use strict'; goog.asserts.assert( !(obj instanceof goog.async.Deferred), 'An execution sequence may not be initiated with a blocking Deferred.'); @@ -416,6 +427,7 @@ goog.async.Deferred.prototype.assertNotDeferred_ = function(obj) { * @template T */ goog.async.Deferred.prototype.addCallback = function(cb, opt_scope) { + 'use strict'; return this.addCallbacks(cb, null, opt_scope); }; @@ -440,6 +452,7 @@ goog.async.Deferred.prototype.addCallback = function(cb, opt_scope) { * @template T */ goog.async.Deferred.prototype.addErrback = function(eb, opt_scope) { + 'use strict'; return this.addCallbacks(null, eb, opt_scope); }; @@ -453,6 +466,7 @@ goog.async.Deferred.prototype.addErrback = function(eb, opt_scope) { * @template T */ goog.async.Deferred.prototype.addBoth = function(f, opt_scope) { + 'use strict'; return this.addCallbacks(f, f, opt_scope); }; @@ -466,7 +480,9 @@ goog.async.Deferred.prototype.addBoth = function(f, opt_scope) { * @template T */ goog.async.Deferred.prototype.addFinally = function(f, opt_scope) { + 'use strict'; return this.addCallbacks(f, function(err) { + 'use strict'; var result = f.call(/** @type {?} */ (this), err); if (result === undefined) { throw err; @@ -493,6 +509,7 @@ goog.async.Deferred.prototype.addFinally = function(f, opt_scope) { * @template T */ goog.async.Deferred.prototype.addCallbacks = function(cb, eb, opt_scope) { + 'use strict'; goog.asserts.assert(!this.blocking_, 'Blocking Deferreds can not be re-used'); this.sequence_.push([cb, eb, opt_scope]); if (this.hasFired()) { @@ -513,16 +530,19 @@ goog.async.Deferred.prototype.addCallbacks = function(cb, eb, opt_scope) { * * @override */ -goog.async.Deferred.prototype.then = function(opt_onFulfilled, opt_onRejected, - opt_context) { +goog.async.Deferred.prototype.then = function( + opt_onFulfilled, opt_onRejected, opt_context) { + 'use strict'; var resolve, reject; var promise = new goog.Promise(function(res, rej) { + 'use strict'; // Copying resolvers to outer scope, so that they are available when the // deferred callback fires (which may be synchronous). resolve = res; reject = rej; }); this.addCallbacks(resolve, function(reason) { + 'use strict'; if (reason instanceof goog.async.Deferred.CanceledError) { promise.cancel(); } else { @@ -543,6 +563,7 @@ goog.Thenable.addImplementation(goog.async.Deferred); * @return {!goog.async.Deferred} This Deferred. */ goog.async.Deferred.prototype.chainDeferred = function(otherDeferred) { + 'use strict'; this.addCallbacks( otherDeferred.callback, otherDeferred.errback, otherDeferred); return this; @@ -562,9 +583,11 @@ goog.async.Deferred.prototype.chainDeferred = function(otherDeferred) { * @return {!goog.async.Deferred} This Deferred. */ goog.async.Deferred.prototype.awaitDeferred = function(otherDeferred) { + 'use strict'; if (!(otherDeferred instanceof goog.async.Deferred)) { // The Thenable case. return this.addCallback(function() { + 'use strict'; return otherDeferred; }); } @@ -588,6 +611,7 @@ goog.async.Deferred.prototype.awaitDeferred = function(otherDeferred) { * the computed result from this stage in the execution sequence. */ goog.async.Deferred.prototype.branch = function(opt_propagateCancel) { + 'use strict'; var d = new goog.async.Deferred(); this.chainDeferred(d); if (opt_propagateCancel) { @@ -603,6 +627,7 @@ goog.async.Deferred.prototype.branch = function(opt_propagateCancel) { * Deferred by invoking `callback` or `errback`. */ goog.async.Deferred.prototype.hasFired = function() { + 'use strict'; return this.fired_; }; @@ -615,6 +640,7 @@ goog.async.Deferred.prototype.hasFired = function() { * @protected */ goog.async.Deferred.prototype.isError = function(res) { + 'use strict'; return res instanceof Error; }; @@ -624,7 +650,9 @@ goog.async.Deferred.prototype.isError = function(res) { * @private */ goog.async.Deferred.prototype.hasErrback_ = function() { + 'use strict'; return goog.array.some(this.sequence_, function(sequenceRow) { + 'use strict'; // The errback is the second element in the array. return goog.isFunction(sequenceRow[1]); }); @@ -639,6 +667,7 @@ goog.async.Deferred.prototype.hasErrback_ = function() { * primitives. */ goog.async.Deferred.prototype.getLastValueForMigration = function() { + 'use strict'; return (this.hasFired() && !this.hadError_) ? this.result_ : undefined; }; @@ -651,6 +680,7 @@ goog.async.Deferred.prototype.getLastValueForMigration = function() { * @private */ goog.async.Deferred.prototype.fire_ = function() { + 'use strict'; if (this.unhandledErrorId_ && this.hasFired() && this.hasErrback_()) { // It is possible to add errbacks after the Deferred has fired. If a new // errback is added immediately after the Deferred encountered an unhandled @@ -744,6 +774,7 @@ goog.async.Deferred.prototype.fire_ = function() { * @return {!goog.async.Deferred} The new Deferred. */ goog.async.Deferred.succeed = function(opt_result) { + 'use strict'; var d = new goog.async.Deferred(); d.callback(opt_result); return d; @@ -764,12 +795,15 @@ goog.async.Deferred.succeed = function(opt_result) { * @template T */ goog.async.Deferred.fromPromise = function(promise) { + 'use strict'; var d = new goog.async.Deferred(); promise.then( function(value) { + 'use strict'; d.callback(value); }, function(error) { + 'use strict'; d.errback(error); }); return d; @@ -783,6 +817,7 @@ goog.async.Deferred.fromPromise = function(promise) { * @return {!goog.async.Deferred} The new Deferred. */ goog.async.Deferred.fail = function(res) { + 'use strict'; var d = new goog.async.Deferred(); d.errback(res); return d; @@ -795,6 +830,7 @@ goog.async.Deferred.fail = function(res) { * @return {!goog.async.Deferred} The new Deferred. */ goog.async.Deferred.canceled = function() { + 'use strict'; var d = new goog.async.Deferred(); d.cancel(); return d; @@ -834,6 +870,7 @@ goog.async.Deferred.canceled = function() { * @template T */ goog.async.Deferred.when = function(value, callback, opt_scope) { + 'use strict'; if (value instanceof goog.async.Deferred) { return value.branch(true).addCallback(callback, opt_scope); } else { @@ -851,6 +888,7 @@ goog.async.Deferred.when = function(value, callback, opt_scope) { * @extends {goog.debug.Error} */ goog.async.Deferred.AlreadyCalledError = function(deferred) { + 'use strict'; goog.debug.Error.call(this); /** @@ -880,6 +918,7 @@ goog.async.Deferred.AlreadyCalledError.prototype.name = 'AlreadyCalledError'; * @extends {goog.debug.Error} */ goog.async.Deferred.CanceledError = function(deferred) { + 'use strict'; goog.debug.Error.call(this); /** @@ -911,6 +950,7 @@ goog.async.Deferred.CanceledError.prototype.name = 'CanceledError'; * @struct */ goog.async.Deferred.Error_ = function(error) { + 'use strict'; /** @const @private {number} */ this.id_ = goog.global.setTimeout(goog.bind(this.throwError, this), 0); @@ -924,7 +964,9 @@ goog.async.Deferred.Error_ = function(error) { * deferred errors. */ goog.async.Deferred.Error_.prototype.throwError = function() { - goog.asserts.assert(goog.async.Deferred.errorMap_[this.id_], + 'use strict'; + goog.asserts.assert( + goog.async.Deferred.errorMap_[this.id_], 'Cannot throw an error that is not scheduled.'); delete goog.async.Deferred.errorMap_[this.id_]; goog.async.Deferred.unhandledErrorHandler_(this.error_); @@ -935,6 +977,7 @@ goog.async.Deferred.Error_.prototype.throwError = function() { * Resets the error throw timer. */ goog.async.Deferred.Error_.prototype.resetTimer = function() { + 'use strict'; goog.global.clearTimeout(this.id_); }; @@ -953,6 +996,7 @@ goog.async.Deferred.errorMap_ = {}; * @private */ goog.async.Deferred.scheduleError_ = function(error) { + 'use strict'; var deferredError = new goog.async.Deferred.Error_(error); goog.async.Deferred.errorMap_[deferredError.id_] = deferredError; return deferredError.id_; @@ -965,6 +1009,7 @@ goog.async.Deferred.scheduleError_ = function(error) { * @private */ goog.async.Deferred.unscheduleError_ = function(id) { + 'use strict'; var error = goog.async.Deferred.errorMap_[id]; if (error) { error.resetTimer(); @@ -978,6 +1023,7 @@ goog.async.Deferred.unscheduleError_ = function(id) { * scheduled errors, one will be thrown immediately to make this function fail. */ goog.async.Deferred.assertNoErrors = function() { + 'use strict'; var map = goog.async.Deferred.errorMap_; for (var key in map) { var error = map[key]; diff --git a/third_party/closure/goog/mochikit/async/deferredlist.js b/third_party/closure/goog/mochikit/async/deferredlist.js index 12ae59005b..44f61c6584 100644 --- a/third_party/closure/goog/mochikit/async/deferredlist.js +++ b/third_party/closure/goog/mochikit/async/deferredlist.js @@ -70,9 +70,9 @@ goog.require('goog.async.Deferred'); goog.async.DeferredList = function( list, opt_fireOnOneCallback, opt_fireOnOneErrback, opt_consumeErrors, opt_canceler, opt_defaultScope) { - - goog.async.DeferredList.base(this, 'constructor', - opt_canceler, opt_defaultScope); + 'use strict'; + goog.async.DeferredList.base( + this, 'constructor', opt_canceler, opt_defaultScope); /** * The list of Deferred objects to wait for. @@ -148,7 +148,7 @@ goog.inherits(goog.async.DeferredList, goog.async.Deferred); */ goog.async.DeferredList.prototype.handleCallback_ = function( index, success, result) { - + 'use strict'; this.numFinished_++; this.deferredResults_[index] = [success, result]; @@ -172,6 +172,7 @@ goog.async.DeferredList.prototype.handleCallback_ = function( /** @override */ goog.async.DeferredList.prototype.errback = function(res) { + 'use strict'; goog.async.DeferredList.base(this, 'errback', res); // On error, cancel any pending requests. @@ -194,8 +195,10 @@ goog.async.DeferredList.prototype.errback = function(res) { * if they all succeed, or the error result of the first input to fail. */ goog.async.DeferredList.gatherResults = function(list) { - return new goog.async.DeferredList(list, false, true). - addCallback(function(results) { + 'use strict'; + return new goog.async.DeferredList(list, false, true) + .addCallback(function(results) { + 'use strict'; var output = []; for (var i = 0; i < results.length; i++) { output[i] = results[i][1];