[browser] rename C symbols

src/coreclr/vm/wasm/helpers.cpp

@@ -379,9 +379,9 @@ void _DacGlobals::Initialize()
 // Incorrectly typed temporary symbol to satisfy the linker.
 int g_pDebugger;
 
-extern "C" int32_t mono_wasm_browser_entropy(uint8_t* buffer, int32_t bufferLength)
+extern "C" int32_t dotnet_browser_random_bytes(uint8_t* buffer, int32_t bufferLength)
 {
-    PORTABILITY_ASSERT("mono_wasm_browser_entropy is not implemented");
+    PORTABILITY_ASSERT("dotnet_browser_random_bytes is not implemented");
     return -1;
 }
 

src/libraries/System.Runtime.InteropServices.JavaScript/src/System/Runtime/InteropServices/JavaScript/Interop/JavaScriptExports.cs

@@ -291,7 +291,7 @@ public static void BeforeSyncJSExport(JSMarshalerArgument* arguments_buffer)
             try
             {
                 var ctx = arg_exc.AssertCurrentThreadContext();
-                // note that this method is only executed when the caller is on another thread, via mono_wasm_invoke_jsexport_sync -> mono_wasm_install_js_worker_interop_wrapper
+                // note that this method is only executed when the caller is on another thread, via mono_wasm_invoke_jsexport_sync -> dotnet_browser_install_js_worker_interop_wrapper
                 ctx.IsPendingSynchronousCall = true;
                 if (ctx.IsMainThread)
                 {

src/libraries/System.Runtime.InteropServices.JavaScript/src/System/Runtime/InteropServices/JavaScript/JSFunctionBinding.cs

@@ -478,7 +478,7 @@ internal static unsafe void ResolveOrRejectPromise(JSProxyContext targetContext,
                 // meaning JS side needs to dispose it
                 exc.slot.ReceiverShouldFree = true;
 
-                // this copy is freed in mono_wasm_resolve_or_reject_promise
+                // this copy is freed in dotnet_browser_resolve_or_reject_promise
                 var bytes = sizeof(JSMarshalerArgument) * arguments.Length;
                 void* cpy = (void*)Marshal.AllocHGlobal(bytes);
                 arguments.CopyTo(new Span<JSMarshalerArgument>(cpy, arguments.Length));

src/libraries/System.Runtime.InteropServices.JavaScript/src/System/Runtime/InteropServices/JavaScript/Marshaling/JSMarshalerArgument.Task.cs

@@ -425,7 +425,7 @@ private bool CanMarshalTaskResultOnSameCall(JSProxyContext ctx)
             }
 
             // Otherwise this is JSExport return value and we can't use the args buffer, because the args buffer arrived in async message and nobody is reading after this.
-            // In such case the JS side already pre-created the Promise and we have to use it, to resolve it in separate call via `mono_wasm_resolve_or_reject_promise_post`
+            // In such case the JS side already pre-created the Promise and we have to use it, to resolve it in separate call via `dotnet_browser_resolve_or_reject_promise_post`
             // there is JSVHandle in this arg
             return false;
         }

src/mono/browser/runtime/cancelable-promise.ts

@@ -35,12 +35,12 @@ export function wrap_as_cancelable<T> (inner: Promise<T>): ControllablePromise<T
     return promise;
 }
 
