Rework how rate-limiting of resize events works on Windows.

Before, we'd spawn bespoke threads every 50ms. One issue with this design was that
destroying a display before that 50ms elapsed caused crashes, which happened in the menu code.

The new code has a persistent thread that periodically sends those resize events. More
importantly, we make sure that thread is aware of displays being destroyed.

Fixes #1381

Author: SiegeLordEx

include/allegro5/platform/aintwin.h

@@ -85,11 +85,6 @@ struct ALLEGRO_DISPLAY_WIN
    volatile bool end_thread;    /* The display thread should end */
    volatile bool thread_ended;  /* The display thread has ended */
 
-   /* For internal use by drivers, when this has been set to true
-    * after al_resize_display called you can call acknowledge_resize
-    */
-   bool can_acknowledge;
-
    /* For internal use by the windows driver. When this is set and a Windows
     * window resize event is received by the window procedure, the event is
     * ignored and this value is set to false.
@@ -179,6 +174,7 @@ HWND _al_win_create_faux_fullscreen_window(LPCTSTR devname, ALLEGRO_DISPLAY *dis
                                            int x1, int y1, int width, int height,
                                            int refresh_rate, int flags);
 int  _al_win_init_window(void);
+void  _al_win_shutdown_window(void);
 HWND _al_win_create_hidden_window(void);
 void _al_win_post_create_window(ALLEGRO_DISPLAY *display);
 

src/win/d3d_disp.cpp

@@ -1818,7 +1818,6 @@ static ALLEGRO_DISPLAY *d3d_create_display_locked(int w, int h)
    win_display->mouse_selected_hcursor = 0;
    win_display->mouse_cursor_shown = false;
    win_display->hide_mouse_on_move = false;
-   win_display->can_acknowledge = false;
 
    SetForegroundWindow(win_display->window);
    _al_win_grab_input(win_display);
@@ -2238,8 +2237,6 @@ static bool d3d_resize_helper(ALLEGRO_DISPLAY *d, int width, int height)
       return true;
    }
 
-   win_display->can_acknowledge = false;
-
    if (d->flags & ALLEGRO_FULLSCREEN) {
       /* Don't generate ALLEGRO_EVENT_DISPLAY_LOST events when destroying a
        * display for resizing.

src/win/wgl_disp.c

@@ -999,7 +999,6 @@ static bool create_display_internals(ALLEGRO_DISPLAY_WGL *wgl_disp)
    win_disp->mouse_selected_hcursor = 0;
    win_disp->mouse_cursor_shown = false;
    win_disp->hide_mouse_on_move = false;
-   win_disp->can_acknowledge = false;
 
    _al_win_grab_input(win_disp);
 
@@ -1371,8 +1370,6 @@ static bool wgl_resize_helper(ALLEGRO_DISPLAY *d, int width, int height)
       return true;
    }
 
-   win_disp->can_acknowledge = false;
-
    if (d->flags & ALLEGRO_FULLSCREEN) {
       ALLEGRO_BITMAP *target_bmp;
       _AL_VECTOR disp_bmps;

src/win/wsystem.c

@@ -230,6 +230,8 @@ static void win_shutdown(void)
    _al_d3d_shutdown_display();
 #endif
 
+   _al_win_shutdown_window();
+
    _al_win_shutdown_time();
 
    if (using_higher_res_timer) {

src/win/wwindow.c

@@ -49,7 +49,10 @@ ALLEGRO_DEBUG_CHANNEL("wwindow")
 
 static WNDCLASS window_class;
 
-static bool resize_postponed = false;
+static _AL_VECTOR resizing_displays;
+static ALLEGRO_MUTEX *resize_event_thread_mutex;
+static bool end_resize_event_thread;
+static bool resize_event_thread_ended;
 
 
 UINT _al_win_msg_call_proc = 0;
@@ -308,6 +311,10 @@ static void win_generate_resize_event(ALLEGRO_DISPLAY_WIN *win_display)
    WINDOWINFO wi;
    int x, y, w, h;
 
+   if (win_display->ignore_resize) {
+      return;
+   }
+
    wi.cbSize = sizeof(WINDOWINFO);
    GetWindowInfo(win_display->window, &wi);
    x = wi.rcClient.left;
@@ -347,25 +354,6 @@ static void win_generate_resize_event(ALLEGRO_DISPLAY_WIN *win_display)
    }
 }
 
-static void postpone_thread_proc(void *arg)
-{
-   ALLEGRO_DISPLAY *display = (ALLEGRO_DISPLAY *)arg;
-   ALLEGRO_DISPLAY_WIN *win_display = (ALLEGRO_DISPLAY_WIN *)display;
-
-   Sleep(50);
-
-   if (win_display->ignore_resize) {
-      win_display->ignore_resize = false;
-   }
-   else {
-      win_generate_resize_event(win_display);
-   }
-
-   resize_postponed = false;
-   win_display->can_acknowledge = true;
-}
-
-
 static void handle_mouse_capture(bool down, HWND hWnd)
 {
    int i;
@@ -412,6 +400,32 @@ static bool accept_mouse_event(void)
    return !((GetMessageExtraInfo() & _AL_MOUSEEVENTF_FROMTOUCH) == _AL_MOUSEEVENTF_FROMTOUCH);
 }
 
+/* We want to rate-limit the ALLEGRO_EVENT_DISPLAY_RESIZE events while
+ * live-resizing via mouse. To this end, we detect start/end of this
+ * via WM_ENTERSIZEMOVE/WM_EXITSIZEMOVE and then enable this code to
+ * periodically send those events.
+ */
+static void resize_event_thread_proc(void *arg)
+{
+   (void)arg;
+   while (true) {
+      al_lock_mutex(resize_event_thread_mutex);
+      if (end_resize_event_thread) {
+         al_unlock_mutex(resize_event_thread_mutex);
+         break;
+      }
+
+      for (int j = 0; j < (int)_al_vector_size(&resizing_displays); j++) {
+         ALLEGRO_DISPLAY_WIN **win_display = (ALLEGRO_DISPLAY_WIN **)_al_vector_ref(&resizing_displays, j);
+         win_generate_resize_event(*win_display);
+      }
+
+      al_unlock_mutex(resize_event_thread_mutex);
+      Sleep(50);
+   }
+   resize_event_thread_ended = true;
+}
+
 static LRESULT CALLBACK window_callback(HWND hWnd, UINT message,
     WPARAM wParam, LPARAM lParam)
 {
@@ -438,6 +452,9 @@ static LRESULT CALLBACK window_callback(HWND hWnd, UINT message,
       break_window_message_pump(win_display, hWnd);
       if (_al_win_unregister_touch_window)
          _al_win_unregister_touch_window(hWnd);
+      al_lock_mutex(resize_event_thread_mutex);
+      _al_vector_find_and_delete(&resizing_displays, &win_display);
+      al_unlock_mutex(resize_event_thread_mutex);
       DestroyWindow(hWnd);
       return 0;
    }
@@ -459,6 +476,9 @@ static LRESULT CALLBACK window_callback(HWND hWnd, UINT message,
       break_window_message_pump(win_display, hWnd);
       if (_al_win_unregister_touch_window)
          _al_win_unregister_touch_window(hWnd);
+      al_lock_mutex(resize_event_thread_mutex);
+      _al_vector_find_and_delete(&resizing_displays, &win_display);
+      al_unlock_mutex(resize_event_thread_mutex);
       DestroyWindow(hWnd);
       return 0;
    }
@@ -939,15 +959,10 @@ static LRESULT CALLBACK window_callback(HWND hWnd, UINT message,
             }
          }
          break;
