wef 0.6.0

Wef is a Rust library for embedding WebView functionality using Chromium Embedded Framework (CEF3) with offscreen rendering support.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

use std::marker::PhantomData;

use futures_util::future::BoxFuture;
use serde_json::Value;

use crate::{AsyncFunctionType, Frame, FunctionType, query::QueryCallback};

pub(crate) trait DynFunctionType: Send + Sync {
    fn num_arguments(&self) -> usize;

    fn call(
        &self,
        spawner: Option<&(dyn Fn(BoxFuture<'static, ()>) + Send + Sync)>,
        frame: Frame,
        args: Vec<Value>,
        callback: QueryCallback,
    );
}

pub(crate) struct DynFunctionWrapper<F, S, R> {
    func: F,
    _mark: PhantomData<(S, R)>,
}

impl<F, S, R> DynFunctionWrapper<F, S, R> {
    #[inline]
    pub(crate) fn new(func: F) -> Self {
        Self {
            func,
            _mark: PhantomData,
        }
    }
}

impl<F, S, R> DynFunctionType for DynFunctionWrapper<F, S, R>
where
    F: FunctionType<S, R> + Send + Sync,
    S: Send + Sync,
    R: Send + Sync,
{
    #[inline]
    fn num_arguments(&self) -> usize {
        F::NUM_ARGUMENTS
    }

    #[inline]
    fn call(
        &self,
        _spawner: Option<&(dyn Fn(BoxFuture<'static, ()>) + Send + Sync)>,
        frame: Frame,
        args: Vec<Value>,
        callback: QueryCallback,
    ) {
        callback.result(self.func.call(frame, args))
    }
}

pub(crate) struct DynAsyncFunctionWrapper<F, S, R> {
    func: F,
    _mark: PhantomData<(S, R)>,
}

impl<F, S, R> DynAsyncFunctionWrapper<F, S, R> {
    #[inline]
    pub(crate) fn new(func: F) -> Self {
        Self {
            func,
            _mark: PhantomData,
        }
    }
}

impl<F, S, R> DynFunctionType for DynAsyncFunctionWrapper<F, S, R>
where
    F: AsyncFunctionType<S, R> + Send + Sync,
    S: Send + Sync,
    R: Send + Sync,
{
    #[inline]
    fn num_arguments(&self) -> usize {
        F::NUM_ARGUMENTS
    }

    #[inline]
    fn call(
        &self,
        spawner: Option<&(dyn Fn(BoxFuture<'static, ()>) + Send + Sync)>,
        frame: Frame,
        args: Vec<Value>,
        callback: QueryCallback,
    ) {
        let spawner = spawner.expect("BUG: spawner is None");
        let fut = self.func.call(frame, args);
        spawner(Box::pin(async move { callback.result(fut.await) }));
    }
}