(#251): Surface::create_similar() and friends should return a Result

Cairo's surface creation functions never return NULL; instead they
always return a surface, but it may be in an error state.  In #141 we
started making the binding functions return Result for this; some
returned the plain FooSurface type, some others Option<FooSurface>.

This makes the following functions return Result<FooSurface, Status>

  Surface::create_similar()
  Surface::create_similar_image()
  RecordingSurface::create()
  Device.surface_create()
  Device.surface_create_for_target()

The foundation for all of this is that Surface::from_raw_full() now
also returns Result<FooSurface, Status>.  This is to make things
consistent with ImageSurface::from_raw_full().  Analogously, we now
have RecordingSurface::from_raw_full() that also returns Result.

Fixes #251

Author: federicomenaquintero

src/device.rs

@@ -67,29 +67,28 @@ impl Device {
         unsafe { ffi::cairo_script_set_mode(self.to_raw_none(), mode.into()) }
     }
 
-    pub fn surface_create(&self, content: Content, width: f64, height: f64) -> Option<Surface> {
+    pub fn surface_create(
+        &self,
+        content: Content,
+        width: f64,
+        height: f64,
+    ) -> Result<Surface, Status> {
         unsafe {
-            let p =
-                ffi::cairo_script_surface_create(self.to_raw_none(), content.into(), width, height);
-            if p.is_null() {
-                None
-            } else {
-                Some(Surface::from_raw_full(p))
-            }
+            Ok(Surface::from_raw_full(ffi::cairo_script_surface_create(
+                self.to_raw_none(),
+                content.into(),
+                width,
+                height,
+            ))?)
         }
     }
 
-    pub fn surface_create_for_target(&self, target: &Surface) -> Option<Surface> {
+    pub fn surface_create_for_target(&self, target: &Surface) -> Result<Surface, Status> {
         unsafe {
-            let p = ffi::cairo_script_surface_create_for_target(
+            Ok(Surface::from_raw_full(ffi::cairo_script_surface_create_for_target(
                 self.to_raw_none(),
                 target.to_raw_none(),
-            );
-            if p.is_null() {
-                None
-            } else {
-                Some(Surface::from_raw_full(p))
-            }
+            ))?)
         }
     }
 

src/image_surface.rs

@@ -34,12 +34,8 @@ impl TryFrom<Surface> for ImageSurface {
 
 impl ImageSurface {
     pub unsafe fn from_raw_full(ptr: *mut ffi::cairo_surface_t) -> Result<ImageSurface, Status> {
-        let surface = Self::try_from(Surface::from_raw_full(ptr)).unwrap();
-        let status = surface.status();
-        match status {
-            Status::Success => Ok(surface),
-            _ => Err(status),
-        }
+        let surface = Surface::from_raw_full(ptr)?;
+        Self::try_from(surface).map_err(|_| Status::SurfaceTypeMismatch)
     }
 
     pub fn create(format: Format, width: i32, height: i32) -> Result<ImageSurface, Status> {

src/recording_surface.rs

@@ -6,7 +6,7 @@ use std::convert::TryFrom;
 use std::fmt;
 use std::ops::Deref;
 
-use enums::{Content, SurfaceType};
+use enums::{Content, Status, SurfaceType};
 use ffi;
 #[cfg(feature = "use_glib")]
 use glib::translate::*;
@@ -30,22 +30,28 @@ impl TryFrom<Surface> for RecordingSurface {
 }
 
 impl RecordingSurface {
+    pub unsafe fn from_raw_full(
+        ptr: *mut ffi::cairo_surface_t,
+    ) -> Result<RecordingSurface, Status> {
+        let surface = Surface::from_raw_full(ptr)?;
+        Self::try_from(surface).map_err(|_| Status::SurfaceTypeMismatch)
+    }
+
     pub fn create<T: Into<Option<Rectangle>>>(
         content: Content,
         extends: T,
-    ) -> Option<RecordingSurface> {
+    ) -> Result<RecordingSurface, Status> {
         unsafe {
             let extends = extends.into();
             let extends = match extends {
                 Some(c) => c.to_raw_none(),
                 None => ::std::ptr::null(),
             };
-            let p = ffi::cairo_recording_surface_create(content.into(), extends);
-            if p.is_null() {
-                None
-            } else {
-                Some(RecordingSurface(Surface::from_raw_full(p)))
-            }
+
+            Ok(Self::from_raw_full(ffi::cairo_recording_surface_create(
+                content.into(),
+                extends,
+            ))?)
         }
     }
 
@@ -101,7 +107,7 @@ impl FromGlibPtrBorrow<*mut ffi::cairo_surface_t> for RecordingSurface {
 impl FromGlibPtrFull<*mut ffi::cairo_surface_t> for RecordingSurface {
     #[inline]
     unsafe fn from_glib_full(ptr: *mut ffi::cairo_surface_t) -> RecordingSurface {
-        RecordingSurface(Surface::from_raw_full(ptr))
+        Self::from_raw_full(ptr).unwrap()
     }
 }
 

src/surface.rs

@@ -32,16 +32,25 @@ impl Surface {
         Surface(ptr, true)
     }
 
-    pub unsafe fn from_raw_full(ptr: *mut ffi::cairo_surface_t) -> Surface {
+    pub unsafe fn from_raw_full(ptr: *mut ffi::cairo_surface_t) -> Result<Surface, Status> {
         assert!(!ptr.is_null());
-        Surface(ptr, false)
+        let status = Status::from(ffi::cairo_surface_status(ptr));
+        match status {
+            Status::Success => Ok(Surface(ptr, false)),
+            _ => Err(status),
+        }
     }
 
     pub fn to_raw_none(&self) -> *mut ffi::cairo_surface_t {
         self.0
     }
 
-    pub fn create_similar(&self, content: Content, width: i32, height: i32) -> Surface {
+    pub fn create_similar(
+        &self,
+        content: Content,
+        width: i32,
+        height: i32
+    ) -> Result<Surface, Status> {
         unsafe {
             Self::from_raw_full(ffi::cairo_surface_create_similar(
                 self.0,
@@ -185,19 +194,14 @@ impl Surface {
         (x_pixels_per_inch, y_pixels_per_inch)
     }
 
-    pub fn create_similar_image(&self, format: Format, width: i32, height: i32) -> Option<Surface> {
+    pub fn create_similar_image(&self, format: Format, width: i32, height: i32) -> Result<Surface, Status> {
         unsafe {
-            let p = ffi::cairo_surface_create_similar_image(
+            Self::from_raw_full(ffi::cairo_surface_create_similar_image(
                 self.to_raw_none(),
                 format.into(),
                 width,
                 height,
-            );
-            if p.is_null() {
-                None
-            } else {
-                Some(Self::from_raw_full(p))
-            }
+            ))
         }
     }
 
@@ -258,7 +262,7 @@ impl FromGlibPtrBorrow<*mut ffi::cairo_surface_t> for Surface {
 impl FromGlibPtrFull<*mut ffi::cairo_surface_t> for Surface {
     #[inline]
     unsafe fn from_glib_full(ptr: *mut ffi::cairo_surface_t) -> Surface {
-        Self::from_raw_full(ptr)
+        Self::from_raw_full(ptr).unwrap()
     }
 }