Usa stable version of rustfmt for formatting

This changes the way rustfmt runs, since right now it uses nightly
versions and it's not properly checked on CI, while we can use nightly
on CI, the stable rustfmt should work fine.

Also the 'small' heuristics was changed to 'Max' to make code more
compact.

Author: kchibisov

glutin/src/api/android/mod.rs

@@ -1,12 +1,8 @@
 #![cfg(target_os = "android")]
 
-use crate::api::egl::{
-    Context as EglContext, NativeDisplay, SurfaceType as EglSurfaceType,
-};
+use crate::api::egl::{Context as EglContext, NativeDisplay, SurfaceType as EglSurfaceType};
 use crate::CreationError::{self, OsError};
-use crate::{
-    Api, ContextError, GlAttributes, PixelFormat, PixelFormatRequirements, Rect,
-};
+use crate::{Api, ContextError, GlAttributes, PixelFormat, PixelFormatRequirements, Rect};
 
 use crate::platform::android::EventLoopExtAndroid;
 use glutin_egl_sys as ffi;
@@ -66,18 +62,12 @@ impl Context {
             return Err(OsError("Android's native window is null".to_string()));
         }
         let native_display = NativeDisplay::Android;
-        let egl_context = EglContext::new(
-            pf_reqs,
-            &gl_attr,
-            native_display,
-            EglSurfaceType::Window,
-            |c, _| Ok(c[0]),
-        )
-        .and_then(|p| p.finish(nwin as *const _))?;
-        let ctx = Arc::new(AndroidContext {
-            egl_context,
-            stopped: Some(Mutex::new(false)),
-        });
+        let egl_context =
+            EglContext::new(pf_reqs, &gl_attr, native_display, EglSurfaceType::Window, |c, _| {
+                Ok(c[0])
+            })
+            .and_then(|p| p.finish(nwin as *const _))?;
+        let ctx = Arc::new(AndroidContext { egl_context, stopped: Some(Mutex::new(false)) });
 
         let handler = Box::new(AndroidSyncEventHandler(ctx.clone()));
         android_glue::add_sync_event_handler(handler);
@@ -121,10 +111,7 @@ impl Context {
             |c, _| Ok(c[0]),
         )?;
         let egl_context = context.finish_pbuffer(size)?;
-        let ctx = Arc::new(AndroidContext {
-            egl_context,
-            stopped: None,
-        });
+        let ctx = Arc::new(AndroidContext { egl_context, stopped: None });
         Ok(Context(ctx))
     }
 
@@ -177,10 +164,7 @@ impl Context {
     }
 
     #[inline]
-    pub fn swap_buffers_with_damage(
-        &self,
-        rects: &[Rect],
-    ) -> Result<(), ContextError> {
+    pub fn swap_buffers_with_damage(&self, rects: &[Rect]) -> Result<(), ContextError> {
         if let Some(ref stopped) = self.0.stopped {
             let stopped = stopped.lock();
             if *stopped {

glutin/src/api/dlloader.rs

@@ -33,11 +33,8 @@ impl<T: SymTrait> SymWrapper<T> {
         for path in lib_paths {
             // Avoid loading from PATH
             #[cfg(target_os = "windows")]
-            let lib = windows::Library::load_with_flags(
-                path,
-                LOAD_LIBRARY_SEARCH_DEFAULT_DIRS,
-            )
-            .map(From::from);
+            let lib = windows::Library::load_with_flags(path, LOAD_LIBRARY_SEARCH_DEFAULT_DIRS)
+                .map(From::from);
 
             #[cfg(not(target_os = "windows"))]
             let lib = Library::new(path);

glutin/src/api/egl/make_current_guard.rs

@@ -30,10 +30,8 @@ impl MakeCurrentGuard {
                 display,
                 old_display: egl.GetCurrentDisplay(),
                 possibly_invalid: Some(MakeCurrentGuardInner {
-                    old_draw_surface: egl
-                        .GetCurrentSurface(ffi::egl::DRAW as i32),
-                    old_read_surface: egl
-                        .GetCurrentSurface(ffi::egl::READ as i32),
+                    old_draw_surface: egl.GetCurrentSurface(ffi::egl::DRAW as i32),
+                    old_read_surface: egl.GetCurrentSurface(ffi::egl::READ as i32),
                     old_context: egl.GetCurrentContext(),
                 }),
             };
@@ -42,8 +40,7 @@ impl MakeCurrentGuard {
                 ret.invalidate();
             }
 
-            let res =
-                egl.MakeCurrent(display, draw_surface, read_surface, context);
+            let res = egl.MakeCurrent(display, draw_surface, read_surface, context);
 
             if res == 0 {
                 let err = egl.GetError();
@@ -62,10 +59,8 @@ impl MakeCurrentGuard {
     ) {
         if self.possibly_invalid.is_some() {
             let pi = self.possibly_invalid.as_ref().unwrap();
-            if pi.old_draw_surface == draw_surface
-                && draw_surface != ffi::egl::NO_SURFACE
-                || pi.old_read_surface == read_surface
-                    && read_surface != ffi::egl::NO_SURFACE
+            if pi.old_draw_surface == draw_surface && draw_surface != ffi::egl::NO_SURFACE
+                || pi.old_read_surface == read_surface && read_surface != ffi::egl::NO_SURFACE
                 || pi.old_context == context
             {
                 self.invalidate();
@@ -81,28 +76,18 @@ impl MakeCurrentGuard {
 impl Drop for MakeCurrentGuard {
     fn drop(&mut self) {
         let egl = super::EGL.as_ref().unwrap();
-        let (draw_surface, read_surface, context) =
-            match self.possibly_invalid.take() {
-                Some(inner) => (
-                    inner.old_draw_surface,
-                    inner.old_read_surface,
-                    inner.old_context,
-                ),
-                None => (
-                    ffi::egl::NO_SURFACE,
-                    ffi::egl::NO_SURFACE,
-                    ffi::egl::NO_CONTEXT,
-                ),
-            };
+        let (draw_surface, read_surface, context) = match self.possibly_invalid.take() {
+            Some(inner) => (inner.old_draw_surface, inner.old_read_surface, inner.old_context),
+            None => (ffi::egl::NO_SURFACE, ffi::egl::NO_SURFACE, ffi::egl::NO_CONTEXT),
+        };
 
         let display = match self.old_display {
             ffi::egl::NO_DISPLAY => self.display,
             old_display => old_display,
         };
 
         unsafe {
-            let res =
-                egl.MakeCurrent(display, draw_surface, read_surface, context);
+            let res = egl.MakeCurrent(display, draw_surface, read_surface, context);
 
             if res == 0 {
                 let err = egl.GetError();