diff --git a/third_party/closure/goog/a11y/aria/aria.js b/third_party/closure/goog/a11y/aria/aria.js
index 3908c89289648..1220d2382851e 100644
--- a/third_party/closure/goog/a11y/aria/aria.js
+++ b/third_party/closure/goog/a11y/aria/aria.js
@@ -171,7 +171,8 @@ goog.a11y.aria.setState = function(element, stateName, value) {
  */
 goog.a11y.aria.toggleState = function(el, attr) {
   var val = goog.a11y.aria.getState(el, attr);
-  if (!goog.string.isEmptySafe(val) && !(val == 'true' || val == 'false')) {
+  if (!goog.string.isEmptyOrWhitespace(goog.string.makeSafe(val)) &&
+      !(val == 'true' || val == 'false')) {
     goog.a11y.aria.removeState(el, /** @type {!goog.a11y.aria.State} */ (attr));
     return;
   }
diff --git a/third_party/closure/goog/asserts/asserts.js b/third_party/closure/goog/asserts/asserts.js
index fc0be61cc8cd0..96a20818dc0e6 100644
--- a/third_party/closure/goog/asserts/asserts.js
+++ b/third_party/closure/goog/asserts/asserts.js
@@ -355,10 +355,9 @@ goog.asserts.assertObjectPrototypeIsIntact = function() {
  */
 goog.asserts.getType_ = function(value) {
   if (value instanceof Function) {
-    // TODO(martone): unquote this after the next Closure Compiler release.
-    return value['displayName'] || value.name || 'unknown type name';
+    return value.displayName || value.name || 'unknown type name';
   } else if (value instanceof Object) {
-    return value.constructor['displayName'] || value.constructor.name ||
+    return value.constructor.displayName || value.constructor.name ||
         Object.prototype.toString.call(value);
   } else {
     return value === null ? 'null' : typeof value;
diff --git a/third_party/closure/goog/base.js b/third_party/closure/goog/base.js
index 8431abfdf9b82..7f37fdd627cfa 100644
--- a/third_party/closure/goog/base.js
+++ b/third_party/closure/goog/base.js
@@ -274,6 +274,17 @@ goog.constructNamespace_ = function(name, opt_obj) {
 };
 
 
+/**
+ * Module identifier validation regexp.
+ * Note: This is a conservative check, it is very possible to be more lienent,
+ *   the primary exclusion here is "/" and "\" and a leading ".", these
+ *   restrictions are intended to leave the door open for using goog.require
+ *   with relative file paths rather than module identifiers.
+ * @private
+ */
+goog.VALID_MODULE_RE_ = /^[a-zA-Z_$][a-zA-Z0-9._$]*$/;
+
+
 /**
  * goog.module serves two purposes:
  * - marks a file that must be loaded as a module
@@ -296,7 +307,9 @@ goog.constructNamespace_ = function(name, opt_obj) {
  *     "goog.package.part", is expected but not required.
  */
 goog.module = function(name) {
-  if (!goog.isString(name) || !name) {
+  if (!goog.isString(name) ||
+      !name ||
+      name.search(goog.VALID_MODULE_RE_) == -1) {
     throw Error('Invalid module identifier');
   }
   if (!goog.isInModuleLoader_()) {
@@ -888,58 +901,6 @@ if (goog.DEPENDENCIES_ENABLED) {
   goog.queuedModules_ = [];
 
 
-  /**
-   * Retrieve and execute a module.
-   * @param {string} src Script source URL.
-   * @private
-   */
-  goog.retrieveAndExecModule_ = function(src) {
-    // The full but non-canonicalized URL for later use.
-    var originalPath = src;
-
-    // Canonicalize the path, removing any /./ or /../ since Chrome's debugging
-    // console doesn't auto-canonicalize XHR loads as it does <script> srcs.
-    var separator;
-    while ((separator = src.indexOf('/./')) != -1) {
-      src = src.substr(0, separator) + src.substr(separator + '/.'.length);
-    }
-    while ((separator = src.indexOf('/../')) != -1) {
-      var previousComponent = src.lastIndexOf('/', separator - 1);
-      src = src.substr(0, previousComponent) +
-          src.substr(separator + '/..'.length);
-    }
-
-    var importScript = goog.global.CLOSURE_IMPORT_SCRIPT ||
-        goog.writeScriptTag_;
-
-    var scriptText = null;
-
-    var xhr = new goog.global['XMLHttpRequest']();
-
-    /** @this {Object} */
-    xhr.onload = function() {
-      scriptText = this.responseText;
-    };
-    xhr.open('get', src, false);
-    xhr.send();
-
-    scriptText = xhr.responseText;
-
-    if (scriptText != null) {
-      var execModuleScript = goog.wrapModule_(src, scriptText);
-      var isOldIE = goog.IS_OLD_IE_;
-      if (isOldIE) {
-        goog.dependencies_.deferred[originalPath] = execModuleScript;
-        goog.queuedModules_.push(originalPath);
-      } else {
-        importScript(src, execModuleScript);
-      }
-    } else {
-      throw new Error('load of ' + src + 'failed');
-    }
-  };
-
-
   /**
    * Return an appropriate module text. Suitable to insert into
    * a script tag (that is unescaped).
@@ -1324,6 +1285,74 @@ if (goog.DEPENDENCIES_ENABLED) {
 }
 
 
+/**
+ * Normalize a file path by removing redundant ".." and extraneous "." file
+ * path components.
+ * @param {string} path
+ * @return {string}
+ * @private
+ */
+goog.normalizePath_ = function(path) {
+  var components = path.split('/');
+  var i = 0;
+  while (i < components.length) {
+    if (components[i] == '.') {
+      components.splice(i, 1);
+    } else if (i && components[i] == '..' &&
+        components[i - 1] && components[i - 1] != '..') {
+      components.splice(--i, 2);
+    } else {
+      i++;
+    }
+  }
+  return components.join('/');
+};
+
+
+/**
+ * Retrieve and execute a module.
+ * @param {string} src Script source URL.
+ * @private
+ */
+goog.retrieveAndExecModule_ = function(src) {
+  if (!COMPILED) {
+    // The full but non-canonicalized URL for later use.
+    var originalPath = src;
+    // Canonicalize the path, removing any /./ or /../ since Chrome's debugging
+    // console doesn't auto-canonicalize XHR loads as it does <script> srcs.
+    src = goog.normalizePath_(src);
+
+    var importScript = goog.global.CLOSURE_IMPORT_SCRIPT ||
+        goog.writeScriptTag_;
+
+    var scriptText = null;
+
+    var xhr = new goog.global['XMLHttpRequest']();
+
+    /** @this {Object} */
+    xhr.onload = function() {
+      scriptText = this.responseText;
+    };
+    xhr.open('get', src, false);
+    xhr.send();
+
+    scriptText = xhr.responseText;
+
+    if (scriptText != null) {
+      var execModuleScript = goog.wrapModule_(src, scriptText);
+      var isOldIE = goog.IS_OLD_IE_;
+      if (isOldIE) {
+        goog.dependencies_.deferred[originalPath] = execModuleScript;
+        goog.queuedModules_.push(originalPath);
+      } else {
+        importScript(src, execModuleScript);
+      }
+    } else {
+      throw new Error('load of ' + src + 'failed');
+    }
+  }
+};
+
 
 //==============================================================================
 // Language Enhancements
diff --git a/third_party/closure/goog/cssom/cssom.js b/third_party/closure/goog/cssom/cssom.js
index 53b5f29ee21f7..0be1b5add99e3 100644
--- a/third_party/closure/goog/cssom/cssom.js
+++ b/third_party/closure/goog/cssom/cssom.js
@@ -68,7 +68,7 @@ goog.cssom.getAllCssText = function(opt_styleSheet) {
  */
 goog.cssom.getAllCssStyleRules = function(opt_styleSheet) {
   var styleSheet = opt_styleSheet || document.styleSheets;
-  return /** @type {Array<CSSStyleRule>} */ (
+  return /** @type {!Array<CSSStyleRule>} */ (
       goog.cssom.getAllCss_(styleSheet, false));
 };
 
@@ -146,7 +146,7 @@ goog.cssom.getAllCssStyleSheets = function(opt_styleSheet,
     // to see if there are styleSheets buried in there.
     // If we have a CSSStyleSheet within CssRules.
     var cssRuleList = goog.cssom.getCssRulesFromStyleSheet(
-        /** @type {CSSStyleSheet} */ (styleSheet));
+        /** @type {!CSSStyleSheet} */ (styleSheet));
     if (cssRuleList && cssRuleList.length) {
       // Chrome does not evaluate cssRuleList[i] to undefined when i >=n;
       // so we use a (i < n) check instead of cssRuleList[i] in the loop below
diff --git a/third_party/closure/goog/cssom/iframe/style.js b/third_party/closure/goog/cssom/iframe/style.js
index ae78aa070bef3..731bf357ceb78 100644
--- a/third_party/closure/goog/cssom/iframe/style.js
+++ b/third_party/closure/goog/cssom/iframe/style.js
@@ -941,7 +941,7 @@ goog.cssom.iframe.style.getBackgroundContext = function(element) {
   while ((ancestor = ancestor.parentNode) &&
          ancestor.nodeType == goog.dom.NodeType.ELEMENT) {
     var computedStyle = goog.cssom.iframe.style.getComputedStyleObject_(
-        /** @type {Element} */ (ancestor));
+        /** @type {!Element} */ (ancestor));
     // Copy background color if a non-transparent value is found.
     var backgroundColorValue = computedStyle['backgroundColor'];
     if (!goog.cssom.iframe.style.isTransparentValue_(backgroundColorValue)) {
@@ -962,8 +962,8 @@ goog.cssom.iframe.style.getBackgroundContext = function(element) {
             element, currentIframeWindow);
         var frameElement = currentIframeWindow.frameElement;
         var iframeRelativePosition = goog.style.getRelativePosition(
-            /** @type {Element} */ (frameElement),
-            /** @type {Element} */ (ancestor));
+            /** @type {!Element} */ (frameElement),
+            /** @type {!Element} */ (ancestor));
         var iframeBorders = goog.style.getBorderBox(frameElement);
         relativePosition.x += iframeRelativePosition.x + iframeBorders.left;
         relativePosition.y += iframeRelativePosition.y + iframeBorders.top;
diff --git a/third_party/closure/goog/datasource/fastdatanode.js b/third_party/closure/goog/datasource/fastdatanode.js
index b89259ea127bd..f6578843f051f 100644
--- a/third_party/closure/goog/datasource/fastdatanode.js
+++ b/third_party/closure/goog/datasource/fastdatanode.js
@@ -299,7 +299,7 @@ goog.ds.FastDataNode.prototype.getJsObject = function() {
  * @return {goog.ds.FastDataNode} Clone of this data node.
  */
 goog.ds.FastDataNode.prototype.clone = function() {
-  return /** @type {goog.ds.FastDataNode} */(goog.ds.FastDataNode.fromJs(
+  return /** @type {!goog.ds.FastDataNode} */(goog.ds.FastDataNode.fromJs(
       this.getJsObject(), this.getDataName()));
 };
 
diff --git a/third_party/closure/goog/db/transaction.js b/third_party/closure/goog/db/transaction.js
index ba4b5a5ed9538..f22cb730816a2 100644
--- a/third_party/closure/goog/db/transaction.js
+++ b/third_party/closure/goog/db/transaction.js
@@ -72,21 +72,21 @@ goog.db.Transaction = function(tx, db) {
   // TODO(user): remove these casts once the externs file is updated to
   // correctly reflect that IDBTransaction extends EventTarget
   this.eventHandler_.listen(
-      /** @type {EventTarget} */ (this.tx_),
+      /** @type {!EventTarget} */ (this.tx_),
       'complete',
       goog.bind(
           this.dispatchEvent,
           this,
           goog.db.Transaction.EventTypes.COMPLETE));
   this.eventHandler_.listen(
-      /** @type {EventTarget} */ (this.tx_),
+      /** @type {!EventTarget} */ (this.tx_),
       'abort',
       goog.bind(
           this.dispatchEvent,
           this,
           goog.db.Transaction.EventTypes.ABORT));
   this.eventHandler_.listen(
-      /** @type {EventTarget} */ (this.tx_),
+      /** @type {!EventTarget} */ (this.tx_),
       'error',
       this.dispatchError_);
 };
diff --git a/third_party/closure/goog/deps.js b/third_party/closure/goog/deps.js
index 6f956cb2ee7ab..03f8df561d955 100644
--- a/third_party/closure/goog/deps.js
+++ b/third_party/closure/goog/deps.js
@@ -471,6 +471,8 @@ goog.addDependency('history/history.js', ['goog.History', 'goog.History.Event',
 goog.addDependency('history/history_test.js', ['goog.HistoryTest'], ['goog.History', 'goog.dispose', 'goog.dom', 'goog.testing.jsunit', 'goog.userAgent'], false);
 goog.addDependency('history/html5history.js', ['goog.history.Html5History', 'goog.history.Html5History.TokenTransformer'], ['goog.asserts', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.history.Event'], false);
 goog.addDependency('history/html5history_test.js', ['goog.history.Html5HistoryTest'], ['goog.history.Html5History', 'goog.testing.MockControl', 'goog.testing.jsunit', 'goog.testing.mockmatchers'], false);
+goog.addDependency('html/flash.js', ['goog.html.flash'], ['goog.html.SafeHtml'], false);
+goog.addDependency('html/flash_test.js', ['goog.html.flashTest'], ['goog.html.SafeHtml', 'goog.html.TrustedResourceUrl', 'goog.html.flash', 'goog.string.Const', 'goog.testing.jsunit'], false);
 goog.addDependency('html/legacyconversions.js', ['goog.html.legacyconversions'], ['goog.html.SafeHtml', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl'], false);
 goog.addDependency('html/legacyconversions_test.js', ['goog.html.legacyconversionsTest'], ['goog.html.SafeHtml', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.html.legacyconversions', 'goog.testing.PropertyReplacer', 'goog.testing.jsunit'], false);
 goog.addDependency('html/safehtml.js', ['goog.html.SafeHtml'], ['goog.array', 'goog.asserts', 'goog.dom.tags', 'goog.html.SafeStyle', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.i18n.bidi.Dir', 'goog.i18n.bidi.DirectionalString', 'goog.object', 'goog.string', 'goog.string.Const', 'goog.string.TypedString'], false);
@@ -1083,8 +1085,8 @@ goog.addDependency('testing/style/layoutasserts.js', ['goog.testing.style.layout
 goog.addDependency('testing/style/layoutasserts_test.js', ['goog.testing.style.layoutassertsTest'], ['goog.dom', 'goog.style', 'goog.testing.jsunit', 'goog.testing.style.layoutasserts'], false);
 goog.addDependency('testing/style/style.js', ['goog.testing.style'], ['goog.dom', 'goog.math.Rect', 'goog.style'], false);
 goog.addDependency('testing/style/style_test.js', ['goog.testing.styleTest'], ['goog.dom', 'goog.style', 'goog.testing.jsunit', 'goog.testing.style'], false);
-goog.addDependency('testing/testcase.js', ['goog.testing.TestCase', 'goog.testing.TestCase.Error', 'goog.testing.TestCase.Order', 'goog.testing.TestCase.Result', 'goog.testing.TestCase.Test'], ['goog.object', 'goog.testing.asserts', 'goog.testing.stacktrace'], false);
-goog.addDependency('testing/testcase_test.js', ['goog.testing.TestCaseTest'], ['goog.testing.TestCase', 'goog.testing.jsunit'], false);
+goog.addDependency('testing/testcase.js', ['goog.testing.TestCase', 'goog.testing.TestCase.Error', 'goog.testing.TestCase.Order', 'goog.testing.TestCase.Result', 'goog.testing.TestCase.Test'], ['goog.Promise', 'goog.Thenable', 'goog.object', 'goog.testing.asserts', 'goog.testing.stacktrace'], false);
+goog.addDependency('testing/testcase_test.js', ['goog.testing.TestCaseTest'], ['goog.Promise', 'goog.testing.TestCase', 'goog.testing.jsunit'], false);
 goog.addDependency('testing/testqueue.js', ['goog.testing.TestQueue'], [], false);
 goog.addDependency('testing/testrunner.js', ['goog.testing.TestRunner'], ['goog.testing.TestCase'], false);
 goog.addDependency('testing/ui/rendererasserts.js', ['goog.testing.ui.rendererasserts'], ['goog.testing.asserts'], false);
diff --git a/third_party/closure/goog/dom/browserrange/ierange.js b/third_party/closure/goog/dom/browserrange/ierange.js
index 08ee3b08bb2ab..00e6bba2eebb5 100644
--- a/third_party/closure/goog/dom/browserrange/ierange.js
+++ b/third_party/closure/goog/dom/browserrange/ierange.js
@@ -900,7 +900,7 @@ goog.dom.browserrange.IeRange.insertNode_ = function(clone, node,
 
   clone.collapse(before);
   node = goog.dom.browserrange.IeRange.pasteElement_(clone,
-      /** @type {Element} */ (node), opt_domHelper);
+      /** @type {!Element} */ (node), opt_domHelper);
 
   // If we didn't want an element, unwrap the element and return the node.
   if (isNonElement) {
diff --git a/third_party/closure/goog/dom/browserrange/w3crange.js b/third_party/closure/goog/dom/browserrange/w3crange.js
index e1cd504910370..599b50ca53eaa 100644
--- a/third_party/closure/goog/dom/browserrange/w3crange.js
+++ b/third_party/closure/goog/dom/browserrange/w3crange.js
@@ -227,7 +227,7 @@ goog.dom.browserrange.W3cRange.prototype.getValidHtml = function() {
       container.parentNode;
 
   var html = goog.dom.getOuterHtml(
-      /** @type {Element} */ (container.cloneNode(false)));
+      /** @type {!Element} */ (container.cloneNode(false)));
   return html.replace('>', '>' + result);
 };
 
diff --git a/third_party/closure/goog/dom/dom.js b/third_party/closure/goog/dom/dom.js
index 8a0fad01a6c0f..d6dbed102d749 100644
--- a/third_party/closure/goog/dom/dom.js
+++ b/third_party/closure/goog/dom/dom.js
@@ -1142,7 +1142,7 @@ goog.dom.getChildren = function(element) {
  */
 goog.dom.getFirstElementChild = function(node) {
   if (node.firstElementChild != undefined) {
-    return /** @type {Element} */(node).firstElementChild;
+    return /** @type {!Element} */(node).firstElementChild;
   }
   return goog.dom.getNextElementNode_(node.firstChild, true);
 };
@@ -1155,7 +1155,7 @@ goog.dom.getFirstElementChild = function(node) {
  */
 goog.dom.getLastElementChild = function(node) {
   if (node.lastElementChild != undefined) {
-    return /** @type {Element} */(node).lastElementChild;
+    return /** @type {!Element} */(node).lastElementChild;
   }
   return goog.dom.getNextElementNode_(node.lastChild, false);
 };
@@ -1168,7 +1168,7 @@ goog.dom.getLastElementChild = function(node) {
  */
 goog.dom.getNextElementSibling = function(node) {
   if (node.nextElementSibling != undefined) {
-    return /** @type {Element} */(node).nextElementSibling;
+    return /** @type {!Element} */(node).nextElementSibling;
   }
   return goog.dom.getNextElementNode_(node.nextSibling, true);
 };
@@ -1182,7 +1182,7 @@ goog.dom.getNextElementSibling = function(node) {
  */
 goog.dom.getPreviousElementSibling = function(node) {
   if (node.previousElementSibling != undefined) {
-    return /** @type {Element} */(node).previousElementSibling;
+    return /** @type {!Element} */(node).previousElementSibling;
   }
   return goog.dom.getNextElementNode_(node.previousSibling, false);
 };
diff --git a/third_party/closure/goog/dom/forms.js b/third_party/closure/goog/dom/forms.js
index 4acff31bee070..86bde60ce4a26 100644
--- a/third_party/closure/goog/dom/forms.js
+++ b/third_party/closure/goog/dom/forms.js
@@ -27,8 +27,8 @@ goog.require('goog.structs.Map');
  * Returns form data as a map of name to value arrays. This doesn't
  * support file inputs.
  * @param {HTMLFormElement} form The form.
- * @return {!goog.structs.Map} A map of the form data as form name to arrays of
- *     values.
+ * @return {!goog.structs.Map.<string, !Array.<string>>} A map of the form data
+ *     as field name to arrays of values.
  */
 goog.dom.forms.getFormDataMap = function(form) {
   var map = new goog.structs.Map();
@@ -117,7 +117,7 @@ goog.dom.forms.getFormDataHelper_ = function(form, result, fnAppend) {
 
 /**
  * Adds the name/value pair to the map.
- * @param {goog.structs.Map} map The map to add to.
+ * @param {!goog.structs.Map.<string, !Array.<string>>} map The map to add to.
  * @param {string} name The name.
  * @param {string} value The value.
  * @private
@@ -247,6 +247,7 @@ goog.dom.forms.getValue = function(el) {
  * Alias for goog.dom.form.element.getValue
  * @type {Function}
  * @deprecated Use {@link goog.dom.forms.getValue} instead.
+ * @suppress {missingProvide}
  */
 goog.dom.$F = goog.dom.forms.getValue;
 
diff --git a/third_party/closure/goog/dom/range.js b/third_party/closure/goog/dom/range.js
index 0886035cd2cec..f71374cfc5e12 100644
--- a/third_party/closure/goog/dom/range.js
+++ b/third_party/closure/goog/dom/range.js
@@ -69,7 +69,7 @@ goog.dom.Range.createFromBrowserSelection = function(selection) {
   } else if (selection.rangeCount) {
     if (selection.rangeCount > 1) {
       return goog.dom.MultiRange.createFromBrowserSelection(
-          /** @type {Selection} */ (selection));
+          /** @type {!Selection} */ (selection));
     } else {
       range = selection.getRangeAt(0);
       isReversed = goog.dom.Range.isReversed(selection.anchorNode,
diff --git a/third_party/closure/goog/editor/field.js b/third_party/closure/goog/editor/field.js
index ca9c917f7c972..fc81c2e063ebf 100644
--- a/third_party/closure/goog/editor/field.js
+++ b/third_party/closure/goog/editor/field.js
@@ -2584,7 +2584,7 @@ goog.editor.Field.prototype.makeIframeField_ = function(opt_iframeSrc) {
     html = this.reduceOp_(goog.editor.Plugin.Op.PREPARE_CONTENTS_HTML,
         html, styles);
 
-    var iframe = /** @type {HTMLIFrameElement} */(
+    var iframe = /** @type {!HTMLIFrameElement} */(
         this.originalDomHelper.createDom(goog.dom.TagName.IFRAME,
             this.getIframeAttributes()));
 
diff --git a/third_party/closure/goog/editor/node.js b/third_party/closure/goog/editor/node.js
index 8c9480b4da7ed..006936d1c25a4 100644
--- a/third_party/closure/goog/editor/node.js
+++ b/third_party/closure/goog/editor/node.js
@@ -211,7 +211,7 @@ goog.editor.node.getChildHelper_ = function(parent, isReversed) {
   return (!parent || parent.nodeType != goog.dom.NodeType.ELEMENT) ? null :
       /** @type {Node} */ (goog.editor.node.getFirstValue_(goog.iter.filter(
           new goog.dom.iter.ChildIterator(
-              /** @type {Element} */ (parent), isReversed),
+              /** @type {!Element} */ (parent), isReversed),
           goog.editor.node.isImportant)));
 };
 
diff --git a/third_party/closure/goog/editor/plugins/basictextformatter.js b/third_party/closure/goog/editor/plugins/basictextformatter.js
index 5816e7404a240..c19a660a39c9d 100644
--- a/third_party/closure/goog/editor/plugins/basictextformatter.js
+++ b/third_party/closure/goog/editor/plugins/basictextformatter.js
@@ -1307,7 +1307,7 @@ goog.editor.plugins.BasicTextFormatter.prototype.fixSafariLists_ = function() {
       var range = node.ownerDocument.createRange();
       range.setStartAfter(previousElementSibling);
       range.setEndBefore(node);
-      if (!goog.string.isEmpty(range.toString())) {
+      if (!goog.string.isEmptyOrWhitespace(range.toString())) {
         return;
       }
       // Make sure both are lists of the same type (ordered or unordered)
diff --git a/third_party/closure/goog/editor/plugins/tagonenterhandler.js b/third_party/closure/goog/editor/plugins/tagonenterhandler.js
index 81371fdf3a254..e5776fdbb43b3 100644
--- a/third_party/closure/goog/editor/plugins/tagonenterhandler.js
+++ b/third_party/closure/goog/editor/plugins/tagonenterhandler.js
@@ -525,10 +525,10 @@ goog.editor.plugins.TagOnEnterHandler.prototype.handleRegularEnterGecko_ =
       // it out of the anchor.
       var anchorToRemove = goog.editor.node.isEmpty(leftAnchor, false) ?
           leftAnchor : rightAnchor;
-      goog.dom.flattenElement(/** @type {Element} */ (anchorToRemove));
+      goog.dom.flattenElement(/** @type {!Element} */ (anchorToRemove));
     }
   }
-  return /** @type {Element} */ (newNode);
+  return /** @type {!Element} */ (newNode);
 };
 
 
diff --git a/third_party/closure/goog/editor/style.js b/third_party/closure/goog/editor/style.js
index 38bf3bc1e2d2d..53a8b416131ac 100644
--- a/third_party/closure/goog/editor/style.js
+++ b/third_party/closure/goog/editor/style.js
@@ -49,7 +49,7 @@ goog.require('goog.userAgent');
  * for text nodes (instead of throwing an exception), and never reads
  * inline style. These two functions may need to be reconciled.
  *
- * @param {Node} node Node to get style of.
+ * @param {!Node} node Node to get style of.
  * @param {string} stylePropertyName Property to get (must be camelCase,
  *     not css-style).
  * @return {?string} Style value, or null if this is not an element node.
@@ -62,16 +62,16 @@ goog.editor.style.getComputedOrCascadedStyle_ = function(
     return null;
   }
   return goog.userAgent.IE ?
-      goog.style.getCascadedStyle(/** @type {Element} */ (node),
+      goog.style.getCascadedStyle(/** @type {!Element} */ (node),
           stylePropertyName) :
-      goog.style.getComputedStyle(/** @type {Element} */ (node),
+      goog.style.getComputedStyle(/** @type {!Element} */ (node),
           stylePropertyName);
 };
 
 
 /**
  * Checks whether the given element inherits display: block.
- * @param {Node} node The Node to check.
+ * @param {!Node} node The Node to check.
  * @return {boolean} Whether the element inherits CSS display: block.
  */
 goog.editor.style.isDisplayBlock = function(node) {
diff --git a/third_party/closure/goog/events/eventhandler.js b/third_party/closure/goog/events/eventhandler.js
index 9c67d44b1786e..16b1ad0ff7a58 100644
--- a/third_party/closure/goog/events/eventhandler.js
+++ b/third_party/closure/goog/events/eventhandler.js
@@ -211,8 +211,6 @@ goog.events.EventHandler.prototype.listen_ = function(src, type, opt_fn,
  */
 goog.events.EventHandler.prototype.listenOnce = function(
     src, type, opt_fn, opt_capture) {
-  // TODO(mknichel): Remove the opt_scope from this function and then
-  // templatize it.
   return this.listenOnce_(src, type, opt_fn, opt_capture);
 };
 
diff --git a/third_party/closure/goog/events/events.js b/third_party/closure/goog/events/events.js
index bdd744a81eca8..e93b0d9fcfcc2 100644
--- a/third_party/closure/goog/events/events.js
+++ b/third_party/closure/goog/events/events.js
@@ -181,7 +181,7 @@ goog.events.listen = function(src, type, listener, opt_capt, opt_handler) {
         listener, opt_capt, opt_handler);
   } else {
     return goog.events.listen_(
-        /** @type {EventTarget} */ (src),
+        /** @type {!EventTarget} */ (src),
         /** @type {string|!goog.events.EventId} */ (type),
         listener, /* callOnce */ false, opt_capt, opt_handler);
   }
@@ -329,7 +329,7 @@ goog.events.listenOnce = function(src, type, listener, opt_capt, opt_handler) {
         listener, opt_capt, opt_handler);
   } else {
     return goog.events.listen_(
-        /** @type {EventTarget} */ (src),
+        /** @type {!EventTarget} */ (src),
         /** @type {string|!goog.events.EventId} */ (type),
         listener, /* callOnce */ true, opt_capt, opt_handler);
   }
@@ -397,7 +397,7 @@ goog.events.unlisten = function(src, type, listener, opt_capt, opt_handler) {
 
   var capture = !!opt_capt;
   var listenerMap = goog.events.getListenerMap_(
-      /** @type {EventTarget} */ (src));
+      /** @type {!EventTarget} */ (src));
   if (listenerMap) {
     var listenerObj = listenerMap.getListener(
         /** @type {string|!goog.events.EventId} */ (type),
@@ -446,7 +446,7 @@ goog.events.unlistenByKey = function(key) {
   goog.events.listenerCountEstimate_--;
 
   var listenerMap = goog.events.getListenerMap_(
-      /** @type {EventTarget} */ (src));
+      /** @type {!EventTarget} */ (src));
   // TODO(chrishenry): Try to remove this conditional and execute the
   // first branch always. This should be safe.
   if (listenerMap) {
@@ -509,7 +509,7 @@ goog.events.removeAll = function(obj, opt_type) {
   }
 
   var listenerMap = goog.events.getListenerMap_(
-      /** @type {EventTarget} */ (obj));
+      /** @type {!EventTarget} */ (obj));
   if (!listenerMap) {
     return 0;
   }
@@ -551,7 +551,7 @@ goog.events.getListeners = function(obj, type, capture) {
     }
 
     var listenerMap = goog.events.getListenerMap_(
-        /** @type {EventTarget} */ (obj));
+        /** @type {!EventTarget} */ (obj));
     return listenerMap ? listenerMap.getListeners(type, capture) : [];
   }
 };
@@ -589,7 +589,7 @@ goog.events.getListener = function(src, type, listener, opt_capt, opt_handler) {
   }
 
   var listenerMap = goog.events.getListenerMap_(
-      /** @type {EventTarget} */ (src));
+      /** @type {!EventTarget} */ (src));
   if (listenerMap) {
     return listenerMap.getListener(type, listener, capture, opt_handler);
   }
@@ -616,7 +616,7 @@ goog.events.hasListener = function(obj, opt_type, opt_capture) {
   }
 
   var listenerMap = goog.events.getListenerMap_(
-      /** @type {EventTarget} */ (obj));
+      /** @type {!EventTarget} */ (obj));
   return !!listenerMap && listenerMap.hasListener(opt_type, opt_capture);
 };
 
diff --git a/third_party/closure/goog/format/emailaddress.js b/third_party/closure/goog/format/emailaddress.js
index d8b0ed540a8cb..670bc33c783d4 100644
--- a/third_party/closure/goog/format/emailaddress.js
+++ b/third_party/closure/goog/format/emailaddress.js
@@ -405,7 +405,7 @@ goog.format.EmailAddress.parseListInternal = function(
     token = goog.format.EmailAddress.getToken_(str, i);
     if (separatorChecker(token) ||
         (token == ' ' && parser(email).isValid())) {
-      if (!goog.string.isEmpty(email)) {
+      if (!goog.string.isEmptyOrWhitespace(email)) {
         result.push(parser(email));
       }
       email = '';
@@ -417,7 +417,7 @@ goog.format.EmailAddress.parseListInternal = function(
   }
 
   // Add the final token.
-  if (!goog.string.isEmpty(email)) {
+  if (!goog.string.isEmptyOrWhitespace(email)) {
     result.push(parser(email));
   }
   return result;
diff --git a/third_party/closure/goog/format/jsonprettyprinter.js b/third_party/closure/goog/format/jsonprettyprinter.js
index 32a07f26ca86a..15e2cd2aafd40 100644
--- a/third_party/closure/goog/format/jsonprettyprinter.js
+++ b/third_party/closure/goog/format/jsonprettyprinter.js
@@ -87,7 +87,7 @@ goog.format.JsonPrettyPrinter.prototype.format = function(json) {
     return '';
   }
   if (goog.isString(json)) {
-    if (goog.string.isEmpty(json)) {
+    if (goog.string.isEmptyOrWhitespace(json)) {
       return '';
     }
     // Try to coerce a string into a JSON object.
diff --git a/third_party/closure/goog/fx/animation.js b/third_party/closure/goog/fx/animation.js
index 4872f405d80df..0a4401b21926b 100644
--- a/third_party/closure/goog/fx/animation.js
+++ b/third_party/closure/goog/fx/animation.js
@@ -101,6 +101,24 @@ goog.fx.Animation = function(start, end, duration, opt_acc) {
    * @private
    */
   this.useRightPositioningForRtl_ = false;
+
+  /**
+   * Current frame rate.
+   * @private {number}
+   */
+  this.fps_ = 0;
+
+  /**
+   * Percent of the way through the animation.
+   * @protected {number}
+   */
+  this.progress = 0;
+
+  /**
+   * Timestamp for when last frame was run.
+   * @protected {?number}
+   */
+  this.lastFrame = null;
 };
 goog.inherits(goog.fx.Animation, goog.fx.TransitionBase);
 
@@ -216,30 +234,6 @@ goog.fx.Animation.setAnimationWindow = function(animationWindow) {
 };
 
 
-/**
- * Current frame rate.
- * @type {number}
- * @private
- */
-goog.fx.Animation.prototype.fps_ = 0;
-
-
-/**
- * Percent of the way through the animation.
- * @type {number}
- * @protected
- */
-goog.fx.Animation.prototype.progress = 0;
-
-
-/**
- * Timestamp for when last frame was run.
- * @type {?number}
- * @protected
- */
-goog.fx.Animation.prototype.lastFrame = null;
-
-
 /**
  * Starts or resumes an animation.
  * @param {boolean=} opt_restart Whether to restart the
diff --git a/third_party/closure/goog/fx/animationqueue.js b/third_party/closure/goog/fx/animationqueue.js
index 942d6bfecb883..2ad74ab867ccd 100644
--- a/third_party/closure/goog/fx/animationqueue.js
+++ b/third_party/closure/goog/fx/animationqueue.js
@@ -37,6 +37,8 @@ goog.require('goog.fx.TransitionBase');
  *
  * @constructor
  * @extends {goog.fx.TransitionBase}
+ * @struct
+ * @suppress {checkStructDictInheritance}
  */
 goog.fx.AnimationQueue = function() {
   goog.fx.AnimationQueue.base(this, 'constructor');
@@ -111,6 +113,7 @@ goog.fx.AnimationQueue.prototype.disposeInternal = function() {
  * Constructor for AnimationParallelQueue object.
  * @constructor
  * @extends {goog.fx.AnimationQueue}
+ * @struct
  */
 goog.fx.AnimationParallelQueue = function() {
   goog.fx.AnimationParallelQueue.base(this, 'constructor');
@@ -208,6 +211,7 @@ goog.fx.AnimationParallelQueue.prototype.onAnimationFinish = function(e) {
  * Constructor for AnimationSerialQueue object.
  * @constructor
  * @extends {goog.fx.AnimationQueue}
+ * @struct
  */
 goog.fx.AnimationSerialQueue = function() {
   goog.fx.AnimationSerialQueue.base(this, 'constructor');
diff --git a/third_party/closure/goog/html/flash.js b/third_party/closure/goog/html/flash.js
new file mode 100644
index 0000000000000..b393567d0373b
--- /dev/null
+++ b/third_party/closure/goog/html/flash.js
@@ -0,0 +1,217 @@
+// Copyright 2014 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+/**
+ * @fileoverview SafeHtml factory methods for creating object and embed tags
+ * for loading Flash files.
+ */
+
+goog.provide('goog.html.flash');
+
+goog.require('goog.asserts');
+goog.require('goog.html.SafeHtml');
+
+
+/**
+ * Attributes and param tag name attributes not allowed to be overriden
+ * when calling createObjectFlash*().
+ *
+ * While values that should be specified as params are probably not
+ * recognized as attributes, we block them anyway just to be sure.
+ * @const {!Array<string>}
+ * @private
+ */
+goog.html.flash.FORBIDDEN_ATTRS_AND_PARAMS_ON_FLASH_ = [
+  'classid',  // Used on old IE.
+  'data',  // Used in <object> to specify a URL.
+  'movie',  // Used on old IE.
+  'type',  // Used in <object> on for non-IE/modern IE.
+  'typemustmatch'
+];
+
+
+goog.html.flash.createEmbed = function(src, opt_attributes) {
+  var fixedAttributes = {
+    'src': src,
+    'type': 'application/x-shockwave-flash',
+    'pluginspage': 'https://www.macromedia.com/go/getflashplayer'
+  };
+  var defaultAttributes = {
+    'allownetworking': 'none',
+    'allowscriptaccess': 'never'
+  };
+  var attributes = goog.html.flash.combineAttributes_(
+      fixedAttributes, defaultAttributes, opt_attributes);
+  return goog.html.SafeHtml.
+      createSafeHtmlTagSecurityPrivateDoNotAccessOrElse('embed', attributes);
+};
+
+
+goog.html.flash.createObject = function(
+    data, opt_params, opt_attributes) {
+  goog.html.flash.verifyKeysNotInMaps_(
+      goog.html.flash.FORBIDDEN_ATTRS_AND_PARAMS_ON_FLASH_,
+      opt_attributes,
+      opt_params);
+
+  var paramTags = goog.html.flash.combineParams_(
+      {
+        'allownetworking': 'none',
+        'allowscriptaccess': 'never'
+      },
+      opt_params);
+  var fixedAttributes = {
+    'data': data,
+    'type': 'application/x-shockwave-flash',
+    'typemustmatch': ''
+  };
+  var attributes = goog.html.flash.combineAttributes_(
+      fixedAttributes, {}, opt_attributes);
+
+  return goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse(
+      'object', attributes, paramTags);
+};
+
+
+goog.html.flash.createObjectForOldIe = function(
+    movie, opt_params, opt_attributes) {
+  goog.html.flash.verifyKeysNotInMaps_(
+      goog.html.flash.FORBIDDEN_ATTRS_AND_PARAMS_ON_FLASH_,
+      opt_attributes,
+      opt_params);
+
+  var paramTags = goog.html.flash.combineParams_(
+      {
+        'allownetworking': 'none',
+        'allowscriptaccess': 'never',
+        'movie': movie
+      },
+      opt_params);
+  var fixedAttributes =
+      {'classid': 'clsid:d27cdb6e-ae6d-11cf-96b8-444553540000'};
+  var attributes = goog.html.flash.combineAttributes_(
+      fixedAttributes, {}, opt_attributes);
+
+  return goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse(
+      'object', attributes, paramTags);
+};
+
+
+/**
+ * @param {!Object<string, string>} fixedAttributes
+ * @param {!Object<string, string>} defaultAttributes
+ * @param {!Object<string, goog.html.SafeHtml.AttributeValue_>=}
+ *     opt_attributes Optional attributes passed to create*().
+ * @return {!Object<string, goog.html.SafeHtml.AttributeValue_>}
+ * @throws {Error} If opt_attributes contains an attribute with the same name
+ *     as an attribute in fixedAttributes.
+ * @private
+ */
+goog.html.flash.combineAttributes_ = function(
+    fixedAttributes, defaultAttributes, opt_attributes) {
+  var combinedAttributes = {};
+  var name;
+
+  for (name in fixedAttributes) {
+    goog.asserts.assert(name.toLowerCase() == name, 'Must be lower case');
+    combinedAttributes[name] = fixedAttributes[name];
+  }
+  for (name in defaultAttributes) {
+    goog.asserts.assert(name.toLowerCase() == name, 'Must be lower case');
+    combinedAttributes[name] = defaultAttributes[name];
+  }
+
+  for (name in opt_attributes) {
+    var nameLower = name.toLowerCase();
+    if (nameLower in fixedAttributes) {
+      throw Error('Cannot override "' + nameLower + '" attribute, got "' +
+          name + '" with value "' + opt_attributes[name] + '"');
+    }
+    if (nameLower in defaultAttributes) {
+      delete combinedAttributes[nameLower];
+    }
+    combinedAttributes[name] = opt_attributes[name];
+  }
+
+  return combinedAttributes;
+};
+
+
+/**
+ * @param {!Object<string, string|!goog.string.TypedString>} defaultParams
+ * @param {!Object<string, string>=}
+ *     opt_params Optional params passed to create*().
+ * @return {!Array<!goog.html.SafeHtml>} Combined params.
+ * @throws {Error} If opt_attributes contains an attribute with the same name
+ *     as an attribute in fixedAttributes.
+ * @private
+ */
+goog.html.flash.combineParams_ = function(defaultParams, opt_params) {
+  var combinedParams = {};
+  var name;
+
+  for (name in defaultParams) {
+    goog.asserts.assert(name.toLowerCase() == name, 'Must be lower case');
+    combinedParams[name] = defaultParams[name];
+  }
+  for (name in opt_params) {
+    var nameLower = name.toLowerCase();
+    if (nameLower in defaultParams) {
+      delete combinedParams[nameLower];
+    }
+    combinedParams[name] = opt_params[name];
+  }
+
+  var paramTags = [];
+  for (name in combinedParams) {
+    paramTags.push(
+        goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse(
+            'param', {'name': name, 'value': combinedParams[name]}));
+
+  }
+  return paramTags;
+};
+
+
+/**
+ * Checks that keys are not present as keys in maps.
+ * @param {!Array<string>} keys Keys that must not be present, lower-case.
+ * @param {!Object<string, goog.html.SafeHtml.AttributeValue_>=}
+ *     opt_attributes Optional attributes passed to create*().
+ * @param {!Object<string, string>=}  opt_params Optional params passed to
+ *     createObject*().
+ * @throws {Error} If any of keys exist as a key, ignoring case, in
+ *     opt_attributes or opt_params.
+ * @private
+ */
+goog.html.flash.verifyKeysNotInMaps_ = function(
+    keys, opt_attributes, opt_params) {
+  var verifyNotInMap = function(keys, map, type) {
+    for (var keyMap in map) {
+      var keyMapLower = keyMap.toLowerCase();
+      for (var i = 0; i < keys.length; i++) {
+        var keyToCheck = keys[i];
+        goog.asserts.assert(keyToCheck.toLowerCase() == keyToCheck);
+        if (keyMapLower == keyToCheck) {
+          throw Error('Cannot override "' + keyToCheck + '" ' + type +
+              ', got "' + keyMap + '" with value "' + map[keyMap] + '"');
+        }
+      }
+    }
+  };
+
+  verifyNotInMap(keys, opt_attributes, 'attribute');
+  verifyNotInMap(keys, opt_params, 'param');
+};
diff --git a/third_party/closure/goog/html/safehtml.js b/third_party/closure/goog/html/safehtml.js
index 70a18f2d4aa73..b8c4b613368a9 100644
--- a/third_party/closure/goog/html/safehtml.js
+++ b/third_party/closure/goog/html/safehtml.js
@@ -375,112 +375,8 @@ goog.html.SafeHtml.create = function(tagName, opt_attributes, opt_content) {
   if (tagName.toLowerCase() in goog.html.SafeHtml.NOT_ALLOWED_TAG_NAMES_) {
     throw Error('Tag name <' + tagName + '> is not allowed for SafeHtml.');
   }
-  return goog.html.SafeHtml.create_(
-      tagName, null, opt_attributes, opt_content);
-};
-
-
-/**
- * Creates a SafeHtml representing an "embed" tag. All restrictions
- * imposed by goog.html.SafeHtml.create() also apply.
- *
- * @param {!goog.html.TrustedResourceUrl} src Value of "src" attribute.
- * @param {!goog.string.Const} type Value of "type" attribute. Should be a
- *     valid MIME type, see
- *     http://www.w3.org/TR/html5/embedded-content-0.html#attr-embed-type.
- * @param {!Object<string, goog.html.SafeHtml.AttributeValue_>=}
- *     opt_attributes Mapping from other attribute names to their values. Only
- *     attribute names consisting of [a-zA-Z0-9-] are allowed. Value of null or
- *     undefined causes the attribute to be omitted.
- * @return {!goog.html.SafeHtml} The SafeHtml content with the embed tag.
- * @throws {Error} If invalid attribute name, or attribute value is
- *     provided. Also if opt_attributes contains src or type.
- * @see http://www.w3.org/TR/html5/embedded-content-0.html#the-embed-element
- */
-goog.html.SafeHtml.createEmbed = function(src, type, opt_attributes) {
-  if (goog.string.isEmpty(goog.string.Const.unwrap(type))) {
-    throw Error('Must provide non-empty "type"');
-  }
-  for (var attr in opt_attributes) {
-    var attrLower = attr.toLowerCase();
-    if (attrLower == 'src' || attrLower == 'type') {
-      throw Error('Cannot override "src" nor "type" attributes, got "' +
-          attr + '" with value "' + opt_attributes[attr] + '"');
-    }
-  }
-
-  var srcValue =
-      goog.string.htmlEscape(goog.html.TrustedResourceUrl.unwrap(src));
-  var typeValue = goog.string.htmlEscape(goog.string.Const.unwrap(type));
-  var srcAndType = 'src="' + srcValue + '" type="' + typeValue + '"';
-  return goog.html.SafeHtml.create_('embed', srcAndType, opt_attributes);
-};
-
-
-/**
- * @param {string} tagName Tag name. Set or validated by caller.
- * @param {?string} processedAttributes Already processed attributes which are
- *     not in opt_attributes.
- * @param {!Object<string, goog.html.SafeHtml.AttributeValue_>=} opt_attributes
- * @param {(!goog.html.SafeHtml.TextOrHtml_|
- *     !Array<!goog.html.SafeHtml.TextOrHtml_>)=} opt_content
- * @return {!goog.html.SafeHtml}
- * @throws {Error} If invalid or unsafe attribute name or value is provided.
- * @throws {goog.asserts.AssertionError} If content for void tag is provided.
- * @private
- */
-goog.html.SafeHtml.create_ = function(
-    tagName, processedAttributes, opt_attributes, opt_content) {
-  var dir = null;
-  var result = '<' + tagName;
-  if (processedAttributes) {
-    result += ' ' + processedAttributes;
-  }
-
-  if (opt_attributes) {
-    for (var name in opt_attributes) {
-      if (!goog.html.SafeHtml.VALID_NAMES_IN_TAG_.test(name)) {
-        throw Error('Invalid attribute name "' + name + '".');
-      }
-      var value = opt_attributes[name];
-      if (!goog.isDefAndNotNull(value)) {
-        continue;
-      }
-      result += ' ' +
-          goog.html.SafeHtml.getAttrNameAndValue_(tagName, name, value);
-    }
-  }
-
-  var content = opt_content;
-  if (!goog.isDef(content)) {
-    content = [];
-  } else if (!goog.isArray(content)) {
-    content = [content];
-  }
-
-  if (goog.dom.tags.isVoidTag(tagName.toLowerCase())) {
-    goog.asserts.assert(!content.length,
-        'Void tag <' + tagName + '> does not allow content.');
-    result += '>';
-  } else {
-    var html = goog.html.SafeHtml.concat(content);
-    result += '>' + goog.html.SafeHtml.unwrap(html) + '</' + tagName + '>';
-    dir = html.getDirection();
-  }
-
-  var dirAttribute = opt_attributes && opt_attributes['dir'];
-  if (dirAttribute) {
-    if (/^(ltr|rtl|auto)$/i.test(dirAttribute)) {
-      // If the tag has the "dir" attribute specified then its direction is
-      // neutral because it can be safely used in any context.
-      dir = goog.i18n.bidi.Dir.NEUTRAL;
-    } else {
-      dir = null;
-    }
-  }
-
-  return goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(
-      result, dir);
+  return goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse(
+      tagName, opt_attributes, opt_content);
 };
 
 
@@ -650,6 +546,70 @@ goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse = function(
 };
 
 
+/**
+ * Like create() but does not restrict which tags can be constructed.
+ *
+ * @param {string} tagName Tag name. Set or validated by caller.
+ * @param {!Object<string, goog.html.SafeHtml.AttributeValue_>=} opt_attributes
+ * @param {(!goog.html.SafeHtml.TextOrHtml_|
+ *     !Array<!goog.html.SafeHtml.TextOrHtml_>)=} opt_content
+ * @return {!goog.html.SafeHtml}
+ * @throws {Error} If invalid or unsafe attribute name or value is provided.
+ * @throws {goog.asserts.AssertionError} If content for void tag is provided.
+ * @package
+ */
+goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse =
+    function(tagName, opt_attributes, opt_content) {
+  var dir = null;
+  var result = '<' + tagName;
+
+  if (opt_attributes) {
+    for (var name in opt_attributes) {
+      if (!goog.html.SafeHtml.VALID_NAMES_IN_TAG_.test(name)) {
+        throw Error('Invalid attribute name "' + name + '".');
+      }
+      var value = opt_attributes[name];
+      if (!goog.isDefAndNotNull(value)) {
+        continue;
+      }
+      result += ' ' +
+          goog.html.SafeHtml.getAttrNameAndValue_(tagName, name, value);
+    }
+  }
+
+  var content = opt_content;
+  if (!goog.isDef(content)) {
+    content = [];
+  } else if (!goog.isArray(content)) {
+    content = [content];
+  }
+
+  if (goog.dom.tags.isVoidTag(tagName.toLowerCase())) {
+    goog.asserts.assert(!content.length,
+        'Void tag <' + tagName + '> does not allow content.');
+    result += '>';
+  } else {
+    var html = goog.html.SafeHtml.concat(content);
+    result += '>' + goog.html.SafeHtml.unwrap(html) + '</' + tagName + '>';
+    dir = html.getDirection();
+  }
+
+  var dirAttribute = opt_attributes && opt_attributes['dir'];
+  if (dirAttribute) {
+    if (/^(ltr|rtl|auto)$/i.test(dirAttribute)) {
+      // If the tag has the "dir" attribute specified then its direction is
+      // neutral because it can be safely used in any context.
+      dir = goog.i18n.bidi.Dir.NEUTRAL;
+    } else {
+      dir = null;
+    }
+  }
+
+  return goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(
+      result, dir);
+};
+
+
 /**
  * A SafeHtml instance corresponding to the empty string.
  * @const {!goog.html.SafeHtml}
diff --git a/third_party/closure/goog/html/uncheckedconversions.js b/third_party/closure/goog/html/uncheckedconversions.js
index 3db40ec93c599..a1a5a9a7e4872 100644
--- a/third_party/closure/goog/html/uncheckedconversions.js
+++ b/third_party/closure/goog/html/uncheckedconversions.js
@@ -73,7 +73,7 @@ goog.html.uncheckedconversions.safeHtmlFromStringKnownToSatisfyTypeContract =
   goog.asserts.assertString(goog.string.Const.unwrap(justification),
                             'must provide justification');
   goog.asserts.assert(
-      !goog.string.isEmpty(goog.string.Const.unwrap(justification)),
+      !goog.string.isEmptyOrWhitespace(goog.string.Const.unwrap(justification)),
       'must provide non-empty justification');
   return goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(
       html, opt_dir || null);
@@ -133,7 +133,7 @@ goog.html.uncheckedconversions.safeStyleFromStringKnownToSatisfyTypeContract =
   goog.asserts.assertString(goog.string.Const.unwrap(justification),
                             'must provide justification');
   goog.asserts.assert(
-      !goog.string.isEmpty(goog.string.Const.unwrap(justification)),
+      !goog.string.isEmptyOrWhitespace(goog.string.Const.unwrap(justification)),
       'must provide non-empty justification');
   return goog.html.SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(
       style);
@@ -164,7 +164,7 @@ goog.html.uncheckedconversions.
   goog.asserts.assertString(goog.string.Const.unwrap(justification),
                             'must provide justification');
   goog.asserts.assert(
-      !goog.string.isEmpty(goog.string.Const.unwrap(justification)),
+      !goog.string.isEmptyOrWhitespace(goog.string.Const.unwrap(justification)),
       'must provide non-empty justification');
   return goog.html.SafeStyleSheet.
       createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(styleSheet);
@@ -194,7 +194,7 @@ goog.html.uncheckedconversions.safeUrlFromStringKnownToSatisfyTypeContract =
   goog.asserts.assertString(goog.string.Const.unwrap(justification),
                             'must provide justification');
   goog.asserts.assert(
-      !goog.string.isEmpty(goog.string.Const.unwrap(justification)),
+      !goog.string.isEmptyOrWhitespace(goog.string.Const.unwrap(justification)),
       'must provide non-empty justification');
   return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(url);
 };
@@ -224,7 +224,7 @@ goog.html.uncheckedconversions.
   goog.asserts.assertString(goog.string.Const.unwrap(justification),
                             'must provide justification');
   goog.asserts.assert(
-      !goog.string.isEmpty(goog.string.Const.unwrap(justification)),
+      !goog.string.isEmptyOrWhitespace(goog.string.Const.unwrap(justification)),
       'must provide non-empty justification');
   return goog.html.TrustedResourceUrl.
       createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(url);
diff --git a/third_party/closure/goog/labs/net/webchannel/webchannelbase.js b/third_party/closure/goog/labs/net/webchannel/webchannelbase.js
index 899da4cdfb065..903e721451149 100644
--- a/third_party/closure/goog/labs/net/webchannel/webchannelbase.js
+++ b/third_party/closure/goog/labs/net/webchannel/webchannelbase.js
@@ -1316,7 +1316,7 @@ WebChannelBase.prototype.onRequestData = function(request, responseText) {
     if (this.backChannelRequest_ == request) {
       this.clearDeadBackchannelTimer_();
     }
-    if (!goog.string.isEmpty(responseText)) {
+    if (!goog.string.isEmptyOrWhitespace(responseText)) {
       var response = this.wireCodec_.decodeMessage(responseText);
       this.onInput_(/** @type {!Array<?>} */ (response));
     }
diff --git a/third_party/closure/goog/labs/net/xhr.js b/third_party/closure/goog/labs/net/xhr.js
index fe3e8e8c99b4c..4471fc2bd7080 100644
--- a/third_party/closure/goog/labs/net/xhr.js
+++ b/third_party/closure/goog/labs/net/xhr.js
@@ -280,10 +280,15 @@ xhr.send = function(method, url, data, opt_options) {
       contentType = options.headers[xhr.CONTENT_TYPE_HEADER];
     }
 
-    // If a content type hasn't been set, and hasn't been explicitly set to
-    // null, default to form-urlencoded/UTF8 for POSTs.  This is because some
-    // proxies have been known to reject posts without a content-type.
-    if (method == 'POST' && contentType === undefined) {
+    // Browsers will automatically set the content type to multipart/form-data
+    // when passed a FormData object.
+    var dataIsFormData = (goog.global['FormData'] &&
+        (data instanceof goog.global['FormData']));
+    // If a content type hasn't been set, it hasn't been explicitly set to null,
+    // and the data isn't a FormData, default to form-urlencoded/UTF8 for POSTs.
+    // This is because some proxies have been known to reject posts without a
+    // content-type.
+    if (method == 'POST' && contentType === undefined && !dataIsFormData) {
       request.setRequestHeader(xhr.CONTENT_TYPE_HEADER, xhr.FORM_CONTENT_TYPE);
     }
 
diff --git a/third_party/closure/goog/labs/useragent/platform.js b/third_party/closure/goog/labs/useragent/platform.js
index d17ea98ff28bd..ece7c07ea1ae0 100644
--- a/third_party/closure/goog/labs/useragent/platform.js
+++ b/third_party/closure/goog/labs/useragent/platform.js
@@ -80,6 +80,8 @@ goog.labs.userAgent.platform.isMacintosh = function() {
 
 
 /**
+ * Note: ChromeOS is not considered to be Linux as it does not report itself
+ * as Linux in the user agent string.
  * @return {boolean} Whether the platform is Linux.
  */
 goog.labs.userAgent.platform.isLinux = function() {
diff --git a/third_party/closure/goog/messaging/portchannel.js b/third_party/closure/goog/messaging/portchannel.js
index 29580f2c008fe..1904a476ec8d0 100644
--- a/third_party/closure/goog/messaging/portchannel.js
+++ b/third_party/closure/goog/messaging/portchannel.js
@@ -348,7 +348,7 @@ goog.messaging.PortChannel.prototype.extractPorts_ = function(ports, message) {
   // We want to compare the exact constructor here because we only want to
   // recurse into object literals, not native objects like Date.
   } else if (message && message.constructor == Object) {
-    return goog.object.map(/** @type {Object} */ (message), function(val, key) {
+    return goog.object.map(/** @type {!Object} */(message), function(val, key) {
       val = this.extractPorts_(ports, val);
       return key == '_port' ? {'type': 'escaped', 'val': val} : val;
     }, this);
diff --git a/third_party/closure/goog/net/browserchannel.js b/third_party/closure/goog/net/browserchannel.js
index f4fa2ebb2c8b1..9ebfe93b5be28 100644
--- a/third_party/closure/goog/net/browserchannel.js
+++ b/third_party/closure/goog/net/browserchannel.js
@@ -1821,7 +1821,7 @@ goog.net.BrowserChannel.prototype.onRequestData =
     if (this.backChannelRequest_ == request) {
       this.clearDeadBackchannelTimer_();
     }
-    if (!goog.string.isEmpty(responseText)) {
+    if (!goog.string.isEmptyOrWhitespace(responseText)) {
       var response = this.parser_.parse(responseText);
       goog.asserts.assert(goog.isArray(response));
       this.onInput_(/** @type {!Array<?>} */ (response));
diff --git a/third_party/closure/goog/net/iframeio.js b/third_party/closure/goog/net/iframeio.js
index 3dbeb9e9cea99..456a358aa7714 100644
--- a/third_party/closure/goog/net/iframeio.js
+++ b/third_party/closure/goog/net/iframeio.js
@@ -325,7 +325,7 @@ goog.net.IframeIo.getNextName_ = function() {
 goog.net.IframeIo.getForm_ = function() {
   if (!goog.net.IframeIo.form_) {
     goog.net.IframeIo.form_ =
-        /** @type {HTMLFormElement} */(goog.dom.createDom('form'));
+        /** @type {!HTMLFormElement} */(goog.dom.createDom('form'));
     goog.net.IframeIo.form_.acceptCharset = 'utf-8';
 
     // Hide the form and move it off screen
@@ -1012,7 +1012,7 @@ goog.net.IframeIo.prototype.onIeReadyStateChange_ = function(e) {
       this.handleError_(goog.net.ErrorCode.ACCESS_DENIED);
       return;
     }
-    this.handleLoad_(/** @type {HTMLDocument} */(doc));
+    this.handleLoad_(/** @type {!HTMLDocument} */(doc));
   }
 };
 
@@ -1166,7 +1166,7 @@ goog.net.IframeIo.prototype.createIframe_ = function() {
     iframeAttributes.src = 'javascript:""';
   }
 
-  this.iframe_ = /** @type {HTMLIFrameElement} */(
+  this.iframe_ = /** @type {!HTMLIFrameElement} */(
       goog.dom.getDomHelper(this.form_).createDom('iframe', iframeAttributes));
 
   var s = this.iframe_.style;
@@ -1294,7 +1294,7 @@ goog.net.IframeIo.prototype.disposeForm_ = function() {
  */
 goog.net.IframeIo.prototype.getContentDocument_ = function() {
   if (this.iframe_) {
-    return /** @type {HTMLDocument} */(goog.dom.getFrameContentDocument(
+    return /** @type {!HTMLDocument} */(goog.dom.getFrameContentDocument(
         this.getRequestIframe()));
   }
   return null;
diff --git a/third_party/closure/goog/net/ipaddress.js b/third_party/closure/goog/net/ipaddress.js
index 07412d2183694..250847593e68f 100644
--- a/third_party/closure/goog/net/ipaddress.js
+++ b/third_party/closure/goog/net/ipaddress.js
@@ -83,10 +83,10 @@ goog.net.IpAddress.prototype.equals = function(other) {
 
 
 /**
- * @return {goog.math.Integer} The IP Address, as an Integer.
+ * @return {!goog.math.Integer} The IP Address, as an Integer.
  */
 goog.net.IpAddress.prototype.toInteger = function() {
-  return /** @type {goog.math.Integer} */ (goog.object.clone(this.ip_));
+  return /** @type {!goog.math.Integer} */ (goog.object.clone(this.ip_));
 };
 
 
diff --git a/third_party/closure/goog/net/xhrio.js b/third_party/closure/goog/net/xhrio.js
index 29afa41dc4e12..2edb794a584de 100644
--- a/third_party/closure/goog/net/xhrio.js
+++ b/third_party/closure/goog/net/xhrio.js
@@ -1165,7 +1165,7 @@ goog.net.XhrIo.prototype.getResponseHeaders = function() {
   var headersObject = {};
   var headersArray = this.getAllResponseHeaders().split('\r\n');
   for (var i = 0; i < headersArray.length; i++) {
-    if (goog.string.isEmpty(headersArray[i])) {
+    if (goog.string.isEmptyOrWhitespace(headersArray[i])) {
       continue;
     }
     var keyValue = goog.string.splitLimit(headersArray[i], ': ', 2);
diff --git a/third_party/closure/goog/net/xpc/crosspagechannel.js b/third_party/closure/goog/net/xpc/crosspagechannel.js
index e1f7d54fe7e6a..a8e3a6f5a3d2a 100644
--- a/third_party/closure/goog/net/xpc/crosspagechannel.js
+++ b/third_party/closure/goog/net/xpc/crosspagechannel.js
@@ -831,8 +831,8 @@ goog.net.xpc.CrossPageChannel.prototype.updateChannelNameAndCatalog = function(
 goog.net.xpc.CrossPageChannel.prototype.isMessageOriginAcceptable_ = function(
     opt_origin) {
   var peerHostname = this.cfg_[goog.net.xpc.CfgFields.PEER_HOSTNAME];
-  return goog.string.isEmptySafe(opt_origin) ||
-      goog.string.isEmptySafe(peerHostname) ||
+  return goog.string.isEmptyOrWhitespace(goog.string.makeSafe(opt_origin)) ||
+      goog.string.isEmptyOrWhitespace(goog.string.makeSafe(peerHostname)) ||
       opt_origin == this.cfg_[goog.net.xpc.CfgFields.PEER_HOSTNAME];
 };
 
diff --git a/third_party/closure/goog/pubsub/pubsub.js b/third_party/closure/goog/pubsub/pubsub.js
index ef1b34c0dd5e8..e7a2698ace6dd 100644
--- a/third_party/closure/goog/pubsub/pubsub.js
+++ b/third_party/closure/goog/pubsub/pubsub.js
@@ -247,11 +247,19 @@ goog.pubsub.PubSub.prototype.publish = function(topic, var_args) {
     // array.
     this.publishDepth_++;
 
+    // Copy var_args to a new array so they can be passed to subscribers.
+    // Note that we can't use Array.slice or goog.array.toArray for this for
+    // performance reasons. Using those with the arguments object will cause
+    // deoptimization.
+    var args = new Array(arguments.length - 1);
+    for (var i = 1, len = arguments.length; i < len; i++) {
+      args[i - 1] = arguments[i];
+    }
+
     // For each key in the list of subscription keys for the topic, apply the
     // function to the arguments in the appropriate context.  The length of the
     // array mush be fixed during the iteration, since subscribers may add new
     // subscribers during publishing.
-    var args = goog.array.slice(arguments, 1);
     for (var i = 0, len = keys.length; i < len; i++) {
       var key = keys[i];
       this.subscriptions_[key + 1].apply(this.subscriptions_[key + 2], args);
diff --git a/third_party/closure/goog/string/string.js b/third_party/closure/goog/string/string.js
index 3d5b8052066a1..2ac328223f5fc 100644
--- a/third_party/closure/goog/string/string.js
+++ b/third_party/closure/goog/string/string.js
@@ -1326,7 +1326,7 @@ goog.string.createUniqueString = function() {
  */
 goog.string.toNumber = function(str) {
   var num = Number(str);
-  if (num == 0 && goog.string.isEmpty(str)) {
+  if (num == 0 && goog.string.isEmptyOrWhitespace(str)) {
     return NaN;
   }
   return num;
diff --git a/third_party/closure/goog/structs/structs.js b/third_party/closure/goog/structs/structs.js
index 750814f2dc650..cf9f011d264cf 100644
--- a/third_party/closure/goog/structs/structs.js
+++ b/third_party/closure/goog/structs/structs.js
@@ -115,7 +115,7 @@ goog.structs.contains = function(col, val) {
     return col.containsValue(val);
   }
   if (goog.isArrayLike(col) || goog.isString(col)) {
-    return goog.array.contains(/** @type {Array<?>} */ (col), val);
+    return goog.array.contains(/** @type {!Array<?>} */ (col), val);
   }
   return goog.object.containsValue(col, val);
 };
@@ -135,7 +135,7 @@ goog.structs.isEmpty = function(col) {
   // collection and as such even whitespace matters
 
   if (goog.isArrayLike(col) || goog.isString(col)) {
-    return goog.array.isEmpty(/** @type {Array<?>} */ (col));
+    return goog.array.isEmpty(/** @type {!Array<?>} */ (col));
   }
   return goog.object.isEmpty(col);
 };
@@ -177,7 +177,7 @@ goog.structs.forEach = function(col, f, opt_obj) {
   if (typeof col.forEach == 'function') {
     col.forEach(f, opt_obj);
   } else if (goog.isArrayLike(col) || goog.isString(col)) {
-    goog.array.forEach(/** @type {Array<?>} */ (col), f, opt_obj);
+    goog.array.forEach(/** @type {!Array<?>} */ (col), f, opt_obj);
   } else {
     var keys = goog.structs.getKeys(col);
     var values = goog.structs.getValues(col);
diff --git a/third_party/closure/goog/style/style.js b/third_party/closure/goog/style/style.js
index b9b8c48d876b1..5c58ac7609e73 100644
--- a/third_party/closure/goog/style/style.js
+++ b/third_party/closure/goog/style/style.js
@@ -1967,7 +1967,7 @@ goog.style.getFontSize = function(el) {
       // value is inherited and we therefore don't want to count it twice.  If
       // it is different, this element either has explicit style or has a CSS
       // rule applying to it.
-      var parentElement = /** @type {Element} */ (el.parentNode);
+      var parentElement = /** @type {!Element} */ (el.parentNode);
       var parentSize = goog.style.getStyle_(parentElement, 'fontSize');
       return goog.style.getIePixelValue_(parentElement,
                                          fontSize == parentSize ?
diff --git a/third_party/closure/goog/testing/events/events.js b/third_party/closure/goog/testing/events/events.js
index c4c004868d0c7..e2070ab6d02c8 100644
--- a/third_party/closure/goog/testing/events/events.js
+++ b/third_party/closure/goog/testing/events/events.js
@@ -135,7 +135,7 @@ goog.testing.events.setEventClientXY_ = function(event, opt_coords) {
       event.target.nodeType == goog.dom.NodeType.ELEMENT) {
     try {
       opt_coords =
-          goog.style.getClientPosition(/** @type {Element} **/ (event.target));
+          goog.style.getClientPosition(/** @type {!Element} **/ (event.target));
     } catch (ex) {
       // IE sometimes throws if it can't get the position.
     }
diff --git a/third_party/closure/goog/testing/functionmock.js b/third_party/closure/goog/testing/functionmock.js
index 547236e07dc8d..4de9f2021ad9f 100644
--- a/third_party/closure/goog/testing/functionmock.js
+++ b/third_party/closure/goog/testing/functionmock.js
@@ -39,7 +39,7 @@ goog.require('goog.testing.StrictMock');
  *     Set to '[anonymous mocked function]' if not passed in.
  * @param {number=} opt_strictness One of goog.testing.Mock.LOOSE or
  *     goog.testing.Mock.STRICT. The default is STRICT.
- * @return {goog.testing.MockInterface} The mocked function.
+ * @return {!goog.testing.MockInterface} The mocked function.
  * @suppress {missingProperties} Mocks do not fit in the type system well.
  */
 goog.testing.FunctionMock = function(opt_functionName, opt_strictness) {
@@ -52,7 +52,7 @@ goog.testing.FunctionMock = function(opt_functionName, opt_strictness) {
       goog.testing.LooseMock : goog.testing.StrictMock;
   goog.object.extend(fn, new base({}));
 
-  return /** @type {goog.testing.MockInterface} */ (fn);
+  return /** @type {!goog.testing.MockInterface} */ (fn);
 };
 
 
diff --git a/third_party/closure/goog/testing/mockclassfactory.js b/third_party/closure/goog/testing/mockclassfactory.js
index be24fbc5e166b..e4adc103839f6 100644
--- a/third_party/closure/goog/testing/mockclassfactory.js
+++ b/third_party/closure/goog/testing/mockclassfactory.js
@@ -440,11 +440,11 @@ goog.testing.MockClassFactory.prototype.getMockClass_ =
  * @param {Function} classToMock The class that will be mocked.
  * @param {...*} var_args The arguments associated with this instance's
  *     constructor.
- * @return {goog.testing.StrictMock} The mock created for the provided class.
+ * @return {!goog.testing.StrictMock} The mock created for the provided class.
  */
 goog.testing.MockClassFactory.prototype.getStrictMockClass =
     function(namespace, classToMock, var_args) {
-  return /** @type {goog.testing.StrictMock} */ (this.getMockClass_(namespace,
+  return /** @type {!goog.testing.StrictMock} */ (this.getMockClass_(namespace,
       classToMock, true, arguments));
 };
 
diff --git a/third_party/closure/goog/testing/multitestrunner.js b/third_party/closure/goog/testing/multitestrunner.js
index 305821ac94046..3e41a90934090 100644
--- a/third_party/closure/goog/testing/multitestrunner.js
+++ b/third_party/closure/goog/testing/multitestrunner.js
@@ -1387,7 +1387,7 @@ goog.testing.MultiTestRunner.TestFrame.prototype.finish_ = function() {
  */
 goog.testing.MultiTestRunner.TestFrame.prototype.createIframe_ = function() {
   this.iframeEl_ =
-      /** @type {HTMLIFrameElement} */ (this.dom_.createDom('iframe'));
+      /** @type {!HTMLIFrameElement} */ (this.dom_.createDom('iframe'));
   this.getElement().appendChild(this.iframeEl_);
   this.eh_.listen(this.iframeEl_, 'load', this.onIframeLoaded_);
 };
diff --git a/third_party/closure/goog/testing/testcase.js b/third_party/closure/goog/testing/testcase.js
index a5977a346be98..36648a6cc3f9c 100644
--- a/third_party/closure/goog/testing/testcase.js
+++ b/third_party/closure/goog/testing/testcase.js
@@ -29,6 +29,8 @@ goog.provide('goog.testing.TestCase.Order');
 goog.provide('goog.testing.TestCase.Result');
 goog.provide('goog.testing.TestCase.Test');
 
+goog.require('goog.Promise');
+goog.require('goog.Thenable');
 goog.require('goog.object');
 goog.require('goog.testing.asserts');
 goog.require('goog.testing.stacktrace');
@@ -91,6 +93,21 @@ goog.testing.TestCase = function(opt_name) {
    */
   this.testsToRun_ = null;
 
+  /** @private {function(!goog.testing.TestCase.Result)} */
+  this.runNextTestCallback_ = goog.nullFunction;
+
+  /**
+   * The number of {@link runNextTest_} frames currently on the stack.
+   * When this exceeds {@link MAX_STACK_DEPTH_}, test execution is rescheduled
+   * for a later tick of the event loop.
+   * @see {finishTestInvocation_}
+   * @private {number}
+   */
+  this.depth_ = 0;
+
+  /** @private {goog.testing.TestCase.Test} */
+  this.curTest_ = null;
+
   var search = '';
   if (goog.global.location) {
     search = goog.global.location.search;
@@ -156,14 +173,25 @@ goog.testing.TestCase.prototype.getName = function() {
 
 
 /**
- * The maximum amount of time that the test can run before we force it to be
- * async.  This prevents the test runner from blocking the browser and
- * potentially hurting the Selenium test harness.
+ * The maximum amount of time in milliseconds that the test case can take
+ * before it is forced to yield and reschedule. This prevents the test runner
+ * from blocking the browser and potentially hurting the test harness.
  * @type {number}
  */
 goog.testing.TestCase.maxRunTime = 200;
 
 
+/**
+ * The maximum number of {@link runNextTest_} frames that can be on the stack
+ * before the test case is forced to yield and reschedule. Although modern
+ * browsers can handle thousands of stack frames, this is set conservatively
+ * because maximum stack depth has never been standardized, and engine-specific
+ * techniques like tail cail optimization can affect the exact depth.
+ * @private @const
+ */
+goog.testing.TestCase.MAX_STACK_DEPTH_ = 100;
+
+
 /**
  * The order to run the auto-discovered tests in.
  * @type {string}
@@ -399,24 +427,40 @@ goog.testing.TestCase.prototype.shouldRunTests = function() {
 
 
 /**
- * Executes each of the tests.
+ * Executes the tests, yielding asynchronously if execution time exceeds
+ * {@link maxRunTime}. There is no guarantee that the test case has finished
+ * once this method has returned. To be notified when the test case
+ * has finished, use {@link #setCompletedCallback} or
+ * {@link #runTestsReturningPromise}.
  */
 goog.testing.TestCase.prototype.execute = function() {
+  if (!this.prepareForRun_()) {
+    return;
+  }
+  this.log('Starting tests: ' + this.name_);
+  this.cycleTests();
+};
+
+
+/**
+ * Sets up the internal state of the test case for a run.
+ * @return {boolean} If false, preparation failed because the test case
+ *     is not supposed to run in the present environment.
+ * @private
+ */
+goog.testing.TestCase.prototype.prepareForRun_ = function() {
   this.started = true;
   this.reset();
   this.startTime_ = this.now();
   this.running = true;
   this.result_.totalCount = this.getCount();
-
   if (!this.shouldRunTests()) {
     this.log('shouldRunTests() returned false, skipping these tests.');
     this.result_.testSuppressed = true;
     this.finalize();
-    return;
+    return false;
   }
-
-  this.log('Starting tests: ' + this.name_);
-  this.cycleTests();
+  return true;
 };
 
 
@@ -592,7 +636,12 @@ goog.testing.TestCase.prototype.getTestResults = function() {
 
 
 /**
- * Executes each of the tests.
+ * Executes each of the tests, yielding asynchronously if execution time
+ * exceeds {@link #maxRunTime}. There is no guarantee that the test case
+ * has finished execution once this method has returned.
+ * To be notified when the test case has finished execution, use
+ * {@link #setCompletedCallback} or {@link #runTestsReturningPromise}.
+ *
  * Overridable by the individual test case.  This allows test cases to defer
  * when the test is actually started.  If overridden, finalize must be called
  * by the test to indicate it has finished.
@@ -607,6 +656,168 @@ goog.testing.TestCase.prototype.runTests = function() {
 };
 
 
+/**
+ * Executes each of the tests, returning a promise that resolves with the
+ * test results once they are done running.
+ * @return {!IThenable.<!goog.testing.TestCase.Result>}
+ * @final
+ * @package
+ */
+goog.testing.TestCase.prototype.runTestsReturningPromise = function() {
+  try {
+    this.setUpPage();
+  } catch (e) {
+    this.exceptionBeforeTest = e;
+  }
+  if (!this.prepareForRun_()) {
+    return goog.Promise.resolve(this.result_);
+  }
+  this.log('Starting tests: ' + this.name_);
+  this.saveMessage('Start');
+  this.batchTime_ = this.now();
+  return new goog.Promise(function(resolve) {
+    this.runNextTestCallback_ = resolve;
+    this.runNextTest_();
+  }, this);
+};
+
+
+/**
+ * Executes the next test method synchronously or with promises, depending on
+ * the test method's return value.
+ *
+ * If the test method returns a promise, the next test method will run once
+ * the promise is resolved or rejected. If the test method does not
+ * return a promise, it is assumed to be synchronous, and execution proceeds
+ * immediately to the next test method. This means that test cases can run
+ * partially synchronously and partially asynchronously, depending on
+ * the return values of their test methods. In particular, a test case
+ * executes synchronously until the first promise is returned from a
+ * test method (or until a resource limit is reached; see
+ * {@link finishTestInvocation_}).
+ * @private
+ */
+goog.testing.TestCase.prototype.runNextTest_ = function() {
+  this.curTest_ = this.next();
+  if (!this.curTest_ || !this.running) {
+    this.finalize();
+    this.runNextTestCallback_(this.result_);
+    return;
+  }
+  this.result_.runCount++;
+  this.log('Running test: ' + this.curTest_.name);
+  if (this.maybeFailTestEarly(this.curTest_)) {
+    this.finishTestInvocation_();
+    return;
+  }
+  goog.testing.TestCase.currentTestName = this.curTest_.name;
+  this.invokeTestFunction_(
+      this.setUp, this.safeRunTest_, this.safeTearDown_);
+};
+
+
+/**
+ * Calls the given test function, handling errors appropriately.
+ * @private
+ */
+goog.testing.TestCase.prototype.safeRunTest_ = function() {
+  this.invokeTestFunction_(
+      goog.bind(this.curTest_.ref, this.curTest_.scope),
+      this.safeTearDown_,
+      this.safeTearDown_);
+};
+
+
+/**
+ * Calls {@link tearDown}, handling errors appropriately.
+ * @param {*=} opt_error Error associated with the test, if any.
+ * @private
+ */
+goog.testing.TestCase.prototype.safeTearDown_ = function(opt_error) {
+  if (arguments.length == 1) {
+    this.doError(this.curTest_, opt_error);
+  }
+  this.invokeTestFunction_(
+      this.tearDown, this.finishTestInvocation_, this.finishTestInvocation_);
+};
+
+
+/**
+ * Calls the given {@code fn}, then calls either {@code onSuccess} or
+ * {@code onFailure}, either synchronously or using promises, depending on
+ * {@code fn}'s return value.
+ *
+ * If {@code fn} throws an exception, {@code onFailure} is called immediately
+ * with the exception.
+ *
+ * If {@code fn} returns a promise, and the promise is eventually resolved,
+ * {@code onSuccess} is called with no arguments. If the promise is eventually
+ * rejected, {@code onFailure} is called with the rejection reason.
+ *
+ * Otherwise, if {@code fn} neither returns a promise nor throws an exception,
+ * {@code onSuccess} is called immediately with no arguments.
+ *
+ * {@code fn}, {@code onSuccess}, and {@code onFailure} are all called with
+ * the TestCase instance as the method receiver.
+ *
+ * @param {function()} fn The function to call.
+ * @param {function()} onSuccess Success callback.
+ * @param {function(*)} onFailure Failure callback.
+ * @private
+ */
+goog.testing.TestCase.prototype.invokeTestFunction_ = function(
+    fn, onSuccess, onFailure) {
+  try {
+    var retval = fn.call(this);
+    if (goog.Thenable.isImplementedBy(retval) ||
+        goog.isFunction(retval && retval['then'])) {
+      var self = this;
+      retval.then(
+          function() { onSuccess.call(self); },
+          function(e) { onFailure.call(self, e); });
+    } else {
+      onSuccess.call(this);
+    }
+  } catch (e) {
+    onFailure.call(this, e);
+  }
+};
+
+
+/**
+ * Finishes up bookkeeping for the current test function, and schedules
+ * the next test function to run, either immediately or asychronously.
+ * @param {*=} opt_error Optional error resulting from the test invocation.
+ * @private
+ */
+goog.testing.TestCase.prototype.finishTestInvocation_ = function(opt_error) {
+  if (arguments.length == 1) {
+    this.doError(this.curTest_, opt_error);
+  }
+
+  // If no errors have been recorded for the test, it is a success.
+  if (!(this.curTest_.name in this.result_.resultsByName) ||
+      !this.result_.resultsByName[this.curTest_.name].length) {
+    this.doSuccess(this.curTest_);
+  }
+
+  goog.testing.TestCase.currentTestName = null;
+
+  // If the test case has consumed too much time or stack space,
+  // yield to avoid blocking the browser. Otherwise, proceed to the next test.
+  if (this.depth_ > goog.testing.TestCase.MAX_STACK_DEPTH_ ||
+      this.now() - this.batchTime_ > goog.testing.TestCase.maxRunTime) {
+    this.saveMessage('Breaking async');
+    this.batchTime_ = this.now();
+    this.depth_ = 0;
+    this.timeout(goog.bind(this.runNextTest_, this), 0);
+  } else {
+    ++this.depth_;
+    this.runNextTest_();
+  }
+};
+
+
 /**
  * Reorders the tests depending on the {@code order} field.
  * @param {Array<goog.testing.TestCase.Test>} tests An array of tests to
@@ -840,8 +1051,8 @@ goog.testing.TestCase.prototype.autoDiscoverTests = function() {
 goog.testing.TestCase.prototype.maybeFailTestEarly = function(testCase) {
   if (this.exceptionBeforeTest) {
     // We just use the first error to report an error on a failed test.
-    testCase.name = 'setUpPage for ' + testCase.name;
-    this.doError(testCase, this.exceptionBeforeTest);
+    this.curTest_.name = 'setUpPage for ' + this.curTest_.name;
+    this.doError(this.curTest_, this.exceptionBeforeTest);
     return true;
   }
   return false;
@@ -849,55 +1060,21 @@ goog.testing.TestCase.prototype.maybeFailTestEarly = function(testCase) {
 
 
 /**
- * Cycles through the tests, breaking out using a setTimeout if the execution
- * time has execeeded {@link #maxRunTime}.
+ * Cycles through the tests, yielding asynchronously if the execution time
+ * execeeds {@link #maxRunTime}. In particular, there is no guarantee that
+ * the test case has finished execution once this method has returned.
+ * To be notified when the test case has finished execution, use
+ * {@link #setCompletedCallback} or {@link #runTestsReturningPromise}.
  */
 goog.testing.TestCase.prototype.cycleTests = function() {
   this.saveMessage('Start');
   this.batchTime_ = this.now();
-  var nextTest;
-  while ((nextTest = this.next()) && this.running) {
-    this.result_.runCount++;
-    // Execute the test and handle the error, we execute all tests rather than
-    // stopping after a single error.
-    var cleanedUp = false;
-    try {
-      this.log('Running test: ' + nextTest.name);
-
-      if (this.maybeFailTestEarly(nextTest)) {
-        cleanedUp = true;
-      } else {
-        goog.testing.TestCase.currentTestName = nextTest.name;
-        this.setUp();
-        nextTest.execute();
-        this.tearDown();
-        goog.testing.TestCase.currentTestName = null;
-
-        cleanedUp = true;
-
-        this.doSuccess(nextTest);
-      }
-    } catch (e) {
-      this.doError(nextTest, e);
-
-      if (!cleanedUp) {
-        try {
-          this.tearDown();
-        } catch (e2) {} // Fail silently if tearDown is throwing the errors.
-      }
-    }
-
-    // If the max run time is exceeded call this function again async so as not
-    // to block the browser.
-    if (this.currentTestPointer_ < this.tests_.length &&
-        this.now() - this.batchTime_ > goog.testing.TestCase.maxRunTime) {
-      this.saveMessage('Breaking async');
-      this.timeout(goog.bind(this.cycleTests, this), 0);
-      return;
-    }
+  if (this.running) {
+    this.runNextTestCallback_ = goog.nullFunction;
+    // Kick off the tests. runNextTest_ will schedule all of the tests,
+    // using a mixture of synchronous and asynchronous strategies.
+    this.runNextTest_();
   }
-  // Tests are done.
-  this.finalize();
 };
 
 
@@ -1107,6 +1284,7 @@ goog.testing.TestCase.Test = function(name, ref, opt_scope) {
 
 /**
  * Executes the test function.
+ * @package
  */
 goog.testing.TestCase.Test.prototype.execute = function() {
   this.ref.call(this.scope);
diff --git a/third_party/closure/goog/testing/testrunner.js b/third_party/closure/goog/testing/testrunner.js
index 5678849d494db..a05041f4e795f 100644
--- a/third_party/closure/goog/testing/testrunner.js
+++ b/third_party/closure/goog/testing/testrunner.js
@@ -264,7 +264,21 @@ goog.testing.TestRunner.prototype.execute = function() {
   }
 
   this.testCase.setCompletedCallback(goog.bind(this.onComplete_, this));
-  this.testCase.runTests();
+  if (goog.testing.TestRunner.shouldUsePromises_(this.testCase)) {
+    this.testCase.runTestsReturningPromise();
+  } else {
+    this.testCase.runTests();
+  }
+};
+
+
+/**
+ * @param {!goog.testing.TestCase} testCase
+ * @return {boolean}
+ * @private
+ */
+goog.testing.TestRunner.shouldUsePromises_ = function(testCase) {
+  return testCase.constructor === goog.testing.TestCase;
 };
 
 
diff --git a/third_party/closure/goog/testing/ui/rendererharness.js b/third_party/closure/goog/testing/ui/rendererharness.js
index be7cc76a0e29c..43d955cf7f27c 100644
--- a/third_party/closure/goog/testing/ui/rendererharness.js
+++ b/third_party/closure/goog/testing/ui/rendererharness.js
@@ -135,7 +135,7 @@ goog.testing.ui.RendererHarness.prototype.attachControlAndDecorate =
   var child = this.decorateParent_.firstChild;
   assertEquals('The decorated node must be an element',
                goog.dom.NodeType.ELEMENT, child.nodeType);
-  control.decorate(/** @type {Element} */ (child));
+  control.decorate(/** @type {!Element} */ (child));
   return control.getElement();
 };
 
diff --git a/third_party/closure/goog/ui/ac/inputhandler.js b/third_party/closure/goog/ui/ac/inputhandler.js
index da19e640266c1..bedc799a323db 100644
--- a/third_party/closure/goog/ui/ac/inputhandler.js
+++ b/third_party/closure/goog/ui/ac/inputhandler.js
@@ -465,7 +465,7 @@ goog.ui.ac.InputHandler.prototype.attachInput = function(target) {
       var ownerDocument = goog.dom.getOwnerDocument(
           /** @type {Element} */ (target));
       if (goog.dom.getActiveElement(ownerDocument) == target) {
-        this.processFocus(/** @type {Element} */ (target));
+        this.processFocus(/** @type {!Element} */ (target));
       }
     }
   }
diff --git a/third_party/closure/goog/ui/component.js b/third_party/closure/goog/ui/component.js
index 134faa8426321..9e6564a77e256 100644
--- a/third_party/closure/goog/ui/component.js
+++ b/third_party/closure/goog/ui/component.js
@@ -1256,7 +1256,7 @@ goog.ui.Component.prototype.removeChild = function(child, opt_unrender) {
     throw Error(goog.ui.Component.Error.NOT_OUR_CHILD);
   }
 
-  return /** @type {goog.ui.Component} */(child);
+  return /** @type {!goog.ui.Component} */(child);
 };
 
 
diff --git a/third_party/closure/goog/ui/containerrenderer.js b/third_party/closure/goog/ui/containerrenderer.js
index ed17430d79614..c6ac213fdd018 100644
--- a/third_party/closure/goog/ui/containerrenderer.js
+++ b/third_party/closure/goog/ui/containerrenderer.js
@@ -247,17 +247,17 @@ goog.ui.ContainerRenderer.prototype.decorateChildren = function(container,
       next = node.nextSibling;
       if (node.nodeType == goog.dom.NodeType.ELEMENT) {
         // Decorate element node.
-        var child = this.getDecoratorForChild(/** @type {Element} */(node));
+        var child = this.getDecoratorForChild(/** @type {!Element} */(node));
         if (child) {
           // addChild() may need to look at the element.
-          child.setElementInternal(/** @type {Element} */(node));
+          child.setElementInternal(/** @type {!Element} */(node));
           // If the container is disabled, mark the child disabled too.  See
           // bug 1263729.  Note that this must precede the call to addChild().
           if (!container.isEnabled()) {
             child.setEnabled(false);
           }
           container.addChild(child);
-          child.decorate(/** @type {Element} */(node));
+          child.decorate(/** @type {!Element} */(node));
         }
       } else if (!node.nodeValue || goog.string.trim(node.nodeValue) == '') {
         // Remove empty text node, otherwise madness ensues (e.g. controls that
diff --git a/third_party/closure/goog/ui/control.js b/third_party/closure/goog/ui/control.js
index 4a418fc63d230..ef41d46283e73 100644
--- a/third_party/closure/goog/ui/control.js
+++ b/third_party/closure/goog/ui/control.js
@@ -518,6 +518,9 @@ goog.ui.Control.prototype.decorateInternal = function(element) {
 goog.ui.Control.prototype.enterDocument = function() {
   goog.ui.Control.superClass_.enterDocument.call(this);
 
+  // Call the renderer's setAriaStates method to set element's aria attributes.
+  this.renderer_.setAriaStates(this, this.getElementStrict());
+
   // Call the renderer's initializeDom method to configure properties of the
   // control's DOM that can only be done once it's in the document.
   this.renderer_.initializeDom(this);
diff --git a/third_party/closure/goog/ui/controlrenderer.js b/third_party/closure/goog/ui/controlrenderer.js
index b11c6ac753f70..b3e0c220bc43b 100644
--- a/third_party/closure/goog/ui/controlrenderer.js
+++ b/third_party/closure/goog/ui/controlrenderer.js
@@ -200,7 +200,6 @@ goog.ui.ControlRenderer.prototype.createDom = function(control) {
   var element = control.getDomHelper().createDom(
       'div', this.getClassNames(control).join(' '), control.getContent());
 
-  this.setAriaStates(control, element);
   return element;
 };
 
@@ -363,7 +362,6 @@ goog.ui.ControlRenderer.prototype.decorate = function(control, element) {
     goog.dom.classlist.set(element, classNames.join(' '));
   }
 
-  this.setAriaStates(control, element);
   return element;
 };
 
@@ -660,7 +658,8 @@ goog.ui.ControlRenderer.prototype.setContent = function(element, content) {
           // NodeList. The second condition filters out TextNode which also has
           // length attribute but is not array like. The nodes have to be cloned
           // because childHandler removes them from the list during iteration.
-          goog.array.forEach(goog.array.clone(/** @type {NodeList} */(content)),
+          goog.array.forEach(
+              goog.array.clone(/** @type {!NodeList} */(content)),
               childHandler);
         } else {
           // Node or string.
diff --git a/third_party/closure/goog/ui/cookieeditor.js b/third_party/closure/goog/ui/cookieeditor.js
index 1ac21bff7f927..6c7ee7b0d3118 100644
--- a/third_party/closure/goog/ui/cookieeditor.js
+++ b/third_party/closure/goog/ui/cookieeditor.js
@@ -105,14 +105,15 @@ goog.ui.CookieEditor.prototype.canDecorate = function() {
 /** @override */
 goog.ui.CookieEditor.prototype.createDom = function() {
   // Debug-only, so we don't need i18n.
-  this.clearButtonElem_ = /** @type {HTMLButtonElement} */ (goog.dom.createDom(
+  this.clearButtonElem_ = /** @type {!HTMLButtonElement} */ (goog.dom.createDom(
       goog.dom.TagName.BUTTON, /* attributes */ null, 'Clear'));
-  this.updateButtonElem_ = /** @type {HTMLButtonElement} */ (goog.dom.createDom(
-      goog.dom.TagName.BUTTON, /* attributes */ null, 'Update'));
+  this.updateButtonElem_ =
+      /** @type {!HTMLButtonElement} */ (goog.dom.createDom(
+          goog.dom.TagName.BUTTON, /* attributes */ null, 'Update'));
   var value = this.cookieKey_ && goog.net.cookies.get(this.cookieKey_);
-  this.textAreaElem_ = /** @type {HTMLTextAreaElement} */ (goog.dom.createDom(
+  this.textAreaElem_ = /** @type {!HTMLTextAreaElement} */ (goog.dom.createDom(
       goog.dom.TagName.TEXTAREA, /* attibutes */ null, value || ''));
-  this.valueWarningElem_ = /** @type {HTMLSpanElement} */ (goog.dom.createDom(
+  this.valueWarningElem_ = /** @type {!HTMLSpanElement} */ (goog.dom.createDom(
       goog.dom.TagName.SPAN, /* attibutes */ {
         'style': 'display:none;color:red'
       }, 'Invalid cookie value.'));
diff --git a/third_party/closure/goog/ui/custombuttonrenderer.js b/third_party/closure/goog/ui/custombuttonrenderer.js
index c11d3c04a3f3e..40150acd7eb46 100644
--- a/third_party/closure/goog/ui/custombuttonrenderer.js
+++ b/third_party/closure/goog/ui/custombuttonrenderer.js
@@ -78,7 +78,6 @@ goog.ui.CustomButtonRenderer.prototype.createDom = function(control) {
       this.createButton(button.getContent(), button.getDomHelper()));
   this.setTooltip(
       buttonElement, /** @type {!string}*/ (button.getTooltip()));
-  this.setAriaStates(button, buttonElement);
 
   return buttonElement;
 };
diff --git a/third_party/closure/goog/ui/dragdropdetector.js b/third_party/closure/goog/ui/dragdropdetector.js
index 0357c5491c4dd..53416a9e40175 100644
--- a/third_party/closure/goog/ui/dragdropdetector.js
+++ b/third_party/closure/goog/ui/dragdropdetector.js
@@ -61,7 +61,7 @@ goog.ui.DragDropDetector = function(opt_filePath) {
           goog.ui.DragDropDetector.BASE_CSS_NAME_, 'w3c-editable-iframe');
   iframe.src = opt_filePath || goog.ui.DragDropDetector.DEFAULT_FILE_PATH_;
 
-  this.element_ = /** @type {HTMLIFrameElement} */ (iframe);
+  this.element_ = /** @type {!HTMLIFrameElement} */ (iframe);
 
   this.handler_ = new goog.events.EventHandler(this);
   this.handler_.listen(iframe, goog.events.EventType.LOAD, this.initIframe_);
diff --git a/third_party/closure/goog/ui/editor/linkdialog.js b/third_party/closure/goog/ui/editor/linkdialog.js
index f992579cbfee2..44275adea6ce6 100644
--- a/third_party/closure/goog/ui/editor/linkdialog.js
+++ b/third_party/closure/goog/ui/editor/linkdialog.js
@@ -484,7 +484,7 @@ goog.ui.editor.LinkDialog.prototype.stopReferrerLeaks_ = false;
  * @private
  */
 goog.ui.editor.LinkDialog.prototype.createDialogContent_ = function() {
-  this.textToDisplayDiv_ = /** @type {HTMLDivElement} */(
+  this.textToDisplayDiv_ = /** @type {!HTMLDivElement} */(
       this.buildTextToDisplayDiv_());
   var content = this.dom.createDom(goog.dom.TagName.DIV, null,
       this.textToDisplayDiv_);
@@ -538,7 +538,7 @@ goog.ui.editor.LinkDialog.prototype.buildTextToDisplayDiv_ = function() {
     }
   }, [goog.ui.editor.messages.MSG_TEXT_TO_DISPLAY, goog.string.Unicode.NBSP]);
   goog.dom.safe.setInnerHtml(table.rows[0].cells[0], html);
-  this.textToDisplayInput_ = /** @type {HTMLInputElement} */(
+  this.textToDisplayInput_ = /** @type {!HTMLInputElement} */(
       this.dom.createDom(goog.dom.TagName.INPUT,
           {id: goog.ui.editor.LinkDialog.Id_.TEXT_TO_DISPLAY}));
   var textInput = this.textToDisplayInput_;
@@ -565,7 +565,7 @@ goog.ui.editor.LinkDialog.prototype.buildTextToDisplayDiv_ = function() {
  * @private
  */
 goog.ui.editor.LinkDialog.prototype.buildOpenInNewWindowDiv_ = function() {
-  this.openInNewWindowCheckbox_ = /** @type {HTMLInputElement} */(
+  this.openInNewWindowCheckbox_ = /** @type {!HTMLInputElement} */(
       this.dom.createDom(goog.dom.TagName.INPUT, {'type': 'checkbox'}));
   return this.dom.createDom(goog.dom.TagName.DIV, null,
       this.dom.createDom(goog.dom.TagName.LABEL, null,
@@ -589,7 +589,7 @@ goog.ui.editor.LinkDialog.prototype.buildRelNoFollowDiv_ = function() {
         'linkEnd': '</a>'
       });
 
-  this.relNoFollowCheckbox_ = /** @type {HTMLInputElement} */(
+  this.relNoFollowCheckbox_ = /** @type {!HTMLInputElement} */(
       this.dom.createDom(goog.dom.TagName.INPUT, {'type': 'checkbox'}));
   return this.dom.createDom(goog.dom.TagName.DIV, null,
       this.dom.createDom(goog.dom.TagName.LABEL, null,
@@ -801,7 +801,8 @@ goog.ui.editor.LinkDialog.prototype.syncOkButton_ = function() {
   } else {
     return;
   }
-  this.getOkButtonElement().disabled = goog.string.isEmptyOrWhitespace(inputValue);
+  this.getOkButtonElement().disabled =
+      goog.string.isEmptyOrWhitespace(inputValue);
 };
 
 
diff --git a/third_party/closure/goog/ui/emoji/emojipalette.js b/third_party/closure/goog/ui/emoji/emojipalette.js
index 0f4fa40603bb1..6f19144ffe330 100644
--- a/third_party/closure/goog/ui/emoji/emojipalette.js
+++ b/third_party/closure/goog/ui/emoji/emojipalette.js
@@ -181,7 +181,7 @@ goog.ui.emoji.EmojiPalette.prototype.getEmojiArrayFromProperties_ =
 goog.ui.emoji.EmojiPalette.prototype.loadAnimatedEmoji = function() {
   if (this.animatedEmoji_.length > 0) {
     for (var i = 0; i < this.animatedEmoji_.length; i++) {
-      var paletteItem = /** @type {Element} */ (this.animatedEmoji_[i][0]);
+      var paletteItem = /** @type {!Element} */ (this.animatedEmoji_[i][0]);
       var emoji =
           /** @type {goog.ui.emoji.Emoji} */ (this.animatedEmoji_[i][1]);
       var url = this.urlPrefix_ + emoji.getUrl();
diff --git a/third_party/closure/goog/ui/emoji/emojipaletterenderer.js b/third_party/closure/goog/ui/emoji/emojipaletterenderer.js
index b452c1493e099..ece47dbf2c82a 100644
--- a/third_party/closure/goog/ui/emoji/emojipaletterenderer.js
+++ b/third_party/closure/goog/ui/emoji/emojipaletterenderer.js
@@ -79,7 +79,7 @@ goog.ui.emoji.EmojiPaletteRenderer.getCssClass = function() {
  * @param {goog.ui.emoji.SpriteInfo} spriteInfo Spriting info for the emoji.
  * @param {string} displayUrl URL of the image served for this cell, whether
  *     an individual emoji image or a sprite.
- * @return {HTMLDivElement} The palette item for this emoji.
+ * @return {!HTMLDivElement} The palette item for this emoji.
  */
 goog.ui.emoji.EmojiPaletteRenderer.prototype.createPaletteItem =
     function(dom, id, spriteInfo, displayUrl) {
@@ -99,7 +99,7 @@ goog.ui.emoji.EmojiPaletteRenderer.prototype.createPaletteItem =
   var outerdiv =
       dom.createDom('div', goog.getCssName('goog-palette-cell-wrapper'), el);
   outerdiv.setAttribute(goog.ui.emoji.Emoji.ATTRIBUTE, id);
-  return /** @type {HTMLDivElement} */ (outerdiv);
+  return /** @type {!HTMLDivElement} */ (outerdiv);
 };
 
 
@@ -159,7 +159,7 @@ goog.ui.emoji.EmojiPaletteRenderer.prototype.buildElementFromSpriteMetadata =
     'background-position': x + ' ' + y
   });
 
-  return /** @type {HTMLDivElement} */ (el);
+  return /** @type {!HTMLDivElement} */ (el);
 };
 
 
diff --git a/third_party/closure/goog/ui/emoji/progressiveemojipaletterenderer.js b/third_party/closure/goog/ui/emoji/progressiveemojipaletterenderer.js
index 305944fab817a..c6896a65f17bf 100644
--- a/third_party/closure/goog/ui/emoji/progressiveemojipaletterenderer.js
+++ b/third_party/closure/goog/ui/emoji/progressiveemojipaletterenderer.js
@@ -53,7 +53,7 @@ goog.ui.emoji.ProgressiveEmojiPaletteRenderer.prototype.
   var y = spriteInfo.getYOffsetCssValue();
   // Need this extra div for proper vertical centering.
   var inner = dom.createDom('img', {'src': displayUrl});
-  var el = /** @type {HTMLDivElement} */ (dom.createDom('div',
+  var el = /** @type {!HTMLDivElement} */ (dom.createDom('div',
       goog.getCssName('goog-palette-cell-extra'), inner));
   goog.style.setStyle(el, {
     'width': width,
@@ -80,7 +80,7 @@ goog.ui.emoji.ProgressiveEmojiPaletteRenderer.prototype.
   var el = item.firstChild;
   while (el) {
     if ('IMG' == el.tagName) {
-      img = /** @type {Element} */ (el);
+      img = /** @type {!Element} */ (el);
       break;
     }
     el = el.firstChild;
diff --git a/third_party/closure/goog/ui/flatbuttonrenderer.js b/third_party/closure/goog/ui/flatbuttonrenderer.js
index 3309d3410adac..bb5b742fc1131 100644
--- a/third_party/closure/goog/ui/flatbuttonrenderer.js
+++ b/third_party/closure/goog/ui/flatbuttonrenderer.js
@@ -69,7 +69,6 @@ goog.ui.FlatButtonRenderer.prototype.createDom = function(button) {
   var element = button.getDomHelper().createDom(
       'div', attributes, button.getContent());
   this.setTooltip(element, button.getTooltip());
-  this.setAriaStates(button, element);
   return element;
 };
 
diff --git a/third_party/closure/goog/ui/flatmenubuttonrenderer.js b/third_party/closure/goog/ui/flatmenubuttonrenderer.js
index 35b5136c66e76..a3455b856327d 100644
--- a/third_party/closure/goog/ui/flatmenubuttonrenderer.js
+++ b/third_party/closure/goog/ui/flatmenubuttonrenderer.js
@@ -83,7 +83,6 @@ goog.ui.FlatMenuButtonRenderer.prototype.createDom = function(control) {
        this.createDropdown(button.getDomHelper())]);
   this.setTooltip(
       element, /** @type {!string}*/ (button.getTooltip()));
-  this.setAriaStates(button, element);
   return element;
 };
 
diff --git a/third_party/closure/goog/ui/hovercard.js b/third_party/closure/goog/ui/hovercard.js
index 4b8f597d59526..d6ed3c77e7d1b 100644
--- a/third_party/closure/goog/ui/hovercard.js
+++ b/third_party/closure/goog/ui/hovercard.js
@@ -199,7 +199,7 @@ goog.ui.HoverCard.prototype.handleTriggerMouseOver_ = function(e) {
                                        this.maxSearchSteps_);
     if (trigger) {
       this.setPosition(null);
-      this.triggerForElement(/** @type {Element} */ (trigger));
+      this.triggerForElement(/** @type {!Element} */ (trigger));
     }
   }
 };
diff --git a/third_party/closure/goog/ui/menubutton.js b/third_party/closure/goog/ui/menubutton.js
index 6160d1cf685d6..c9e20fd977bb3 100644
--- a/third_party/closure/goog/ui/menubutton.js
+++ b/third_party/closure/goog/ui/menubutton.js
@@ -97,14 +97,6 @@ goog.ui.MenuButton = function(opt_content, opt_menu, opt_renderer,
     this.setFocusablePopupMenu(true);
   }
 
-  /**
-   * Whether the enter or space key should close the menu, if it is already
-   * open. This should be true for accessibility reasons, but is provided as an
-   * option for backward compatibility.
-   * @private {boolean}
-   */
-  this.closeOnEnterOrSpace_ = true;
-
   /** @private {!goog.ui.MenuRenderer} */
   this.menuRenderer_ = opt_menuRenderer || goog.ui.MenuRenderer.getInstance();
 };
@@ -351,8 +343,7 @@ goog.ui.MenuButton.prototype.handleKeyEventInternal = function(e) {
     var isEnterOrSpace = e.keyCode == goog.events.KeyCodes.ENTER ||
         e.keyCode == goog.events.KeyCodes.SPACE;
     var handledByMenu = this.menu_.handleKeyEvent(e);
-    if (e.keyCode == goog.events.KeyCodes.ESC ||
-        isEnterOrSpace && this.closeOnEnterOrSpace_) {
+    if (e.keyCode == goog.events.KeyCodes.ESC || isEnterOrSpace) {
       // Dismiss the menu.
       this.setOpen(false);
       return true;
@@ -508,17 +499,6 @@ goog.ui.MenuButton.prototype.setMenuMargin = function(margin) {
 };
 
 
-/**
- * Sets whether the enter or space key should close the menu, if it is already
- * open. By default, only the ESC key will close an open menu.
- * @param {boolean} close Whether pressing Enter or Space when the button has
- *     focus will close the menu if it is already open.
- */
-goog.ui.MenuButton.prototype.setCloseOnEnterOrSpace = function(close) {
-  this.closeOnEnterOrSpace_ = close;
-};
-
-
 /**
  * Sets whether to select the first item in the menu when it is opened using
  * enter or space. By default, the first item is selected only when
@@ -1051,7 +1031,7 @@ goog.ui.MenuButton.prototype.attachPopupListeners_ = function(attach) {
 
   // Only listen for blur events dispatched by the menu if it is focusable.
   if (this.isFocusablePopupMenu()) {
-    method.call(handler, /** @type {goog.events.EventTarget} */ (this.menu_),
+    method.call(handler, /** @type {!goog.events.EventTarget} */ (this.menu_),
         goog.ui.Component.EventType.BLUR, this.handleMenuBlur);
   }
 
diff --git a/third_party/closure/goog/ui/modalpopup.js b/third_party/closure/goog/ui/modalpopup.js
index 7a549fd6201ca..a9953c0a99019 100644
--- a/third_party/closure/goog/ui/modalpopup.js
+++ b/third_party/closure/goog/ui/modalpopup.js
@@ -475,7 +475,7 @@ goog.ui.ModalPopup.prototype.show_ = function() {
 
   if (this.popupShowTransition_ && this.bgShowTransition_) {
     goog.events.listenOnce(
-        /** @type {goog.events.EventTarget} */ (this.popupShowTransition_),
+        /** @type {!goog.events.EventTarget} */ (this.popupShowTransition_),
         goog.fx.Transition.EventType.END, this.onShow, false, this);
     this.bgShowTransition_.play();
     this.popupShowTransition_.play();
@@ -507,7 +507,7 @@ goog.ui.ModalPopup.prototype.hide_ = function() {
 
   if (this.popupHideTransition_ && this.bgHideTransition_) {
     goog.events.listenOnce(
-        /** @type {goog.events.EventTarget} */ (this.popupHideTransition_),
+        /** @type {!goog.events.EventTarget} */ (this.popupHideTransition_),
         goog.fx.Transition.EventType.END, this.onHide, false, this);
     this.bgHideTransition_.play();
     // The transition whose END event you are listening to must be played last
diff --git a/third_party/closure/goog/ui/plaintextspellchecker.js b/third_party/closure/goog/ui/plaintextspellchecker.js
index 391206dfb47c8..5f65cca03525e 100644
--- a/third_party/closure/goog/ui/plaintextspellchecker.js
+++ b/third_party/closure/goog/ui/plaintextspellchecker.js
@@ -53,10 +53,9 @@ goog.ui.PlainTextSpellChecker = function(handler, opt_domHelper) {
 
   /**
    * Correction UI container.
-   * @type {HTMLDivElement}
-   * @private
+   * @private {!HTMLDivElement}
    */
-  this.overlay_ = /** @type {HTMLDivElement} */
+  this.overlay_ = /** @type {!HTMLDivElement} */
       (this.getDomHelper().createDom('div'));
   goog.style.setPreWrap(this.overlay_);
 
@@ -468,7 +467,7 @@ goog.ui.PlainTextSpellChecker.prototype.getElementProperties =
 goog.ui.PlainTextSpellChecker.prototype.onWordClick_ = function(event) {
   if (event.target.className == this.invalidWordClassName ||
       event.target.className == this.correctedWordClassName) {
-    this.showSuggestionsMenu(/** @type {Element} */ (event.target), event);
+    this.showSuggestionsMenu(/** @type {!Element} */ (event.target), event);
 
     // Prevent document click handler from closing the menu.
     event.stopPropagation();
diff --git a/third_party/closure/goog/ui/popupbase.js b/third_party/closure/goog/ui/popupbase.js
index 9e554da118490..8b986221ca43f 100644
--- a/third_party/closure/goog/ui/popupbase.js
+++ b/third_party/closure/goog/ui/popupbase.js
@@ -424,7 +424,10 @@ goog.ui.PopupBase.prototype.getLastHideTime = function() {
  * @template T
  */
 goog.ui.PopupBase.prototype.getHandler = function() {
-  return this.handler_;
+  // As the template type is unbounded, narrow the "this" type
+  var self = /** @type {!goog.ui.PopupBase} */ (this);
+
+  return self.handler_;
 };
 
 
@@ -607,7 +610,7 @@ goog.ui.PopupBase.prototype.show_ = function() {
   // the transition is over.
   if (this.showTransition_) {
     goog.events.listenOnce(
-        /** @type {goog.events.EventTarget} */ (this.showTransition_),
+        /** @type {!goog.events.EventTarget} */ (this.showTransition_),
         goog.fx.Transition.EventType.END, this.onShow_, false, this);
     this.showTransition_.play();
   } else {
@@ -643,7 +646,7 @@ goog.ui.PopupBase.prototype.hide_ = function(opt_target) {
   // (and fire HIDE event) after the transition is over.
   if (this.hideTransition_) {
     goog.events.listenOnce(
-        /** @type {goog.events.EventTarget} */ (this.hideTransition_),
+        /** @type {!goog.events.EventTarget} */ (this.hideTransition_),
         goog.fx.Transition.EventType.END,
         goog.partial(this.continueHidingPopup_, opt_target), false, this);
     this.hideTransition_.play();
diff --git a/third_party/closure/goog/ui/progressbar.js b/third_party/closure/goog/ui/progressbar.js
index 94e2ccd449a7f..f3a53b8a9e138 100644
--- a/third_party/closure/goog/ui/progressbar.js
+++ b/third_party/closure/goog/ui/progressbar.js
@@ -129,7 +129,7 @@ goog.ui.ProgressBar.prototype.exitDocument = function() {
  * @return {HTMLDivElement} The created thumb element.
  */
 goog.ui.ProgressBar.prototype.createThumb_ = function() {
-  return /** @type {HTMLDivElement} */ (this.getDomHelper().createDom('div',
+  return /** @type {!HTMLDivElement} */ (this.getDomHelper().createDom('div',
       goog.getCssName('progress-bar-thumb')));
 };
 
diff --git a/third_party/closure/goog/ui/prompt.js b/third_party/closure/goog/ui/prompt.js
index 820a3912bf256..752f49ca8db87 100644
--- a/third_party/closure/goog/ui/prompt.js
+++ b/third_party/closure/goog/ui/prompt.js
@@ -283,7 +283,7 @@ goog.ui.Prompt.prototype.createDom = function() {
     'value': this.defaultValue_};
   if (this.rows_ == 1) {
     // If rows == 1 then use an input element.
-    this.userInputEl_ = /** @type {HTMLInputElement} */
+    this.userInputEl_ = /** @type {!HTMLInputElement} */
         (this.getDomHelper().createDom('input', attrs));
     this.userInputEl_.type = 'text';
     if (this.cols_) {
@@ -291,7 +291,7 @@ goog.ui.Prompt.prototype.createDom = function() {
     }
   } else {
     // If rows > 1 then use a textarea.
-    this.userInputEl_ = /** @type {HTMLInputElement} */
+    this.userInputEl_ = /** @type {!HTMLInputElement} */
         (this.getDomHelper().createDom('textarea', attrs));
     this.userInputEl_.rows = this.rows_;
     if (this.cols_) {
diff --git a/third_party/closure/goog/ui/select.js b/third_party/closure/goog/ui/select.js
index 86dd82ab58370..6afa9e250beca 100644
--- a/third_party/closure/goog/ui/select.js
+++ b/third_party/closure/goog/ui/select.js
@@ -336,7 +336,7 @@ goog.ui.Select.prototype.setValue = function(value) {
     for (var i = 0, item; item = this.selectionModel_.getItemAt(i); i++) {
       if (item && typeof item.getValue == 'function' &&
           item.getValue() == value) {
-        this.setSelectedItem(/** @type {goog.ui.MenuItem} */ (item));
+        this.setSelectedItem(/** @type {!goog.ui.MenuItem} */ (item));
         return;
       }
     }
diff --git a/third_party/closure/goog/ui/slider.js b/third_party/closure/goog/ui/slider.js
index 83400657e0e19..bb243716c2387 100644
--- a/third_party/closure/goog/ui/slider.js
+++ b/third_party/closure/goog/ui/slider.js
@@ -124,13 +124,13 @@ goog.ui.Slider.prototype.createThumbs = function() {
 
 /**
  * Creates the thumb element.
- * @return {HTMLDivElement} The created thumb element.
+ * @return {!HTMLDivElement} The created thumb element.
  * @private
  */
 goog.ui.Slider.prototype.createThumb_ = function() {
   var thumb =
       this.getDomHelper().createDom('div', goog.ui.Slider.THUMB_CSS_CLASS);
   goog.a11y.aria.setRole(thumb, goog.a11y.aria.Role.BUTTON);
-  return /** @type {HTMLDivElement} */ (thumb);
+  return /** @type {!HTMLDivElement} */ (thumb);
 };
 
diff --git a/third_party/closure/goog/ui/tree/basenode.js b/third_party/closure/goog/ui/tree/basenode.js
index 930fa6d9e1344..d0a325d241468 100644
--- a/third_party/closure/goog/ui/tree/basenode.js
+++ b/third_party/closure/goog/ui/tree/basenode.js
@@ -232,7 +232,7 @@ goog.ui.tree.BaseNode.prototype.createDom = function() {
   // TODO(jakubvrana): Use safeHtmlToDocumentFragment() once it is ready.
   var element = this.getDomHelper().htmlToDocumentFragment(
       goog.html.SafeHtml.unwrap(this.toSafeHtml()));
-  this.setElementInternal(/** @type {Element} */ (element));
+  this.setElementInternal(/** @type {!Element} */ (element));
 };
 
 
diff --git a/third_party/closure/goog/ui/twothumbslider.js b/third_party/closure/goog/ui/twothumbslider.js
index 50054a06aff7a..79485112f61fd 100644
--- a/third_party/closure/goog/ui/twothumbslider.js
+++ b/third_party/closure/goog/ui/twothumbslider.js
@@ -109,13 +109,13 @@ goog.ui.TwoThumbSlider.prototype.getCssClass = function(orient) {
 /**
  * This creates a thumb element with the specified CSS class name.
  * @param {string} cs  CSS class name of the thumb to be created.
- * @return {HTMLDivElement} The created thumb element.
+ * @return {!HTMLDivElement} The created thumb element.
  * @private
  */
 goog.ui.TwoThumbSlider.prototype.createThumb_ = function(cs) {
   var thumb = this.getDomHelper().createDom('div', cs);
   goog.a11y.aria.setRole(thumb, goog.a11y.aria.Role.BUTTON);
-  return /** @type {HTMLDivElement} */ (thumb);
+  return /** @type {!HTMLDivElement} */ (thumb);
 };
 
 
diff --git a/third_party/closure/goog/ui/zippy.js b/third_party/closure/goog/ui/zippy.js
index 73f2b2e898269..004f84f5d1c63 100644
--- a/third_party/closure/goog/ui/zippy.js
+++ b/third_party/closure/goog/ui/zippy.js
@@ -96,7 +96,7 @@ goog.ui.Zippy = function(header, opt_content, opt_expanded,
    * @private
    */
   this.elContent_ = this.lazyCreateFunc_ || !opt_content ? null :
-      this.dom_.getElement(/** @type {Element} */ (opt_content));
+      this.dom_.getElement(/** @type {!Element} */ (opt_content));
 
   /**
    * Expanded state.
diff --git a/third_party/closure/goog/useragent/useragent.js b/third_party/closure/goog/useragent/useragent.js
index 8f65044bb52ba..c8999024c1bd5 100644
--- a/third_party/closure/goog/useragent/useragent.js
+++ b/third_party/closure/goog/useragent/useragent.js
@@ -277,13 +277,31 @@ goog.userAgent.WINDOWS = goog.userAgent.PLATFORM_KNOWN_ ?
     goog.labs.userAgent.platform.isWindows();
 
 
+/**
+ * Whether the user agent is Linux per the legacy behavior of
+ * goog.userAgent.LINUX, which considered ChromeOS to also be
+ * Linux.
+ * @return {boolean}
+ * @private
+ */
+goog.userAgent.isLegacyLinux_ = function() {
+  return goog.labs.userAgent.platform.isLinux() ||
+      goog.labs.userAgent.platform.isChromeOS();
+};
+
+
 /**
  * Whether the user agent is running on a Linux operating system.
+ *
+ * Note that goog.userAgent.LINUX considers ChromeOS to be Linux,
+ * while goog.labs.userAgent.platform considers ChromeOS and
+ * Linux to be different OSes.
+ *
  * @type {boolean}
  */
 goog.userAgent.LINUX = goog.userAgent.PLATFORM_KNOWN_ ?
     goog.userAgent.ASSUME_LINUX :
-    goog.labs.userAgent.platform.isLinux();
+    goog.userAgent.isLegacyLinux_();
 
 
 /**
diff --git a/third_party/closure/goog/useragent/useragenttestutil.js b/third_party/closure/goog/useragent/useragenttestutil.js
index e913c05237626..8f156600e08e7 100644
--- a/third_party/closure/goog/useragent/useragenttestutil.js
+++ b/third_party/closure/goog/useragent/useragenttestutil.js
@@ -54,7 +54,7 @@ goog.userAgentTestUtil.reinitializeUserAgent = function() {
 
   goog.userAgent.MAC = goog.labs.userAgent.platform.isMacintosh();
   goog.userAgent.WINDOWS = goog.labs.userAgent.platform.isWindows();
-  goog.userAgent.LINUX = goog.labs.userAgent.platform.isLinux();
+  goog.userAgent.LINUX = goog.userAgent.isLegacyLinux_();
   goog.userAgent.X11 = goog.userAgent.isX11_();
   goog.userAgent.ANDROID = goog.labs.userAgent.platform.isAndroid();
   goog.userAgent.IPAD = goog.labs.userAgent.platform.isIpad();