morgan pushed to branch maint-14.0 at The Tor Project / Applications / tor-browser-build

Commits: 94f1da7f by june wilde at 2024-10-31T19:18:40+00:00 Bug 41291 - Bump and patch mingw-w64-clang

- - - - - 60286499 by Morgan at 2024-10-31T19:34:02+00:00 Bug 41291: Only enable WebRTC mingw changes for alpha build in the maint-14.0 branch

- Revert this patch once Mullvad Browser 14.0 reaches stable

- - - - - f9e2c4dd by Morgan at 2024-10-31T20:02:16+00:00 Bug 41263: Prepare Mullvad Browser Alpha 14.0a10

- - - - -

8 changed files:

- projects/browser/Bundle-Data/Docs-MB/ChangeLog.txt - projects/browser/config - projects/firefox/config - projects/mingw-w64-clang/build - projects/mingw-w64-clang/config - + projects/mingw-w64-clang/mingw-webrtc.patch - projects/translation/config - rbm.conf

Changes:

===================================== projects/browser/Bundle-Data/Docs-MB/ChangeLog.txt ===================================== @@ -1,3 +1,40 @@ +Mullvad Browser 14.0a10 - November 01 2024 + * All Platforms + * Updated Firefox to 128.4.0esr + * Updated NoScript to 11.5.0 + * Bug 42356: Review 000-tor-browser.js and 001-base-profile.js for 128 [tor-browser] + * Bug 43134: Backport Bugzilla 1436226 Hardcode VP8/VP9 [tor-browser] + * Bug 43174: Issue with custom home page on local filesystem [tor-browser] + * Bug 43184: Backport Bugzilla 1922294: RFP: fixup square spoofed orientation [tor-browser] + * Bug 43209: UI freezes when clipboard is empty after screen lock [tor-browser] + * Bug 43217: Fullscreen videos have rounded letterboxing corners [tor-browser] + * Bug 43240: Backport security fixes from Firefox 132 [tor-browser] + * Windows + * Bug 373: Re-enable WebRTC for Windows builds [mullvad-browser] + * Linux + * Bug 43101: Security features warning links to Firefox installation support page with incomplete info [tor-browser] + * Bug 43196: Remove the vendor name from the "is playing media" notification on Linux [tor-browser] + * Build System + * All Platforms + * Bug 41273: relprep.py: bump Firefox and GV to a (yet) non-existing tag when the last one does not match HEAD [tor-browser-build] + * Bug 41274: Improve fetch_changelogs.py for major releases [tor-browser-build] + * Bug 41279: Add @pierov and @ma1 as new signers [tor-browser-build] + * Bug 41289: Fix single-browser in relprep.py [tor-browser-build] + * Windows + * Bug 41296: Implement missing Windows headers required for building cross-compiling WebRTC with mingw [tor-browser-build] + * Linux + * Bug 41243: Add own apparmor profile to deb package [tor-browser-build] + * Bug 41282: Add SSL to our custom Python for MozBug 1924022 [tor-browser-build] + +Mullvad Browser 13.5.9 - October 28 2024 + * All Platforms + * Updated Firefox to 115.17.0esr + * Updated NoScript to 11.4.42 + * Bug 43174: Issue with custom home page on local filesystem [tor-browser] + * Bug 43207: Backport Mozbug 1886222 [tor-browser] + * Bug 43240: Backport security fixes from Firefox 132 [tor-browser] + * Bug 41273: relprep.py: bump Firefox and GV to a (yet) non-existing tag when the last one does not match HEAD [tor-browser-build] + Mullvad Browser 14.0a9 - October 08 2024 * All Platforms * Bug 43197: Disable automatic exception for HTTPS-First [tor-browser]

===================================== projects/browser/config ===================================== @@ -108,9 +108,9 @@ input_files: enable: '[% ! c("var/android") %]' - filename: Bundle-Data enable: '[% ! c("var/android") %]' - - URL: https://addons.mozilla.org/firefox/downloads/file/4363712/noscript-11.4.42.x... + - URL: https://addons.mozilla.org/firefox/downloads/file/4377088/noscript-11.5.0.xp... name: noscript - sha256sum: fd2d420afd93829bb6fe30ec6f8ba926d3d54d7583b8bbd822053b8cd13c0472 + sha256sum: 999244c7be75e58fe16cb2880711013ca079822da1dab65e7eb375c1faf5baad - URL: https://addons.mozilla.org/firefox/downloads/file/4359936/ublock_origin-1.60... name: ublock-origin sha256sum: e2cda9b2a1b0a7f6e5ef0da9f87f28df52f8560587ba2e51a3003121cfb81600

===================================== projects/firefox/config ===================================== @@ -107,7 +107,6 @@ targets: gitlab_project: https://gitlab.torproject.org/tpo/applications/mullvad-browser updater_url: 'https://cdn.mullvad.net/browser/update_responses/update_1/' nightly_updates_publish_dir_prefix: mullvadbrowser- - browser_build: 1

linux-x86_64: var:

===================================== projects/mingw-w64-clang/build ===================================== @@ -89,6 +89,9 @@ EOF patch -p1 < "$rootdir/mingw-dispatchqueue.patch" patch -p1 < "$rootdir/mingw-ts_sd.patch" patch -p1 < "$rootdir/mingw-composition.patch" + [% IF !c("var/release") %] + patch -p1 < "$rootdir/mingw-webrtc.patch" + [% END %]

cd $builddir/mingw-w64-clang/mingw-w64-headers mkdir build && cd build

===================================== projects/mingw-w64-clang/config ===================================== @@ -1,7 +1,7 @@ # vim: filetype=yaml sw=2 filename: '[% project %]-[% c("version") %]-[% pc("llvm-project", "version") %]-[% c("var/build_id") %].tar.[% c("compress_tar") %]' git_url: https://git.code.sf.net/p/mingw-w64/mingw-w64 -git_hash: cd4cf9b279f8fb0815f8b9665d3cea60a30290bc +git_hash: '[% IF c("var/release") %]cd4cf9b279f8fb0815f8b9665d3cea60a30290bc[% ELSE %]4ef04b0a7f7a20735de2f58b5c0496fcb4c7d191[% END -%]' version: '[% c("abbrev") %]' container: use_container: 1 @@ -35,3 +35,5 @@ input_files: - filename: mingw-dispatchqueue.patch - filename: mingw-ts_sd.patch - filename: mingw-composition.patch + - filename: mingw-webrtc.patch + enable: '[% !c("var/release") %]' \ No newline at end of file

