gdk-pixbuf: Use SystemTime instead of Duration for PixbufAnimation::iter() and PixbufAnimationIter::advance()

They're `GTimeVal` relative to the UNIX epoch in C and not a plain
duration.

Fixes https://github.com/gtk-rs/gtk-rs-core/918

Author: sdroege

gdk-pixbuf/src/pixbuf_animation_iter.rs

@@ -17,8 +17,8 @@ glib::wrapper! {
 
 impl PixbufAnimationIter {
     #[doc(alias = "gdk_pixbuf_animation_iter_advance")]
-    pub fn advance(&self, start_time: SystemTime) -> bool {
-        let diff = start_time
+    pub fn advance(&self, current_time: SystemTime) -> bool {
+        let diff = current_time
             .duration_since(SystemTime::UNIX_EPOCH)
             .expect("failed to convert time");
 

gdk-pixbuf/src/subclass/pixbuf_animation.rs

@@ -3,7 +3,10 @@
 // rustdoc-stripper-ignore-next
 //! Traits intended for subclassing [`PixbufAnimation`](crate::PixbufAnimation).
 
-use std::{mem::MaybeUninit, time::Duration};
+use std::{
+    mem::MaybeUninit,
+    time::{Duration, SystemTime},
+};
 
 use glib::{subclass::prelude::*, translate::*, Cast};
 
@@ -22,7 +25,7 @@ pub trait PixbufAnimationImpl: ObjectImpl {
         self.parent_size()
     }
 
-    fn iter(&self, start_time: Duration) -> PixbufAnimationIter {
+    fn iter(&self, start_time: SystemTime) -> PixbufAnimationIter {
         self.parent_iter(start_time)
     }
 }
@@ -31,7 +34,7 @@ pub trait PixbufAnimationImplExt: ObjectSubclass {
     fn parent_is_static_image(&self) -> bool;
     fn parent_static_image(&self) -> Option<Pixbuf>;
     fn parent_size(&self) -> (i32, i32);
-    fn parent_iter(&self, start_time: Duration) -> PixbufAnimationIter;
+    fn parent_iter(&self, start_time: SystemTime) -> PixbufAnimationIter;
 }
 
 impl<T: PixbufAnimationImpl> PixbufAnimationImplExt for T {
@@ -88,24 +91,27 @@ impl<T: PixbufAnimationImpl> PixbufAnimationImplExt for T {
         }
     }
 
-    fn parent_iter(&self, start_time: Duration) -> PixbufAnimationIter {
+    fn parent_iter(&self, start_time: SystemTime) -> PixbufAnimationIter {
         unsafe {
             let data = T::type_data();
             let parent_class = data.as_ref().parent_class() as *mut ffi::GdkPixbufAnimationClass;
             let f = (*parent_class)
                 .get_iter
                 .expect("No parent class implementation for \"get_iter\"");
 
+            let diff = start_time
+                .duration_since(SystemTime::UNIX_EPOCH)
+                .expect("failed to convert time");
             let time = glib::ffi::GTimeVal {
-                tv_sec: start_time.as_secs() as _,
-                tv_usec: start_time.subsec_micros() as _,
+                tv_sec: diff.as_secs() as _,
+                tv_usec: diff.subsec_micros() as _,
             };
             from_glib_full(f(
                 self.obj()
                     .unsafe_cast_ref::<PixbufAnimation>()
                     .to_glib_none()
                     .0,
-                &time as *const _,
+                &time,
             ))
         }
     }
@@ -169,8 +175,9 @@ unsafe extern "C" fn animation_get_iter<T: PixbufAnimationImpl>(
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
-    let total = Duration::from_secs((*start_time_ptr).tv_sec.try_into().unwrap())
+    let start_time = SystemTime::UNIX_EPOCH
+        + Duration::from_secs((*start_time_ptr).tv_sec.try_into().unwrap())
         + Duration::from_micros((*start_time_ptr).tv_usec.try_into().unwrap());
 
-    imp.iter(total).into_glib_ptr()
+    imp.iter(start_time).into_glib_ptr()
 }

gdk-pixbuf/src/subclass/pixbuf_animation_iter.rs

@@ -3,7 +3,7 @@
 // rustdoc-stripper-ignore-next
 //! Traits intended for subclassing [`PixbufAnimationIter`](crate::PixbufAnimationIter).
 
-use std::time::Duration;
+use std::time::{Duration, SystemTime};
 
 use glib::{subclass::prelude::*, translate::*, Cast};
 
@@ -24,16 +24,16 @@ pub trait PixbufAnimationIterImpl: ObjectImpl {
         self.parent_on_currently_loading_frame()
     }
 
-    fn advance(&self, time: Duration) -> bool {
-        self.parent_advance(time)
+    fn advance(&self, current_time: SystemTime) -> bool {
+        self.parent_advance(current_time)
     }
 }
 
 pub trait PixbufAnimationIterImplExt: ObjectSubclass {
     fn parent_delay_time(&self) -> Option<Duration>;
     fn parent_pixbuf(&self) -> Pixbuf;
     fn parent_on_currently_loading_frame(&self) -> bool;
-    fn parent_advance(&self, time: Duration) -> bool;
+    fn parent_advance(&self, current_time: SystemTime) -> bool;
 }
 
 impl<T: PixbufAnimationIterImpl> PixbufAnimationIterImplExt for T {
@@ -51,10 +51,10 @@ impl<T: PixbufAnimationIterImpl> PixbufAnimationIterImplExt for T {
                 .unsafe_cast_ref::<PixbufAnimationIter>()
                 .to_glib_none()
                 .0);
-            if time == -1 {
+            if time < 0 {
                 None
             } else {
-                Some(Duration::from_millis(time.try_into().unwrap()))
+                Some(Duration::from_millis(time as u64))
             }
         }
     }
@@ -93,7 +93,7 @@ impl<T: PixbufAnimationIterImpl> PixbufAnimationIterImplExt for T {
         }
     }
 
-    fn parent_advance(&self, time: Duration) -> bool {
+    fn parent_advance(&self, current_time: SystemTime) -> bool {
         unsafe {
             let data = T::type_data();
             let parent_class =
@@ -102,16 +102,19 @@ impl<T: PixbufAnimationIterImpl> PixbufAnimationIterImplExt for T {
                 .advance
                 .expect("No parent class implementation for \"advance\"");
 
+            let diff = current_time
+                .duration_since(SystemTime::UNIX_EPOCH)
+                .expect("failed to convert time");
             let time = glib::ffi::GTimeVal {
-                tv_sec: time.as_secs() as _,
-                tv_usec: time.subsec_micros() as _,
+                tv_sec: diff.as_secs() as _,
+                tv_usec: diff.subsec_micros() as _,
             };
             from_glib(f(
                 self.obj()
                     .unsafe_cast_ref::<PixbufAnimationIter>()
                     .to_glib_none()
                     .0,
-                &time as *const _,
+                &time,
             ))
         }
     }
@@ -158,13 +161,14 @@ unsafe extern "C" fn animation_iter_on_currently_loading_frame<T: PixbufAnimatio
 
 unsafe extern "C" fn animation_iter_advance<T: PixbufAnimationIterImpl>(
     ptr: *mut ffi::GdkPixbufAnimationIter,
-    time_ptr: *const glib::ffi::GTimeVal,
+    current_time_ptr: *const glib::ffi::GTimeVal,
 ) -> glib::ffi::gboolean {
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
-    let total = Duration::from_secs((*time_ptr).tv_sec.try_into().unwrap())
-        + Duration::from_micros((*time_ptr).tv_usec.try_into().unwrap());
+    let current_time = SystemTime::UNIX_EPOCH
+        + Duration::from_secs((*current_time_ptr).tv_sec.try_into().unwrap())
+        + Duration::from_micros((*current_time_ptr).tv_usec.try_into().unwrap());
 
-    imp.advance(total).into_glib()
+    imp.advance(current_time).into_glib()
 }