[wasm] Bumped DEPS for public js api tests, fixed failures.

test/mjsunit/wasm/js-api.js

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Flags: --expose-wasm --allow-natives-syntax
 
 load('test/mjsunit/wasm/wasm-constants.js');
 load('test/mjsunit/wasm/wasm-module-builder.js');
 
 function unexpectedSuccess() {
@@ skipping 347 matching lines @@
     'first argument must be a WebAssembly.Module');
 assertErrorMessage(
     () => new Instance(emptyModule, null), TypeError,
     'second argument must be an object');
 assertErrorMessage(() => new Instance(importingModule, null), TypeError, '');
 assertErrorMessage(
     () => new Instance(importingModule, undefined), TypeError, '');
 assertErrorMessage(
     () => new Instance(importingModule, {'': {g: () => {}}}), LinkError, '');
 assertErrorMessage(
-    () => new Instance(importingModule, {t: {f: () => {}}}), LinkError, '');
+    () => new Instance(importingModule, {t: {f: () => {}}}), TypeError, '');
 
 assertTrue(new Instance(emptyModule) instanceof Instance);
 assertTrue(new Instance(emptyModule, {}) instanceof Instance);
 
 // 'WebAssembly.Instance.prototype' data property
 let instanceProtoDesc = Object.getOwnPropertyDescriptor(Instance, 'prototype');
 assertEq(typeof instanceProtoDesc.value, 'object');
 assertFalse(instanceProtoDesc.writable);
 assertFalse(instanceProtoDesc.enumerable);
 assertFalse(instanceProtoDesc.configurable);
@@ skipping 407 matching lines @@
 assertInstantiateError(
     [importingModuleBinary, null], TypeError,
     /second argument must be an object/);
 assertInstantiateError(
     [emptyModule, null], TypeError, /first argument must be a BufferSource/);
 assertInstantiateError(
     [importingModuleBinary, null], TypeError, /TODO: error messages?/);
 assertInstantiateError(
     [importingModuleBinary, undefined], TypeError, /TODO: error messages?/);
 assertInstantiateError(
-    [importingModuleBinary, {}], LinkError, /TODO: error messages?/);
+    [importingModuleBinary, {}], TypeError, /TODO: error messages?/);
 assertInstantiateError(
     [importingModuleBinary, {'': {g: () => {}}}], LinkError,
     /TODO: error messages?/);
 assertInstantiateError(
-    [importingModuleBinary, {t: {f: () => {}}}], LinkError,
+    [importingModuleBinary, {t: {f: () => {}}}], TypeError,
     /TODO: error messages?/);
 assertInstantiateError(
     [memoryImportingModuleBinary, null], TypeError, /TODO: error messages?/);
 assertInstantiateError(
     [memoryImportingModuleBinary, undefined], TypeError,
     /TODO: error messages?/);
 assertInstantiateError(
-    [memoryImportingModuleBinary, {}], LinkError, /TODO: error messages?/);
+    [memoryImportingModuleBinary, {}], TypeError, /TODO: error messages?/);
 assertInstantiateError(
     [memoryImportingModuleBinary, {'mod': {'my_memory': scratch_memory}}],
-    LinkError, /TODO: error messages?/);
+    TypeError, /TODO: error messages?/);
 assertInstantiateError(
     [memoryImportingModuleBinary, {'': {'memory': scratch_memory}}], LinkError,
     /TODO: error messages?/);
 
 function assertInstantiateSuccess(module_or_bytes, imports) {
   var result = null;
   assertPromiseResult(instantiate(module_or_bytes, imports), result => {
     if (module_or_bytes instanceof Module) {
       assertTrue(result instanceof Instance);
     } else {
       assertTrue(result.module instanceof Module);
       assertTrue(result.instance instanceof Instance);
     }
   });
 }
 assertInstantiateSuccess(emptyModule);
 assertInstantiateSuccess(emptyModuleBinary);
 assertInstantiateSuccess(emptyModuleBinary.buffer);
 assertInstantiateSuccess(importingModule, {'': {f: () => {}}});
 assertInstantiateSuccess(importingModuleBinary, {'': {f: () => {}}});
 assertInstantiateSuccess(importingModuleBinary.buffer, {'': {f: () => {}}});
 assertInstantiateSuccess(
     memoryImportingModuleBinary, {'': {'my_memory': scratch_memory}});