[wasm] Deleted old way of checking embedder limits on wasm size.

src/wasm/wasm-js.cc

 // Copyright 2015 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.
 
 #include "src/api-natives.h"
 #include "src/api.h"
 #include "src/asmjs/asm-js.h"
 #include "src/asmjs/asm-typer.h"
 #include "src/asmjs/asm-wasm-builder.h"
 #include "src/assert-scope.h"
@@ skipping 56 matching lines @@
                   i::handle(i_context->wasm_module_sym()), thrower,
                   "Argument 0 must be a WebAssembly.Module")) {
     return {};
   }
 
   Local<Object> module_obj = Local<Object>::Cast(args[0]);
   return i::Handle<i::WasmModuleObject>::cast(
       v8::Utils::OpenHandle(*module_obj));
 }
 
-bool IsCompilationAllowed(i::Isolate* isolate, ErrorThrower* thrower,
-                          v8::Local<v8::Value> source, bool is_async) {
-  // Allow caller to do one final check on thrower state, rather than
-  // one at each step. No information is lost - failure reason is captured
-  // in the thrower state.
-  if (thrower->error()) return false;
-
-  AllowWasmCompileCallback callback = isolate->allow_wasm_compile_callback();
-  if (callback != nullptr &&
-      !callback(reinterpret_cast<v8::Isolate*>(isolate), source, is_async)) {
-    thrower->RangeError(
-        "%ssynchronous compilation disallowed due to module size limit set by "
-        "embedder",
-        is_async ? "a" : "");
-    return false;
-  }
-  return true;
-}
-
-bool IsInstantiationAllowed(i::Isolate* isolate, ErrorThrower* thrower,
-                            v8::Local<v8::Value> module_or_bytes,
-                            i::MaybeHandle<i::JSReceiver> ffi, bool is_async) {
-  // Allow caller to do one final check on thrower state, rather than
-  // one at each step. No information is lost - failure reason is captured
-  // in the thrower state.
-  if (thrower->error()) return false;
-  v8::MaybeLocal<v8::Value> v8_ffi;
-  if (!ffi.is_null()) {
-    v8_ffi = v8::Local<v8::Value>::Cast(Utils::ToLocal(ffi.ToHandleChecked()));
-  }
-  AllowWasmInstantiateCallback callback =
-      isolate->allow_wasm_instantiate_callback();
-  if (callback != nullptr &&
-      !callback(reinterpret_cast<v8::Isolate*>(isolate), module_or_bytes,
-                v8_ffi, is_async)) {
-    thrower->RangeError(
-        "%ssynchronous instantiation disallowed due to module size limit set "
-        "by embedder",
-        is_async ? "a" : "");
-    return false;
-  }
-  return true;
-}
-
 i::wasm::ModuleWireBytes GetFirstArgumentAsBytes(
     const v8::FunctionCallbackInfo<v8::Value>& args, ErrorThrower* thrower) {
   if (args.Length() < 1) {
     thrower->TypeError("Argument 0 must be a buffer source");
     return i::wasm::ModuleWireBytes(nullptr, nullptr);
   }
 
   const byte* start = nullptr;
   size_t length = 0;
   v8::Local<v8::Value> source = args[0];
@@ skipping 52 matching lines @@
   HandleScope scope(isolate);
   ErrorThrower thrower(i_isolate, "WebAssembly.compile()");
 
   Local<Context> context = isolate->GetCurrentContext();
   v8::Local<v8::Promise::Resolver> resolver;
   if (!v8::Promise::Resolver::New(context).ToLocal(&resolver)) return;
   v8::ReturnValue<v8::Value> return_value = args.GetReturnValue();
   return_value.Set(resolver->GetPromise());
 
   auto bytes = GetFirstArgumentAsBytes(args, &thrower);
-  if (!IsCompilationAllowed(i_isolate, &thrower, args[0], true)) {
+  if (thrower.error()) {
     auto maybe = resolver->Reject(context, Utils::ToLocal(thrower.Reify()));
     CHECK(!maybe.IsNothing());
     return;
   }
-  DCHECK(!thrower.error());
   i::Handle<i::JSPromise> promise = Utils::OpenHandle(*resolver->GetPromise());
   i::wasm::AsyncCompile(i_isolate, promise, bytes);
 }
 
 // WebAssembly.validate(bytes) -> bool
 void WebAssemblyValidate(const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::Isolate* isolate = args.GetIsolate();
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   HandleScope scope(isolate);
   ErrorThrower thrower(i_isolate, "WebAssembly.validate()");
@@ skipping 14 matching lines @@
 // new WebAssembly.Module(bytes) -> WebAssembly.Module
 void WebAssemblyModule(const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::Isolate* isolate = args.GetIsolate();
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   if (i_isolate->wasm_module_callback()(args)) return;
 
   HandleScope scope(isolate);
   ErrorThrower thrower(i_isolate, "WebAssembly.Module()");
 
   auto bytes = GetFirstArgumentAsBytes(args, &thrower);
-  if (!IsCompilationAllowed(i_isolate, &thrower, args[0], false)) return;
 
-  DCHECK(!thrower.error());
+  if (thrower.error()) {
+    return;
+  }
   i::MaybeHandle<i::Object> module_obj =
       i::wasm::SyncCompile(i_isolate, &thrower, bytes);
   if (module_obj.is_null()) return;
 
   v8::ReturnValue<v8::Value> return_value = args.GetReturnValue();
   return_value.Set(Utils::ToLocal(module_obj.ToHandleChecked()));
 }
 
 // WebAssembly.Module.imports(module) -> Array<Import>
 void WebAssemblyModuleImports(const v8::FunctionCallbackInfo<v8::Value>& args) {
@@ skipping 56 matching lines @@
   v8::Isolate* isolate = args.GetIsolate();
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   if (i_isolate->wasm_instance_callback()(args)) return;
 
   ErrorThrower thrower(i_isolate, "WebAssembly.Instance()");
 
   auto maybe_module = GetFirstArgumentAsModule(args, &thrower);
   if (thrower.error()) return;
 
   auto maybe_imports = GetSecondArgumentAsImports(args, &thrower);
-  if (!IsInstantiationAllowed(i_isolate, &thrower, args[0], maybe_imports,
-                              false)) {
-    return;
-  }
-  DCHECK(!thrower.error());
+  if (thrower.error()) return;
 
   i::MaybeHandle<i::Object> instance_object = i::wasm::SyncInstantiate(
       i_isolate, &thrower, maybe_module.ToHandleChecked(), maybe_imports,
       i::MaybeHandle<i::JSArrayBuffer>());
   if (instance_object.is_null()) return;
   args.GetReturnValue().Set(Utils::ToLocal(instance_object.ToHandleChecked()));
 }
 
 // WebAssembly.instantiate(module, imports) -> WebAssembly.Instance
 // WebAssembly.instantiate(bytes, imports) ->
@@ skipping 32 matching lines @@
     CHECK(!maybe.IsNothing());
     return;
   }
 
   auto maybe_imports = GetSecondArgumentAsImports(args, &thrower);
   if (thrower.error()) {
     auto maybe = resolver->Reject(context, Utils::ToLocal(thrower.Reify()));
     CHECK(!maybe.IsNothing());
     return;
   }
-  if (!IsInstantiationAllowed(i_isolate, &thrower, args[0], maybe_imports,
-                              true)) {
-    auto maybe = resolver->Reject(context, Utils::ToLocal(thrower.Reify()));
-    CHECK(!maybe.IsNothing());
-    return;
-  }
   i::Handle<i::JSPromise> promise = Utils::OpenHandle(*resolver->GetPromise());
   if (HasBrand(first_arg, i::Handle<i::Symbol>(i_context->wasm_module_sym()))) {
     // WebAssembly.instantiate(module, imports) -> WebAssembly.Instance
     auto module_object = GetFirstArgumentAsModule(args, &thrower);
     i::wasm::AsyncInstantiate(i_isolate, promise,
                               module_object.ToHandleChecked(), maybe_imports);
   } else {
     // WebAssembly.instantiate(bytes, imports) -> {module, instance}
     auto bytes = GetFirstArgumentAsBytes(args, &thrower);
     if (thrower.error()) {
@@ skipping 548 matching lines @@
   i::Handle<i::Symbol> symbol(isolate->context()->wasm_memory_sym(), isolate);
   return HasBrand(value, symbol);
 }
 
 bool WasmJs::IsWasmTableObject(Isolate* isolate, Handle<Object> value) {
   i::Handle<i::Symbol> symbol(isolate->context()->wasm_table_sym(), isolate);
   return HasBrand(value, symbol);
 }
 }  // namespace internal
 }  // namespace v8