===================================== projects/mingw-w64-clang/mingw-webrtc.patch ===================================== @@ -0,0 +1,1727 @@ +diff --git a/mingw-w64-headers/include/weakreference.h b/mingw-w64-headers/include/weakreference.h +new file mode 100644 +index 000000000..9776dd194 +--- /dev/null ++++ b/mingw-w64-headers/include/weakreference.h +@@ -0,0 +1,218 @@ ++/*** Autogenerated by WIDL 8.0 from include/weakreference.idl - Do not edit ***/ ++ ++#ifdef _WIN32 ++#ifndef __REQUIRED_RPCNDR_H_VERSION__ ++#define __REQUIRED_RPCNDR_H_VERSION__ 475 ++#endif ++#include <rpc.h> ++#include <rpcndr.h> ++#endif ++ ++#ifndef COM_NO_WINDOWS_H ++#include <windows.h> ++#include <ole2.h> ++#endif ++ ++#ifndef __weakreference_h__ ++#define __weakreference_h__ ++ ++#ifndef __WIDL_INLINE ++#if defined(__cplusplus) || defined(_MSC_VER) ++#define __WIDL_INLINE inline ++#elif defined(__GNUC__) ++#define __WIDL_INLINE __inline__ ++#endif ++#endif ++ ++/* Forward declarations */ ++ ++#ifndef __IWeakReference_FWD_DEFINED__ ++#define __IWeakReference_FWD_DEFINED__ ++typedef interface IWeakReference IWeakReference; ++#ifdef __cplusplus ++interface IWeakReference; ++#endif /* __cplusplus */ ++#endif ++ ++#ifndef __IWeakReferenceSource_FWD_DEFINED__ ++#define __IWeakReferenceSource_FWD_DEFINED__ ++typedef interface IWeakReferenceSource IWeakReferenceSource; ++#ifdef __cplusplus ++interface IWeakReferenceSource; ++#endif /* __cplusplus */ ++#endif ++ ++/* Headers for imported files */ ++ ++#include <inspectable.h> ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/***************************************************************************** ++ * IWeakReference interface ++ */ ++#ifndef __IWeakReference_INTERFACE_DEFINED__ ++#define __IWeakReference_INTERFACE_DEFINED__ ++ ++DEFINE_GUID(IID_IWeakReference, 0x00000037, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); ++#if defined(__cplusplus) && !defined(CINTERFACE) ++MIDL_INTERFACE("00000037-0000-0000-c000-000000000046") ++IWeakReference : public IUnknown ++{ ++ virtual HRESULT STDMETHODCALLTYPE Resolve( ++ REFIID riid, ++ IInspectable **objectReference) = 0; ++ ++}; ++#ifdef __CRT_UUID_DECL ++__CRT_UUID_DECL(IWeakReference, 0x00000037, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46) ++#endif ++#else ++typedef struct IWeakReferenceVtbl { ++ BEGIN_INTERFACE ++ ++ /*** IUnknown methods ***/ ++ HRESULT (STDMETHODCALLTYPE *QueryInterface)( ++ IWeakReference *This, ++ REFIID riid, ++ void **ppvObject); ++ ++ ULONG (STDMETHODCALLTYPE *AddRef)( ++ IWeakReference *This); ++ ++ ULONG (STDMETHODCALLTYPE *Release)( ++ IWeakReference *This); ++ ++ /*** IWeakReference methods ***/ ++ HRESULT (STDMETHODCALLTYPE *Resolve)( ++ IWeakReference *This, ++ REFIID riid, ++ IInspectable **objectReference); ++ ++ END_INTERFACE ++} IWeakReferenceVtbl; ++ ++interface IWeakReference { ++ CONST_VTBL IWeakReferenceVtbl* lpVtbl; ++}; ++ ++#ifdef COBJMACROS ++#ifndef WIDL_C_INLINE_WRAPPERS ++/*** IUnknown methods ***/ ++#define IWeakReference_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) ++#define IWeakReference_AddRef(This) (This)->lpVtbl->AddRef(This) ++#define IWeakReference_Release(This) (This)->lpVtbl->Release(This) ++/*** IWeakReference methods ***/ ++#define IWeakReference_Resolve(This,riid,objectReference) (This)->lpVtbl->Resolve(This,riid,objectReference) ++#else ++/*** IUnknown methods ***/ ++static __WIDL_INLINE HRESULT IWeakReference_QueryInterface(IWeakReference* This,REFIID riid,void **ppvObject) { ++ return This->lpVtbl->QueryInterface(This,riid,ppvObject); ++} ++static __WIDL_INLINE ULONG IWeakReference_AddRef(IWeakReference* This) { ++ return This->lpVtbl->AddRef(This); ++} ++static __WIDL_INLINE ULONG IWeakReference_Release(IWeakReference* This) { ++ return This->lpVtbl->Release(This); ++} ++/*** IWeakReference methods ***/ ++static __WIDL_INLINE HRESULT IWeakReference_Resolve(IWeakReference* This,REFIID riid,IInspectable **objectReference) { ++ return This->lpVtbl->Resolve(This,riid,objectReference); ++} ++#endif ++#endif ++ ++#endif ++ ++ ++#endif /* __IWeakReference_INTERFACE_DEFINED__ */ ++ ++/***************************************************************************** ++ * IWeakReferenceSource interface ++ */ ++#ifndef __IWeakReferenceSource_INTERFACE_DEFINED__ ++#define __IWeakReferenceSource_INTERFACE_DEFINED__ ++ ++DEFINE_GUID(IID_IWeakReferenceSource, 0x00000038, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); ++#if defined(__cplusplus) && !defined(CINTERFACE) ++MIDL_INTERFACE("00000038-0000-0000-c000-000000000046") ++IWeakReferenceSource : public IUnknown ++{ ++ virtual HRESULT STDMETHODCALLTYPE GetWeakReference( ++ IWeakReference **weakReference) = 0; ++ ++}; ++#ifdef __CRT_UUID_DECL ++__CRT_UUID_DECL(IWeakReferenceSource, 0x00000038, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46) ++#endif ++#else ++typedef struct IWeakReferenceSourceVtbl { ++ BEGIN_INTERFACE ++ ++ /*** IUnknown methods ***/ ++ HRESULT (STDMETHODCALLTYPE *QueryInterface)( ++ IWeakReferenceSource *This, ++ REFIID riid, ++ void **ppvObject); ++ ++ ULONG (STDMETHODCALLTYPE *AddRef)( ++ IWeakReferenceSource *This); ++ ++ ULONG (STDMETHODCALLTYPE *Release)( ++ IWeakReferenceSource *This); ++ ++ /*** IWeakReferenceSource methods ***/ ++ HRESULT (STDMETHODCALLTYPE *GetWeakReference)( ++ IWeakReferenceSource *This, ++ IWeakReference **weakReference); ++ ++ END_INTERFACE ++} IWeakReferenceSourceVtbl; ++ ++interface IWeakReferenceSource { ++ CONST_VTBL IWeakReferenceSourceVtbl* lpVtbl; ++}; ++ ++#ifdef COBJMACROS ++#ifndef WIDL_C_INLINE_WRAPPERS ++/*** IUnknown methods ***/ ++#define IWeakReferenceSource_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) ++#define IWeakReferenceSource_AddRef(This) (This)->lpVtbl->AddRef(This) ++#define IWeakReferenceSource_Release(This) (This)->lpVtbl->Release(This) ++/*** IWeakReferenceSource methods ***/ ++#define IWeakReferenceSource_GetWeakReference(This,weakReference) (This)->lpVtbl->GetWeakReference(This,weakReference) ++#else ++/*** IUnknown methods ***/ ++static __WIDL_INLINE HRESULT IWeakReferenceSource_QueryInterface(IWeakReferenceSource* This,REFIID riid,void **ppvObject) { ++ return This->lpVtbl->QueryInterface(This,riid,ppvObject); ++} ++static __WIDL_INLINE ULONG IWeakReferenceSource_AddRef(IWeakReferenceSource* This) { ++ return This->lpVtbl->AddRef(This); ++} ++static __WIDL_INLINE ULONG IWeakReferenceSource_Release(IWeakReferenceSource* This) { ++ return This->lpVtbl->Release(This); ++} ++/*** IWeakReferenceSource methods ***/ ++static __WIDL_INLINE HRESULT IWeakReferenceSource_GetWeakReference(IWeakReferenceSource* This,IWeakReference **weakReference) { ++ return This->lpVtbl->GetWeakReference(This,weakReference); ++} ++#endif ++#endif ++ ++#endif ++ ++ ++#endif /* __IWeakReferenceSource_INTERFACE_DEFINED__ */ ++ ++/* Begin additional prototypes for all interfaces */ ++ ++ ++/* End additional prototypes */ ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif /* __weakreference_h__ */ +diff --git a/mingw-w64-headers/include/weakreference.idl b/mingw-w64-headers/include/weakreference.idl +new file mode 100644 +index 000000000..037fce859 +--- /dev/null ++++ b/mingw-w64-headers/include/weakreference.idl +@@ -0,0 +1,28 @@ ++import "inspectable.idl"; ++ ++[object, uuid(00000037-0000-0000-C000-000000000046), pointer_default (unique)] ++interface IWeakReference: IUnknown ++{ ++// cpp_quote("#if (_MSC_VER >= 1600) && defined(__cplusplus) && !defined(CINTERFACE)") ++// cpp_quote(" EXTERN_C const IID IID_IWeakReference;") ++// cpp_quote(" extern "C++"") ++// cpp_quote(" {") ++// cpp_quote(" MIDL_INTERFACE("00000037-0000-0000-C000-000000000046")") ++// cpp_quote(" IWeakReference : public IUnknown {") ++// cpp_quote(" public:") ++// cpp_quote(" virtual HRESULT STDMETHODCALLTYPE Resolve(REFIID riid, IInspectable **objectReference) = 0;") ++// cpp_quote("") ++// cpp_quote(" template <typename T>") ++// cpp_quote(" HRESULT Resolve(T** objectReference) {") ++// cpp_quote(" return 0;") ++// cpp_quote(" }") ++// cpp_quote(" };") ++// cpp_quote(" } // extern C++") ++// cpp_quote("#else") ++ HRESULT Resolve([in] REFIID riid, [out, retval, iid_is(riid)] IInspectable **objectReference); ++} ++ ++[object, uuid(00000038-0000-0000-C000-000000000046), pointer_default (unique)] ++interface IWeakReferenceSource : IUnknown { ++ HRESULT GetWeakReference([out, retval] IWeakReference **weakReference); ++} +diff --git a/mingw-w64-headers/include/windows.graphics.capture.h b/mingw-w64-headers/include/windows.graphics.capture.h +index 203b0f034..4a0c0b546 100644 +--- a/mingw-w64-headers/include/windows.graphics.capture.h ++++ b/mingw-w64-headers/include/windows.graphics.capture.h +@@ -902,7 +902,7 @@ namespace ABI { + { + virtual HRESULT STDMETHODCALLTYPE Recreate( + ABI::Windows::Graphics::DirectX::Direct3D11::IDirect3DDevice *device, +- enum DirectXPixelFormat pixel_format, ++ enum DirectX::DirectXPixelFormat pixel_format, + INT32 number_of_buffers, + struct SizeInt32 size) = 0; + +@@ -1100,7 +1100,7 @@ namespace ABI { + { + virtual HRESULT STDMETHODCALLTYPE Create( + ABI::Windows::Graphics::DirectX::Direct3D11::IDirect3DDevice *device, +- enum DirectXPixelFormat pixel_format, ++ enum DirectX::DirectXPixelFormat pixel_format, + INT32 number_of_buffers, + struct SizeInt32 size, + ABI::Windows::Graphics::Capture::IDirect3D11CaptureFramePool **result) = 0; +@@ -1236,7 +1236,7 @@ namespace ABI { + { + virtual HRESULT STDMETHODCALLTYPE CreateFreeThreaded( + ABI::Windows::Graphics::DirectX::Direct3D11::IDirect3DDevice *device, +- enum DirectXPixelFormat pixel_format, ++ enum DirectX::DirectXPixelFormat pixel_format, + INT32 number_of_buffers, + struct SizeInt32 size, + ABI::Windows::Graphics::Capture::IDirect3D11CaptureFramePool **result) = 0; +diff --git a/mingw-w64-headers/include/windows.graphics.directx.direct3d11.interop.h b/mingw-w64-headers/include/windows.graphics.directx.direct3d11.interop.h +new file mode 100644 +index 000000000..7b66f7d16 +--- /dev/null ++++ b/mingw-w64-headers/include/windows.graphics.directx.direct3d11.interop.h +@@ -0,0 +1,164 @@ ++/*** Autogenerated by WIDL 8.0 from include/windows.graphics.directx.direct3d11.interop.idl - Do not edit ***/ ++ ++#ifdef _WIN32 ++#ifndef __REQUIRED_RPCNDR_H_VERSION__ ++#define __REQUIRED_RPCNDR_H_VERSION__ 475 ++#endif ++#include <rpc.h> ++#include <rpcndr.h> ++#endif ++ ++#ifndef COM_NO_WINDOWS_H ++#include <windows.h> ++#include <ole2.h> ++#endif ++ ++#ifndef __windows_graphics_directx_direct3d11_interop_h__ ++#define __windows_graphics_directx_direct3d11_interop_h__ ++ ++#ifndef __WIDL_INLINE ++#if defined(__cplusplus) || defined(_MSC_VER) ++#define __WIDL_INLINE inline ++#elif defined(__GNUC__) ++#define __WIDL_INLINE __inline__ ++#endif ++#endif ++ ++/* Forward declarations */ ++ ++#ifndef ____x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess_FWD_DEFINED__ ++#define ____x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess_FWD_DEFINED__ ++typedef interface __x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess __x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess; ++#ifdef __cplusplus ++#define __x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess ABI::Windows::Graphics::DirectX::Direct3D11::IDirect3DDxgiInterfaceAccess ++namespace ABI { ++ namespace Windows { ++ namespace Graphics { ++ namespace DirectX { ++ namespace Direct3D11 { ++ interface IDirect3DDxgiInterfaceAccess; ++ } ++ } ++ } ++ } ++} ++#endif /* __cplusplus */ ++#endif ++ ++/* Headers for imported files */ ++ ++#include <windows.graphics.directx.direct3d11.h> ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/***************************************************************************** ++ * IDirect3DDxgiInterfaceAccess interface ++ */ ++#ifndef ____x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess_INTERFACE_DEFINED__ ++#define ____x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess_INTERFACE_DEFINED__ ++ ++DEFINE_GUID(IID___x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess, 0xa9b3d012, 0x3df2, 0x4ee3, 0xb8,0xd1, 0x86,0x95,0xf4,0x57,0xd3,0xc1); ++#if defined(__cplusplus) && !defined(CINTERFACE) ++} /* extern "C" */ ++namespace ABI { ++ namespace Windows { ++ namespace Graphics { ++ namespace DirectX { ++ namespace Direct3D11 { ++ MIDL_INTERFACE("a9b3d012-3df2-4ee3-b8d1-8695f457d3c1") ++ IDirect3DDxgiInterfaceAccess : public IUnknown ++ { ++ virtual HRESULT STDMETHODCALLTYPE GetInterface( ++ REFIID iid, ++ void **object) = 0; ++ ++ }; ++ } ++ } ++ } ++ } ++} ++extern "C" { ++#ifdef __CRT_UUID_DECL ++__CRT_UUID_DECL(__x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess, 0xa9b3d012, 0x3df2, 0x4ee3, 0xb8,0xd1, 0x86,0x95,0xf4,0x57,0xd3,0xc1) ++#endif ++#else ++typedef struct __x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccessVtbl { ++ BEGIN_INTERFACE ++ ++ /*** IUnknown methods ***/ ++ HRESULT (STDMETHODCALLTYPE *QueryInterface)( ++ __x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess *This, ++ REFIID riid, ++ void **ppvObject); ++ ++ ULONG (STDMETHODCALLTYPE *AddRef)( ++ __x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess *This); ++ ++ ULONG (STDMETHODCALLTYPE *Release)( ++ __x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess *This); ++ ++ /*** IDirect3DDxgiInterfaceAccess methods ***/ ++ HRESULT (STDMETHODCALLTYPE *GetInterface)( ++ __x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess *This, ++ REFIID iid, ++ void **object); ++ ++ END_INTERFACE ++} __x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccessVtbl; ++ ++interface __x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess { ++ CONST_VTBL __x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccessVtbl* lpVtbl; ++}; ++ ++#ifdef COBJMACROS ++#ifndef WIDL_C_INLINE_WRAPPERS ++/*** IUnknown methods ***/ ++#define __x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) ++#define __x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess_AddRef(This) (This)->lpVtbl->AddRef(This) ++#define __x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess_Release(This) (This)->lpVtbl->Release(This) ++/*** IDirect3DDxgiInterfaceAccess methods ***/ ++#define __x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess_GetInterface(This,iid,object) (This)->lpVtbl->GetInterface(This,iid,object) ++#else ++/*** IUnknown methods ***/ ++static __WIDL_INLINE HRESULT __x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess_QueryInterface(__x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess* This,REFIID riid,void **ppvObject) { ++ return This->lpVtbl->QueryInterface(This,riid,ppvObject); ++} ++static __WIDL_INLINE ULONG __x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess_AddRef(__x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess* This) { ++ return This->lpVtbl->AddRef(This); ++} ++static __WIDL_INLINE ULONG __x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess_Release(__x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess* This) { ++ return This->lpVtbl->Release(This); ++} ++/*** IDirect3DDxgiInterfaceAccess methods ***/ ++static __WIDL_INLINE HRESULT __x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess_GetInterface(__x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess* This,REFIID iid,void **object) { ++ return This->lpVtbl->GetInterface(This,iid,object); ++} ++#endif ++#ifdef WIDL_using_Windows_Graphics_DirectX_Direct3D11 ++#define IID_IDirect3DDxgiInterfaceAccess IID___x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess ++#define IDirect3DDxgiInterfaceAccessVtbl __x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccessVtbl ++#define IDirect3DDxgiInterfaceAccess __x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess ++#define IDirect3DDxgiInterfaceAccess_QueryInterface __x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess_QueryInterface ++#define IDirect3DDxgiInterfaceAccess_AddRef __x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess_AddRef ++#define IDirect3DDxgiInterfaceAccess_Release __x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess_Release ++#define IDirect3DDxgiInterfaceAccess_GetInterface __x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess_GetInterface ++#endif /* WIDL_using_Windows_Graphics_DirectX_Direct3D11 */ ++#endif ++ ++#endif ++ ++#endif /* ____x_ABI_CWindows_CGraphics_CDirectX_CDirect3D11_CIDirect3DDxgiInterfaceAccess_INTERFACE_DEFINED__ */ ++ ++/* Begin additional prototypes for all interfaces */ ++ ++ ++/* End additional prototypes */ ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif /* __windows_graphics_directx_direct3d11_interop_h__ */ +diff --git a/mingw-w64-headers/include/windows.graphics.directx.direct3d11.interop.idl b/mingw-w64-headers/include/windows.graphics.directx.direct3d11.interop.idl +new file mode 100644 +index 000000000..51e2845ea +--- /dev/null ++++ b/mingw-w64-headers/include/windows.graphics.directx.direct3d11.interop.idl +@@ -0,0 +1,14 @@ ++#ifdef __WIDL__ ++#pragma winrt ns_prefix ++#endif ++ ++import "windows.graphics.directx.direct3d11.idl"; ++ ++namespace Windows.Graphics.DirectX.Direct3D11 { ++ [ ++ uuid(A9B3D012-3DF2-4EE3-B8D1-8695F457D3C1) ++ ] ++ interface IDirect3DDxgiInterfaceAccess : IUnknown { ++ HRESULT GetInterface([in] REFIID iid, [out, iid_is(iid)] void **object); ++ }; ++} +diff --git a/mingw-w64-headers/include/windows.ui.core.h b/mingw-w64-headers/include/windows.ui.core.h +index 5eb820b33..8a2e93ce4 100644 +--- a/mingw-w64-headers/include/windows.ui.core.h ++++ b/mingw-w64-headers/include/windows.ui.core.h +@@ -1602,7 +1602,7 @@ namespace ABI { + namespace Core { + struct CoreProximityEvaluation { + INT32 Score; +- struct Point AdjustedPoint; ++ struct Foundation::Point AdjustedPoint; + }; + } + } +@@ -2759,11 +2759,11 @@ namespace ABI { + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAsyncKeyState( +- enum VirtualKey key, ++ enum System::VirtualKey key, + enum CoreVirtualKeyStates *state) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetKeyState( +- enum VirtualKey key, ++ enum System::VirtualKey key, + enum CoreVirtualKeyStates *state) = 0; + + virtual HRESULT STDMETHODCALLTYPE ReleasePointerCapture( +@@ -3491,7 +3491,7 @@ namespace ABI { + ICoreWindow2 : public IInspectable + { + virtual HRESULT STDMETHODCALLTYPE put_PointerPosition( +- struct Point value) = 0; ++ struct Foundation::Point value) = 0; + + }; + } +@@ -4605,7 +4605,7 @@ namespace ABI { + IKeyEventArgs : public IInspectable + { + virtual HRESULT STDMETHODCALLTYPE get_VirtualKey( +- enum VirtualKey *value) = 0; ++ enum System::VirtualKey *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_KeyStatus( + struct CorePhysicalKeyStatus *value) = 0; +@@ -4876,7 +4876,7 @@ namespace ABI { + ABI::Windows::UI::Input::IPointerPoint **value) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_KeyModifiers( +- enum VirtualKeyModifiers *value) = 0; ++ enum System::VirtualKeyModifiers *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetIntermediatePoints( + ABI::Windows::Foundation::Collections::IVector<ABI::Windows::UI::Input::PointerPoint* > **value) = 0; +diff --git a/mingw-w64-headers/include/wrl/client.h b/mingw-w64-headers/include/wrl/client.h +index aeb886ea8..4fcadc7fc 100644 +--- a/mingw-w64-headers/include/wrl/client.h ++++ b/mingw-w64-headers/include/wrl/client.h +@@ -9,12 +9,15 @@ + + #include <stddef.h> + #include <unknwn.h> +-/* #include <weakreference.h> */ ++#include <weakreference.h> + #include <roapi.h> + + /* #include <wrl/def.h> */ + #include <wrl/internal.h> + ++#define WrlFinal final ++#define WrlSealed sealed ++ + namespace Microsoft { + namespace WRL { + namespace Details { +diff --git a/mingw-w64-headers/include/wrl/event.h b/mingw-w64-headers/include/wrl/event.h +new file mode 100644 +index 000000000..2e883e241 +--- /dev/null ++++ b/mingw-w64-headers/include/wrl/event.h +@@ -0,0 +1,368 @@ ++#ifndef _WRL_EVENT_H_ ++#define _WRL_EVENT_H_ ++ ++// #include <wrl/def.h> ++#include <wrl/internal.h> ++#include <wrl/client.h> ++#include <wrl/implements.h> ++#include <wrl/wrappers/corewrappers.h> ++#include <eventtoken.h> ++// #include <roerrorapi.h> ++ ++#include <pshpack8.h> ++ ++namespace Microsoft { ++ namespace WRL { ++ enum DelegateCheckMode { ++ NoCheck = 1 ++ }; ++ ++ template<DelegateCheckMode delegateCheckMode> struct DelegateTraits; ++ ++ template<> struct DelegateTraits<NoCheck> { ++ static HRESULT CheckReturn(HRESULT hr) { ++ return 0; ++ } ++ }; ++ ++ extern __declspec(selectany) const DelegateCheckMode DefaultDelegateCheckMode = NoCheck; ++ ++ enum InvokeMode { ++ StopOnFirstError = 1, ++ FireAll = 2, ++ }; ++ ++ template<InvokeMode invokeModeValue> struct InvokeModeOptions { ++ static const InvokeMode invokeMode = invokeModeValue; ++ }; ++ ++ template<InvokeMode invokeMode> struct InvokeTraits; ++ ++ template<typename TDelegateInterface, typename EventSourceOptions> ++ class EventSource; ++ ++ namespace Details { ++ template<typename TDelegateInterface> ++ void* GetDelegateBucketAssist(TDelegateInterface *pDelegate) { ++ return nullptr; ++ } ++ ++ template<typename TMemberFunction> struct ArgTraits { ++ static const int args = -1; ++ }; ++ ++ template<typename TDelegateInterface> ++ struct ArgTraits<HRESULT(STDMETHODCALLTYPE TDelegateInterface::*)(void)> { ++ static const int args = 0; ++ }; ++ ++ template<typename TDelegateInterface, typename TArg1> ++ struct ArgTraits<HRESULT(STDMETHODCALLTYPE TDelegateInterface::*)(TArg1)> { ++ static const int args = 1; ++ typedef TArg1 Arg1Type; ++ }; ++ ++ template<typename TDelegateInterface, typename TArg1, typename TArg2> ++ struct ArgTraits<HRESULT(STDMETHODCALLTYPE TDelegateInterface::*)(TArg1, TArg2)> ++ { ++ static const int args = 2; ++ typedef TArg1 Arg1Type; ++ typedef TArg2 Arg2Type; ++ }; ++ ++ template<typename TDelegateInterface, typename TArg1, typename TArg2, typename TArg3> ++ struct ArgTraits<HRESULT(STDMETHODCALLTYPE TDelegateInterface::*)(TArg1, TArg2, TArg3)> ++ { ++ static const int args = 3; ++ typedef TArg1 Arg1Type; ++ typedef TArg2 Arg2Type; ++ typedef TArg3 Arg3Type; ++ }; ++ ++ template<typename TDelegateInterface, typename TArg1, typename TArg2, typename TArg3, typename TArg4> ++ struct ArgTraits<HRESULT(STDMETHODCALLTYPE TDelegateInterface::*)(TArg1, TArg2, TArg3, TArg4)> ++ { ++ static const int args = 4; ++ typedef TArg1 Arg1Type; ++ typedef TArg2 Arg2Type; ++ typedef TArg3 Arg3Type; ++ typedef TArg4 Arg4Type; ++ }; ++ ++ template<typename TDelegateInterface, typename TArg1, typename TArg2, typename TArg3, typename TArg4, typename TArg5> ++ struct ArgTraits<HRESULT(STDMETHODCALLTYPE TDelegateInterface::*)(TArg1, TArg2, TArg3, TArg4, TArg5)> ++ { ++ static const int args = 5; ++ typedef TArg1 Arg1Type; ++ typedef TArg2 Arg2Type; ++ typedef TArg3 Arg3Type; ++ typedef TArg4 Arg4Type; ++ typedef TArg5 Arg5Type; ++ }; ++ ++ template<typename TDelegateInterface, typename TArg1, typename TArg2, typename TArg3, typename TArg4, typename TArg5, typename TArg6> ++ struct ArgTraits<HRESULT(STDMETHODCALLTYPE TDelegateInterface::*)(TArg1, TArg2, TArg3, TArg4, TArg5, TArg6)> ++ { ++ static const int args = 6; ++ typedef TArg1 Arg1Type; ++ typedef TArg2 Arg2Type; ++ typedef TArg3 Arg3Type; ++ typedef TArg4 Arg4Type; ++ typedef TArg5 Arg5Type; ++ typedef TArg6 Arg6Type; ++ }; ++ ++ template<typename TDelegateInterface, typename TArg1, typename TArg2, typename TArg3, typename TArg4, typename TArg5, typename TArg6, typename TArg7> ++ struct ArgTraits<HRESULT(STDMETHODCALLTYPE TDelegateInterface::*)(TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7)> ++ { ++ static const int args = 7; ++ typedef TArg1 Arg1Type; ++ typedef TArg2 Arg2Type; ++ typedef TArg3 Arg3Type; ++ typedef TArg4 Arg4Type; ++ typedef TArg5 Arg5Type; ++ typedef TArg6 Arg6Type; ++ typedef TArg7 Arg7Type; ++ }; ++ ++ template<typename TDelegateInterface, typename TArg1, typename TArg2, typename TArg3, typename TArg4, typename TArg5, typename TArg6, typename TArg7, typename TArg8> ++ struct ArgTraits<HRESULT(STDMETHODCALLTYPE TDelegateInterface::*)(TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8)> ++ { ++ static const int args = 8; ++ typedef TArg1 Arg1Type; ++ typedef TArg2 Arg2Type; ++ typedef TArg3 Arg3Type; ++ typedef TArg4 Arg4Type; ++ typedef TArg5 Arg5Type; ++ typedef TArg6 Arg6Type; ++ typedef TArg7 Arg7Type; ++ typedef TArg8 Arg8Type; ++ }; ++ ++ template<typename TDelegateInterface, typename TArg1, typename TArg2, typename TArg3, typename TArg4, typename TArg5, typename TArg6, typename TArg7, typename TArg8, typename TArg9> ++ struct ArgTraits<HRESULT(STDMETHODCALLTYPE TDelegateInterface::*)(TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9)> ++ { ++ static const int args = 9; ++ typedef TArg1 Arg1Type; ++ typedef TArg2 Arg2Type; ++ typedef TArg3 Arg3Type; ++ typedef TArg4 Arg4Type; ++ typedef TArg5 Arg5Type; ++ typedef TArg6 Arg6Type; ++ typedef TArg7 Arg7Type; ++ typedef TArg8 Arg8Type; ++ typedef TArg9 Arg9Type; ++ }; ++ ++ template<typename TDelegateInterface, bool isImplements = __is_base_of(ImplementsBase, TDelegateInterface)> ++ struct ArgTraitsHelper; ++ ++ template<typename TDelegateInterface> ++ struct ArgTraitsHelper<TDelegateInterface, false> ++ { ++ typedef decltype(&TDelegateInterface::Invoke) methodType; ++ typedef ArgTraits<methodType> Traits; ++ static const int args = Traits::args; ++ typedef TDelegateInterface Interface; ++ }; ++ ++ template<typename TDelegateInterface> ++ struct ArgTraitsHelper<TDelegateInterface, true> {}; ++ ++ template<typename TDelegateInterface> class DelegateArgTraits {}; ++ ++ template<typename TDelegateInterface, typename ...TArgs> ++ class DelegateArgTraits<HRESULT (STDMETHODCALLTYPE TDelegateInterface::*)(TArgs...)> ++ { ++ template<typename TCallback, DelegateCheckMode checkMode> ++ struct DelegateInvokeHelper WrlSealed : public ::Microsoft::WRL::RuntimeClass<RuntimeClassFlags<Delegate>, TDelegateInterface>, RemoveReference<TCallback>::Type { ++ DelegateInvokeHelper(TCallback&& callback) noexcept {} ++ ++ HRESULT STDMETHODCALLTYPE Invoke(TArgs... args) noexcept override { ++ return 0; ++ } ++ }; ++ ++ public: ++ template<typename TImplements, DelegateCheckMode checkMode = DefaultDelegateCheckMode, typename TLambda> ++ static ComPtr<TImplements> Callback(TLambda&& callback) noexcept { ++ ComPtr<TImplements> empty; ++ return empty; ++ } ++ }; ++ ++ template<typename TDelegateInterface, bool isImplements = __is_base_of(ImplementsBase, TDelegateInterface)> ++ struct DelegateArgTraitsHelper; ++ ++ template<typename TDelegateInterface> ++ struct DelegateArgTraitsHelper<TDelegateInterface, false> { ++ typedef TDelegateInterface Interface; ++ typedef DelegateArgTraits<decltype(&TDelegateInterface::Invoke)> Traits; ++ }; ++ ++ template<typename TDelegateInterface> ++ struct DelegateArgTraitsHelper<TDelegateInterface, true> {}; ++ ++ template<typename TDelegateInterface> ++ HRESULT CreateAgileHelper(TDelegateInterface* delegateInterface, TDelegateInterface** wrapper) { ++ return 0; ++ } ++ } ++ ++ template<typename TDelegateInterface, typename TLambda> ++ ComPtr<typename Details::DelegateArgTraitsHelper<TDelegateInterface>::Interface> Callback(TLambda&& callback) noexcept { ++ return 0; ++ } ++ ++ template<typename TDelegateInterface, typename TFunc> ++ ComPtr<typename Details::DelegateArgTraitsHelper<TDelegateInterface>::Interface> Callback(TFunc* callback) noexcept { ++ return 0; ++ }; ++ ++ template<typename TDelegateInterface, typename TCallbackObject, typename... TArgs> ++ ComPtr<typename Details::DelegateArgTraitsHelper<TDelegateInterface>::Interface> Callback(TCallbackObject *object, HRESULT(TCallbackObject::* method)(TArgs...)) noexcept { ++ return 0; ++ } ++ ++ template<typename TDelegateInterface> ++ HRESULT WeakReferenceCallback(IWeakReferenceSource* innerCallback, TDelegateInterface** callback) { ++ return 0; ++ } ++ ++ template<typename TDelegateInterface> ++ HRESULT WeakReferenceCallback(TDelegateInterface* innerCallback, TDelegateInterface** callback) { ++ return 0; ++ } ++ ++ template<typename T, typename TDelegateInterface, typename ...TArgs> ++ HRESULT WeakReferenceCallback(T* targetObject, HRESULT (T::*targetMethod)(TArgs... args), TDelegateInterface** callback) { ++ return 0; ++ } ++ ++ template<typename T, typename TDelegateInterface, typename ...TArgs> ++ HRESULT WeakReferenceCallback(T* targetObject, HRESULT(T::*targetMethod)(TArgs... args), ::Microsoft::WRL::Details::ComPtrRef< ::Microsoft::WRL::ComPtr<TDelegateInterface>> callback) { ++ return 0; ++ } ++ ++ namespace Details { ++ ++ class EventTargetArray WrlSealed : public ::Microsoft::WRL::RuntimeClass< ::Microsoft::WRL::RuntimeClassFlags<ClassicCom>, IUnknown > { ++ public: ++ EventTargetArray() noexcept {} ++ ++ HRESULT RuntimeClassInitialize(size_t items) noexcept { ++ return 0; ++ } ++ ++ ~EventTargetArray() noexcept ++ { ++ delete[] begin_; ++ delete[] bucketAssists_; ++ } ++ ++ ComPtr<IUnknown>* Begin() noexcept { ++ return nullptr; ++ } ++ ++ ComPtr<IUnknown>* End() noexcept { ++ return nullptr; ++ } ++ ++ void AddTail(IUnknown* element) noexcept { ++ } ++ ++ void AddTail(IUnknown* element, void *bucketAssist) noexcept { ++ } ++ ++ size_t Length() noexcept { ++ return 0; ++ } ++ ++ void **Begin_BucketAssists() { ++ return nullptr; ++ } ++ ++ void **End_BucketAssists() { ++ return nullptr; ++ } ++ ++ private: ++ ComPtr<IUnknown>* begin_; ++ ++ ComPtr<IUnknown>* end_; ++ ++ void **bucketAssists_; ++ }; ++ } ++ ++ template<> ++ struct InvokeTraits<FireAll> ++ { ++ template<typename TInvokeMethod, typename TDelegateInterface> ++ static HRESULT InvokeDelegates(TInvokeMethod invokeOne, Details::EventTargetArray *targetArray, EventSource<TDelegateInterface, InvokeModeOptions<FireAll>>* pEvent) { ++ return 0; ++ } ++ }; ++ ++ template<> ++ struct InvokeTraits<StopOnFirstError> ++ { ++ template<typename TInvokeMethod, typename TDelegateInterface> ++ static HRESULT InvokeDelegates(TInvokeMethod invokeOne, Details::EventTargetArray *targetArray, EventSource<TDelegateInterface, InvokeModeOptions<StopOnFirstError>>* pEvent) { ++ return 0; ++ } ++ }; ++ ++ template<typename TDelegateInterface, typename TEventSourceOptions> ++ class EventSource { ++ public: ++ EventSource() noexcept {} ++ ++ HRESULT Add(TDelegateInterface* delegateInterface, EventRegistrationToken* token) noexcept { ++ return 0; ++ } ++ ++ HRESULT Remove(EventRegistrationToken token) noexcept { ++ return 0; ++ } ++ ++ protected: ++ ++ HRESULT Add(TDelegateInterface* delegateInterface, void *bucketAssist, EventRegistrationToken* token) noexcept { ++ return 0; ++ } ++ ++ private: ++ ++ HRESULT AddInternal(TDelegateInterface* delegateInterface, void *bucketAssist, EventRegistrationToken* token) noexcept { ++ return 0; ++ } ++ ++ template <typename TInvokeMethod> ++ HRESULT DoInvoke(TInvokeMethod invokeOne) noexcept { ++ return 0; ++ } ++ ++ public: ++ template<typename ...TArgs> ++ HRESULT InvokeAll(TArgs... args) noexcept { ++ return 0; ++ } ++ ++ size_t GetSize() const noexcept { ++ return 0; ++ } ++ ++ protected: ++ ComPtrDetails::EventTargetArray targets_; ++ ++ mutable Wrappers::SRWLock targetsPointerLock_; ++ ++ Wrappers::SRWLock addRemoveLock_; ++ }; ++ } ++} ++ ++#include <poppack.h> ++ ++#endif +diff --git a/mingw-w64-headers/include/wrl/implements.h b/mingw-w64-headers/include/wrl/implements.h +new file mode 100644 +index 000000000..9d5fe962f +--- /dev/null ++++ b/mingw-w64-headers/include/wrl/implements.h +@@ -0,0 +1,619 @@ ++#ifndef _WRL_IMPLEMENTS_H_ ++#define _WRL_IMPLEMENTS_H_ ++ ++#include <weakreference.h> ++ ++#include <wrl\client.h> ++ ++#include <pshpack8.h> ++ ++ ++namespace Microsoft { ++ namespace WRL { ++ template<typename T> ++ struct CloakedIid : T {}; ++ ++ enum RuntimeClassType { ++ WinRt = 0x0001, ++ ClassicCom = 0x0002, ++ WinRtClassicComMix = WinRt | ClassicCom, ++ InhibitWeakReference = 0x0004, ++ Delegate = ClassicCom, ++ InhibitFtmBase = 0x0008, ++ InhibitRoOriginateError = 0x0010 ++ }; ++ ++ template <unsigned int flags> ++ struct RuntimeClassFlags { ++ static const unsigned int value = flags; ++ }; ++ ++ namespace Details { ++ struct ImplementsBase {}; ++ } ++ ++ template<typename Derived, typename MixInType, bool hasImplements> ++ struct MixIn {}; ++ ++ template <typename FactoryInterface> ++ class ComposableBase {}; ++ ++ typedef RuntimeClassFlags<WinRt | InhibitWeakReference> InhibitWeakReferencePolicy; ++ ++ namespace Details { ++ ++ class Nil {}; ++ ++ class DontUseNewUseMake { ++ private: ++ void* operator new(size_t) throw() { ++ return nullptr; ++ } ++ ++ public: ++ void* operator new(size_t, void* placement) throw() { ++ return nullptr; ++ } ++ }; ++ ++ class RuntimeClassBase {}; ++ ++ template <unsigned int RuntimeClassTypeT> ++ class RuntimeClassBaseT : private RuntimeClassBase { ++ protected: ++ template<typename T> ++ static HRESULT AsIID(T* implements, REFIID riid, void **ppvObject) throw() { ++ return 0; ++ } ++ ++ template<typename T> ++ static HRESULT GetImplementedIIDS(T* implements, ULONG *iidCount, IID **iids) throw() { ++ return 0; ++ } ++ ++ public: ++ HRESULT RuntimeClassInitialize() throw() { ++ return 0; ++ } ++ }; ++ ++ class FtmBaseMarker {}; ++ ++ template <typename I, typename Base> ++ struct VerifyInheritanceHelper { ++ static void Verify() throw() {} ++ }; ++ ++ template <typename I> ++ struct VerifyInheritanceHelper<I, Nil> { ++ static void Verify() throw() {} ++ }; ++ } ++ ++ template <typename I0, typename I1, typename I2 = Details::Nil, typename I3 = Details::Nil, ++ typename I4 = Details::Nil, typename I5 = Details::Nil, typename I6 = Details::Nil, ++ typename I7 = Details::Nil, typename I8 = Details::Nil, typename I9 = Details::Nil> ++ struct ChainInterfaces : I0 ++ { ++ protected: ++ template<unsigned int ClassType> ++ static void Verify() throw() {} ++ ++ HRESULT CanCastTo(REFIID riid, void **ppv) throw() { ++ return 0; ++ } ++ ++ IUnknown* CastToUnknown() throw() { ++ return nullptr; ++ } ++ ++ static const unsigned long IidCount; ++ ++ static void FillArrayWithIid(unsigned long *index, IID* iids) throw() {} ++ }; ++ ++ template <typename DerivedType, typename BaseType, bool hasImplements, typename I1, typename I2, typename I3, ++ typename I4, typename I5, typename I6, ++ typename I7, typename I8, typename I9> ++ struct ChainInterfaces<MixIn<DerivedType, BaseType, hasImplements>, I1, I2, I3, I4, I5, I6, I7, I8, I9> ++ { ++ protected: ++ template<unsigned int ClassType> ++ static void Verify() throw() {} ++ ++ HRESULT CanCastTo(REFIID riid, void **ppv) throw() { ++ return 0; ++ } ++ ++ IUnknown* CastToUnknown() throw() { ++ return nullptr; ++ } ++ ++ static const unsigned long IidCount; ++ ++ static void FillArrayWithIid(unsigned long *index, IID* iids) throw() {} ++ }; ++ ++ namespace Details { ++ template <typename RuntimeClassFlagsT, bool doStrictCheck, typename ...TInterfaces> ++ struct __declspec(novtable) ImplementsHelper; ++ ++ template <typename RuntimeClassFlagsT, bool doStrictCheck, typename I0, typename ...TInterfaces> ++ struct __declspec(novtable) ImplementsHelper<RuntimeClassFlagsT, doStrictCheck, I0, TInterfaces...> : I0, ImplementsHelper<RuntimeClassFlagsT, true, TInterfaces...> { ++ protected: ++ template <unsigned int RuntimeClassTypeT> friend class Details::RuntimeClassBaseT; ++ ++ template <bool IsDelegateToClass> ++ HRESULT CanCastToHelper(REFIID riid, void **ppv, bool *pRefDelegated) throw(); ++ ++ template <> ++ HRESULT inline CanCastToHelper<true>(REFIID riid, void **ppv, bool *pRefDelegated) throw() { ++ return 0; ++ } ++ ++ template <> ++ HRESULT inline CanCastToHelper<false>(REFIID riid, void **ppv, bool *pRefDelegated) throw() { ++ return 0; ++ } ++ ++ HRESULT CanCastTo(REFIID riid, void **ppv, bool *pRefDelegated) throw() { ++ return 0; ++ } ++ ++ template <bool IsDelegateToClass> IUnknown* CastToUnknownHelper() throw(); ++ ++ template <> inline IUnknown* CastToUnknownHelper<true>() throw() { ++ return nullptr; ++ } ++ ++ template <> inline IUnknown* CastToUnknownHelper<false>() throw() { ++ return nullptr; ++ } ++ ++ IUnknown* CastToUnknown() throw() { ++ return nullptr; ++ } ++ ++ template <bool IsDelegateToClass> long GetIidCountHelper() throw(); ++ ++ template <> inline long GetIidCountHelper<true>() throw() { ++ return 0; ++ } ++ ++ template <> inline long GetIidCountHelper<false>() throw() { ++ return 0; ++ } ++ ++ unsigned long GetIidCount() throw() { ++ return 0; ++ } ++ ++ template <bool IsDelegateToClass> void FillArrayWithIidHelper(unsigned long *index, IID* iids) throw(); ++ ++ template <> inline void FillArrayWithIidHelper<true>(unsigned long *index, IID* iids) throw() {} ++ ++ template <> inline void FillArrayWithIidHelper<false>(unsigned long *index, IID* iids) throw() {} ++ ++ void FillArrayWithIid(unsigned long *index, IID* iids) throw() {} ++ }; ++ ++ template <typename RuntimeClassFlagsT, bool doStrictCheck, typename ...TInterfaces> ++ struct __declspec(novtable) ImplementsHelper<RuntimeClassFlagsT, doStrictCheck, Details::Nil, TInterfaces...> : ImplementsHelper<RuntimeClassFlagsT, doStrictCheck, TInterfaces...> { ++ protected: ++ template <unsigned int RuntimeClassTypeT> friend class Details::RuntimeClassBaseT; ++ ++ HRESULT CanCastTo(REFIID riid, void **ppv, bool * pRefDelegated) throw() { ++ return 0; ++ } ++ ++ unsigned long GetIidCount() throw() { ++ return 0; ++ } ++ ++ void FillArrayWithIid(unsigned long *index, IID* iids) throw() {} ++ }; ++ ++ template <typename RuntimeClassFlagsT, bool doStrictCheck> ++ struct __declspec(novtable) ImplementsHelper<RuntimeClassFlagsT, doStrictCheck> ++ { ++ protected: ++ template <unsigned int RuntimeClassTypeT> friend class Details::RuntimeClassBaseT; ++ ++ HRESULT CanCastTo(REFIID, void **, bool*) throw() { ++ return 0; ++ } ++ ++ unsigned long GetIidCount() throw() { ++ return 0; ++ } ++ ++ void FillArrayWithIid(unsigned long*, IID*) throw() {} ++ }; ++ ++ template <typename RuntimeClassFlagsT, bool doStrictCheck, typename I0, typename ...TInterfaces> ++ struct __declspec(novtable) ImplementsHelper<RuntimeClassFlagsT, doStrictCheck, CloakedIid<I0>, TInterfaces...> : ImplementsHelper<RuntimeClassFlagsT, doStrictCheck, I0>, ImplementsHelper<RuntimeClassFlagsT, true, TInterfaces...> { ++ protected: ++ template <unsigned int RuntimeClassTypeT> friend class Details::RuntimeClassBaseT; ++ ++ HRESULT CanCastTo(REFIID riid, void **ppv, bool *pRefDelegated) throw() { ++ return 0; ++ } ++ ++ IUnknown* CastToUnknown() throw() { ++ return 0; ++ } ++ ++ unsigned long GetIidCount() throw() { ++ return 0; ++ } ++ ++ void FillArrayWithIid(unsigned long *index, IID* iids) throw() {} ++ }; ++ ++ template <typename RuntimeClassFlagsT, bool doStrictCheck, typename C0, typename C1, typename C2, typename C3, typename C4, typename C5, typename C6, typename C7, typename C8, typename C9, typename ...TInterfaces> ++ struct __declspec(novtable) ImplementsHelper<RuntimeClassFlagsT, doStrictCheck, ChainInterfaces<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9>, TInterfaces...> : ChainInterfaces<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9>, ImplementsHelper<RuntimeClassFlagsT, true, TInterfaces...> { ++ protected: ++ template <unsigned int RuntimeClassTypeT> friend class Details::RuntimeClassBaseT; ++ ++ HRESULT CanCastTo(REFIID riid, void **ppv, bool *pRefDelegated) throw() { ++ return 0; ++ } ++ ++ IUnknown* CastToUnknown() throw() { ++ return nullptr; ++ } ++ ++ unsigned long GetIidCount() throw() { ++ return 0; ++ } ++ ++ void FillArrayWithIid(unsigned long *index, IID* iids) throw() {} ++ }; ++ ++ template <typename RuntimeClassFlagsT, typename DerivedType, typename BaseType, bool hasImplements, typename ...TInterfaces, bool doStrictCheck> ++ struct __declspec(novtable) ImplementsHelper<RuntimeClassFlagsT, doStrictCheck, MixIn<DerivedType, BaseType, hasImplements>, TInterfaces...> : ImplementsHelper<RuntimeClassFlagsT, true, TInterfaces...> { ++ protected: ++ template <unsigned int RuntimeClassTypeT> friend class Details::RuntimeClassBaseT; ++ ++ HRESULT CanCastTo(REFIID riid, void **ppv, bool *pRefDelegated) throw() { ++ return 0; ++ } ++ ++ IUnknown* CastToUnknown() throw() { ++ return nullptr; ++ } ++ ++ unsigned long GetIidCount() throw() { ++ return 0; ++ } ++ ++ void FillArrayWithIid(unsigned long *index, IID* iids) throw() {} ++ }; ++ ++ template <typename I0, typename ...> ++ struct AreAllNil { ++ static const bool value = false; ++ }; ++ ++ template <typename ...TInterfaces> ++ struct AreAllNil<Microsoft::WRL::Details::Nil, TInterfaces...> { ++ static const bool value = AreAllNil<TInterfaces...>::value; ++ }; ++ ++ template <> ++ struct AreAllNilMicrosoft::WRL::Details::Nil { ++ static const bool value = true; ++ }; ++ ++ template <typename RuntimeClassFlagsT, typename FactoryInterface, bool doStrictCheck, typename ...TInterfaces> ++ struct __declspec(novtable) ImplementsHelper<RuntimeClassFlagsT, doStrictCheck, ComposableBase<FactoryInterface>, TInterfaces...> : ImplementsHelper<RuntimeClassFlagsT, true, ComposableBase<FactoryInterface>> { ++ protected: ++ template <unsigned int RuntimeClassTypeT> friend class Details::RuntimeClassBaseT; ++ ++ typedef ImplementsHelper<RuntimeClassFlagsT, true, ComposableBase<FactoryInterface>> Base; ++ ++ HRESULT CanCastTo(REFIID riid, void **ppv, bool *pRefDelegated) throw() { ++ return 0; ++ } ++ ++ IUnknown* CastToUnknown() throw() { ++ return 0; ++ } ++ ++ unsigned long GetIidCount() throw() { ++ return 0; ++ } ++ ++ void FillArrayWithIid(unsigned long *index, IID* iids) throw() {} ++ }; ++ ++ template <typename RuntimeClassFlagsT, typename FactoryInterface, bool doStrictCheck> ++ struct __declspec(novtable) ImplementsHelper<RuntimeClassFlagsT, doStrictCheck, ComposableBase<FactoryInterface>> { ++ protected: ++ template <unsigned int RuntimeClassTypeT> friend class Details::RuntimeClassBaseT; ++ ++ HRESULT CanCastTo(REFIID riid, void **ppv, bool *pRefDelegated) throw() { ++ return 0; ++ } ++ ++ IUnknown* CastToUnknown() throw() { ++ return nullptr; ++ } ++ ++ unsigned long GetIidCount() throw() { ++ return 0; ++ } ++ ++ void FillArrayWithIid(unsigned long *index, IID* iids) throw() {} ++ ++ ImplementsHelper() throw() {} ++ ++ ~ImplementsHelper() throw() {} ++ ++ public: ++ HRESULT SetComposableBasePointers(IInspectable* base, FactoryInterface* baseFactory) throw() { ++ return 0; ++ } ++ ++ ComPtr<IInspectable> GetComposableBase() throw() { ++ return composableBase_; ++ } ++ ++ ComPtr<FactoryInterface> GetComposableBaseFactory() throw() { ++ return composableBaseFactory_; ++ } ++ ++ private: ++ ComPtr<IInspectable> composableBase_; ++ ++ ComPtr<FactoryInterface> composableBaseFactory_; ++ ++ IID *iidsCached_; ++ ++ unsigned long iidCount_; ++ }; ++ ++ } ++ ++ template <typename I0, typename ...TInterfaces> ++ struct __declspec(novtable) Implements : Details::ImplementsHelper<RuntimeClassFlags<WinRt>, true, I0, TInterfaces...>, Details::ImplementsBase { ++ public: ++ typedef RuntimeClassFlags<WinRt> ClassFlags; ++ ++ typedef I0 FirstInterface; ++ ++ protected: ++ HRESULT CanCastTo(REFIID riid, void **ppv) throw() { ++ return 0; ++ } ++ ++ IUnknown* CastToUnknown() throw() { ++ return nullptr; ++ } ++ ++ unsigned long GetIidCount() throw() { ++ return 0; ++ } ++ ++ void FillArrayWithIid(unsigned long *index, IID* iids) throw() {} ++ }; ++ ++ template <int flags, typename I0, typename ...TInterfaces> ++ struct __declspec(novtable) Implements<RuntimeClassFlags<flags>, I0, TInterfaces...> : Details::ImplementsHelper<RuntimeClassFlags<flags>, true, I0, TInterfaces...>, Details::ImplementsBase { ++ public: ++ typedef RuntimeClassFlags<flags> ClassFlags; ++ ++ typedef I0 FirstInterface; ++ ++ protected: ++ HRESULT CanCastTo(REFIID riid, void **ppv) throw() { ++ return 0; ++ } ++ ++ IUnknown* CastToUnknown() throw() { ++ return nullptr; ++ } ++ ++ unsigned long GetIidCount() throw() { ++ return 0; ++ } ++ ++ void FillArrayWithIid(unsigned long *index, IID* iids) throw() {} ++ }; ++ ++ class FtmBase : public Implements< ::Microsoft::WRL::RuntimeClassFlags<WinRtClassicComMix>, ::Microsoft::WRL::CloakedIid< ::IMarshal> >, private ::Microsoft::WRL::Details::FtmBaseMarker { ++ protected: ++ template <typename RuntimeClassFlagsT, bool doStrictCheck, typename ...TInterfaces> friend struct Details::ImplementsHelper; ++ ++ HRESULT CanCastTo(REFIID riid, void **ppv) throw() { ++ return 0; ++ } ++ ++ public: ++ FtmBase() throw() {} ++ ++ STDMETHOD(GetUnmarshalClass)(REFIID riid, void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags, CLSID *pCid) override { ++ return 0; ++ } ++ ++ STDMETHOD(GetMarshalSizeMax)(REFIID riid, void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags, DWORD *pSize) override { ++ return 0; ++ } ++ ++ STDMETHOD(MarshalInterface)(IStream *pStm, REFIID riid, void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags) override { ++ return 0; ++ } ++ ++ STDMETHOD(UnmarshalInterface)(IStream *pStm, REFIID riid, void **ppv) override { ++ return 0; ++ } ++ ++ STDMETHOD(ReleaseMarshalData)(IStream *pStm) override { ++ return 0; ++ } ++ ++ STDMETHOD(DisconnectObject)(DWORD dwReserved) override { ++ return 0; ++ } ++ ++ static HRESULT CreateGlobalInterfaceTable(IGlobalInterfaceTable **git) throw() { ++ return 0; ++ } ++ ++ ::Microsoft::WRL::ComPtr<IMarshal> marshaller_; ++ }; ++ ++ namespace Details { ++ #define DETAILS_RTCLASS_FLAGS_ARGUMENTS(RuntimeClassFlagsT) \ ++ RuntimeClassFlagsT, \ ++ (RuntimeClassFlagsT::value & InhibitWeakReference) == 0, \ ++ (RuntimeClassFlagsT::value & WinRt) == WinRt, \ ++ __WRL_IMPLEMENTS_FTM_BASE__(RuntimeClassFlagsT::value) \ ++ ++ template <class RuntimeClassFlagsT, bool implementsWeakReferenceSource, bool implementsInspectable, bool implementsFtmBase, typename ...TInterfaces> ++ class __declspec(novtable) RuntimeClassImpl; ++ ++ template <class RuntimeClassFlagsT, bool implementsWeakReferenceSource, bool implementsFtmBase, typename ...TInterfaces> ++ class __declspec(novtable) RuntimeClassImpl<RuntimeClassFlagsT, implementsWeakReferenceSource, false, implementsFtmBase, TInterfaces...> : public Details::ImplementsHelper<RuntimeClassFlagsT, false, TInterfaces...>, public RuntimeClassBaseTRuntimeClassFlagsT::value, protected RuntimeClassFlags<InhibitWeakReference>, public DontUseNewUseMake { ++ public: ++ typedef RuntimeClassFlagsT ClassFlags; ++ ++ STDMETHOD(QueryInterface)(REFIID riid, void **ppvObject) { ++ return 0; ++ } ++ ++ STDMETHOD_(ULONG, AddRef)() { ++ return 0; ++ } ++ ++ STDMETHOD_(ULONG, Release)() { ++ return 0; ++ } ++ ++ protected: ++ RuntimeClassImpl() throw() {} ++ ++ virtual ~RuntimeClassImpl() throw() {} ++ ++ unsigned long InternalAddRef() throw() { ++ return 0; ++ } ++ ++ unsigned long InternalRelease() throw() { ++ return 0; ++ } ++ ++ unsigned long GetRefCount() const throw() { ++ return 0; ++ } ++ ++ friend class WeakReferenceImpl; ++ ++ private: ++ volatile long refcount_; ++ }; ++ ++ template<typename I, bool isImplementsBased = __is_base_of(ImplementsBase, I)> ++ struct HasIInspectable; ++ ++ template<typename I> ++ struct HasIInspectable<I, false> { ++ static const bool isIInspectable; ++ }; ++ ++ template<typename I> ++ struct HasIInspectable<I, true> { ++ static const bool isIInspectable; ++ }; ++ ++ template<typename I0, bool isIInspectable = true> ++ struct IInspectableInjector; ++ ++ template<typename I0> ++ struct IInspectableInjector<I0, true> { ++ typedef Details::Nil InspectableIfNeeded; ++ }; ++ ++ template<typename I0> ++ struct IInspectableInjector<I0, false> { ++ typedef IInspectable InspectableIfNeeded; ++ }; ++ ++ template <class RuntimeClassFlagsT, typename I0, typename ...TInterfaces> ++ class __declspec(novtable) RuntimeClassImpl<RuntimeClassFlagsT, false, true, false, I0, TInterfaces...> : public Details::ImplementsHelper<RuntimeClassFlagsT, false, typename IInspectableInjector<I0>::InspectableIfNeeded, I0, TInterfaces...>, public RuntimeClassBaseTRuntimeClassFlagsT::value, protected RuntimeClassFlags<InhibitWeakReference>, public DontUseNewUseMake { ++ public: ++ typedef RuntimeClassFlagsT ClassFlags; ++ ++ STDMETHOD(QueryInterface)(REFIID riid, void **ppvObject) { ++ return 0; ++ } ++ ++ STDMETHOD_(ULONG, AddRef)() { ++ return 0; ++ } ++ ++ STDMETHOD_(ULONG, Release)() { ++ return 0; ++ } ++ ++ STDMETHOD(GetIids)(ULONG *iidCount, IID **iids) { ++ return 0; ++ } ++ ++ protected: ++ RuntimeClassImpl() throw() {} ++ ++ virtual ~RuntimeClassImpl() throw() {} ++ ++ unsigned long InternalAddRef() throw() { ++ return 0; ++ } ++ ++ unsigned long InternalRelease() throw() { ++ return 0; ++ } ++ ++ unsigned long GetRefCount() const throw() { ++ return 0; ++ } ++ ++ private: ++ volatile long refcount_; ++ }; ++ ++ template <class RuntimeClassFlagsT, typename I0, typename ...TInterfaces> ++ class __declspec(novtable) RuntimeClassImpl<RuntimeClassFlagsT, false, true, true, I0, TInterfaces...> : public RuntimeClassImpl<RuntimeClassFlagsT, false, true, false, I0, TInterfaces...> {}; ++ ++ template <class RuntimeClassFlagsT, typename I0, typename ...TInterfaces> ++ class __declspec(novtable) RuntimeClassImpl<RuntimeClassFlagsT, true, true, true, I0, TInterfaces...> : public RuntimeClassImpl<RuntimeClassFlagsT, true, true, false, I0, FtmBase, TInterfaces...> {}; ++ } ++ ++ template <typename ...TInterfaces> ++ class RuntimeClass : public Details::RuntimeClassImpl<DETAILS_RTCLASS_FLAGS_ARGUMENTS(RuntimeClassFlags<WinRt>), TInterfaces...> { ++ RuntimeClass(const RuntimeClass&); ++ ++ RuntimeClass& operator=(const RuntimeClass&); ++ ++ public: ++ RuntimeClass() throw() {} ++ ++ typedef RuntimeClass RuntimeClassT; ++ }; ++ ++ template <unsigned int classFlags, typename ...TInterfaces> ++ class RuntimeClass<RuntimeClassFlags<classFlags>, TInterfaces...> : public Details::RuntimeClassImpl<DETAILS_RTCLASS_FLAGS_ARGUMENTS(RuntimeClassFlags<classFlags>), TInterfaces...> { ++ RuntimeClass(const RuntimeClass&); ++ ++ RuntimeClass& operator=(const RuntimeClass&); ++ ++ public: ++ RuntimeClass() throw() {} ++ ++ typedef RuntimeClass RuntimeClassT; ++ }; ++ } ++} ++ ++#include <poppack.h> ++ ++#endif +diff --git a/mingw-w64-headers/include/wrl/internal.h b/mingw-w64-headers/include/wrl/internal.h +index 715ef74e3..dffa7153d 100644 +--- a/mingw-w64-headers/include/wrl/internal.h ++++ b/mingw-w64-headers/include/wrl/internal.h +@@ -7,6 +7,8 @@ + #ifndef _WRL_INTERNAL_H_ + #define _WRL_INTERNAL_H_ + ++#define __WRL_IMPLEMENTS_FTM_BASE__(flags) (false) ++ + #include <windows.h> + + namespace Microsoft { +@@ -29,6 +31,26 @@ namespace Microsoft { + struct EnableIf<true, T> { + typedef T type; + }; ++ ++ template<class T> ++ struct RemoveReference { ++ typedef T Type; ++ }; ++ ++ template<class T> ++ struct RemoveReference<T&> { ++ typedef T Type; ++ }; ++ ++ template<class T> ++ struct RemoveReference<T&&> { ++ typedef T Type; ++ }; ++ ++ template<class T> ++ inline typename RemoveReference<T>::Type&& Move(T&& arg) throw() { ++ return nullptr; ++ } + } + } + } +diff --git a/mingw-w64-headers/include/wrl/wrappers/corewrappers.h b/mingw-w64-headers/include/wrl/wrappers/corewrappers.h +index 221d9cc8f..4b15f43ec 100644 +--- a/mingw-w64-headers/include/wrl/wrappers/corewrappers.h ++++ b/mingw-w64-headers/include/wrl/wrappers/corewrappers.h +@@ -22,6 +22,129 @@ namespace Microsoft { + } + + namespace Wrappers { ++ namespace HandleTraits { ++ struct SRWLockSharedTraits { ++ typedef SRWLOCK* Type; ++ ++ inline static Type GetInvalidValue() throw() { ++ return nullptr; ++ } ++ ++ inline static void Unlock(Type srwlock) throw() {} ++ }; ++ ++ struct SRWLockExclusiveTraits { ++ typedef SRWLOCK* Type; ++ ++ inline static Type GetInvalidValue() throw() { ++ return nullptr; ++ } ++ ++ inline static void Unlock(Type srwlock) throw() {} ++ }; ++ } ++ ++ class SRWLock; ++ ++ namespace Details { ++ class SyncLockExclusive { ++ public: ++ SyncLockExclusive(SyncLockExclusive&& other) throw() {} ++ ++ SyncLockExclusive(const SyncLockExclusive&); ++ SyncLockExclusive& operator=(const SyncLockExclusive&); ++ ++ ~SyncLockExclusive() throw() {} ++ ++ void Unlock() throw() {} ++ ++ bool IsLocked() const throw() { ++ return 0; ++ } ++ ++ friend class Wrappers::SRWLock; ++ ++ protected: ++ explicit SyncLockExclusive(SRWLOCK* sync) throw() {} ++ ++ SRWLOCK* sync_; ++ ++ private: ++ void InternalUnlock() throw() {} ++ }; ++ ++ class SyncLockShared { ++ public: ++ SyncLockShared(SyncLockShared&& other) throw() {} ++ ++ SyncLockShared(const SyncLockShared&); ++ SyncLockShared& operator=(const SyncLockShared&); ++ ++ ~SyncLockShared() throw() {} ++ ++ void Unlock() throw() {} ++ ++ bool IsLocked() const throw() { ++ return 0; ++ } ++ ++ friend class Wrappers::SRWLock; ++ ++ protected: ++ explicit SyncLockShared(SRWLOCK* sync) throw() {} ++ ++ SRWLOCK* sync_; ++ ++ private: ++ void InternalUnlock() throw() {} ++ }; ++ } ++ ++ class SRWLock { ++ public: ++ SRWLock() throw() {} ++ ++ SRWLock(const SRWLock&) = delete; ++ SRWLock& operator=(const SRWLock&) = delete; ++ ++ ~SRWLock() throw() {} ++ ++ Details::SyncLockExclusive LockExclusive() throw() { ++ return Details::SyncLockExclusive(nullptr); ++ } ++ ++ static Details::SyncLockExclusive LockExclusive(SRWLOCK* lock) throw() { ++ return Details::SyncLockExclusive(nullptr); ++ } ++ ++ Details::SyncLockExclusive TryLockExclusive() throw() { ++ return Details::SyncLockExclusive(nullptr); ++ } ++ ++ static Details::SyncLockExclusive TryLockExclusive(SRWLOCK* lock) throw() { ++ return Details::SyncLockExclusive(nullptr); ++ } ++ ++ Details::SyncLockShared LockShared() throw() { ++ return Details::SyncLockShared(nullptr); ++ } ++ ++ static Details::SyncLockShared LockShared(SRWLOCK* lock) throw() { ++ return Details::SyncLockShared(nullptr); ++ } ++ ++ Details::SyncLockShared TryLockShared() throw() { ++ return Details::SyncLockShared(nullptr); ++ } ++ ++ static Details::SyncLockShared TryLockShared(SRWLOCK* lock) throw() { ++ return Details::SyncLockShared(nullptr); ++ } ++ ++ protected: ++ SRWLOCK SRWLock_; ++ }; ++ + class HStringReference { + private: + void Init(const wchar_t* str, unsigned int len) {

