perf(skia): Reuse surfaces/bitmaps and reduce native calls

- Cache surfaces and bitmap between invocation
- Avoid repetitive calls ending up calling native code (transition is costly), e.g.
	- successive calls to properties like `surface.Canvas` and `_bitmap.Width`
	- multiple calls to `_bitmap.GetPixels(out _)`
- Dispose existing `SKBitmap` and `SKSurface` when needed (e.g. window resizing)
- Removed nullable on `float? _dpi;` is already assigned to a value (by
  .ctor) and `UpdateDpi` never set it to `null`

Measuring the impact was tricky since there are huge differences between
frame redraw times. I ended up logging an average of a 1000 frames.
Numbers are in ticks (100 ns).

**before**
```
trce: Uno.UI.Runtime.Skia.SoftwareRenderSurface[0]
      Average render time: 116098
trce: Uno.UI.Runtime.Skia.SoftwareRenderSurface[0]
      Average render time: 116879
trce: Uno.UI.Runtime.Skia.SoftwareRenderSurface[0]
      Average render time: 114771
trce: Uno.UI.Runtime.Skia.SoftwareRenderSurface[0]
      Average render time: 114271
```

**after**
```
trce: Uno.UI.Runtime.Skia.SoftwareRenderSurface[0]
      Average render time: 112252
trce: Uno.UI.Runtime.Skia.SoftwareRenderSurface[0]
      Average render time: 114341
trce: Uno.UI.Runtime.Skia.SoftwareRenderSurface[0]
      Average render time: 115398
trce: Uno.UI.Runtime.Skia.SoftwareRenderSurface[0]
      Average render time: 113393
```

Author: spouliot

src/Uno.UI.Runtime.Skia.Gtk/SoftwareRenderSurface.cs

@@ -3,6 +3,7 @@
 using System;
 using System.IO;
 using System.Runtime.InteropServices;
+using Cairo;
 using SkiaSharp;
 using Uno.Extensions;
 using Uno.UI.Xaml.Core;
@@ -11,7 +12,6 @@
 using Uno.Foundation.Logging;
 using Windows.UI.Xaml.Controls;
 using System.Diagnostics;
-using System.Runtime.InteropServices;
 using Uno.UI.Runtime.Skia.Helpers.Windows;
 using Uno.UI.Runtime.Skia.Helpers.Dpi;
 using Windows.Graphics.Display;
@@ -22,10 +22,13 @@ internal class SoftwareRenderSurface : Gtk.DrawingArea, IRenderSurface
 	{
 		private readonly DisplayInformation _displayInformation;
 		private FocusManager? _focusManager;
+		private SKSurface? _surface;
 		private SKBitmap? _bitmap;
+		private int _bheight, _bwidth;
+		private ImageSurface? _gtkSurface;
 		private int renderCount;
 
-		private float? _dpi = 1;
+		private float _dpi = 1;
 
 		private readonly SKColorType _colorType;
 
@@ -67,54 +70,45 @@ private void InvalidateOverlays()
 		private void Invalidate()
 			=> QueueDrawArea(0, 0, 10000, 10000);
 
-		protected override bool OnDrawn(Cairo.Context cr)
+		protected override bool OnDrawn(Context cr)
 		{
 			Stopwatch? sw = null;
 
-			int width, height;
-
 			if (this.Log().IsEnabled(LogLevel.Trace))
 			{
 				sw = Stopwatch.StartNew();
 				this.Log().Trace($"Render {renderCount++}");
 			}
 
-			var dpi = UpdateDpi();
-			
-			width = (int)AllocatedWidth;
-			height = (int)AllocatedHeight;
-
-			var scaledWidth = (int)(width * dpi);
-			var scaledHeight = (int)(height * dpi);
+			var scaledWidth = (int)(AllocatedWidth * _dpi);
+			var scaledHeight = (int)(AllocatedHeight * _dpi);
 
-			var info = new SKImageInfo(scaledWidth, scaledHeight, _colorType, SKAlphaType.Premul);
-
-			// reset the bitmap if the size has changed
-			if (_bitmap == null || info.Width != _bitmap.Width || info.Height != _bitmap.Height)
+			// reset the surfaces (skia/cairo) and bitmap if the size has changed
+			if (_surface == null || scaledWidth != _bwidth || scaledHeight != _bheight)
 			{
+				_gtkSurface?.Dispose ();
+				_surface?.Dispose();
+				_bitmap?.Dispose();
+
+				var info = new SKImageInfo(scaledWidth, scaledHeight, _colorType, SKAlphaType.Premul);
 				_bitmap = new SKBitmap(info);
+				_bwidth = _bitmap.Width;
+				_bheight = _bitmap.Height;
+				var pixels = _bitmap.GetPixels(out _);
+				_surface = SKSurface.Create(info, pixels);
+				_gtkSurface = new ImageSurface(pixels, Format.Argb32, _bwidth, _bheight, _bwidth * 4);
 			}
 
-			using (var surface = SKSurface.Create(info, _bitmap.GetPixels(out _)))
-			{
-				surface.Canvas.Clear(SKColors.White);
-
-				surface.Canvas.Scale(dpi);
+			var canvas = _surface.Canvas;
+			canvas.Clear(SKColors.White);
+			canvas.Scale(_dpi);
 
-				WUX.Window.Current.Compositor.Render(surface);
+			WUX.Window.Current.Compositor.Render(_surface);
 
-				using (var gtkSurface = new Cairo.ImageSurface(
-					_bitmap.GetPixels(out _),
-					Cairo.Format.Argb32,
-					_bitmap.Width, _bitmap.Height,
-					_bitmap.Width * 4))
-				{
-					gtkSurface.MarkDirty();
-					cr.Scale(1 / dpi, 1 / dpi);
-					cr.SetSourceSurface(gtkSurface, 0, 0);
-					cr.Paint();
-				}
-			}
+			_gtkSurface!.MarkDirty();
+			cr.Scale(1 / _dpi, 1 / _dpi);
+			cr.SetSourceSurface(_gtkSurface, 0, 0);
+			cr.Paint();
 
 			if (this.Log().IsEnabled(LogLevel.Trace))
 			{
@@ -133,6 +127,6 @@ public void TakeScreenshot(string filePath)
 			_bitmap?.Encode(wstream, SKEncodedImageFormat.Png, 100);
 		}
 
-		private float UpdateDpi() => _dpi ??= (float)_displayInformation.RawPixelsPerViewPixel;
+		private float UpdateDpi() => _dpi = (float)_displayInformation.RawPixelsPerViewPixel;
 	}
 }