Windows: Refactored the internal message queue to avoid hitting the message limit

modules/juce_events/native/juce_win32_Messaging.cpp

@@ -80,35 +80,36 @@ public:
         }
     }
 
-    bool postMessage (MessageManager::MessageBase* message)
+    void postMessage (MessageManager::MessageBase* message)
     {
-        message->incReferenceCount();
+        bool shouldTriggerMessageQueueDispatch = false;
 
-        #if JUCE_MODULE_AVAILABLE_juce_audio_plugin_client && JucePlugin_Build_Unity
-         if (juce_isRunningInUnity())
-             return SendNotifyMessage (juce_messageWindowHandle, customMessageID, 0, (LPARAM) message) != 0;
-        #endif
-
-         if (PostMessage (juce_messageWindowHandle, customMessageID, 0, (LPARAM) message) != 0)
-             return true;
-
-        if (GetLastError() == ERROR_NOT_ENOUGH_QUOTA)
         {
             const ScopedLock sl (lock);
-            overflowQueue.add (message);
-            message->decReferenceCount();
 
-            return true;
+            shouldTriggerMessageQueueDispatch = messageQueue.isEmpty();
+            messageQueue.add (message);
+        }
+
+        if (! shouldTriggerMessageQueueDispatch)
+            return;
+
+       #if JUCE_MODULE_AVAILABLE_juce_audio_plugin_client && JucePlugin_Build_Unity
+        if (juce_isRunningInUnity())
+        {
+            SendNotifyMessage (juce_messageWindowHandle, customMessageID, 0, 0);
+            return;
         }
+        #endif
 
-        return false;
+        PostMessage (juce_messageWindowHandle, customMessageID, 0, 0);
     }
 
     bool dispatchNextMessage (bool returnIfNoPendingMessages)
     {
         MSG m;
 
-        if (returnIfNoPendingMessages && ! PeekMessage (&m, (HWND) 0, 0, 0, PM_NOREMOVE) && overflowQueue.size() == 0)
+        if (returnIfNoPendingMessages && ! PeekMessage (&m, (HWND) 0, 0, 0, PM_NOREMOVE))
             return false;
 
         if (GetMessage (&m, (HWND) 0, 0, 0) >= 0)
@@ -120,7 +121,7 @@ public:
 
             if (m.message == customMessageID && m.hwnd == juce_messageWindowHandle)
             {
-                dispatchMessageFromLParam (m.lParam);
+                dispatchMessages();
             }
             else if (m.message == WM_QUIT)
             {
@@ -145,8 +146,6 @@ public:
             }
         }
 
-        dispatchOverflowMessages();
-
         return true;
     }
 
@@ -158,12 +157,8 @@ private:
         {
             if (message == customMessageID)
             {
-                // (These are trapped early in our dispatch loop, but must also be checked
-                // here in case some 3rd-party code is running the dispatch loop).
-                dispatchMessageFromLParam (lParam);
-
                 if (auto* queue = InternalMessageQueue::getInstanceWithoutCreating())
-                    queue->dispatchOverflowMessages();
+                    queue->dispatchMessages();
 
                 return 0;
             }
@@ -196,18 +191,15 @@ private:
         return TRUE;
     }
 
-    static void dispatchMessageFromLParam (LPARAM lParam)
+    static void dispatchMessage (MessageManager::MessageBase* message)
     {
-        if (auto message = reinterpret_cast<MessageManager::MessageBase*> (lParam))
+        JUCE_TRY
         {
-            JUCE_TRY
-            {
-                message->messageCallback();
-            }
-            JUCE_CATCH_EXCEPTION
-
-            message->decReferenceCount();
+            message->messageCallback();
         }
+        JUCE_CATCH_EXCEPTION
+
+        message->decReferenceCount();
     }
 
     static void handleBroadcastMessage (const COPYDATASTRUCT* data)
@@ -228,24 +220,24 @@ private:
         }
     }
 
-    void dispatchOverflowMessages()
+    void dispatchMessages()
     {
         ReferenceCountedArray<MessageManager::MessageBase> messagesToDispatch;
 
         {
             const ScopedLock sl (lock);
 
-            if (overflowQueue.isEmpty())
+            if (messageQueue.isEmpty())
                 return;
 
-            messagesToDispatch.swapWith (overflowQueue);
+            messagesToDispatch.swapWith (messageQueue);
         }
 
         for (int i = 0; i < messagesToDispatch.size(); ++i)
         {
             auto message = messagesToDispatch.getUnchecked (i);
             message->incReferenceCount();
-            dispatchMessageFromLParam ((LPARAM) message.get());
+            dispatchMessage (message.get());
         }
     }
 
@@ -257,7 +249,7 @@ private:
     std::unique_ptr<HiddenMessageWindow> messageWindow;
 
     CriticalSection lock;
-    ReferenceCountedArray<MessageManager::MessageBase> overflowQueue;
+    ReferenceCountedArray<MessageManager::MessageBase> messageQueue;
 
     //==============================================================================
     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (InternalMessageQueue)