feat: use future for async storage

Author: LeuisKen

bridge/core/api/executing_context.cc

@@ -132,4 +132,12 @@ void ExecutingContextWebFMethods::ClearInterval(ExecutingContext* context,
  WindowOrWorkerGlobalScope::clearInterval(context, interval_id, shared_exception_state->exception_state);
 }
 
+void ExecutingContextWebFMethods::SetRunRustFutureTasks(ExecutingContext* context,
+ WebFNativeFunctionContext* callback_context,
+ SharedExceptionState* shared_exception_state) {
+ auto callback_impl = WebFNativeFunction::Create(callback_context, shared_exception_state);
+
+ context->SetRunRustFutureTasks(callback_impl);
+}
+
 } // namespace webf

bridge/core/executing_context.cc

@@ -392,6 +392,14 @@ void ExecutingContext::EnqueueMicrotask(MicrotaskCallback callback, void* data)
  JS_FreeValue(ctx(), proxy_data);
 }
 
+void ExecutingContext::SetRunRustFutureTasks(const std::shared_ptr<WebFNativeFunction>& run_future_task) {
+ run_rust_future_tasks_ = run_future_task;
+}
+
+void ExecutingContext::RunRustFutureTasks() {
+ run_rust_future_tasks_->Invoke(this, 0, nullptr);
+}
+
 void ExecutingContext::DrainPendingPromiseJobs() {
  // should executing pending promise jobs.
  JSContext* pctx;

bridge/core/executing_context.h

@@ -101,6 +101,8 @@ class ExecutingContext {
  void ReportError(JSValueConst error, char** rust_errmsg, uint32_t* rust_errmsg_length);
  void DrainMicrotasks();
  void EnqueueMicrotask(MicrotaskCallback callback, void* data = nullptr);
+ void SetRunRustFutureTasks(const std::shared_ptr<WebFNativeFunction>& run_rust_future_tasks);
+ void RunRustFutureTasks();
  void DefineGlobalProperty(const char* prop, JSValueConst value);
  ExecutionContextData* contextData();
  uint8_t* DumpByteCode(const char* code, uint32_t codeLength, const char* sourceURL, uint64_t* bytecodeLength);
@@ -225,6 +227,9 @@ class ExecutingContext {
 
  // Rust methods ptr should keep alive when ExecutingContext is disposing.
  const std::unique_ptr<ExecutingContextWebFMethods> public_method_ptr_ = nullptr;
+
+ // Rust future task queue run trigger
+ std::shared_ptr<WebFNativeFunction> run_rust_future_tasks_;
 };
 
 class ObjectProperty {

bridge/core/frame/dom_timer.cc

@@ -39,6 +39,7 @@ void DOMTimer::Fire() {
  }
  } else if (auto* callback = DynamicTo<WebFNativeFunction>(callback_.get())) {
  callback->Invoke(context_, 0, nullptr);
+ context_->RunRustFutureTasks();
  }
 }
 

bridge/core/frame/module_manager.cc

@@ -92,6 +92,7 @@ NativeValue* handleInvokeModuleTransientCallback(void* ptr,
  }
  context->dartIsolateContext()->profiler()->FinishTrackSteps();
  context->dartIsolateContext()->profiler()->FinishTrackAsyncEvaluation();
+ context->RunRustFutureTasks();
  return return_value;
  }
 }

bridge/core/native/native_loader.cc

@@ -37,6 +37,7 @@ static void ExecuteNativeLibrary(PluginLibraryEntryPoint entry_point,
  native_library_load_context->context, native_library_load_context->context->publicMethodPtr(),
  native_library_load_context->context->status()};
  void* result = entry_point(entry_data);
+ native_library_load_context->context->RunRustFutureTasks();
  }
 
  delete native_library_load_context;

bridge/core/page.cc

@@ -122,6 +122,7 @@ NativeValue* WebFPage::invokeModuleEvent(SharedNativeString* native_module_name,
  NativeValue tmp = callback->Invoke(context_, 2, params);
  auto* return_value = static_cast<NativeValue*>(dart_malloc(sizeof(NativeValue)));
  memcpy(return_value, &tmp, sizeof(NativeValue));
+ context_->RunRustFutureTasks();
  return return_value;
  }
 }

bridge/include/plugin_api/executing_context.h

@@ -41,6 +41,9 @@ using PublicContextSetInterval = int32_t (*)(ExecutingContext*,
  SharedExceptionState*);
 using PublicContextClearTimeout = void (*)(ExecutingContext*, int32_t, SharedExceptionState*);
 using PublicContextClearInterval = void (*)(ExecutingContext*, int32_t, SharedExceptionState*);
