spice: win32 client: fix gdi locking

While the fix could have been more effective,
it seems like this patch stream better with the coding
logic that was there..., maybe later we will want to change
the locking into more effective way.

(There is just the primary surface to protect in reiality)

Signed-off-by: Izik Eidus <ieidus@redhat.com>

7 files changed, 125 insertions, 60 deletions

diff --git a/client/red_pixmap_gdi.h b/client/red_pixmap_gdi.h
index d5a028a8..6bf28fd0 100644
--- a/client/red_pixmap_gdi.h
+++ b/client/red_pixmap_gdi.h
@@ -20,7 +20,7 @@
 
 #include "red_pixmap.h"
 
-class Mutex;
+class RecurciveMutex;
 
 class RedPixmapGdi: public RedPixmap {
 public:
@@ -29,7 +29,7 @@ public:
     HDC get_dc();
     void *get_memptr();
     ~RedPixmapGdi();
-    Mutex& get_mutex();
+    RecurciveMutex& get_mutex();
 };
 
 #endif
diff --git a/client/windows/pixels_source.cpp b/client/windows/pixels_source.cpp
index 178b88fd..7b6fe813 100644
--- a/client/windows/pixels_source.cpp
+++ b/client/windows/pixels_source.cpp
@@ -41,7 +41,7 @@ PixelsSource::PixelsSource()
     _origin.x = _origin.y = 0;
     memset(_opaque, 0, sizeof(_opaque));
     PixelsSource_p* p_data = (PixelsSource_p*)_opaque;
-    p_data->_mutex = new Mutex();
+    p_data->_mutex = new RecurciveMutex();
 }
 
 PixelsSource::~PixelsSource()
diff --git a/client/windows/pixels_source_p.h b/client/windows/pixels_source_p.h
index eb646395..0f59f2d7 100644
--- a/client/windows/pixels_source_p.h
+++ b/client/windows/pixels_source_p.h
@@ -18,11 +18,11 @@
 #ifndef _H_PIXELE_SOURSR_P
 #define _H_PIXELE_SOURSR_P
 
-class Mutex;
+class RecurciveMutex;
 
 struct PixelsSource_p {
     HDC dc;
-    Mutex* _mutex;
+    RecurciveMutex* _mutex;
 };
 
 #endif
diff --git a/client/windows/red_drawable.cpp b/client/windows/red_drawable.cpp
index cac7299e..bc01adec 100644
--- a/client/windows/red_drawable.cpp
+++ b/client/windows/red_drawable.cpp
@@ -51,8 +51,8 @@ void RedDrawable::blend_pixels(const PixelsSource& src, int src_x, int src_y, co
     PixelsSource_p* dest_p_data = (PixelsSource_p*)get_opaque();
     PixelsSource_p* src_p_data = (PixelsSource_p*)src.get_opaque();
     for (;;) {
-        Lock lock(*dest_p_data->_mutex);
-        Lock timed_lock(*src_p_data->_mutex, lock_timout);
+        RecurciveLock lock(*dest_p_data->_mutex);
+        RecurciveLock timed_lock(*src_p_data->_mutex, lock_timout);
         if (!timed_lock.is_locked()) {
             continue;
         }
@@ -84,8 +84,8 @@ void RedDrawable::combine_pixels(const PixelsSource& src, int src_x, int src_y,
     PixelsSource_p* dest_p_data = (PixelsSource_p*)get_opaque();
     PixelsSource_p* src_p_data = (PixelsSource_p*)src.get_opaque();
     for (;;) {
-        Lock lock(*dest_p_data->_mutex);
-        Lock timed_lock(*src_p_data->_mutex, lock_timout);
+        RecurciveLock lock(*dest_p_data->_mutex);
+        RecurciveLock timed_lock(*src_p_data->_mutex, lock_timout);
         if (!timed_lock.is_locked()) {
             continue;
         }
@@ -106,7 +106,7 @@ void RedDrawable::erase_rect(const SpiceRect& rect, rgb32_t color)
     r.bottom = rect.bottom + _origin.y;
 
     PixelsSource_p* dest_p_data = (PixelsSource_p*)get_opaque();
-    Lock lock(*dest_p_data->_mutex);
+    RecurciveLock lock(*dest_p_data->_mutex);
     FillRect(dest_p_data->dc, &r, (HBRUSH)GetStockObject(BLACK_BRUSH));
 }
 
@@ -123,7 +123,7 @@ void RedDrawable::fill_rect(const SpiceRect& rect, rgb32_t color)
                                         rgb32_get_blue(color)));
     for (;;) {
         PixelsSource_p* dest_p_data = (PixelsSource_p*)get_opaque();
-        Lock lock(*dest_p_data->_mutex);
+        RecurciveLock lock(*dest_p_data->_mutex);
         FillRect(dest_p_data->dc, &r, brush);
         break;
     }
@@ -142,7 +142,7 @@ void RedDrawable::frame_rect(const SpiceRect& rect, rgb32_t color)
                                         rgb32_get_blue(color)));
     for (;;) {
         PixelsSource_p* dest_p_data = (PixelsSource_p*)get_opaque();
-        Lock lock(*dest_p_data->_mutex);
+        RecurciveLock lock(*dest_p_data->_mutex);
         FrameRect(dest_p_data->dc, &r, brush);
         break;
     }