-export function mono_wasm_cancel_promise (task_holder_gc_handle: GCHandle): void {
-    // cancelation should not arrive earlier than the promise created by marshaling in mono_wasm_invoke_jsimport_MT
-    invoke_later_when_on_ui_thread_async(() => mono_wasm_cancel_promise_impl(task_holder_gc_handle));
+export function dotnet_browser_cancel_promise (task_holder_gc_handle: GCHandle): void {
+    // cancelation should not arrive earlier than the promise created by marshaling in dotnet_browser_invoke_jsimport_mt
+    invoke_later_when_on_ui_thread_async(() => dotnet_browser_cancel_promise_impl(task_holder_gc_handle));
 }
 
-export function mono_wasm_cancel_promise_impl (task_holder_gc_handle: GCHandle): void {
+export function dotnet_browser_cancel_promise_impl (task_holder_gc_handle: GCHandle): void {
     if (!loaderHelpers.is_runtime_running()) {
         mono_log_debug("This promise can't be canceled, mono runtime already exited.");
         return;

src/mono/browser/runtime/corebindings.c

@@ -21,81 +21,81 @@
 #include "gc-common.h"
 
 //JS funcs
-extern void mono_wasm_release_cs_owned_object (int js_handle);
-extern void mono_wasm_resolve_or_reject_promise (void *args);
-extern void mono_wasm_cancel_promise (int task_holder_gc_handle);
-extern void mono_wasm_console_clear ();
+extern void dotnet_browser_release_cs_owned_object (int js_handle);
+extern void dotnet_browser_resolve_or_reject_promise (void *args);
+extern void dotnet_browser_cancel_promise (int task_holder_gc_handle);
+extern void dotnet_browser_console_clear ();
 extern void mono_wasm_set_entrypoint_breakpoint (int entry_point_metadata_token);
 extern void mono_wasm_trace_logger (const char *log_domain, const char *log_level, const char *message, mono_bool fatal, void *user_data);
-extern void mono_wasm_invoke_js_function (int function_js_handle, void *args);
+extern void dotnet_browser_invoke_js_function (int function_js_handle, void *args);
 
 extern int mono_runtime_run_module_cctor (MonoImage *image, MonoError *error);
 
 typedef void (*background_job_cb)(void);
 typedef int (*ds_job_cb)(void* data);
 
-void mono_wasm_bind_assembly_exports (char *assembly_name);
-void mono_wasm_assembly_get_entry_point (char *assembly_name, int auto_insert_breakpoint, MonoMethod **method_out);
-void mono_wasm_get_assembly_export (char *assembly_name, char *namespace, char *classname, char *methodname, int signature_hash, MonoMethod **method_out);
+void dotnet_browser_bind_assembly_exports (char *assembly_name);
+void dotnet_browser_get_entry_point (char *assembly_name, int auto_insert_breakpoint, MonoMethod **method_out);
+void dotnet_browser_get_assembly_export (char *assembly_name, char *namespace, char *classname, char *methodname, int signature_hash, MonoMethod **method_out);
 
 #ifndef DISABLE_THREADS
-void mono_wasm_release_cs_owned_object_post (pthread_t target_tid, int js_handle);
-void mono_wasm_resolve_or_reject_promise_post (pthread_t target_tid, void *args);
-void mono_wasm_cancel_promise_post (pthread_t target_tid, int task_holder_gc_handle);
+void dotnet_browser_release_cs_owned_object_post (pthread_t target_tid, int js_handle);
+void dotnet_browser_resolve_or_reject_promise_post (pthread_t target_tid, void *args);
+void dotnet_browser_cancel_promise_post (pthread_t target_tid, int task_holder_gc_handle);
 
 extern void mono_wasm_install_js_worker_interop (int context_gc_handle);
-void mono_wasm_install_js_worker_interop_wrapper (int context_gc_handle, void* beforeSyncJSImport, void* afterSyncJSImport, void* pumpHandler);
-extern void mono_wasm_uninstall_js_worker_interop ();
-extern void mono_wasm_invoke_jsimport_MT (void* signature, void* args);
-void mono_wasm_invoke_jsimport_async_post (pthread_t target_tid, void* signature, void* args);
-void mono_wasm_invoke_jsimport_sync_send (pthread_t target_tid, void* signature, void* args);
-void mono_wasm_invoke_js_function_send (pthread_t target_tid, int function_js_handle, void *args);
+void dotnet_browser_install_js_worker_interop_wrapper (int context_gc_handle, void* beforeSyncJSImport, void* afterSyncJSImport, void* pumpHandler);
+extern void dotnet_browser_uninstall_js_worker_interop ();
+extern void dotnet_browser_invoke_jsimport_mt (void* signature, void* args);
+void dotnet_browser_jsimport_async_post (pthread_t target_tid, void* signature, void* args);
+void dotnet_browser_jsimport_sync_send (pthread_t target_tid, void* signature, void* args);
+void dotnet_browser_invoke_js_function_send (pthread_t target_tid, int function_js_handle, void *args);
 extern void mono_threads_wasm_async_run_in_target_thread_vi (pthread_t target_thread, void (*func) (gpointer), gpointer user_data1);
 extern void mono_threads_wasm_async_run_in_target_thread_vii (pthread_t target_thread, void (*func) (gpointer, gpointer), gpointer user_data1, gpointer user_data2);
 extern void mono_threads_wasm_sync_run_in_target_thread_vii (pthread_t target_thread, void (*func) (gpointer, gpointer), gpointer user_data1, gpointer args);
-extern void mono_wasm_warn_about_blocking_wait (void* ptr, int32_t length);
+extern void dotnet_browser_warn_about_blocking_wait (void* ptr, int32_t length);
 #else
-extern void* mono_wasm_bind_js_import_ST (void *signature);
-extern void mono_wasm_invoke_jsimport_ST (int function_handle, void *args);
+extern void* dotnet_browser_bind_js_import_st (void *signature);
+extern void dotnet_browser_invoke_jsimport_st (int function_handle, void *args);
 #endif /* DISABLE_THREADS */
 
 // JS-based globalization
-extern char16_t* mono_wasm_get_locale_info (const uint16_t* locale, int32_t localeLength, const uint16_t* culture, int32_t cultureLength, const uint16_t* result, int32_t resultMaxLength, int *resultLength);
+extern char16_t* dotnet_browser_get_locale_info (const uint16_t* locale, int32_t localeLength, const uint16_t* culture, int32_t cultureLength, const uint16_t* result, int32_t resultMaxLength, int *resultLength);
 
 void bindings_initialize_internals (void)
 {
 #ifndef	ENABLE_JS_INTEROP_BY_VALUE
-	mono_add_internal_call ("Interop/Runtime::RegisterGCRoot", mono_wasm_register_root);
-	mono_add_internal_call ("Interop/Runtime::DeregisterGCRoot", mono_wasm_deregister_root);
+	mono_add_internal_call ("Interop/Runtime::RegisterGCRoot", dotnet_browser_register_root);
+	mono_add_internal_call ("Interop/Runtime::DeregisterGCRoot", dotnet_browser_unregister_root);
 #endif /* ENABLE_JS_INTEROP_BY_VALUE */
 
 #ifndef DISABLE_THREADS
-	mono_add_internal_call ("Interop/Runtime::ReleaseCSOwnedObjectPost", mono_wasm_release_cs_owned_object_post);
-	mono_add_internal_call ("Interop/Runtime::ResolveOrRejectPromisePost", mono_wasm_resolve_or_reject_promise_post);
-	mono_add_internal_call ("Interop/Runtime::InstallWebWorkerInterop", mono_wasm_install_js_worker_interop_wrapper);
-	mono_add_internal_call ("Interop/Runtime::UninstallWebWorkerInterop", mono_wasm_uninstall_js_worker_interop);
-	mono_add_internal_call ("Interop/Runtime::InvokeJSImportSync", mono_wasm_invoke_jsimport_MT);
-	mono_add_internal_call ("Interop/Runtime::InvokeJSImportSyncSend", mono_wasm_invoke_jsimport_sync_send);
-	mono_add_internal_call ("Interop/Runtime::InvokeJSImportAsyncPost", mono_wasm_invoke_jsimport_async_post);
-	mono_add_internal_call ("Interop/Runtime::InvokeJSFunctionSend", mono_wasm_invoke_js_function_send);
-	mono_add_internal_call ("Interop/Runtime::CancelPromisePost", mono_wasm_cancel_promise_post);
-	mono_add_internal_call ("System.Threading.Thread::WarnAboutBlockingWait", mono_wasm_warn_about_blocking_wait);
+	mono_add_internal_call ("Interop/Runtime::ReleaseCSOwnedObjectPost", dotnet_browser_release_cs_owned_object_post);
+	mono_add_internal_call ("Interop/Runtime::ResolveOrRejectPromisePost", dotnet_browser_resolve_or_reject_promise_post);
+	mono_add_internal_call ("Interop/Runtime::InstallWebWorkerInterop", dotnet_browser_install_js_worker_interop_wrapper);
+	mono_add_internal_call ("Interop/Runtime::UninstallWebWorkerInterop", dotnet_browser_uninstall_js_worker_interop);
+	mono_add_internal_call ("Interop/Runtime::InvokeJSImportSync", dotnet_browser_invoke_jsimport_mt);
+	mono_add_internal_call ("Interop/Runtime::InvokeJSImportSyncSend", dotnet_browser_jsimport_sync_send);
+	mono_add_internal_call ("Interop/Runtime::InvokeJSImportAsyncPost", dotnet_browser_jsimport_async_post);
+	mono_add_internal_call ("Interop/Runtime::InvokeJSFunctionSend", dotnet_browser_invoke_js_function_send);
+	mono_add_internal_call ("Interop/Runtime::CancelPromisePost", dotnet_browser_cancel_promise_post);
+	mono_add_internal_call ("System.Threading.Thread::WarnAboutBlockingWait", dotnet_browser_warn_about_blocking_wait);
 #else
-	mono_add_internal_call ("Interop/Runtime::BindJSImportST", mono_wasm_bind_js_import_ST);
-	mono_add_internal_call ("Interop/Runtime::InvokeJSImportST", mono_wasm_invoke_jsimport_ST);
+	mono_add_internal_call ("Interop/Runtime::BindJSImportST", dotnet_browser_bind_js_import_st);
+	mono_add_internal_call ("Interop/Runtime::InvokeJSImportST", dotnet_browser_invoke_jsimport_st);
 #endif /* DISABLE_THREADS */
 
-	mono_add_internal_call ("Interop/Runtime::ReleaseCSOwnedObject", mono_wasm_release_cs_owned_object);
-	mono_add_internal_call ("Interop/Runtime::ResolveOrRejectPromise", mono_wasm_resolve_or_reject_promise);
-	mono_add_internal_call ("Interop/Runtime::InvokeJSFunction", mono_wasm_invoke_js_function);
-	mono_add_internal_call ("Interop/Runtime::CancelPromise", mono_wasm_cancel_promise);
-	mono_add_internal_call ("Interop/Runtime::AssemblyGetEntryPoint", mono_wasm_assembly_get_entry_point);
-	mono_add_internal_call ("Interop/Runtime::BindAssemblyExports", mono_wasm_bind_assembly_exports);
-	mono_add_internal_call ("Interop/Runtime::GetAssemblyExport", mono_wasm_get_assembly_export);
-	mono_add_internal_call ("System.ConsolePal::Clear", mono_wasm_console_clear);
+	mono_add_internal_call ("Interop/Runtime::ReleaseCSOwnedObject", dotnet_browser_release_cs_owned_object);
+	mono_add_internal_call ("Interop/Runtime::ResolveOrRejectPromise", dotnet_browser_resolve_or_reject_promise);
+	mono_add_internal_call ("Interop/Runtime::InvokeJSFunction", dotnet_browser_invoke_js_function);
+	mono_add_internal_call ("Interop/Runtime::CancelPromise", dotnet_browser_cancel_promise);
+	mono_add_internal_call ("Interop/Runtime::AssemblyGetEntryPoint", dotnet_browser_get_entry_point);
+	mono_add_internal_call ("Interop/Runtime::BindAssemblyExports", dotnet_browser_bind_assembly_exports);
+	mono_add_internal_call ("Interop/Runtime::GetAssemblyExport", dotnet_browser_get_assembly_export);
+	mono_add_internal_call ("System.ConsolePal::Clear", dotnet_browser_console_clear);
 
 	// JS-based globalization
-	mono_add_internal_call ("Interop/JsGlobalization::GetLocaleInfo", mono_wasm_get_locale_info);
+	mono_add_internal_call ("Interop/JsGlobalization::GetLocaleInfo", dotnet_browser_get_locale_info);
 }
 
 static MonoAssembly* _mono_wasm_assembly_load (char *assembly_name)
@@ -112,7 +112,7 @@ static MonoAssembly* _mono_wasm_assembly_load (char *assembly_name)
 	return res;
 }
 
-void mono_wasm_assembly_get_entry_point (char *assembly_name, int auto_insert_breakpoint, MonoMethod **method_out)
+void dotnet_browser_get_entry_point (char *assembly_name, int auto_insert_breakpoint, MonoMethod **method_out)
 {
 	assert (assembly_name);
 	*method_out = NULL;
@@ -176,7 +176,7 @@ void mono_wasm_assembly_get_entry_point (char *assembly_name, int auto_insert_br
 	*method_out = method;
 }
 
-void mono_wasm_bind_assembly_exports (char *assembly_name)
+void dotnet_browser_bind_assembly_exports (char *assembly_name)
 {
 	MonoError error;
 	MonoAssembly* assembly;
@@ -200,7 +200,7 @@ void mono_wasm_bind_assembly_exports (char *assembly_name)
 				PVOLATILE(MonoObject) exc2 = NULL;
 				store_volatile((MonoObject**)&temp_exc, (MonoObject*)mono_object_to_string ((MonoObject*)temp_exc, (MonoObject **)&exc2));
 				if (exc2) {
-					mono_wasm_trace_logger ("jsinterop", "critical", "mono_wasm_bind_assembly_exports unexpected double fault", 1, NULL);
+					mono_wasm_trace_logger ("jsinterop", "critical", "dotnet_browser_bind_assembly_exports unexpected double fault", 1, NULL);
 				} else {
 					mono_wasm_trace_logger ("jsinterop", "critical", mono_string_to_utf8((MonoString*)temp_exc), 1, NULL);
 				}
@@ -213,7 +213,7 @@ void mono_wasm_bind_assembly_exports (char *assembly_name)
 	}
 }
 
-void mono_wasm_get_assembly_export (char *assembly_name, char *namespace, char *classname, char *methodname, int signature_hash, MonoMethod **method_out)
+void dotnet_browser_get_assembly_export (char *assembly_name, char *namespace, char *classname, char *methodname, int signature_hash, MonoMethod **method_out)
 {
 	MonoError error;
 	MonoAssembly* assembly;
@@ -251,7 +251,7 @@ void* before_sync_js_import;
 void* after_sync_js_import;
 void* synchronization_context_pump_handler;
 
-void mono_wasm_install_js_worker_interop_wrapper (int context_gc_handle, void* beforeSyncJSImport, void* afterSyncJSImport, void* pumpHandler)
+void dotnet_browser_install_js_worker_interop_wrapper (int context_gc_handle, void* beforeSyncJSImport, void* afterSyncJSImport, void* pumpHandler)
 {
 	before_sync_js_import = beforeSyncJSImport;
 	after_sync_js_import = afterSyncJSImport;
@@ -260,39 +260,39 @@ void mono_wasm_install_js_worker_interop_wrapper (int context_gc_handle, void* b
 }
 
 // async
-void mono_wasm_release_cs_owned_object_post (pthread_t target_tid, int js_handle)
+void dotnet_browser_release_cs_owned_object_post (pthread_t target_tid, int js_handle)
 {
-	mono_threads_wasm_async_run_in_target_thread_vi (target_tid, (void (*) (gpointer))mono_wasm_release_cs_owned_object, (gpointer)js_handle);
+	mono_threads_wasm_async_run_in_target_thread_vi (target_tid, (void (*) (gpointer))dotnet_browser_release_cs_owned_object, (gpointer)js_handle);
 }
 
 // async
-void mono_wasm_resolve_or_reject_promise_post (pthread_t target_tid, void* args)
+void dotnet_browser_resolve_or_reject_promise_post (pthread_t target_tid, void* args)
 {
-	mono_threads_wasm_async_run_in_target_thread_vi (target_tid, (void (*) (gpointer))mono_wasm_resolve_or_reject_promise, (gpointer)args);
+	mono_threads_wasm_async_run_in_target_thread_vi (target_tid, (void (*) (gpointer))dotnet_browser_resolve_or_reject_promise, (gpointer)args);
 }
 
 // async
-void mono_wasm_cancel_promise_post (pthread_t target_tid, int task_holder_gc_handle)
+void dotnet_browser_cancel_promise_post (pthread_t target_tid, int task_holder_gc_handle)
 {
-	mono_threads_wasm_async_run_in_target_thread_vi (target_tid, (void (*) (gpointer))mono_wasm_cancel_promise, (gpointer)task_holder_gc_handle);
+	mono_threads_wasm_async_run_in_target_thread_vi (target_tid, (void (*) (gpointer))dotnet_browser_cancel_promise, (gpointer)task_holder_gc_handle);
 }
 
 // async
-void mono_wasm_invoke_jsimport_async_post (pthread_t target_tid, void* signature, void* args)
+void dotnet_browser_jsimport_async_post (pthread_t target_tid, void* signature, void* args)
 {
-	mono_threads_wasm_async_run_in_target_thread_vii (target_tid, (void (*) (gpointer, gpointer))mono_wasm_invoke_jsimport_MT, (gpointer)signature, (gpointer)args);
+	mono_threads_wasm_async_run_in_target_thread_vii (target_tid, (void (*) (gpointer, gpointer))dotnet_browser_invoke_jsimport_mt, (gpointer)signature, (gpointer)args);
 }
 
 // sync
-void mono_wasm_invoke_jsimport_sync_send (pthread_t target_tid, void* signature, void* args)
+void dotnet_browser_jsimport_sync_send (pthread_t target_tid, void* signature, void* args)
 {
-	mono_threads_wasm_sync_run_in_target_thread_vii (target_tid, (void (*) (gpointer, gpointer))mono_wasm_invoke_jsimport_MT, (gpointer)signature, (gpointer)args);
+	mono_threads_wasm_sync_run_in_target_thread_vii (target_tid, (void (*) (gpointer, gpointer))dotnet_browser_invoke_jsimport_mt, (gpointer)signature, (gpointer)args);
 }
 
 // sync
-void mono_wasm_invoke_js_function_send (pthread_t target_tid, int function_js_handle, void *args)
+void dotnet_browser_invoke_js_function_send (pthread_t target_tid, int function_js_handle, void *args)
 {
-	mono_threads_wasm_sync_run_in_target_thread_vii (target_tid, (void (*) (gpointer, gpointer))mono_wasm_invoke_js_function, (gpointer)function_js_handle, (gpointer)args);
+	mono_threads_wasm_sync_run_in_target_thread_vii (target_tid, (void (*) (gpointer, gpointer))dotnet_browser_invoke_js_function, (gpointer)function_js_handle, (gpointer)args);
 }
 
 #endif /* DISABLE_THREADS */

src/mono/browser/runtime/crypto.ts

@@ -7,7 +7,7 @@ import { isSharedArrayBuffer, localHeapViewU8 } from "./memory";
 const batchedQuotaMax = 65536;
 let warnOnce = true;
 
-export function mono_wasm_browser_entropy (bufferPtr: number, bufferLength: number): number {
+export function dotnet_browser_random_bytes (bufferPtr: number, bufferLength: number): number {
     if (!globalThis.crypto || !globalThis.crypto.getRandomValues) {
         if (warnOnce) {
             mono_log_warn("This engine doesn't support crypto.getRandomValues. Please use a modern version or provide polyfill for 'globalThis.crypto.getRandomValues'.");