[tbb-commits] [Git][tpo/applications/tor-browser-build][maint-14.0] 3 commits: Bug 41291 - Bump and patch mingw-w64-clang
morgan (@morgan)
git at gitlab.torproject.org
Thu Oct 31 21:08:47 UTC 2024
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.xpi
+ - URL: https://addons.mozilla.org/firefox/downloads/file/4377088/noscript-11.5.0.xpi
name: noscript
- sha256sum: fd2d420afd93829bb6fe30ec6f8ba926d3d54d7583b8bbd822053b8cd13c0472
+ sha256sum: 999244c7be75e58fe16cb2880711013ca079822da1dab65e7eb375c1faf5baad
- URL: https://addons.mozilla.org/firefox/downloads/file/4359936/ublock_origin-1.60.0.xpi
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:
++ ComPtr<Details::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 AreAllNil<Microsoft::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 RuntimeClassBaseT<RuntimeClassFlagsT::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 RuntimeClassBaseT<RuntimeClassFlagsT::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/4a836c670bf62b6f78ef6024b775bc7b35bc0f4c...f9e2c4dd4c3b2e52e3c58f2edfebaa520342d32e
--
View it on GitLab: https://gitlab.torproject.org/tpo/applications/tor-browser-build/-/compare/4a836c670bf62b6f78ef6024b775bc7b35bc0f4c...f9e2c4dd4c3b2e52e3c58f2edfebaa520342d32e
You're receiving this email because of your account on gitlab.torproject.org.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.torproject.org/pipermail/tbb-commits/attachments/20241031/1264a311/attachment-0001.htm>
More information about the tbb-commits
mailing list