Good enough to start

src/cascadia/WindowsTerminal/WindowEmperor.cpp

@@ -59,6 +59,25 @@ WindowEmperor::~WindowEmperor()
     _app = nullptr;
 }
 
+static bool IsWindows11()
+{
+    static const bool isWindows11 = []() {
+        OSVERSIONINFOEXW osver{};
+        osver.dwOSVersionInfoSize = sizeof(osver);
+        osver.dwBuildNumber = 22000;
+
+        DWORDLONG dwlConditionMask = 0;
+        VER_SET_CONDITION(dwlConditionMask, VER_BUILDNUMBER, VER_GREATER_EQUAL);
+
+        if (VerifyVersionInfoW(&osver, VER_BUILDNUMBER, dwlConditionMask) != FALSE)
+        {
+            return true;
+        }
+        return false;
+    }();
+    return isWindows11;
+}
+
 void _buildArgsFromCommandline(std::vector<winrt::hstring>& args)
 {
     if (auto commandline{ GetCommandLineW() })
@@ -111,7 +130,8 @@ bool WindowEmperor::HandleCommandlineArgs()
 
     const auto result = _manager.ProposeCommandline(eventArgs, isolatedMode);
 
-    if (result.ShouldCreateWindow())
+    const bool makeWindow = result.ShouldCreateWindow();
+    if (makeWindow)
     {
         _createNewWindowThread(Remoting::WindowRequestedArgs{ result, eventArgs });
 
@@ -127,7 +147,7 @@ bool WindowEmperor::HandleCommandlineArgs()
         }
     }
 
-    return result.ShouldCreateWindow();
+    return makeWindow;
 }
 
 void WindowEmperor::WaitForWindows()
