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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

#[cfg(any(feature = "v2_16", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
use crate::WebsiteData;
use crate::WebsiteDataManager;
#[cfg(any(feature = "v2_16", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
use crate::WebsiteDataTypes;
use glib::object::IsA;
use glib::translate::*;
#[cfg(any(feature = "v2_16", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
use std::boxed::Box as Box_;
use std::ptr;

pub trait WebsiteDataManagerExtManual: 'static {
    /// Asynchronously clear the website data of the given `types` modified in the past `timespan`.
    ///
    /// If `timespan` is 0, all website data will be removed.
    ///
    /// When the operation is finished, `callback` will be called. You can then call
    /// `webkit_website_data_manager_clear_finish()` to get the result of the operation.
    ///
    /// Due to implementation limitations, this function does not currently delete
    /// any stored cookies if `timespan` is nonzero. This behavior may change in the
    /// future.
    /// ## `types`
    /// [`WebsiteDataTypes`][crate::WebsiteDataTypes]
    /// ## `timespan`
    /// a `GTimeSpan`
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable] or [`None`] to ignore
    /// ## `callback`
    /// a `GAsyncReadyCallback` to call when the request is satisfied
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    #[doc(alias = "webkit_website_data_manager_clear")]
    fn clear<P: FnOnce(Result<(), glib::Error>) + Send + 'static>(
        &self,
        types: WebsiteDataTypes,
        timespan: glib::TimeSpan,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    );

    /// Asynchronously removes the website data in the given `website_data` list.
    ///
    /// Asynchronously removes the website data of the given `types` for websites in the given `website_data` list.
    /// Use [`clear()`][Self::clear()] if you want to remove the website data for all sites.
    ///
    /// When the operation is finished, `callback` will be called. You can then call
    /// `webkit_website_data_manager_remove_finish()` to get the result of the operation.
    /// ## `types`
    /// [`WebsiteDataTypes`][crate::WebsiteDataTypes]
    /// ## `website_data`
    /// a `GList` of [`WebsiteData`][crate::WebsiteData]
    /// ## `cancellable`
    /// a [`gio::Cancellable`][crate::gio::Cancellable] or [`None`] to ignore
    /// ## `callback`
    /// a `GAsyncReadyCallback` to call when the request is satisfied
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    #[doc(alias = "webkit_website_data_manager_remove")]
    fn remove<P: FnOnce(Result<(), glib::Error>) + Send + 'static>(
        &self,
        types: WebsiteDataTypes,
        website_data: &[&WebsiteData],
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    );
}

impl<O: IsA<WebsiteDataManager>> WebsiteDataManagerExtManual for O {
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    fn clear<P: FnOnce(Result<(), glib::Error>) + Send + 'static>(
        &self,
        types: WebsiteDataTypes,
        timespan: glib::TimeSpan,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    ) {
        let user_data: Box_<P> = Box_::new(callback);
        unsafe extern "C" fn clear_trampoline<
            P: FnOnce(Result<(), glib::Error>) + Send + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = ptr::null_mut();
            let _ = ffi::webkit_website_data_manager_clear_finish(
                _source_object as *mut _,
                res,
                &mut error,
            );
            let result = if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<P> = Box_::from_raw(user_data as *mut _);
            callback(result);
        }
        let callback = clear_trampoline::<P>;
        unsafe {
            ffi::webkit_website_data_manager_clear(
                self.as_ref().to_glib_none().0,
                types.into_glib(),
                timespan.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    fn remove<P: FnOnce(Result<(), glib::Error>) + Send + 'static>(
        &self,
        types: WebsiteDataTypes,
        website_data: &[&WebsiteData],
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    ) {
        let user_data: Box_<P> = Box_::new(callback);
        unsafe extern "C" fn remove_trampoline<
            P: FnOnce(Result<(), glib::Error>) + Send + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = ptr::null_mut();
            let _ = ffi::webkit_website_data_manager_remove_finish(
                _source_object as *mut _,
                res,
                &mut error,
            );
            let result = if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<P> = Box_::from_raw(user_data as *mut _);
            callback(result);
        }
        let callback = remove_trampoline::<P>;
        unsafe {
            ffi::webkit_website_data_manager_remove(
                self.as_ref().to_glib_none().0,
                types.into_glib(),
                website_data.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }
}