+using PublicContextSetRunRustFutureTasks = void (*)(ExecutingContext*,
+ WebFNativeFunctionContext*,
+ SharedExceptionState*);
 
 // Memory aligned and readable from WebF side.
 // Only C type member can be included in this class, any C++ type and classes can is not allowed to use here.
@@ -77,6 +80,9 @@ struct ExecutingContextWebFMethods {
  static void ClearInterval(ExecutingContext* context,
  int32_t interval_id,
  SharedExceptionState* shared_exception_state);
+ static void SetRunRustFutureTasks(ExecutingContext* context,
+ WebFNativeFunctionContext* callback_context,
+ SharedExceptionState* shared_exception_state);
 
  double version{1.0};
  PublicContextGetDocument context_get_document{document};
@@ -92,6 +98,7 @@ struct ExecutingContextWebFMethods {
  PublicContextSetInterval context_set_interval{SetInterval};
  PublicContextClearTimeout context_clear_timeout{ClearTimeout};
  PublicContextClearInterval context_clear_interval{ClearInterval};
+ PublicContextSetRunRustFutureTasks context_set_run_rust_future_tasks{SetRunRustFutureTasks};
 };
 
 } // namespace webf

bridge/rusty_webf_sys/Cargo.toml

@@ -10,7 +10,7 @@ license = "Apache-2.0"
 
 [dependencies]
 libc = "0.2.0"
-
+futures = "0.3"
 
 [dependencies.windows]
 version = "0.58.0"

bridge/rusty_webf_sys/src/executing_context.rs

@@ -22,10 +22,12 @@ pub struct ExecutingContextRustMethods {
  pub set_interval: extern "C" fn(*const OpaquePtr, *const WebFNativeFunctionContext, c_int, *const OpaquePtr) -> c_int,
  pub clear_timeout: extern "C" fn(*const OpaquePtr, c_int, *const OpaquePtr),
  pub clear_interval: extern "C" fn(*const OpaquePtr, c_int, *const OpaquePtr),
+ pub set_run_rust_future_tasks: extern "C" fn(*const OpaquePtr, *const WebFNativeFunctionContext, *const OpaquePtr) -> c_void,
 }
 
 pub type TimeoutCallback = Box<dyn Fn()>;
 pub type IntervalCallback = Box<dyn Fn()>;
+pub type RunRustFutureTasksCallback = Box<dyn Fn()>;
 
 /// An environment contains all the necessary running states of a web page.
 ///
@@ -259,6 +261,43 @@ impl ExecutingContext {
  }
  }
 
+ pub fn set_run_rust_future_tasks(&self, callback: RunRustFutureTasksCallback, exception_state: &ExceptionState) -> Result<(), String> {
+ let general_callback: WebFNativeFunction = Box::new(move |argc, argv| {
+ if argc != 0 {
+ println!("Invalid argument count for run rust future tasks callback");
+ return NativeValue::new_null();
+ }
+ callback();
+ NativeValue::new_null()
+ });
+
+ let callback_data = Box::new(WebFNativeFunctionContextData {
+ func: general_callback,
+ });
+ let callback_context_data_ptr = Box::into_raw(callback_data);
+ let callback_context = Box::new(WebFNativeFunctionContext {
+ callback: invoke_webf_native_function,
+ free_ptr: release_webf_native_function,
+ ptr: callback_context_data_ptr,
+ });
+ let callback_context_ptr = Box::into_raw(callback_context);
+
+ unsafe {
+ ((*self.method_pointer).set_run_rust_future_tasks)(self.ptr, callback_context_ptr, exception_state.ptr);
+ }
+
+ if exception_state.has_exception() {
+ unsafe {
+ let _ = Box::from_raw(callback_context_ptr);
+ let _ = Box::from_raw(callback_context_data_ptr);
+ }
+ return Err(exception_state.stringify(self));
+ }
+
+ Ok(())
+
+ }
+
 }
 
 impl Drop for ExecutingContext {
@@ -271,3 +310,13 @@ impl Drop for ExecutingContext {
  }
  }
 }
+
+impl Clone for ExecutingContext {
+ fn clone(&self) -> Self {
+ ExecutingContext {
+ ptr: self.ptr,
+ method_pointer: self.method_pointer,
+ status: self.status,
+ }
+ }
+}