[librsvg: 8/14] Convert the gflags to glib-rs's new macros

[Federico Mena Quintero <federico src gnome org>]

commit 94af19e32ba7104cd5a91ba2fc1805eb51ee2d86
Author: Federico Mena Quintero <federico gnome org>
Date:   Mon Mar 22 20:35:23 2021 -0600

    Convert the gflags to glib-rs's new macros

 Cargo.lock          |   9 ++--
 Cargo.toml          |   1 -
 src/c_api/handle.rs | 124 ++++++++--------------------------------------------
 tests/api.c         |  40 ++++++++---------
 4 files changed, 42 insertions(+), 132 deletions(-)
---
diff --git a/Cargo.lock b/Cargo.lock
index eefb251e..176a1b24 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -908,7 +908,6 @@ name = "librsvg"
 version = "2.51.0"
 dependencies = [
  "assert_cmd",
- "bitflags",
  "cairo-rs",
  "cairo-sys-rs",
  "cast",
@@ -1845,9 +1844,9 @@ checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
 
 [[package]]
 name = "serde"
-version = "1.0.124"
+version = "1.0.125"
 source = "registry+https://github.com/rust-lang/crates.io-index";
-checksum = "bd761ff957cb2a45fbb9ab3da6512de9de55872866160b23c25f1a841e99d29f"
+checksum = "558dc50e1a5a5fa7112ca2ce4effcb321b0300c0d4ccf0776a9f60cd89031171"
 
 [[package]]
 name = "serde_cbor"
@@ -1861,9 +1860,9 @@ dependencies = [
 
 [[package]]
 name = "serde_derive"
-version = "1.0.124"
+version = "1.0.125"
 source = "registry+https://github.com/rust-lang/crates.io-index";
-checksum = "1800f7693e94e186f5e25a28291ae1570da908aff7d97a095dec1e56ff99069b"
+checksum = "b093b7a2bb58203b5da3056c05b4ec1fed827dcfdb37347a8841695263b3d06d"
 dependencies = [
  "proc-macro2 1.0.24",
  "quote 1.0.9",
diff --git a/Cargo.toml b/Cargo.toml
index 447fc1bf..343cf664 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -33,7 +33,6 @@ name = "librsvg"
 crate-type = [ "staticlib", "rlib" ]
 
 [dependencies]
-bitflags = "1.0"
 # Keep these in sync with respect to the cairo-rs version:
 #   src/lib.rs - toplevel example in the docs
 cairo-rs = { version="0.9.1", features=["v1_16", "png", "pdf", "ps", "svg"] }
diff --git a/src/c_api/handle.rs b/src/c_api/handle.rs
index e05535fe..2aa9a372 100644
--- a/src/c_api/handle.rs
+++ b/src/c_api/handle.rs
@@ -33,7 +33,6 @@ use std::str;
 use std::sync::Once;
 use std::{f64, i32};
 
-use bitflags::bitflags;
 use gdk_pixbuf::Pixbuf;
 use gio::prelude::*;
 use glib::error::ErrorDomain;
@@ -44,15 +43,14 @@ use glib::subclass;
 use glib::subclass::object::ObjectClassSubclassExt;
 use glib::subclass::prelude::*;
 use glib::translate::*;
-use glib::value::{FromValue, FromValueOptional, SetValue};
 use glib::{
     glib_object_impl, glib_object_subclass, Bytes, Cast, ParamFlags, ParamSpec, StaticType,
-    ToValue, Type, Value,
+    ToValue, Type,
 };
 
 use glib::types::instance_of;
 
-use gobject_sys::{GEnumValue, GFlagsValue};
+use gobject_sys::GEnumValue;
 
 use crate::api::{self, CairoRenderer, IntrinsicDimensions, Loader, LoadingError, SvgHandle};
 
@@ -93,76 +91,31 @@ impl fmt::Display for RenderingError {
     }
 }
 
-mod handle_flags {
-    // The following is entirely stolen from the auto-generated code
-    // for GBindingFlags, from gtk-rs/glib/src/gobject/auto/flags.rs
+#[glib::gflags("RsvgHandleFlags")]
+pub enum HandleFlags {
+    #[gflags(name = "RSVG_HANDLE_FLAGS_NONE", nick = "flags-none")]
+    NONE = 0,
 
-    use super::*;
-
-    // Keep these in sync with rsvg.h:RsvgHandleFlags
-    #[rustfmt::skip]
-    bitflags! {
-        pub struct HandleFlags: u32 {
-            const NONE            = 0;
-            const UNLIMITED       = 1 << 0;
-            const KEEP_IMAGE_DATA = 1 << 1;
-        }
-    }
-
-    pub type RsvgHandleFlags = libc::c_uint;
+    #[gflags(name = "RSVG_HANDLE_FLAG_UNLIMITED", nick = "flag-unlimited")]
+    UNLIMITED = 1 << 0,
 
-    impl ToGlib for HandleFlags {
-        type GlibType = RsvgHandleFlags;
-
-        fn to_glib(&self) -> RsvgHandleFlags {
-            self.bits()
-        }
-    }
-
-    impl FromGlib<RsvgHandleFlags> for HandleFlags {
-        fn from_glib(value: RsvgHandleFlags) -> HandleFlags {
-            HandleFlags::from_bits_truncate(value)
-        }
-    }
-
-    impl StaticType for HandleFlags {
-        fn static_type() -> Type {
-            unsafe { from_glib(rsvg_handle_flags_get_type()) }
-        }
-    }
-
-    impl<'a> FromValueOptional<'a> for HandleFlags {
-        unsafe fn from_value_optional(value: &Value) -> Option<Self> {
-            Some(FromValue::from_value(value))
-        }
-    }
-
-    impl<'a> FromValue<'a> for HandleFlags {
-        unsafe fn from_value(value: &Value) -> Self {
-            from_glib(gobject_sys::g_value_get_flags(value.to_glib_none().0))
-        }
-    }
-
-    impl SetValue for HandleFlags {
-        unsafe fn set_value(value: &mut Value, this: &Self) {
-            gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
-        }
-    }
+    #[gflags(name = "RSVG_HANDLE_FLAG_KEEP_IMAGE_DATA", nick = "flag-keep-image-data")]
+    KEEP_IMAGE_DATA = 1 << 1,
 }
 
+pub type RsvgHandleFlags = u32;
+
 #[derive(Default, Copy, Clone)]
 struct LoadFlags {
     unlimited_size: bool,
     keep_image_data: bool,
 }
 
-use self::handle_flags::*;
-
 impl From<HandleFlags> for LoadFlags {
-    fn from(hflags: HandleFlags) -> LoadFlags {
+    fn from(flags: HandleFlags) -> LoadFlags {
         LoadFlags {
-            unlimited_size: hflags.contains(HandleFlags::UNLIMITED),
-            keep_image_data: hflags.contains(HandleFlags::KEEP_IMAGE_DATA),
+            unlimited_size: flags.contains(HandleFlags::UNLIMITED),
+            keep_image_data: flags.contains(HandleFlags::KEEP_IMAGE_DATA),
         }
     }
 }
@@ -1188,48 +1141,7 @@ pub unsafe extern "C" fn rsvg_error_get_type() -> glib_sys::GType {
 
 #[no_mangle]
 pub unsafe extern "C" fn rsvg_handle_flags_get_type() -> glib_sys::GType {
-    static ONCE: Once = Once::new();
-    static mut FTYPE: glib_sys::GType = gobject_sys::G_TYPE_INVALID;
-
-    // We have to store the GFlagsValue in a static variable but
-    // that requires it to be Sync. It is not Sync by default
-    // because it contains pointers, so we have define a custom
-    // wrapper type here on which we can implement Sync.
-    #[repr(transparent)]
-    struct GFlagsValueWrapper(GFlagsValue);
-    unsafe impl Sync for GFlagsValueWrapper {}
-
-    static VALUES: [GFlagsValueWrapper; 4] = [
-        GFlagsValueWrapper(GFlagsValue {
-            value: 0, // handle_flags::HandleFlags::NONE.bits(),
-            value_name: b"RSVG_HANDLE_FLAGS_NONE\0" as *const u8 as *const _,
-            value_nick: b"flags-none\0" as *const u8 as *const _,
-        }),
-        GFlagsValueWrapper(GFlagsValue {
-            value: 1 << 0, // HandleFlags::UNLIMITED.to_glib(),
-            value_name: b"RSVG_HANDLE_FLAG_UNLIMITED\0" as *const u8 as *const _,
-            value_nick: b"flag-unlimited\0" as *const u8 as *const _,
-        }),
-        GFlagsValueWrapper(GFlagsValue {
-            value: 1 << 1, // HandleFlags::KEEP_IMAGE_DATA.to_glib(),
-            value_name: b"RSVG_HANDLE_FLAG_KEEP_IMAGE_DATA\0" as *const u8 as *const _,
-            value_nick: b"flag-keep-image-data\0" as *const u8 as *const _,
-        }),
-        GFlagsValueWrapper(GFlagsValue {
-            value: 0,
-            value_name: 0 as *const _,
-            value_nick: 0 as *const _,
-        }),
-    ];
-
-    ONCE.call_once(|| {
-        FTYPE = gobject_sys::g_flags_register_static(
-            b"RsvgHandleFlags\0" as *const u8 as *const _,
-            &VALUES as *const GFlagsValueWrapper as *const GFlagsValue,
-        );
-    });
-
-    FTYPE
+    HandleFlags::static_type().to_glib()
 }
 
 #[no_mangle]
@@ -1629,7 +1541,7 @@ pub unsafe extern "C" fn rsvg_handle_new() -> *const RsvgHandle {
 #[no_mangle]
 pub unsafe extern "C" fn rsvg_handle_new_with_flags(flags: RsvgHandleFlags) -> *const RsvgHandle {
     let obj: *mut gobject_sys::GObject =
-        glib::Object::new(CHandle::get_type(), &[("flags", &flags)])
+        glib::Object::new(CHandle::get_type(), &[("flags", &HandleFlags::from_bits_truncate(flags))])
             .unwrap()
             .to_glib_full();
 
@@ -1772,7 +1684,7 @@ pub unsafe extern "C" fn rsvg_handle_new_from_data(
     let ret = rsvg_handle_new_from_stream_sync(
         raw_stream,
         ptr::null_mut(), // base_file
-        0,               // flags
+        0,
         ptr::null_mut(), // cancellable
         error,
     );
diff --git a/tests/api.c b/tests/api.c
index bd5f417c..75b8b245 100644
--- a/tests/api.c
+++ b/tests/api.c
@@ -35,15 +35,15 @@ handle_has_gtype (void)
     g_object_unref (handle);
 }
 
-static gboolean
-flags_value_matches (GFlagsValue *v,
-                     guint value,
-                     const char *value_name,
-                     const char *value_nick)
+static void
+assert_flags_value_matches (GFlagsValue *v,
+                            guint value,
+                            const char *value_name,
+                            const char *value_nick)
 {
-    return (v->value == value
-            && strcmp (v->value_name, value_name) == 0
-            && strcmp (v->value_nick, value_nick) == 0);
+    g_assert_cmpint(v->value, ==, value);
+    g_assert_cmpstr(v->value_name, ==, value_name);
+    g_assert_cmpstr(v->value_nick, ==, value_nick);
 }
 
 static void
@@ -70,20 +70,20 @@ flags_registration (void)
     flags_class = G_FLAGS_CLASS (type_class);
     g_assert_cmpint (flags_class->n_values, ==, 3);
 
-    g_assert (flags_value_matches(&flags_class->values[0],
-                                  RSVG_HANDLE_FLAGS_NONE,
-                                  "RSVG_HANDLE_FLAGS_NONE",
-                                  "flags-none"));
+    assert_flags_value_matches(&flags_class->values[0],
+                               RSVG_HANDLE_FLAGS_NONE,
+                               "RSVG_HANDLE_FLAGS_NONE",
+                               "flags-none");
 
-    g_assert (flags_value_matches(&flags_class->values[1],
-                                  RSVG_HANDLE_FLAG_UNLIMITED,
-                                  "RSVG_HANDLE_FLAG_UNLIMITED",
-                                  "flag-unlimited"));
+    assert_flags_value_matches(&flags_class->values[1],
+                               RSVG_HANDLE_FLAG_UNLIMITED,
+                               "RSVG_HANDLE_FLAG_UNLIMITED",
+                               "flag-unlimited");
 
-    g_assert (flags_value_matches(&flags_class->values[2],
-                                  RSVG_HANDLE_FLAG_KEEP_IMAGE_DATA,
-                                  "RSVG_HANDLE_FLAG_KEEP_IMAGE_DATA",
-                                  "flag-keep-image-data"));
+    assert_flags_value_matches(&flags_class->values[2],
+                               RSVG_HANDLE_FLAG_KEEP_IMAGE_DATA,
+                               "RSVG_HANDLE_FLAG_KEEP_IMAGE_DATA",
+                               "flag-keep-image-data");
 
     g_type_class_unref (type_class);
 }