-      case WM_SIZE:
+      case WM_SIZE: {
+         bool generate = false;
          if (wParam == SIZE_RESTORED || wParam == SIZE_MAXIMIZED || wParam == SIZE_MINIMIZED) {
-            /*
-             * Delay the resize event so we don't get bogged down with them
-             */
-            if (!resize_postponed) {
-               resize_postponed = true;
-               _beginthread(postpone_thread_proc, 0, (void *)d);
-            }
+            generate = true;
             d->flags &= ~ALLEGRO_MAXIMIZED;
             if (wParam == SIZE_MAXIMIZED) {
                d->flags |= ALLEGRO_MAXIMIZED;
@@ -959,31 +974,43 @@ static LRESULT CALLBACK window_callback(HWND hWnd, UINT message,
              * We have to create the resize event, so the application could
              * redraw its content.
              */
-            if (!resize_postponed) {
-               resize_postponed = true;
-               _beginthread(postpone_thread_proc, 0, (void *)d);
-            }
+            generate = true;
+         }
+         al_lock_mutex(resize_event_thread_mutex);
+         if (_al_vector_contains(&resizing_displays, &win_display)) {
+            generate = false;
+         }
+         al_unlock_mutex(resize_event_thread_mutex);
+         if (generate) {
+            win_generate_resize_event(win_display);
          }
          return 0;
-      case WM_ENTERSIZEMOVE:
+      }
+      case WM_ENTERSIZEMOVE: {
          /* DefWindowProc for WM_ENTERSIZEMOVE enters a modal loop, which also
           * ends up blocking the loop in d3d_display_thread_proc (which is
           * where we are called from, if using D3D).  Rather than batching up
           * intermediate resize events which the user cannot acknowledge in the
           * meantime anyway, make it so only a single resize event is generated
           * at WM_EXITSIZEMOVE.
           */
+         al_lock_mutex(resize_event_thread_mutex);
          if (d->flags & ALLEGRO_DIRECT3D_INTERNAL) {
-            resize_postponed = true;
+            win_display->ignore_resize = true;
          }
+         ALLEGRO_DISPLAY_WIN **add = (ALLEGRO_DISPLAY_WIN **)_al_vector_alloc_back(&resizing_displays);
+         *add = win_display;
+         al_unlock_mutex(resize_event_thread_mutex);
          break;
+      }
       case WM_EXITSIZEMOVE:
-         if (resize_postponed) {
-            win_generate_resize_event(win_display);
+         al_lock_mutex(resize_event_thread_mutex);
+         if (d->flags & ALLEGRO_DIRECT3D_INTERNAL) {
             win_display->ignore_resize = false;
-            resize_postponed = false;
-            win_display->can_acknowledge = true;
          }
+         _al_vector_find_and_delete(&resizing_displays, &win_display);
+         al_unlock_mutex(resize_event_thread_mutex);
+         win_generate_resize_event(win_display);
          break;
       case WM_DPICHANGED:
         if ((d->flags & ALLEGRO_RESIZABLE) && !(d->flags & ALLEGRO_FULLSCREEN)) {
@@ -1008,7 +1035,7 @@ static LRESULT CALLBACK window_callback(HWND hWnd, UINT message,
    return DefWindowProc(hWnd,message,wParam,lParam);
 }
 
-int _al_win_init_window()
+int _al_win_init_window(void)
 {
    // Create A Window Class Structure
    window_class.cbClsExtra = 0;
@@ -1029,9 +1056,33 @@ int _al_win_init_window()
       _al_win_msg_suicide = RegisterWindowMessage(TEXT("Allegro window suicide"));
    }
 
+   resize_event_thread_mutex = al_create_mutex();
+   _al_vector_init(&resizing_displays, sizeof(ALLEGRO_DISPLAY_WIN *));
+   _beginthread(resize_event_thread_proc, 0, 0);
+
    return true;
 }
 
+void _al_win_shutdown_window(void)
+{
+   al_lock_mutex(resize_event_thread_mutex);
+   end_resize_event_thread = true;
+   al_unlock_mutex(resize_event_thread_mutex);
+
+   while (true) {
+      al_lock_mutex(resize_event_thread_mutex);
+      if (resize_event_thread_ended) {
+         al_unlock_mutex(resize_event_thread_mutex);
+         break;
+      }
+      al_unlock_mutex(resize_event_thread_mutex);
+      Sleep(10);
+   }
+   _al_vector_free(&resizing_displays);
+   al_destroy_mutex(resize_event_thread_mutex);
+   resize_event_thread_mutex = NULL;
+}
+
 
 static int win_choose_icon_bitmap(const int sys_w, const int sys_h,
    const int num_icons, ALLEGRO_BITMAP *bmps[])