diff --git a/client/windows/red_pixmap_gdi.cpp b/client/windows/red_pixmap_gdi.cpp
index adb21da8..860c90c0 100644
--- a/client/windows/red_pixmap_gdi.cpp
+++ b/client/windows/red_pixmap_gdi.cpp
@@ -94,7 +94,7 @@ RedPixmapGdi::~RedPixmapGdi()
     }
 }
 
-Mutex& RedPixmapGdi::get_mutex()
+RecurciveMutex& RedPixmapGdi::get_mutex()
 {
     RedPixmap_p* p_data = (RedPixmap_p*)get_opaque();
     return *p_data->pixels_source_p._mutex;
diff --git a/common/gdi_canvas.c b/common/gdi_canvas.c
index 4362b384..db1975ab 100644
--- a/common/gdi_canvas.c
+++ b/common/gdi_canvas.c
@@ -31,7 +31,7 @@ typedef struct GdiCanvas GdiCanvas;
 struct GdiCanvas {
     CanvasBase base;
     HDC dc;
-    Mutex* lock;
+    RecurciveMutex* lock;
 };
 
 
@@ -635,10 +635,12 @@ static inline COLORREF get_color_ref(GdiCanvas *canvas, uint32_t color)
     return RGB(r, g, b);
 }
 
