diff options
Diffstat (limited to 'third_party/libwebrtc/rtc_base/win')
16 files changed, 1455 insertions, 0 deletions
diff --git a/third_party/libwebrtc/rtc_base/win/BUILD.gn b/third_party/libwebrtc/rtc_base/win/BUILD.gn new file mode 100644 index 0000000000..cf8bc21950 --- /dev/null +++ b/third_party/libwebrtc/rtc_base/win/BUILD.gn @@ -0,0 +1,68 @@ +# Copyright (c) 2021 The WebRTC project authors. All Rights Reserved. +# +# Use of this source code is governed by a BSD-style license +# that can be found in the LICENSE file in the root of the source +# tree. An additional intellectual property rights grant can be found +# in the file PATENTS. All contributing project authors may +# be found in the AUTHORS file in the root of the source tree. + +import("../../webrtc.gni") + +rtc_library("create_direct3d_device") { + sources = [ + "create_direct3d_device.cc", + "create_direct3d_device.h", + ] + data_deps = [ "//build/win:runtime_libs" ] +} + +rtc_library("get_activation_factory") { + sources = [ + "get_activation_factory.cc", + "get_activation_factory.h", + ] + data_deps = [ "//build/win:runtime_libs" ] + deps = [ ":hstring" ] +} + +rtc_library("hstring") { + sources = [ + "hstring.cc", + "hstring.h", + ] + data_deps = [ "//build/win:runtime_libs" ] +} + +rtc_library("scoped_com_initializer") { + sources = [ + "scoped_com_initializer.cc", + "scoped_com_initializer.h", + ] + data_deps = [ "//build/win:runtime_libs" ] + deps = [ + "..:checks", + "..:logging", + ] +} + +rtc_library("windows_version") { + sources = [ + "windows_version.cc", + "windows_version.h", + ] + data_deps = [ "//build/win:runtime_libs" ] + deps = [ + "..:checks", + "..:stringutils", + ] +} + +rtc_library("windows_version_unittest") { + testonly = true + sources = [ "windows_version_unittest.cc" ] + deps = [ + ":windows_version", + "..:gunit_helpers", + "..:logging", + ] +} diff --git a/third_party/libwebrtc/rtc_base/win/create_direct3d_device.cc b/third_party/libwebrtc/rtc_base/win/create_direct3d_device.cc new file mode 100644 index 0000000000..35bbec1156 --- /dev/null +++ b/third_party/libwebrtc/rtc_base/win/create_direct3d_device.cc @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2020 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "rtc_base/win/create_direct3d_device.h" + +#include <libloaderapi.h> + +#include <utility> + +namespace { + +FARPROC LoadD3D11Function(const char* function_name) { + static HMODULE const handle = + ::LoadLibraryExW(L"d3d11.dll", nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32); + return handle ? ::GetProcAddress(handle, function_name) : nullptr; +} + +decltype(&::CreateDirect3D11DeviceFromDXGIDevice) +GetCreateDirect3D11DeviceFromDXGIDevice() { + static decltype(&::CreateDirect3D11DeviceFromDXGIDevice) const function = + reinterpret_cast<decltype(&::CreateDirect3D11DeviceFromDXGIDevice)>( + LoadD3D11Function("CreateDirect3D11DeviceFromDXGIDevice")); + return function; +} + +} // namespace + +namespace webrtc { + +bool ResolveCoreWinRTDirect3DDelayload() { + return GetCreateDirect3D11DeviceFromDXGIDevice(); +} + +HRESULT CreateDirect3DDeviceFromDXGIDevice( + IDXGIDevice* dxgi_device, + ABI::Windows::Graphics::DirectX::Direct3D11::IDirect3DDevice** + out_d3d11_device) { + decltype(&::CreateDirect3D11DeviceFromDXGIDevice) create_d3d11_device_func = + GetCreateDirect3D11DeviceFromDXGIDevice(); + if (!create_d3d11_device_func) + return E_FAIL; + + Microsoft::WRL::ComPtr<IInspectable> inspectableSurface; + HRESULT hr = create_d3d11_device_func(dxgi_device, &inspectableSurface); + if (FAILED(hr)) + return hr; + + return inspectableSurface->QueryInterface(IID_PPV_ARGS(out_d3d11_device)); +} + +} // namespace webrtc diff --git a/third_party/libwebrtc/rtc_base/win/create_direct3d_device.h b/third_party/libwebrtc/rtc_base/win/create_direct3d_device.h new file mode 100644 index 0000000000..7c21f8720a --- /dev/null +++ b/third_party/libwebrtc/rtc_base/win/create_direct3d_device.h @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2020 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef RTC_BASE_WIN_CREATE_DIRECT3D_DEVICE_H_ +#define RTC_BASE_WIN_CREATE_DIRECT3D_DEVICE_H_ + +#include <windows.graphics.directX.direct3d11.h> +#include <windows.graphics.directX.direct3d11.interop.h> +#include <winerror.h> +#include <wrl/client.h> + +namespace webrtc { + +// Callers must check the return value of ResolveCoreWinRTDirect3DDelayload() +// before using CreateDirect3DDeviceFromDXGIDevice(). +bool ResolveCoreWinRTDirect3DDelayload(); + +// Allows for the creating of Direct3D Devices from a DXGI device on versions +// of Windows greater than Win7. +HRESULT CreateDirect3DDeviceFromDXGIDevice( + IDXGIDevice* dxgi_device, + ABI::Windows::Graphics::DirectX::Direct3D11::IDirect3DDevice** + out_d3d11_device); + +} // namespace webrtc + +#endif // RTC_BASE_WIN_CREATE_DIRECT3D_DEVICE_H_ diff --git a/third_party/libwebrtc/rtc_base/win/create_direct3d_device_gn/moz.build b/third_party/libwebrtc/rtc_base/win/create_direct3d_device_gn/moz.build new file mode 100644 index 0000000000..a33d306080 --- /dev/null +++ b/third_party/libwebrtc/rtc_base/win/create_direct3d_device_gn/moz.build @@ -0,0 +1,85 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + + + ### This moz.build was AUTOMATICALLY GENERATED from a GN config, ### + ### DO NOT edit it by hand. ### + +COMPILE_FLAGS["OS_INCLUDES"] = [] +AllowCompilerWarnings() + +DEFINES["ABSL_ALLOCATOR_NOTHROW"] = "1" +DEFINES["CERT_CHAIN_PARA_HAS_EXTRA_FIELDS"] = True +DEFINES["NOMINMAX"] = True +DEFINES["NTDDI_VERSION"] = "0x0A000000" +DEFINES["PSAPI_VERSION"] = "2" +DEFINES["RTC_DAV1D_IN_INTERNAL_DECODER_FACTORY"] = True +DEFINES["RTC_ENABLE_VP9"] = True +DEFINES["RTC_ENABLE_WIN_WGC"] = True +DEFINES["UNICODE"] = True +DEFINES["USE_AURA"] = "1" +DEFINES["WEBRTC_ENABLE_PROTOBUF"] = "0" +DEFINES["WEBRTC_LIBRARY_IMPL"] = True +DEFINES["WEBRTC_MOZILLA_BUILD"] = True +DEFINES["WEBRTC_NON_STATIC_TRACE_EVENT_HANDLERS"] = "0" +DEFINES["WEBRTC_STRICT_FIELD_TRIALS"] = "0" +DEFINES["WEBRTC_WIN"] = True +DEFINES["WIN32"] = True +DEFINES["WIN32_LEAN_AND_MEAN"] = True +DEFINES["WINAPI_FAMILY"] = "WINAPI_FAMILY_DESKTOP_APP" +DEFINES["WINVER"] = "0x0A00" +DEFINES["_ATL_NO_OPENGL"] = True +DEFINES["_CRT_RAND_S"] = True +DEFINES["_CRT_SECURE_NO_DEPRECATE"] = True +DEFINES["_ENABLE_EXTENDED_ALIGNED_STORAGE"] = True +DEFINES["_HAS_EXCEPTIONS"] = "0" +DEFINES["_HAS_NODISCARD"] = True +DEFINES["_SCL_SECURE_NO_DEPRECATE"] = True +DEFINES["_SECURE_ATL"] = True +DEFINES["_UNICODE"] = True +DEFINES["_WIN32_WINNT"] = "0x0A00" +DEFINES["_WINDOWS"] = True +DEFINES["__STD_C"] = True + +FINAL_LIBRARY = "webrtc" + + +LOCAL_INCLUDES += [ + "!/ipc/ipdl/_ipdlheaders", + "!/third_party/libwebrtc/gen", + "/ipc/chromium/src", + "/third_party/libwebrtc/", + "/third_party/libwebrtc/third_party/abseil-cpp/", + "/tools/profiler/public" +] + +UNIFIED_SOURCES += [ + "/third_party/libwebrtc/rtc_base/win/create_direct3d_device.cc" +] + +if not CONFIG["MOZ_DEBUG"]: + + DEFINES["DYNAMIC_ANNOTATIONS_ENABLED"] = "0" + DEFINES["NDEBUG"] = True + DEFINES["NVALGRIND"] = True + +if CONFIG["MOZ_DEBUG"] == "1": + + DEFINES["DYNAMIC_ANNOTATIONS_ENABLED"] = "1" + DEFINES["_HAS_ITERATOR_DEBUGGING"] = "0" + +if CONFIG["TARGET_CPU"] == "aarch64": + + DEFINES["WEBRTC_ARCH_ARM64"] = True + DEFINES["WEBRTC_HAS_NEON"] = True + +if CONFIG["TARGET_CPU"] == "x86": + + DEFINES["WEBRTC_ENABLE_AVX2"] = True + +if CONFIG["TARGET_CPU"] == "x86_64": + + DEFINES["WEBRTC_ENABLE_AVX2"] = True + +Library("create_direct3d_device_gn") diff --git a/third_party/libwebrtc/rtc_base/win/get_activation_factory.cc b/third_party/libwebrtc/rtc_base/win/get_activation_factory.cc new file mode 100644 index 0000000000..b3be9abfa7 --- /dev/null +++ b/third_party/libwebrtc/rtc_base/win/get_activation_factory.cc @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2020 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "rtc_base/win/get_activation_factory.h" + +#include <libloaderapi.h> +#include <roapi.h> + +namespace { + +FARPROC LoadComBaseFunction(const char* function_name) { + static HMODULE const handle = + ::LoadLibraryExW(L"combase.dll", nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32); + return handle ? ::GetProcAddress(handle, function_name) : nullptr; +} + +decltype(&::RoGetActivationFactory) GetRoGetActivationFactoryFunction() { + static decltype(&::RoGetActivationFactory) const function = + reinterpret_cast<decltype(&::RoGetActivationFactory)>( + LoadComBaseFunction("RoGetActivationFactory")); + return function; +} + +} // namespace + +namespace webrtc { + +bool ResolveCoreWinRTDelayload() { + return GetRoGetActivationFactoryFunction() && + ResolveCoreWinRTStringDelayload(); +} + +HRESULT RoGetActivationFactoryProxy(HSTRING class_id, + const IID& iid, + void** out_factory) { + auto get_factory_func = GetRoGetActivationFactoryFunction(); + if (!get_factory_func) + return E_FAIL; + return get_factory_func(class_id, iid, out_factory); +} + +} // namespace webrtc diff --git a/third_party/libwebrtc/rtc_base/win/get_activation_factory.h b/third_party/libwebrtc/rtc_base/win/get_activation_factory.h new file mode 100644 index 0000000000..08f602f0c4 --- /dev/null +++ b/third_party/libwebrtc/rtc_base/win/get_activation_factory.h @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2020 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef RTC_BASE_WIN_GET_ACTIVATION_FACTORY_H_ +#define RTC_BASE_WIN_GET_ACTIVATION_FACTORY_H_ + +#include <winerror.h> + +#include "rtc_base/win/hstring.h" + +namespace webrtc { + +// Provides access to Core WinRT functions which may not be available on +// Windows 7. Loads functions dynamically at runtime to prevent library +// dependencies. + +// Callers must check the return value of ResolveCoreWinRTDelayLoad() before +// using these functions. + +bool ResolveCoreWinRTDelayload(); + +HRESULT RoGetActivationFactoryProxy(HSTRING class_id, + const IID& iid, + void** out_factory); + +// Retrieves an activation factory for the type specified. +template <typename InterfaceType, wchar_t const* runtime_class_id> +HRESULT GetActivationFactory(InterfaceType** factory) { + HSTRING class_id_hstring; + HRESULT hr = CreateHstring(runtime_class_id, wcslen(runtime_class_id), + &class_id_hstring); + if (FAILED(hr)) + return hr; + + hr = RoGetActivationFactoryProxy(class_id_hstring, IID_PPV_ARGS(factory)); + if (FAILED(hr)) { + DeleteHstring(class_id_hstring); + return hr; + } + + return DeleteHstring(class_id_hstring); +} + +} // namespace webrtc + +#endif // RTC_BASE_WIN_GET_ACTIVATION_FACTORY_H_ diff --git a/third_party/libwebrtc/rtc_base/win/get_activation_factory_gn/moz.build b/third_party/libwebrtc/rtc_base/win/get_activation_factory_gn/moz.build new file mode 100644 index 0000000000..387109c968 --- /dev/null +++ b/third_party/libwebrtc/rtc_base/win/get_activation_factory_gn/moz.build @@ -0,0 +1,85 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + + + ### This moz.build was AUTOMATICALLY GENERATED from a GN config, ### + ### DO NOT edit it by hand. ### + +COMPILE_FLAGS["OS_INCLUDES"] = [] +AllowCompilerWarnings() + +DEFINES["ABSL_ALLOCATOR_NOTHROW"] = "1" +DEFINES["CERT_CHAIN_PARA_HAS_EXTRA_FIELDS"] = True +DEFINES["NOMINMAX"] = True +DEFINES["NTDDI_VERSION"] = "0x0A000000" +DEFINES["PSAPI_VERSION"] = "2" +DEFINES["RTC_DAV1D_IN_INTERNAL_DECODER_FACTORY"] = True +DEFINES["RTC_ENABLE_VP9"] = True +DEFINES["RTC_ENABLE_WIN_WGC"] = True +DEFINES["UNICODE"] = True +DEFINES["USE_AURA"] = "1" +DEFINES["WEBRTC_ENABLE_PROTOBUF"] = "0" +DEFINES["WEBRTC_LIBRARY_IMPL"] = True +DEFINES["WEBRTC_MOZILLA_BUILD"] = True +DEFINES["WEBRTC_NON_STATIC_TRACE_EVENT_HANDLERS"] = "0" +DEFINES["WEBRTC_STRICT_FIELD_TRIALS"] = "0" +DEFINES["WEBRTC_WIN"] = True +DEFINES["WIN32"] = True +DEFINES["WIN32_LEAN_AND_MEAN"] = True +DEFINES["WINAPI_FAMILY"] = "WINAPI_FAMILY_DESKTOP_APP" +DEFINES["WINVER"] = "0x0A00" +DEFINES["_ATL_NO_OPENGL"] = True +DEFINES["_CRT_RAND_S"] = True +DEFINES["_CRT_SECURE_NO_DEPRECATE"] = True +DEFINES["_ENABLE_EXTENDED_ALIGNED_STORAGE"] = True +DEFINES["_HAS_EXCEPTIONS"] = "0" +DEFINES["_HAS_NODISCARD"] = True +DEFINES["_SCL_SECURE_NO_DEPRECATE"] = True +DEFINES["_SECURE_ATL"] = True +DEFINES["_UNICODE"] = True +DEFINES["_WIN32_WINNT"] = "0x0A00" +DEFINES["_WINDOWS"] = True +DEFINES["__STD_C"] = True + +FINAL_LIBRARY = "webrtc" + + +LOCAL_INCLUDES += [ + "!/ipc/ipdl/_ipdlheaders", + "!/third_party/libwebrtc/gen", + "/ipc/chromium/src", + "/third_party/libwebrtc/", + "/third_party/libwebrtc/third_party/abseil-cpp/", + "/tools/profiler/public" +] + +UNIFIED_SOURCES += [ + "/third_party/libwebrtc/rtc_base/win/get_activation_factory.cc" +] + +if not CONFIG["MOZ_DEBUG"]: + + DEFINES["DYNAMIC_ANNOTATIONS_ENABLED"] = "0" + DEFINES["NDEBUG"] = True + DEFINES["NVALGRIND"] = True + +if CONFIG["MOZ_DEBUG"] == "1": + + DEFINES["DYNAMIC_ANNOTATIONS_ENABLED"] = "1" + DEFINES["_HAS_ITERATOR_DEBUGGING"] = "0" + +if CONFIG["TARGET_CPU"] == "aarch64": + + DEFINES["WEBRTC_ARCH_ARM64"] = True + DEFINES["WEBRTC_HAS_NEON"] = True + +if CONFIG["TARGET_CPU"] == "x86": + + DEFINES["WEBRTC_ENABLE_AVX2"] = True + +if CONFIG["TARGET_CPU"] == "x86_64": + + DEFINES["WEBRTC_ENABLE_AVX2"] = True + +Library("get_activation_factory_gn") diff --git a/third_party/libwebrtc/rtc_base/win/hstring.cc b/third_party/libwebrtc/rtc_base/win/hstring.cc new file mode 100644 index 0000000000..5a362a97c9 --- /dev/null +++ b/third_party/libwebrtc/rtc_base/win/hstring.cc @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2020 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "rtc_base/win/hstring.h" + +#include <libloaderapi.h> +#include <winstring.h> + +namespace { + +FARPROC LoadComBaseFunction(const char* function_name) { + static HMODULE const handle = + ::LoadLibraryExW(L"combase.dll", nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32); + return handle ? ::GetProcAddress(handle, function_name) : nullptr; +} + +decltype(&::WindowsCreateString) GetWindowsCreateString() { + static decltype(&::WindowsCreateString) const function = + reinterpret_cast<decltype(&::WindowsCreateString)>( + LoadComBaseFunction("WindowsCreateString")); + return function; +} + +decltype(&::WindowsDeleteString) GetWindowsDeleteString() { + static decltype(&::WindowsDeleteString) const function = + reinterpret_cast<decltype(&::WindowsDeleteString)>( + LoadComBaseFunction("WindowsDeleteString")); + return function; +} + +} // namespace + +namespace webrtc { + +bool ResolveCoreWinRTStringDelayload() { + return GetWindowsDeleteString() && GetWindowsCreateString(); +} + +HRESULT CreateHstring(const wchar_t* src, uint32_t len, HSTRING* out_hstr) { + decltype(&::WindowsCreateString) create_string_func = + GetWindowsCreateString(); + if (!create_string_func) + return E_FAIL; + return create_string_func(src, len, out_hstr); +} + +HRESULT DeleteHstring(HSTRING hstr) { + decltype(&::WindowsDeleteString) delete_string_func = + GetWindowsDeleteString(); + if (!delete_string_func) + return E_FAIL; + return delete_string_func(hstr); +} + +} // namespace webrtc diff --git a/third_party/libwebrtc/rtc_base/win/hstring.h b/third_party/libwebrtc/rtc_base/win/hstring.h new file mode 100644 index 0000000000..8fb119a9e6 --- /dev/null +++ b/third_party/libwebrtc/rtc_base/win/hstring.h @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2020 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef RTC_BASE_WIN_HSTRING_H_ +#define RTC_BASE_WIN_HSTRING_H_ + +#include <hstring.h> +#include <stdint.h> +#include <winerror.h> + +namespace webrtc { + +// Callers must check the return value of ResolveCoreWinRTStringDelayLoad() +// before using these functions. +bool ResolveCoreWinRTStringDelayload(); + +HRESULT CreateHstring(const wchar_t* src, uint32_t len, HSTRING* out_hstr); + +HRESULT DeleteHstring(HSTRING hstr); + +} // namespace webrtc + +#endif // RTC_BASE_WIN_HSTRING_H_ diff --git a/third_party/libwebrtc/rtc_base/win/hstring_gn/moz.build b/third_party/libwebrtc/rtc_base/win/hstring_gn/moz.build new file mode 100644 index 0000000000..c69cce6983 --- /dev/null +++ b/third_party/libwebrtc/rtc_base/win/hstring_gn/moz.build @@ -0,0 +1,85 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + + + ### This moz.build was AUTOMATICALLY GENERATED from a GN config, ### + ### DO NOT edit it by hand. ### + +COMPILE_FLAGS["OS_INCLUDES"] = [] +AllowCompilerWarnings() + +DEFINES["ABSL_ALLOCATOR_NOTHROW"] = "1" +DEFINES["CERT_CHAIN_PARA_HAS_EXTRA_FIELDS"] = True +DEFINES["NOMINMAX"] = True +DEFINES["NTDDI_VERSION"] = "0x0A000000" +DEFINES["PSAPI_VERSION"] = "2" +DEFINES["RTC_DAV1D_IN_INTERNAL_DECODER_FACTORY"] = True +DEFINES["RTC_ENABLE_VP9"] = True +DEFINES["RTC_ENABLE_WIN_WGC"] = True +DEFINES["UNICODE"] = True +DEFINES["USE_AURA"] = "1" +DEFINES["WEBRTC_ENABLE_PROTOBUF"] = "0" +DEFINES["WEBRTC_LIBRARY_IMPL"] = True +DEFINES["WEBRTC_MOZILLA_BUILD"] = True +DEFINES["WEBRTC_NON_STATIC_TRACE_EVENT_HANDLERS"] = "0" +DEFINES["WEBRTC_STRICT_FIELD_TRIALS"] = "0" +DEFINES["WEBRTC_WIN"] = True +DEFINES["WIN32"] = True +DEFINES["WIN32_LEAN_AND_MEAN"] = True +DEFINES["WINAPI_FAMILY"] = "WINAPI_FAMILY_DESKTOP_APP" +DEFINES["WINVER"] = "0x0A00" +DEFINES["_ATL_NO_OPENGL"] = True +DEFINES["_CRT_RAND_S"] = True +DEFINES["_CRT_SECURE_NO_DEPRECATE"] = True +DEFINES["_ENABLE_EXTENDED_ALIGNED_STORAGE"] = True +DEFINES["_HAS_EXCEPTIONS"] = "0" +DEFINES["_HAS_NODISCARD"] = True +DEFINES["_SCL_SECURE_NO_DEPRECATE"] = True +DEFINES["_SECURE_ATL"] = True +DEFINES["_UNICODE"] = True +DEFINES["_WIN32_WINNT"] = "0x0A00" +DEFINES["_WINDOWS"] = True +DEFINES["__STD_C"] = True + +FINAL_LIBRARY = "webrtc" + + +LOCAL_INCLUDES += [ + "!/ipc/ipdl/_ipdlheaders", + "!/third_party/libwebrtc/gen", + "/ipc/chromium/src", + "/third_party/libwebrtc/", + "/third_party/libwebrtc/third_party/abseil-cpp/", + "/tools/profiler/public" +] + +SOURCES += [ + "/third_party/libwebrtc/rtc_base/win/hstring.cc" +] + +if not CONFIG["MOZ_DEBUG"]: + + DEFINES["DYNAMIC_ANNOTATIONS_ENABLED"] = "0" + DEFINES["NDEBUG"] = True + DEFINES["NVALGRIND"] = True + +if CONFIG["MOZ_DEBUG"] == "1": + + DEFINES["DYNAMIC_ANNOTATIONS_ENABLED"] = "1" + DEFINES["_HAS_ITERATOR_DEBUGGING"] = "0" + +if CONFIG["TARGET_CPU"] == "aarch64": + + DEFINES["WEBRTC_ARCH_ARM64"] = True + DEFINES["WEBRTC_HAS_NEON"] = True + +if CONFIG["TARGET_CPU"] == "x86": + + DEFINES["WEBRTC_ENABLE_AVX2"] = True + +if CONFIG["TARGET_CPU"] == "x86_64": + + DEFINES["WEBRTC_ENABLE_AVX2"] = True + +Library("hstring_gn") diff --git a/third_party/libwebrtc/rtc_base/win/scoped_com_initializer.cc b/third_party/libwebrtc/rtc_base/win/scoped_com_initializer.cc new file mode 100644 index 0000000000..4b56772ebf --- /dev/null +++ b/third_party/libwebrtc/rtc_base/win/scoped_com_initializer.cc @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2020 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "rtc_base/win/scoped_com_initializer.h" + +#include "rtc_base/checks.h" +#include "rtc_base/logging.h" + +namespace webrtc { + +ScopedCOMInitializer::ScopedCOMInitializer() { + RTC_DLOG(LS_INFO) << "Single-Threaded Apartment (STA) COM thread"; + Initialize(COINIT_APARTMENTTHREADED); +} + +// Constructor for MTA initialization. +ScopedCOMInitializer::ScopedCOMInitializer(SelectMTA mta) { + RTC_DLOG(LS_INFO) << "Multi-Threaded Apartment (MTA) COM thread"; + Initialize(COINIT_MULTITHREADED); +} + +ScopedCOMInitializer::~ScopedCOMInitializer() { + if (Succeeded()) { + CoUninitialize(); + } +} + +void ScopedCOMInitializer::Initialize(COINIT init) { + // Initializes the COM library for use by the calling thread, sets the + // thread's concurrency model, and creates a new apartment for the thread + // if one is required. CoInitializeEx must be called at least once, and is + // usually called only once, for each thread that uses the COM library. + hr_ = CoInitializeEx(NULL, init); + RTC_CHECK_NE(RPC_E_CHANGED_MODE, hr_) + << "Invalid COM thread model change (MTA->STA)"; + // Multiple calls to CoInitializeEx by the same thread are allowed as long + // as they pass the same concurrency flag, but subsequent valid calls + // return S_FALSE. To close the COM library gracefully on a thread, each + // successful call to CoInitializeEx, including any call that returns + // S_FALSE, must be balanced by a corresponding call to CoUninitialize. + if (hr_ == S_OK) { + RTC_DLOG(LS_INFO) + << "The COM library was initialized successfully on this thread"; + } else if (hr_ == S_FALSE) { + RTC_DLOG(LS_WARNING) + << "The COM library is already initialized on this thread"; + } +} + +} // namespace webrtc diff --git a/third_party/libwebrtc/rtc_base/win/scoped_com_initializer.h b/third_party/libwebrtc/rtc_base/win/scoped_com_initializer.h new file mode 100644 index 0000000000..2427097b5b --- /dev/null +++ b/third_party/libwebrtc/rtc_base/win/scoped_com_initializer.h @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2020 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef RTC_BASE_WIN_SCOPED_COM_INITIALIZER_H_ +#define RTC_BASE_WIN_SCOPED_COM_INITIALIZER_H_ + +#include <comdef.h> + +namespace webrtc { + +// Initializes COM in the constructor (STA or MTA), and uninitializes COM in the +// destructor. Taken from base::win::ScopedCOMInitializer. +// +// WARNING: This should only be used once per thread, ideally scoped to a +// similar lifetime as the thread itself. You should not be using this in +// random utility functions that make COM calls; instead ensure that these +// functions are running on a COM-supporting thread! +// See https://msdn.microsoft.com/en-us/library/ms809971.aspx for details. +class ScopedCOMInitializer { + public: + // Enum value provided to initialize the thread as an MTA instead of STA. + // There are two types of apartments, Single Threaded Apartments (STAs) + // and Multi Threaded Apartments (MTAs). Within a given process there can + // be multiple STA’s but there is only one MTA. STA is typically used by + // "GUI applications" and MTA by "worker threads" with no UI message loop. + enum SelectMTA { kMTA }; + + // Constructor for STA initialization. + ScopedCOMInitializer(); + + // Constructor for MTA initialization. + explicit ScopedCOMInitializer(SelectMTA mta); + + ~ScopedCOMInitializer(); + + ScopedCOMInitializer(const ScopedCOMInitializer&) = delete; + ScopedCOMInitializer& operator=(const ScopedCOMInitializer&) = delete; + + bool Succeeded() { return SUCCEEDED(hr_); } + + private: + void Initialize(COINIT init); + + HRESULT hr_; +}; + +} // namespace webrtc + +#endif // RTC_BASE_WIN_SCOPED_COM_INITIALIZER_H_ diff --git a/third_party/libwebrtc/rtc_base/win/windows_version.cc b/third_party/libwebrtc/rtc_base/win/windows_version.cc new file mode 100644 index 0000000000..93af1377be --- /dev/null +++ b/third_party/libwebrtc/rtc_base/win/windows_version.cc @@ -0,0 +1,445 @@ +/* + * Copyright (c) 2017 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "rtc_base/win/windows_version.h" + +#include <windows.h> + +#include <memory> + +#include "rtc_base/checks.h" +#include "rtc_base/string_utils.h" + +#if !defined(__clang__) && _MSC_FULL_VER < 191125507 +#error VS 2017 Update 3.2 or higher is required +#endif + +#if !defined(WINUWP) + +namespace { + +typedef BOOL(WINAPI* GetProductInfoPtr)(DWORD, DWORD, DWORD, DWORD, PDWORD); + +// Mask to pull WOW64 access flags out of REGSAM access. +const REGSAM kWow64AccessMask = KEY_WOW64_32KEY | KEY_WOW64_64KEY; + +// Utility class to read, write and manipulate the Windows Registry. +// Registry vocabulary primer: a "key" is like a folder, in which there +// are "values", which are <name, data> pairs, with an associated data type. +// Based on base::win::RegKey but only implements a small fraction of it. +class RegKey { + public: + RegKey() : key_(nullptr), wow64access_(0) {} + + RegKey(HKEY rootkey, const wchar_t* subkey, REGSAM access) + : key_(nullptr), wow64access_(0) { + if (rootkey) { + if (access & (KEY_SET_VALUE | KEY_CREATE_SUB_KEY | KEY_CREATE_LINK)) + Create(rootkey, subkey, access); + else + Open(rootkey, subkey, access); + } else { + RTC_DCHECK(!subkey); + wow64access_ = access & kWow64AccessMask; + } + } + + ~RegKey() { Close(); } + + LONG Create(HKEY rootkey, const wchar_t* subkey, REGSAM access) { + DWORD disposition_value; + return CreateWithDisposition(rootkey, subkey, &disposition_value, access); + } + + LONG CreateWithDisposition(HKEY rootkey, + const wchar_t* subkey, + DWORD* disposition, + REGSAM access) { + RTC_DCHECK(rootkey && subkey && access && disposition); + HKEY subhkey = NULL; + LONG result = + ::RegCreateKeyExW(rootkey, subkey, 0, NULL, REG_OPTION_NON_VOLATILE, + access, NULL, &subhkey, disposition); + if (result == ERROR_SUCCESS) { + Close(); + key_ = subhkey; + wow64access_ = access & kWow64AccessMask; + } + + return result; + } + + // Opens an existing reg key. + LONG Open(HKEY rootkey, const wchar_t* subkey, REGSAM access) { + RTC_DCHECK(rootkey && subkey && access); + HKEY subhkey = NULL; + + LONG result = ::RegOpenKeyExW(rootkey, subkey, 0, access, &subhkey); + if (result == ERROR_SUCCESS) { + Close(); + key_ = subhkey; + wow64access_ = access & kWow64AccessMask; + } + + return result; + } + + // Closes this reg key. + void Close() { + if (key_) { + ::RegCloseKey(key_); + key_ = nullptr; + } + } + + // Reads a REG_DWORD (uint32_t) into `out_value`. If `name` is null or empty, + // reads the key's default value, if any. + LONG ReadValueDW(const wchar_t* name, DWORD* out_value) const { + RTC_DCHECK(out_value); + DWORD type = REG_DWORD; + DWORD size = sizeof(DWORD); + DWORD local_value = 0; + LONG result = ReadValue(name, &local_value, &size, &type); + if (result == ERROR_SUCCESS) { + if ((type == REG_DWORD || type == REG_BINARY) && size == sizeof(DWORD)) + *out_value = local_value; + else + result = ERROR_CANTREAD; + } + + return result; + } + + // Reads a string into `out_value`. If `name` is null or empty, reads + // the key's default value, if any. + LONG ReadValue(const wchar_t* name, std::wstring* out_value) const { + RTC_DCHECK(out_value); + const size_t kMaxStringLength = 1024; // This is after expansion. + // Use the one of the other forms of ReadValue if 1024 is too small for you. + wchar_t raw_value[kMaxStringLength]; + DWORD type = REG_SZ, size = sizeof(raw_value); + LONG result = ReadValue(name, raw_value, &size, &type); + if (result == ERROR_SUCCESS) { + if (type == REG_SZ) { + *out_value = raw_value; + } else if (type == REG_EXPAND_SZ) { + wchar_t expanded[kMaxStringLength]; + size = + ::ExpandEnvironmentStringsW(raw_value, expanded, kMaxStringLength); + // Success: returns the number of wchar_t's copied + // Fail: buffer too small, returns the size required + // Fail: other, returns 0 + if (size == 0 || size > kMaxStringLength) { + result = ERROR_MORE_DATA; + } else { + *out_value = expanded; + } + } else { + // Not a string. Oops. + result = ERROR_CANTREAD; + } + } + + return result; + } + + LONG ReadValue(const wchar_t* name, + void* data, + DWORD* dsize, + DWORD* dtype) const { + LONG result = RegQueryValueExW(key_, name, 0, dtype, + reinterpret_cast<LPBYTE>(data), dsize); + return result; + } + + private: + HKEY key_; + REGSAM wow64access_; +}; + +} // namespace + +#endif // !defined(WINUWP) + +namespace rtc { +namespace rtc_win { +namespace { + +// Helper to map a major.minor.x.build version (e.g. 6.1) to a Windows release. +Version MajorMinorBuildToVersion(int major, int minor, int build) { + if ((major == 5) && (minor > 0)) { + // Treat XP Pro x64, Home Server, and Server 2003 R2 as Server 2003. + return (minor == 1) ? VERSION_XP : VERSION_SERVER_2003; + } else if (major == 6) { + switch (minor) { + case 0: + // Treat Windows Server 2008 the same as Windows Vista. + return VERSION_VISTA; + case 1: + // Treat Windows Server 2008 R2 the same as Windows 7. + return VERSION_WIN7; + case 2: + // Treat Windows Server 2012 the same as Windows 8. + return VERSION_WIN8; + default: + RTC_DCHECK_EQ(minor, 3); + return VERSION_WIN8_1; + } + } else if (major == 10) { + if (build < 10586) { + return VERSION_WIN10; + } else if (build < 14393) { + return VERSION_WIN10_TH2; + } else if (build < 15063) { + return VERSION_WIN10_RS1; + } else if (build < 16299) { + return VERSION_WIN10_RS2; + } else if (build < 17134) { + return VERSION_WIN10_RS3; + } else if (build < 17763) { + return VERSION_WIN10_RS4; + } else if (build < 18362) { + return VERSION_WIN10_RS5; + } else if (build < 18363) { + return VERSION_WIN10_19H1; + } else if (build < 19041) { + return VERSION_WIN10_19H2; + } else if (build < 19042) { + return VERSION_WIN10_20H1; + } else if (build < 19043) { + return VERSION_WIN10_20H2; + } else if (build < 19044) { + return VERSION_WIN10_21H1; + } else if (build < 20348) { + return VERSION_WIN10_21H2; + } else if (build < 22000) { + return VERSION_SERVER_2022; + } else { + return VERSION_WIN11; + } + } else if (major == 11) { + return VERSION_WIN11; + } else if (major > 6) { + RTC_DCHECK_NOTREACHED(); + return VERSION_WIN_LAST; + } + + return VERSION_PRE_XP; +} + +// Returns the the "UBR" value from the registry. Introduced in Windows 10, +// this undocumented value appears to be similar to a patch number. +// Returns 0 if the value does not exist or it could not be read. +int GetUBR() { +#if defined(WINUWP) + // The registry is not accessible for WinUWP sandboxed store applications. + return 0; +#else + // The values under the CurrentVersion registry hive are mirrored under + // the corresponding Wow6432 hive. + static constexpr wchar_t kRegKeyWindowsNTCurrentVersion[] = + L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion"; + + RegKey key; + if (key.Open(HKEY_LOCAL_MACHINE, kRegKeyWindowsNTCurrentVersion, + KEY_QUERY_VALUE) != ERROR_SUCCESS) { + return 0; + } + + DWORD ubr = 0; + key.ReadValueDW(L"UBR", &ubr); + + return static_cast<int>(ubr); +#endif // defined(WINUWP) +} + +} // namespace + +// static +OSInfo* OSInfo::GetInstance() { + // Note: we don't use the Singleton class because it depends on AtExitManager, + // and it's convenient for other modules to use this class without it. This + // pattern is copied from gurl.cc. + static OSInfo* info; + if (!info) { + OSInfo* new_info = new OSInfo(); + if (InterlockedCompareExchangePointer(reinterpret_cast<PVOID*>(&info), + new_info, NULL)) { + delete new_info; + } + } + return info; +} + +OSInfo::OSInfo() + : version_(VERSION_PRE_XP), + architecture_(OTHER_ARCHITECTURE), + wow64_status_(GetWOW64StatusForProcess(GetCurrentProcess())) { + OSVERSIONINFOEXW version_info = {sizeof version_info}; + // Applications not manifested for Windows 8.1 or Windows 10 will return the + // Windows 8 OS version value (6.2). Once an application is manifested for a + // given operating system version, GetVersionEx() will always return the + // version that the application is manifested for in future releases. + // https://docs.microsoft.com/en-us/windows/desktop/SysInfo/targeting-your-application-at-windows-8-1 + // https://www.codeproject.com/Articles/678606/Part-Overcoming-Windows-s-deprecation-of-GetVe +#pragma warning(push) +#pragma warning(disable : 4996) + ::GetVersionExW(reinterpret_cast<OSVERSIONINFOW*>(&version_info)); +#pragma warning(pop) + version_number_.major = version_info.dwMajorVersion; + version_number_.minor = version_info.dwMinorVersion; + version_number_.build = version_info.dwBuildNumber; + version_number_.patch = GetUBR(); + version_ = MajorMinorBuildToVersion( + version_number_.major, version_number_.minor, version_number_.build); + service_pack_.major = version_info.wServicePackMajor; + service_pack_.minor = version_info.wServicePackMinor; + service_pack_str_ = rtc::ToUtf8(version_info.szCSDVersion); + + SYSTEM_INFO system_info = {}; + ::GetNativeSystemInfo(&system_info); + switch (system_info.wProcessorArchitecture) { + case PROCESSOR_ARCHITECTURE_INTEL: + architecture_ = X86_ARCHITECTURE; + break; + case PROCESSOR_ARCHITECTURE_AMD64: + architecture_ = X64_ARCHITECTURE; + break; + case PROCESSOR_ARCHITECTURE_IA64: + architecture_ = IA64_ARCHITECTURE; + break; + } + processors_ = system_info.dwNumberOfProcessors; + allocation_granularity_ = system_info.dwAllocationGranularity; + +#if !defined(WINUWP) + GetProductInfoPtr get_product_info; + DWORD os_type; + + if (version_info.dwMajorVersion == 6 || version_info.dwMajorVersion == 10) { + // Only present on Vista+. + get_product_info = reinterpret_cast<GetProductInfoPtr>(::GetProcAddress( + ::GetModuleHandleW(L"kernel32.dll"), "GetProductInfo")); + + get_product_info(version_info.dwMajorVersion, version_info.dwMinorVersion, + 0, 0, &os_type); + switch (os_type) { + case PRODUCT_CLUSTER_SERVER: + case PRODUCT_DATACENTER_SERVER: + case PRODUCT_DATACENTER_SERVER_CORE: + case PRODUCT_ENTERPRISE_SERVER: + case PRODUCT_ENTERPRISE_SERVER_CORE: + case PRODUCT_ENTERPRISE_SERVER_IA64: + case PRODUCT_SMALLBUSINESS_SERVER: + case PRODUCT_SMALLBUSINESS_SERVER_PREMIUM: + case PRODUCT_STANDARD_SERVER: + case PRODUCT_STANDARD_SERVER_CORE: + case PRODUCT_WEB_SERVER: + version_type_ = SUITE_SERVER; + break; + case PRODUCT_PROFESSIONAL: + case PRODUCT_ULTIMATE: + version_type_ = SUITE_PROFESSIONAL; + break; + case PRODUCT_ENTERPRISE: + case PRODUCT_ENTERPRISE_E: + case PRODUCT_ENTERPRISE_EVALUATION: + case PRODUCT_ENTERPRISE_N: + case PRODUCT_ENTERPRISE_N_EVALUATION: + case PRODUCT_ENTERPRISE_S: + case PRODUCT_ENTERPRISE_S_EVALUATION: + case PRODUCT_ENTERPRISE_S_N: + case PRODUCT_ENTERPRISE_S_N_EVALUATION: + case PRODUCT_BUSINESS: + case PRODUCT_BUSINESS_N: + version_type_ = SUITE_ENTERPRISE; + break; + case PRODUCT_EDUCATION: + case PRODUCT_EDUCATION_N: + version_type_ = SUITE_EDUCATION; + break; + case PRODUCT_HOME_BASIC: + case PRODUCT_HOME_PREMIUM: + case PRODUCT_STARTER: + default: + version_type_ = SUITE_HOME; + break; + } + } else if (version_info.dwMajorVersion == 5 && + version_info.dwMinorVersion == 2) { + if (version_info.wProductType == VER_NT_WORKSTATION && + system_info.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) { + version_type_ = SUITE_PROFESSIONAL; + } else if (version_info.wSuiteMask & VER_SUITE_WH_SERVER) { + version_type_ = SUITE_HOME; + } else { + version_type_ = SUITE_SERVER; + } + } else if (version_info.dwMajorVersion == 5 && + version_info.dwMinorVersion == 1) { + if (version_info.wSuiteMask & VER_SUITE_PERSONAL) + version_type_ = SUITE_HOME; + else + version_type_ = SUITE_PROFESSIONAL; + } else { + // Windows is pre XP so we don't care but pick a safe default. + version_type_ = SUITE_HOME; + } +#else + // WinUWP sandboxed store apps do not have a mechanism to determine + // product suite thus the most restricted suite is chosen. + version_type_ = SUITE_HOME; +#endif // !defined(WINUWP) +} + +OSInfo::~OSInfo() {} + +std::string OSInfo::processor_model_name() { +#if defined(WINUWP) + // WinUWP sandboxed store apps do not have the ability to + // probe the name of the current processor. + return "Unknown Processor (UWP)"; +#else + if (processor_model_name_.empty()) { + const wchar_t kProcessorNameString[] = + L"HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0"; + RegKey key(HKEY_LOCAL_MACHINE, kProcessorNameString, KEY_READ); + std::wstring value; + key.ReadValue(L"ProcessorNameString", &value); + processor_model_name_ = rtc::ToUtf8(value); + } + return processor_model_name_; +#endif // defined(WINUWP) +} + +// static +OSInfo::WOW64Status OSInfo::GetWOW64StatusForProcess(HANDLE process_handle) { + BOOL is_wow64; +#if defined(WINUWP) + if (!IsWow64Process(process_handle, &is_wow64)) + return WOW64_UNKNOWN; +#else + typedef BOOL(WINAPI * IsWow64ProcessFunc)(HANDLE, PBOOL); + IsWow64ProcessFunc is_wow64_process = reinterpret_cast<IsWow64ProcessFunc>( + GetProcAddress(GetModuleHandleW(L"kernel32.dll"), "IsWow64Process")); + if (!is_wow64_process) + return WOW64_DISABLED; + if (!(*is_wow64_process)(process_handle, &is_wow64)) + return WOW64_UNKNOWN; +#endif // defined(WINUWP) + return is_wow64 ? WOW64_ENABLED : WOW64_DISABLED; +} + +Version GetVersion() { + return OSInfo::GetInstance()->version(); +} + +} // namespace rtc_win +} // namespace rtc diff --git a/third_party/libwebrtc/rtc_base/win/windows_version.h b/third_party/libwebrtc/rtc_base/win/windows_version.h new file mode 100644 index 0000000000..8542626afb --- /dev/null +++ b/third_party/libwebrtc/rtc_base/win/windows_version.h @@ -0,0 +1,156 @@ +/* + * Copyright (c) 2017 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef RTC_BASE_WIN_WINDOWS_VERSION_H_ +#define RTC_BASE_WIN_WINDOWS_VERSION_H_ + +#include <stddef.h> + +#include <string> + +typedef void* HANDLE; + +namespace rtc { +namespace rtc_win { + +// The running version of Windows. This is declared outside OSInfo for +// syntactic sugar reasons; see the declaration of GetVersion() below. +// NOTE: Keep these in order so callers can do things like +// "if (rtc_win::GetVersion() >= rtc_win::VERSION_VISTA) ...". +// +// This enum is used in metrics histograms, so they shouldn't be reordered or +// removed. New values can be added before VERSION_WIN_LAST. +enum Version { + VERSION_PRE_XP = 0, // Not supported. + VERSION_XP = 1, + VERSION_SERVER_2003 = 2, // Also includes XP Pro x64 and Server 2003 R2. + VERSION_VISTA = 3, // Also includes Windows Server 2008. + VERSION_WIN7 = 4, // Also includes Windows Server 2008 R2. + VERSION_WIN8 = 5, // Also includes Windows Server 2012. + VERSION_WIN8_1 = 6, // Also includes Windows Server 2012 R2. + VERSION_WIN10 = 7, // Threshold 1: Version 1507, Build 10240. + VERSION_WIN10_TH2 = 8, // Threshold 2: Version 1511, Build 10586. + VERSION_WIN10_RS1 = 9, // Redstone 1: Version 1607, Build 14393. + VERSION_WIN10_RS2 = 10, // Redstone 2: Version 1703, Build 15063. + VERSION_WIN10_RS3 = 11, // Redstone 3: Version 1709, Build 16299. + VERSION_WIN10_RS4 = 12, // Redstone 4: Version 1803, Build 17134. + VERSION_WIN10_RS5 = 13, // Redstone 5: Version 1809, Build 17763. + VERSION_WIN10_19H1 = 14, // 19H1: Version 1903, Build 18362. + VERSION_WIN10_19H2 = 15, // 19H2: Version 1909, Build 18363. + VERSION_WIN10_20H1 = 16, // 20H1: Version 2004, Build 19041. + VERSION_WIN10_20H2 = 17, // 20H2: Build 19042. + VERSION_WIN10_21H1 = 18, // 21H1: Build 19043. + VERSION_WIN10_21H2 = 19, // 21H2: Build 19044. + VERSION_SERVER_2022 = 20, // Server 2022: Build 20348. + VERSION_WIN11 = 21, // Windows 11: Build 22000. + VERSION_WIN_LAST, // Indicates error condition. +}; + +// A rough bucketing of the available types of versions of Windows. This is used +// to distinguish enterprise enabled versions from home versions and potentially +// server versions. Keep these values in the same order, since they are used as +// is for metrics histogram ids. +enum VersionType { + SUITE_HOME = 0, + SUITE_PROFESSIONAL, + SUITE_SERVER, + SUITE_ENTERPRISE, + SUITE_EDUCATION, + SUITE_LAST, +}; + +// A singleton that can be used to query various pieces of information about the +// OS and process state. Note that this doesn't use the base Singleton class, so +// it can be used without an AtExitManager. +class OSInfo { + public: + struct VersionNumber { + int major; + int minor; + int build; + int patch; + }; + + struct ServicePack { + int major; + int minor; + }; + + // The processor architecture this copy of Windows natively uses. For + // example, given an x64-capable processor, we have three possibilities: + // 32-bit Chrome running on 32-bit Windows: X86_ARCHITECTURE + // 32-bit Chrome running on 64-bit Windows via WOW64: X64_ARCHITECTURE + // 64-bit Chrome running on 64-bit Windows: X64_ARCHITECTURE + enum WindowsArchitecture { + X86_ARCHITECTURE, + X64_ARCHITECTURE, + IA64_ARCHITECTURE, + OTHER_ARCHITECTURE, + }; + + // Whether a process is running under WOW64 (the wrapper that allows 32-bit + // processes to run on 64-bit versions of Windows). This will return + // WOW64_DISABLED for both "32-bit Chrome on 32-bit Windows" and "64-bit + // Chrome on 64-bit Windows". WOW64_UNKNOWN means "an error occurred", e.g. + // the process does not have sufficient access rights to determine this. + enum WOW64Status { + WOW64_DISABLED, + WOW64_ENABLED, + WOW64_UNKNOWN, + }; + + OSInfo(const OSInfo&) = delete; + OSInfo& operator=(const OSInfo&) = delete; + + static OSInfo* GetInstance(); + + Version version() const { return version_; } + VersionNumber version_number() const { return version_number_; } + VersionType version_type() const { return version_type_; } + ServicePack service_pack() const { return service_pack_; } + std::string service_pack_str() const { return service_pack_str_; } + WindowsArchitecture architecture() const { return architecture_; } + int processors() const { return processors_; } + size_t allocation_granularity() const { return allocation_granularity_; } + WOW64Status wow64_status() const { return wow64_status_; } + std::string processor_model_name(); + + // Like wow64_status(), but for the supplied handle instead of the current + // process. This doesn't touch member state, so you can bypass the singleton. + static WOW64Status GetWOW64StatusForProcess(HANDLE process_handle); + + private: + OSInfo(); + ~OSInfo(); + + Version version_; + VersionNumber version_number_; + VersionType version_type_; + ServicePack service_pack_; + + // A string, such as "Service Pack 3", that indicates the latest Service Pack + // installed on the system. If no Service Pack has been installed, the string + // is empty. + std::string service_pack_str_; + WindowsArchitecture architecture_; + int processors_; + size_t allocation_granularity_; + WOW64Status wow64_status_; + std::string processor_model_name_; +}; + +// Because this is by far the most commonly-requested value from the above +// singleton, we add a global-scope accessor here as syntactic sugar. +Version GetVersion(); + +} // namespace rtc_win +} // namespace rtc + +#endif // RTC_BASE_WIN_WINDOWS_VERSION_H_ diff --git a/third_party/libwebrtc/rtc_base/win/windows_version_gn/moz.build b/third_party/libwebrtc/rtc_base/win/windows_version_gn/moz.build new file mode 100644 index 0000000000..33b46947a4 --- /dev/null +++ b/third_party/libwebrtc/rtc_base/win/windows_version_gn/moz.build @@ -0,0 +1,85 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + + + ### This moz.build was AUTOMATICALLY GENERATED from a GN config, ### + ### DO NOT edit it by hand. ### + +COMPILE_FLAGS["OS_INCLUDES"] = [] +AllowCompilerWarnings() + +DEFINES["ABSL_ALLOCATOR_NOTHROW"] = "1" +DEFINES["CERT_CHAIN_PARA_HAS_EXTRA_FIELDS"] = True +DEFINES["NOMINMAX"] = True +DEFINES["NTDDI_VERSION"] = "0x0A000000" +DEFINES["PSAPI_VERSION"] = "2" +DEFINES["RTC_DAV1D_IN_INTERNAL_DECODER_FACTORY"] = True +DEFINES["RTC_ENABLE_VP9"] = True +DEFINES["RTC_ENABLE_WIN_WGC"] = True +DEFINES["UNICODE"] = True +DEFINES["USE_AURA"] = "1" +DEFINES["WEBRTC_ENABLE_PROTOBUF"] = "0" +DEFINES["WEBRTC_LIBRARY_IMPL"] = True +DEFINES["WEBRTC_MOZILLA_BUILD"] = True +DEFINES["WEBRTC_NON_STATIC_TRACE_EVENT_HANDLERS"] = "0" +DEFINES["WEBRTC_STRICT_FIELD_TRIALS"] = "0" +DEFINES["WEBRTC_WIN"] = True +DEFINES["WIN32"] = True +DEFINES["WIN32_LEAN_AND_MEAN"] = True +DEFINES["WINAPI_FAMILY"] = "WINAPI_FAMILY_DESKTOP_APP" +DEFINES["WINVER"] = "0x0A00" +DEFINES["_ATL_NO_OPENGL"] = True +DEFINES["_CRT_RAND_S"] = True +DEFINES["_CRT_SECURE_NO_DEPRECATE"] = True +DEFINES["_ENABLE_EXTENDED_ALIGNED_STORAGE"] = True +DEFINES["_HAS_EXCEPTIONS"] = "0" +DEFINES["_HAS_NODISCARD"] = True +DEFINES["_SCL_SECURE_NO_DEPRECATE"] = True +DEFINES["_SECURE_ATL"] = True +DEFINES["_UNICODE"] = True +DEFINES["_WIN32_WINNT"] = "0x0A00" +DEFINES["_WINDOWS"] = True +DEFINES["__STD_C"] = True + +FINAL_LIBRARY = "webrtc" + + +LOCAL_INCLUDES += [ + "!/ipc/ipdl/_ipdlheaders", + "!/third_party/libwebrtc/gen", + "/ipc/chromium/src", + "/third_party/libwebrtc/", + "/third_party/libwebrtc/third_party/abseil-cpp/", + "/tools/profiler/public" +] + +UNIFIED_SOURCES += [ + "/third_party/libwebrtc/rtc_base/win/windows_version.cc" +] + +if not CONFIG["MOZ_DEBUG"]: + + DEFINES["DYNAMIC_ANNOTATIONS_ENABLED"] = "0" + DEFINES["NDEBUG"] = True + DEFINES["NVALGRIND"] = True + +if CONFIG["MOZ_DEBUG"] == "1": + + DEFINES["DYNAMIC_ANNOTATIONS_ENABLED"] = "1" + DEFINES["_HAS_ITERATOR_DEBUGGING"] = "0" + +if CONFIG["TARGET_CPU"] == "aarch64": + + DEFINES["WEBRTC_ARCH_ARM64"] = True + DEFINES["WEBRTC_HAS_NEON"] = True + +if CONFIG["TARGET_CPU"] == "x86": + + DEFINES["WEBRTC_ENABLE_AVX2"] = True + +if CONFIG["TARGET_CPU"] == "x86_64": + + DEFINES["WEBRTC_ENABLE_AVX2"] = True + +Library("windows_version_gn") diff --git a/third_party/libwebrtc/rtc_base/win/windows_version_unittest.cc b/third_party/libwebrtc/rtc_base/win/windows_version_unittest.cc new file mode 100644 index 0000000000..e1cd920157 --- /dev/null +++ b/third_party/libwebrtc/rtc_base/win/windows_version_unittest.cc @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2017 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "rtc_base/win/windows_version.h" + +#include "rtc_base/gunit.h" +#include "rtc_base/logging.h" + +namespace rtc { +namespace rtc_win { +namespace { + +void MethodSupportedOnWin10AndLater() { + RTC_DLOG(LS_INFO) << "MethodSupportedOnWin10AndLater"; +} + +void MethodNotSupportedOnWin10AndLater() { + RTC_DLOG(LS_INFO) << "MethodNotSupportedOnWin10AndLater"; +} + +// Use global GetVersion() and use it in a way a user would typically use it +// when checking for support of a certain API: +// "if (rtc_win::GetVersion() < VERSION_WIN10) ...". +TEST(WindowsVersion, GetVersionGlobalScopeAccessor) { + if (GetVersion() < VERSION_WIN10) { + MethodNotSupportedOnWin10AndLater(); + } else { + MethodSupportedOnWin10AndLater(); + } +} + +TEST(WindowsVersion, ProcessorModelName) { + std::string name = OSInfo::GetInstance()->processor_model_name(); + EXPECT_FALSE(name.empty()); + RTC_DLOG(LS_INFO) << "processor_model_name: " << name; +} + +} // namespace +} // namespace rtc_win +} // namespace rtc |