@@ -185,12 +205,6 @@ void WindowEmperor::_createNewWindowThread(const Remoting::WindowRequestedArgs&
     std::thread t([weakThis, window]() {
         try
         {
-            auto removeWindow = wil::scope_exit([&]() {
-                if (auto self{ weakThis.lock() })
-                {
-                    self->_removeWindow(window->PeasantID());
-                }
-            });
 
             window->CreateHost();
 
@@ -200,6 +214,23 @@ void WindowEmperor::_createNewWindowThread(const Remoting::WindowRequestedArgs&
             }
             while (window->KeepWarm())
             {
+                // Now that the window is ready to go, we can add it to our list of windows,
+                // because we know it will be well behaved.
+                //
+                // Be sure to only modify the list of windows under lock.
+
+                if (auto self{ weakThis.lock() })
+                {
+                    auto lockedWindows{ self->_windows.lock() };
+                    lockedWindows->push_back(window);
+                }
+                auto removeWindow = wil::scope_exit([&]() {
+                    if (auto self{ weakThis.lock() })
+                    {
+                        self->_removeWindow(window->PeasantID());
+                    }
+                });
+
                 auto decrementWindowCount = wil::scope_exit([&]() {
                     if (auto self{ weakThis.lock() })
                     {
@@ -215,13 +246,24 @@ void WindowEmperor::_createNewWindowThread(const Remoting::WindowRequestedArgs&
                 // elsewhere).
                 removeWindow.reset();
 
-                window->Refrigerate();
-                decrementWindowCount.reset();
+                // On Windows 11, we DONT want to refrigerate the window. There, we can just
+                // close it like normal.
+                // TODO!
 
-                if (auto self{ weakThis.lock() })
+                if (IsWindows11())
                 {
-                    auto fridge{ self->_oldThreads.lock() };
-                    fridge->push_back(window);
+                    decrementWindowCount.reset();
+                }
+                else
+                {
+                    window->Refrigerate();
+                    decrementWindowCount.reset();
+
+                    if (auto self{ weakThis.lock() })
+                    {
+                        auto fridge{ self->_oldThreads.lock() };
+                        fridge->push_back(window);
+                    }
                 }
             }
 
@@ -257,15 +299,6 @@ void WindowEmperor::_windowStartedHandlerPostXAML(const std::shared_ptr<WindowTh
     // the Terminal window, making it visible BEFORE the XAML island is actually
     // ready to be drawn. We want to wait till the app's Initialized event
     // before we make the window visible.
-
-    // Now that the window is ready to go, we can add it to our list of windows,
-    // because we know it will be well behaved.
-    //
-    // Be sure to only modify the list of windows under lock.
-    {
-        auto lockedWindows{ _windows.lock() };
-        lockedWindows->push_back(sender);
-    }
 }
 
 void WindowEmperor::_removeWindow(uint64_t senderID)
@@ -553,6 +586,15 @@ LRESULT WindowEmperor::_messageHandler(UINT const message, WPARAM const wParam,
 
 winrt::fire_and_forget WindowEmperor::_close()
 {
+    {
+        auto fridge{ _oldThreads.lock() };
+        for (auto& window : *fridge)
+        {
+            window->ThrowAway();
+        }
+        fridge->clear();
+    }
+
     // Important! Switch back to the main thread for the emperor. That way, the
     // quit will go to the emperor's message pump.
     co_await wil::resume_foreground(_dispatcher);

src/cascadia/WindowsTerminal/WindowThread.cpp

@@ -18,23 +18,20 @@ WindowThread::WindowThread(winrt::TerminalApp::AppLogic logic,
 
 void WindowThread::CreateHost()
 {
-    const bool coldStart = _warmWindow == nullptr;
+    // Calling this while refrigerated won't work.
+    // * We can't re-initialize our winrt apartment.
+    // * AppHost::Initialize has to be done on the "UI" thread.
+    assert(_warmWindow == nullptr);
+
     // Start the AppHost HERE, on the actual thread we want XAML to run on
-    _host = !coldStart ? std::make_unique<::AppHost>(_appLogic,
-                                                     _args,
-                                                     _manager,
-                                                     _peasant,
-                                                     std::move(_warmWindow)) :
-                         std::make_unique<::AppHost>(_appLogic,
-                                                     _args,
-                                                     _manager,
-                                                     _peasant);
+    _host = std::make_unique<::AppHost>(_appLogic,
+                                        _args,
+                                        _manager,
+                                        _peasant);
+
     _UpdateSettingsRequestedToken = _host->UpdateSettingsRequested([this]() { _UpdateSettingsRequestedHandlers(); });
 
-    if (coldStart)
-    {
-        winrt::init_apartment(winrt::apartment_type::single_threaded);
-    }
+    winrt::init_apartment(winrt::apartment_type::single_threaded);
 
     // Initialize the xaml content. This must be called AFTER the
     // WindowsXamlManager is initialized.
@@ -49,10 +46,29 @@ int WindowThread::RunMessagePump()
     return exitCode;
 }
 
+void WindowThread::_pumpRemainingXamlMessages()
+{
+    MSG msg = {};
+    while (PeekMessageW(&msg, nullptr, 0, 0, PM_REMOVE))
+    {
+        ::DispatchMessageW(&msg);
+    }
+}
+
 void WindowThread::RundownForExit()
 {
-    _host->UpdateSettingsRequested(_UpdateSettingsRequestedToken);
-    _host->Close();
+    if (_host)
+    {
+        _host->UpdateSettingsRequested(_UpdateSettingsRequestedToken);
+        _host->Close();
+    }
+    if (_warmWindow)
+    {
+        // If we have a _warmWindow, we're a refrigerated thread without a
+        // AppHost in control of the window. Manually close the window
+        // ourselves, to free the DWXS.
+        _warmWindow->Close();
+    }
 
     // !! LOAD BEARING !!
     //
@@ -62,13 +78,13 @@ void WindowThread::RundownForExit()
     // exiting. So do that now. If you don't, then the last tab to close
     // will never actually destruct the last tab / TermControl / ControlCore
     // / renderer.
-    {
-        MSG msg = {};
-        while (PeekMessageW(&msg, nullptr, 0, 0, PM_REMOVE))
-        {
-            ::DispatchMessageW(&msg);
-        }
-    }
+    _pumpRemainingXamlMessages();
+}
+
+void WindowThread::ThrowAway()
+{
+    // raise the signal to unblock KeepWarm. We won't have a host, so we'll drop out of the message loop to eventually RundownForExit.
+    _microwaveBuzzer.notify_one();
 }
 
 // Method Description:
@@ -113,6 +129,12 @@ bool WindowThread::KeepWarm()
     }
 }
 
+// Method Description:
+// - "Refrigerate" this thread for later reuse. This will refrigerate the window
+//   itself, and tear down our current app host. We'll save our window for
+//   later. We'll also pump out the existing message from XAML, before
+//   returning. After we return, the emperor will add us to the list of threads
+//   that can be re-used.
 void WindowThread::Refrigerate()
 {
     _host->UpdateSettingsRequested(_UpdateSettingsRequestedToken);
@@ -121,16 +143,15 @@ void WindowThread::Refrigerate()
     _warmWindow = std::move(_host->Refrigerate());
 
     // rundown remaining messages before dtoring the app host
-    {
-        MSG msg = {};
-        while (PeekMessageW(&msg, nullptr, 0, 0, PM_REMOVE))
-        {
-            ::DispatchMessageW(&msg);
-        }
-    }
+    _pumpRemainingXamlMessages();
     _host = nullptr;
 }
 
+// Method Description:
+// - "Reheat" this thread for reuse. We'll build a new AppHost, and pass in the
+//   existing window to it. We'll then trigger the _microwaveBuzzer, so KeepWarm
+//   (which is on the UI thread) will get unblocked, and we can initialize this
+//   window.
 void WindowThread::Microwave(
     winrt::Microsoft::Terminal::Remoting::WindowRequestedArgs args,
     winrt::Microsoft::Terminal::Remoting::Peasant peasant)

src/cascadia/WindowsTerminal/WindowThread.h

@@ -22,6 +22,7 @@ class WindowThread : public std::enable_shared_from_this<WindowThread>
     void Microwave(
         winrt::Microsoft::Terminal::Remoting::WindowRequestedArgs args,
         winrt::Microsoft::Terminal::Remoting::Peasant peasant);
+    void ThrowAway();
 
     uint64_t PeasantID();
 
@@ -42,4 +43,5 @@ class WindowThread : public std::enable_shared_from_this<WindowThread>
     std::condition_variable _microwaveBuzzer;
 
     int _messagePump();
+    void _pumpRemainingXamlMessages();
 };