Repo created

TMessagesProj/jni/voip/webrtc/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

TMessagesProj/jni/voip/webrtc/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_

TMessagesProj/jni/voip/webrtc/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

TMessagesProj/jni/voip/webrtc/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_

TMessagesProj/jni/voip/webrtc/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

TMessagesProj/jni/voip/webrtc/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_

TMessagesProj/jni/voip/webrtc/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

TMessagesProj/jni/voip/webrtc/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_

TMessagesProj/jni/voip/webrtc/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

TMessagesProj/jni/voip/webrtc/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_