[wasm] Remove the use of private symbols for branding.

src/wasm/module-compiler.cc

 // Copyright 2017 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/wasm/module-compiler.h>
 
 #include <atomic>
 
 #include "src/asmjs/asm-js.h"
 #include "src/assembler-inl.h"
@@ skipping 1300 matching lines @@
           ReportLinkError("imported function does not match the expected type",
                           index, module_name, import_name);
           return -1;
         }
         code_table->set(num_imported_functions, *import_wrapper);
         RecordStats(*import_wrapper, counters());
         num_imported_functions++;
         break;
       }
       case kExternalTable: {
-        if (!WasmJs::IsWasmTableObject(isolate_, value)) {
+        if (!value->IsWasmTableObject()) {
           ReportLinkError("table import requires a WebAssembly.Table", index,
                           module_name, import_name);
           return -1;
         }
         WasmIndirectFunctionTable& table =
             module_->function_tables[num_imported_tables];
         TableInstance& table_instance = table_instances_[num_imported_tables];
         table_instance.table_object = Handle<WasmTableObject>::cast(value);
         table_instance.js_wrappers = Handle<FixedArray>(
             table_instance.table_object->functions(), isolate_);
@@ skipping 51 matching lines @@
           table_instance.function_table->set(i, *UnwrapImportWrapper(val));
         }
 
         num_imported_tables++;
         break;
       }
       case kExternalMemory: {
         // Validation should have failed if more than one memory object was
         // provided.
         DCHECK(!instance->has_memory_object());
-        if (!WasmJs::IsWasmMemoryObject(isolate_, value)) {
+        if (!value->IsWasmMemoryObject()) {
           ReportLinkError("memory import must be a WebAssembly.Memory object",
                           index, module_name, import_name);
           return -1;
         }
         auto memory = Handle<WasmMemoryObject>::cast(value);
-        DCHECK(WasmJs::IsWasmMemoryObject(isolate_, memory));
         instance->set_memory_object(*memory);
         memory_ = Handle<JSArrayBuffer>(memory->array_buffer(), isolate_);
         uint32_t imported_cur_pages = static_cast<uint32_t>(
             memory_->byte_length()->Number() / WasmModule::kPageSize);
         if (imported_cur_pages < module_->min_mem_pages) {
           thrower_->LinkError(
               "memory import %d is smaller than maximum %u, got %u", index,
               module_->min_mem_pages, imported_cur_pages);
         }
         int32_t imported_max_pages = memory->maximum_pages();
@@ skipping 945 matching lines @@
     HandleScope scope(job_->isolate_);
     Handle<WasmModuleObject> result =
         WasmModuleObject::New(job_->isolate_, job_->compiled_module_);
     // {job_} is deleted in AsyncCompileSucceeded, therefore the {return}.
     return job_->AsyncCompileSucceeded(result);
   }
 };
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8