===================================== projects/translation/config ===================================== @@ -12,7 +12,7 @@ compress_tar: 'gz' steps: base-browser: base-browser: '[% INCLUDE build %]' - git_hash: 3b1be2065b54939ed019d94174f137847bcf3c66 + git_hash: f7c77f129447921ec1490f5f401ee27e474b932a targets: nightly: git_hash: 'base-browser'

===================================== rbm.conf ===================================== @@ -73,17 +73,20 @@ buildconf: git_signtag_opt: '-s'

var: - torbrowser_version: '14.0.1' - torbrowser_build: 'build2' + torbrowser_version: '[% IF c("var/tor-browser") %]14.0.1[% ELSE %]14.0a10[% END %]' + torbrowser_build: 'build1' # This should be the date of when the build is started. For the build # to be reproducible, browser_release_date should always be in the past. - browser_release_date: '2024/10/28 09:00:00' + browser_release_date: '2024/10/31 19:43:38' browser_release_date_timestamp: '[% USE date; date.format(c("var/browser_release_date"), "%s") %]' updater_enabled: 1 build_mar: 1 torbrowser_incremental_from: + - '[% IF c("var/mullvad-browser") %]14.0a9[% END %]' + - '[% IF c("var/mullvad-browser") %]14.0a8[% END %]' + - '[% IF c("var/mullvad-browser") %]14.0a7[% END %]' - '[% IF c("var/tor-browser") %]14.0[% END %]' - - '13.5.7' + - '[% IF c("var/tor-browser") %]13.5.7[% END %]' mar_channel_id: '[% c("var/projectname") %]-torproject-[% c("var/channel") %]'

torbrowser_legacy_version: 13.5.9

View it on GitLab: https://gitlab.torproject.org/tpo/applications/tor-browser-build/-/compare/4...