-static HBRUSH get_brush(GdiCanvas *canvas, SpiceBrush *brush)
+static HBRUSH get_brush(GdiCanvas *canvas, SpiceBrush *brush, RecurciveMutex **brush_lock)
 {
     HBRUSH hbrush;
 
+    *brush_lock = NULL;
+
     switch (brush->type) {
     case SPICE_BRUSH_TYPE_SOLID:
         if (!(hbrush = CreateSolidBrush(get_color_ref(canvas, brush->u.color)))) {
@@ -660,6 +662,7 @@ static HBRUSH get_brush(GdiCanvas *canvas, SpiceBrush *brush)
             if (!bitmap) {
                 CANVAS_ERROR("GetCurrentObject failed");
             }
+            *brush_lock = gdi_surface->lock;
         } else {
             surface = canvas_get_image(&canvas->base, brush->u.pattern.pat);
             surface_to_image(surface, &image);
@@ -911,6 +914,7 @@ static void draw_str_mask_bitmap(struct GdiCanvas *canvas,
     uint8_t *bitmap_data;
     HBRUSH prev_hbrush;
     HBRUSH hbrush;
+    RecurciveMutex *brush_lock;
 
     bitmap.hbitmap = (HBITMAP)1;
     if (!(surface = canvas_get_str_mask(&canvas->base, str, n, &pos))) {
@@ -960,9 +964,14 @@ static void draw_str_mask_bitmap(struct GdiCanvas *canvas,
     dest_stride = dest_stride + 3;
     dest_stride = dest_stride & ~3;
 
-    hbrush = get_brush(canvas, brush);
+    hbrush = get_brush(canvas, brush, &brush_lock);
     prev_hbrush = set_brush(bitmap.dc, hbrush, brush);
-    gdi_draw_bitmap(bitmap.dc, src, src, bitmap.dc, NULL, _rop3_brush);
+    if (brush_lock) {
+        RecurciveLock b_lock(*brush_lock);
+        gdi_draw_bitmap(bitmap.dc, src, src, bitmap.dc, NULL, _rop3_brush);
+    } else {
+        gdi_draw_bitmap(bitmap.dc, src, src, bitmap.dc, NULL, _rop3_brush);
+    }
 
     unset_brush(bitmap.dc, prev_hbrush);
 
@@ -974,7 +983,7 @@ static void draw_str_mask_bitmap(struct GdiCanvas *canvas,
 
     BLENDFUNCTION bf = {AC_SRC_OVER, 0, 255, AC_SRC_ALPHA};
 
-    Lock lock(*canvas->lock);
+    RecurciveLock lock(*canvas->lock);
     AlphaBlend(canvas->dc, dest->left, dest->top, dest->right - dest->left,
                dest->bottom - dest->top, bitmap.dc, src->left, src->top,
                src->right - src->left, src->bottom - src->top, bf);
@@ -1022,10 +1031,11 @@ static void gdi_canvas_draw_fill(SpiceCanvas *spice_canvas, SpiceRect *bbox, Spi
     HBRUSH prev_hbrush;
     HBRUSH brush;
     struct BitmapData bitmapmask;
+    RecurciveMutex *brush_lock;
 
-    Lock lock(*canvas->lock);
+    RecurciveLock lock(*canvas->lock);
 
-    if (!(brush = get_brush(canvas, &fill->brush))) {
+    if (!(brush = get_brush(canvas, &fill->brush, &brush_lock))) {
         CANVAS_ERROR("no braash");
         return;
     }
@@ -1034,8 +1044,14 @@ static void gdi_canvas_draw_fill(SpiceCanvas *spice_canvas, SpiceRect *bbox, Spi
 
     set_clip(canvas, clip);
     prev_hbrush = set_brush(canvas->dc, brush, &fill->brush);
-    gdi_draw_bitmap_redrop(canvas->dc, bbox, bbox, canvas->dc, &bitmapmask,
-                           fill->rop_decriptor, fill->brush.type != SPICE_BRUSH_TYPE_NONE);
+    if (brush_lock) {
+        RecurciveLock b_lock(*brush_lock);
+        gdi_draw_bitmap_redrop(canvas->dc, bbox, bbox, canvas->dc, &bitmapmask,
+                               fill->rop_decriptor, fill->brush.type != SPICE_BRUSH_TYPE_NONE);
+    } else {
+        gdi_draw_bitmap_redrop(canvas->dc, bbox, bbox, canvas->dc, &bitmapmask,
+                               fill->rop_decriptor, fill->brush.type != SPICE_BRUSH_TYPE_NONE);
+    }
 
     free_mask(&bitmapmask);
     unset_brush(canvas->dc, prev_hbrush);
@@ -1052,7 +1068,8 @@ static void gdi_canvas_draw_copy(SpiceCanvas *spice_canvas, SpiceRect *bbox, Spi
 
     gdi_surface = (GdiCanvas *)canvas_get_surface(&canvas->base, copy->src_bitmap);
     if (gdi_surface) {
-        Lock lock(*canvas->lock);
+        RecurciveLock lock(*canvas->lock);
+        RecurciveLock s_lock(*gdi_surface->lock);
         bitmapmask = get_mask_bitmap(canvas, &copy->mask);
         set_scale_mode(canvas, copy->scale_mode);
         set_clip(canvas, clip);
@@ -1062,7 +1079,7 @@ static void gdi_canvas_draw_copy(SpiceCanvas *spice_canvas, SpiceRect *bbox, Spi
         surface = canvas_get_image(&canvas->base, copy->src_bitmap);
         pixman_data = (PixmanData *)pixman_image_get_destroy_data(surface);
     
-        Lock lock(*canvas->lock);
+        RecurciveLock lock(*canvas->lock);
         bitmapmask = get_mask_bitmap(canvas, &copy->mask);
         set_scale_mode(canvas, copy->scale_mode);
         set_clip(canvas, clip);
@@ -1104,7 +1121,7 @@ static void gdi_canvas_put_image(SpiceCanvas *spice_canvas, HDC dc, const SpiceR
     int num_rects;
     pixman_box32_t *rects;
 
-    Lock lock(*canvas->lock);
+    RecurciveLock lock(*canvas->lock);
     set_scale_mode(canvas, SPICE_IMAGE_SCALE_MODE_NEAREST);
     if (clip) {
         rects = pixman_region32_rectangles((pixman_region32_t*)clip, &num_rects);
@@ -1194,14 +1211,15 @@ static void gdi_canvas_draw_transparent(SpiceCanvas *spice_canvas, SpiceRect *bb
 
     gdi_surface = (GdiCanvas *)canvas_get_surface(&canvas->base, transparent->src_bitmap);
     if (gdi_surface) {
-        Lock lock(*canvas->lock);
+        RecurciveLock lock(*canvas->lock);
+        RecurciveLock s_lock(*gdi_surface->lock);
         set_clip(canvas, clip);
         gdi_draw_bitmap_transparent(canvas, canvas->dc, &transparent->src_area, bbox,
                                     gdi_surface->dc, transparent->true_color);
     } else {
         surface = canvas_get_image(&canvas->base, transparent->src_bitmap);
         pixman_data = (PixmanData *)pixman_image_get_destroy_data(surface);
-        Lock lock(*canvas->lock);
+        RecurciveLock lock(*canvas->lock);
         set_clip(canvas, clip);
         if (pixman_data && (WaitForSingleObject(pixman_data->mutex, INFINITE) != WAIT_FAILED)) {
             HDC dc;
@@ -1276,7 +1294,8 @@ static void gdi_canvas_draw_alpha_blend(SpiceCanvas *spice_canvas, SpiceRect *bb
 
     gdi_surface = (GdiCanvas *)canvas_get_surface(&canvas->base, alpha_blend->src_bitmap);
     if (gdi_surface) {
-        Lock lock(*canvas->lock);
+        RecurciveLock lock(*canvas->lock);
+        RecurciveLock s_lock(*gdi_surface->lock);
         set_clip(canvas, clip);
         use_bitmap_alpha = 0;
         gdi_draw_bitmap_alpha(canvas->dc, &alpha_blend->src_area, bbox, gdi_surface->dc,
@@ -1286,7 +1305,7 @@ static void gdi_canvas_draw_alpha_blend(SpiceCanvas *spice_canvas, SpiceRect *bb
         use_bitmap_alpha = pixman_image_get_depth(surface) == 32;
         pixman_data = (PixmanData *)pixman_image_get_destroy_data(surface);
     
-        Lock lock(*canvas->lock);
+        RecurciveLock lock(*canvas->lock);
         set_clip(canvas, clip);
         if (pixman_data && (WaitForSingleObject(pixman_data->mutex, INFINITE) != WAIT_FAILED)) {
             HDC dc;
@@ -1321,26 +1340,33 @@ static void gdi_canvas_draw_opaque(SpiceCanvas *spice_canvas, SpiceRect *bbox, S
     HBRUSH prev_hbrush;
     HBRUSH hbrush;
     uint8_t rop3;
+    RecurciveMutex *brush_lock;
 
     rop3 = calc_rop3_src_brush(opaque->rop_decriptor);
 
     gdi_surface = (GdiCanvas *)canvas_get_surface(&canvas->base, opaque->src_bitmap);
     if (gdi_surface) {
-        Lock lock(*canvas->lock);
+        RecurciveLock lock(*canvas->lock);
+        RecurciveLock s_lock(*gdi_surface->lock);
         bitmapmask = get_mask_bitmap(canvas, &opaque->mask);
-        hbrush = get_brush(canvas, &opaque->brush);
+        hbrush = get_brush(canvas, &opaque->brush, &brush_lock);
         set_scale_mode(canvas, opaque->scale_mode);
         set_clip(canvas, clip);
         prev_hbrush = set_brush(canvas->dc, hbrush, &opaque->brush);
-        gdi_draw_bitmap(canvas->dc, &opaque->src_area, bbox, gdi_surface->dc, &bitmapmask, rop3);
+        if (brush_lock) {
+            RecurciveLock b_lock(*brush_lock);
+            gdi_draw_bitmap(canvas->dc, &opaque->src_area, bbox, gdi_surface->dc, &bitmapmask, rop3);
+        } else {
+            gdi_draw_bitmap(canvas->dc, &opaque->src_area, bbox, gdi_surface->dc, &bitmapmask, rop3);
+        }
         unset_brush(canvas->dc, prev_hbrush);
     } else {
         surface = canvas_get_image(&canvas->base, opaque->src_bitmap);
         pixman_data = (PixmanData *)pixman_image_get_destroy_data(surface);
     
-        Lock lock(*canvas->lock);
+        RecurciveLock lock(*canvas->lock);
         bitmapmask = get_mask_bitmap(canvas, &opaque->mask);
-        hbrush = get_brush(canvas, &opaque->brush);
+        hbrush = get_brush(canvas, &opaque->brush, &brush_lock);
         set_scale_mode(canvas, opaque->scale_mode);
         set_clip(canvas, clip);
         prev_hbrush = set_brush(canvas->dc, hbrush, &opaque->brush);
@@ -1351,14 +1377,25 @@ static void gdi_canvas_draw_opaque(SpiceCanvas *spice_canvas, SpiceRect *bbox, S
     
             dc = create_compatible_dc();
             prev_bitmap = (HBITMAP)SelectObject(dc, pixman_data->bitmap);
-            gdi_draw_bitmap(canvas->dc, &opaque->src_area, bbox, dc, &bitmapmask, rop3);
+            if (brush_lock) {
+                RecurciveLock b_lock(*brush_lock);
+                gdi_draw_bitmap(canvas->dc, &opaque->src_area, bbox, dc, &bitmapmask, rop3);
+            } else {
+                gdi_draw_bitmap(canvas->dc, &opaque->src_area, bbox, dc, &bitmapmask, rop3);
+            }
             SelectObject(dc, prev_bitmap);
             DeleteObject(dc);
             ReleaseMutex(pixman_data->mutex);
         } else {
             surface_to_image(surface, &image);
-            gdi_draw_image_rop3(canvas->dc, &opaque->src_area, bbox, image.pixels,
-                                image.stride, image.width, image.height, &bitmapmask, rop3, 0);
+            if (brush_lock) {
+                RecurciveLock b_lock(*brush_lock);
+                gdi_draw_image_rop3(canvas->dc, &opaque->src_area, bbox, image.pixels,
+                                    image.stride, image.width, image.height, &bitmapmask, rop3, 0);
+            } else {
+                gdi_draw_image_rop3(canvas->dc, &opaque->src_area, bbox, image.pixels,
+                                    image.stride, image.width, image.height, &bitmapmask, rop3, 0);
+            }
         }
         unset_brush(canvas->dc, prev_hbrush);
         pixman_image_unref(surface);
@@ -1378,7 +1415,8 @@ static void gdi_canvas_draw_blend(SpiceCanvas *spice_canvas, SpiceRect *bbox, Sp
 
     gdi_surface = (GdiCanvas *)canvas_get_surface(&canvas->base, blend->src_bitmap);
     if (gdi_surface) {
-        Lock lock(*canvas->lock);
+        RecurciveLock lock(*canvas->lock);
+        RecurciveLock s_lock(*gdi_surface->lock);
         bitmapmask = get_mask_bitmap(canvas, &blend->mask);
         set_scale_mode(canvas, blend->scale_mode);
         set_clip(canvas, clip);
@@ -1388,7 +1426,7 @@ static void gdi_canvas_draw_blend(SpiceCanvas *spice_canvas, SpiceRect *bbox, Sp
         surface = canvas_get_image(&canvas->base, blend->src_bitmap);
         pixman_data = (PixmanData *)pixman_image_get_destroy_data(surface);
     
-        Lock lock(*canvas->lock);
+        RecurciveLock lock(*canvas->lock);
         bitmapmask = get_mask_bitmap(canvas, &blend->mask);
         set_scale_mode(canvas, blend->scale_mode);
         set_clip(canvas, clip);
@@ -1421,7 +1459,7 @@ static void gdi_canvas_draw_blackness(SpiceCanvas *spice_canvas, SpiceRect *bbox
     GdiCanvas *canvas = (GdiCanvas *)spice_canvas;
     struct BitmapData bitmapmask;
 
-    Lock lock(*canvas->lock);
+    RecurciveLock lock(*canvas->lock);
     bitmapmask = get_mask_bitmap(canvas, &blackness->mask);
     set_clip(canvas, clip);
     gdi_draw_bitmap(canvas->dc, bbox, bbox, canvas->dc, &bitmapmask, 0x0);
@@ -1434,7 +1472,7 @@ static void gdi_canvas_draw_invers(SpiceCanvas *spice_canvas, SpiceRect *bbox, S
     GdiCanvas *canvas = (GdiCanvas *)spice_canvas;
     struct BitmapData bitmapmask;
 
-    Lock lock(*canvas->lock);
+    RecurciveLock lock(*canvas->lock);
     bitmapmask = get_mask_bitmap(canvas, &invers->mask);
     set_clip(canvas, clip);
     gdi_draw_bitmap(canvas->dc, bbox, bbox, canvas->dc, &bitmapmask, 0x55);
@@ -1447,7 +1485,7 @@ static void gdi_canvas_draw_whiteness(SpiceCanvas *spice_canvas, SpiceRect *bbox
     GdiCanvas *canvas = (GdiCanvas *)spice_canvas;
     struct BitmapData bitmapmask;
 
-    Lock lock(*canvas->lock);
+    RecurciveLock lock(*canvas->lock);
     bitmapmask = get_mask_bitmap(canvas, &whiteness->mask);
     set_clip(canvas, clip);
     gdi_draw_bitmap(canvas->dc, bbox, bbox, canvas->dc, &bitmapmask, 0xff);
@@ -1465,23 +1503,31 @@ static void gdi_canvas_draw_rop3(SpiceCanvas *spice_canvas, SpiceRect *bbox, Spi
     HBRUSH prev_hbrush;
     HBRUSH hbrush;
     PixmanData *pixman_data;
+    RecurciveMutex *brush_lock;
 
     gdi_surface = (GdiCanvas *)canvas_get_surface(&canvas->base, rop3->src_bitmap);
     if (gdi_surface) {
-        Lock lock(*canvas->lock);
-        hbrush = get_brush(canvas, &rop3->brush);
+        RecurciveLock lock(*canvas->lock);
+        RecurciveLock s_lock(*gdi_surface->lock);
+        hbrush = get_brush(canvas, &rop3->brush, &brush_lock);
         bitmapmask = get_mask_bitmap(canvas, &rop3->mask);
         set_scale_mode(canvas, rop3->scale_mode);
         set_clip(canvas, clip);
         prev_hbrush = set_brush(canvas->dc, hbrush, &rop3->brush);
-        gdi_draw_bitmap(canvas->dc, &rop3->src_area, bbox, gdi_surface->dc,
-                        &bitmapmask, rop3->rop3);
+        if (brush_lock) {
+            RecurciveLock b_lock(*brush_lock);
+            gdi_draw_bitmap(canvas->dc, &rop3->src_area, bbox, gdi_surface->dc,
+                            &bitmapmask, rop3->rop3);
+        } else {
+            gdi_draw_bitmap(canvas->dc, &rop3->src_area, bbox, gdi_surface->dc,
+                            &bitmapmask, rop3->rop3);
+        }
         unset_brush(canvas->dc, prev_hbrush);
     } else {
         surface = canvas_get_image(&canvas->base, rop3->src_bitmap);
         pixman_data = (PixmanData *)pixman_image_get_destroy_data(surface);
-        Lock lock(*canvas->lock);
-        hbrush = get_brush(canvas, &rop3->brush);
+        RecurciveLock lock(*canvas->lock);
+        hbrush = get_brush(canvas, &rop3->brush, &brush_lock);
         bitmapmask = get_mask_bitmap(canvas, &rop3->mask);
         set_scale_mode(canvas, rop3->scale_mode);
         set_clip(canvas, clip);
@@ -1493,15 +1539,27 @@ static void gdi_canvas_draw_rop3(SpiceCanvas *spice_canvas, SpiceRect *bbox, Spi
     
             dc = create_compatible_dc();
             prev_bitmap = (HBITMAP)SelectObject(dc, pixman_data->bitmap);
-            gdi_draw_bitmap(canvas->dc, &rop3->src_area, bbox, dc,
-                            &bitmapmask, rop3->rop3);
+            if (brush_lock) {
+                RecurciveLock b_lock(*brush_lock);
+                gdi_draw_bitmap(canvas->dc, &rop3->src_area, bbox, dc,
+                                &bitmapmask, rop3->rop3);
+            } else {
+                gdi_draw_bitmap(canvas->dc, &rop3->src_area, bbox, dc,
+                                &bitmapmask, rop3->rop3);
+            }
             SelectObject(dc, prev_bitmap);
             DeleteObject(dc);
             ReleaseMutex(pixman_data->mutex);
         } else {
             surface_to_image(surface, &image);
-            gdi_draw_image_rop3(canvas->dc, &rop3->src_area, bbox, image.pixels,
+            if (brush_lock) {
+                RecurciveLock b_lock(*brush_lock);
+                gdi_draw_image_rop3(canvas->dc, &rop3->src_area, bbox, image.pixels,
                                 image.stride, image.width, image.height, &bitmapmask, rop3->rop3, 0);
+            } else {
+                gdi_draw_image_rop3(canvas->dc, &rop3->src_area, bbox, image.pixels,
+                                    image.stride, image.width, image.height, &bitmapmask, rop3->rop3, 0);
+            }
         }
 
         unset_brush(canvas->dc, prev_hbrush);
@@ -1514,7 +1572,7 @@ static void gdi_canvas_draw_rop3(SpiceCanvas *spice_canvas, SpiceRect *bbox, Spi
 static void gdi_canvas_copy_bits(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpicePoint *src_pos)
 {
     GdiCanvas *canvas = (GdiCanvas *)spice_canvas;
-    Lock lock(*canvas->lock);
+    RecurciveLock lock(*canvas->lock);
 
     set_clip(canvas, clip);
 
@@ -1526,8 +1584,9 @@ static void gdi_canvas_draw_text(SpiceCanvas *spice_canvas, SpiceRect *bbox, Spi
 {
     GdiCanvas *canvas = (GdiCanvas *)spice_canvas;
     SpiceString *str;
+    RecurciveMutex *brush_lock;
 
-    Lock lock(*canvas->lock);
+    RecurciveLock lock(*canvas->lock);
     set_clip(canvas, clip);
     lock.unlock();
 
@@ -1535,11 +1594,17 @@ static void gdi_canvas_draw_text(SpiceCanvas *spice_canvas, SpiceRect *bbox, Spi
         HBRUSH prev_hbrush;
         HBRUSH hbrush;
 
-        Lock lock(*canvas->lock);
-        hbrush = get_brush(canvas, &text->back_brush);
+        RecurciveLock lock(*canvas->lock);
+        hbrush = get_brush(canvas, &text->back_brush, &brush_lock);
         prev_hbrush = set_brush(canvas->dc, hbrush, &text->back_brush);
-        gdi_draw_bitmap_redrop(canvas->dc, bbox, bbox, canvas->dc, NULL,
-                               text->back_mode, 1);
+        if (brush_lock) {
+            RecurciveLock b_lock(*brush_lock);
+            gdi_draw_bitmap_redrop(canvas->dc, bbox, bbox, canvas->dc, NULL,
+                                   text->back_mode, 1);
+        } else {
+            gdi_draw_bitmap_redrop(canvas->dc, bbox, bbox, canvas->dc, NULL,
+                                   text->back_mode, 1);
+        }
         unset_brush(canvas->dc, prev_hbrush);
     }
 
@@ -1644,7 +1709,7 @@ static void gdi_canvas_draw_stroke(SpiceCanvas *spice_canvas, SpiceRect *bbox, S
         surface = canvas_get_image(&canvas->base, stroke->brush.u.pattern.pat);
     }
 
-    Lock lock(*canvas->lock);
+    RecurciveLock lock(*canvas->lock);
     set_clip(canvas, clip);
 
     switch (stroke->fore_mode) {
@@ -1819,7 +1884,7 @@ static int need_init = 1;
 static SpiceCanvasOps gdi_canvas_ops;
 
 SpiceCanvas *gdi_canvas_create(int width, int height,
-                               HDC dc, Mutex* lock, int bits
+                               HDC dc, RecurciveMutex* lock, int bits
 #ifdef CAIRO_CANVAS_CACHE
                              , SpiceImageCache *bits_cache
                              , SpicePaletteCache *palette_cache
diff --git a/common/gdi_canvas.h b/common/gdi_canvas.h
index 73d6978e..e0a43d5a 100644
--- a/common/gdi_canvas.h
+++ b/common/gdi_canvas.h
@@ -34,7 +34,7 @@ typedef struct {
 } GdiImage;
 
 SpiceCanvas *gdi_canvas_create(int width, int height,
-                               HDC dc, class Mutex *lock, int bits,
+                               HDC dc, class RecurciveMutex *lock, int bits,
                                SpiceImageCache *bits_cache,
                                SpicePaletteCache *palette_cache,
 			       SpiceImageSurfaces *surfaces,