From fdc9998609263d9f531079e2cbe0f3f31eba3382 Mon Sep 17 00:00:00 2001 From: Jeremy Koritzinsky Date: Thu, 4 Apr 2019 11:04:13 -0700 Subject: Runtime support for upcoming .NET Core WinRT Host (#23402) * First pass at adding winrt host entry-point. * There's no way to specify HResult-swapping on a function called via hosted-interop so just return the HResult instead. * Use the WindowsRuntimeMarshal class to create the activation factory and initialize it. * Implement loading the dependent assemblies of a WinRT assembly into an isolated load context. * PR Feedback. * Fail to get the activation factory if the found type is not a managed type exported from a winmd. * Rearrange parameters based on PR feedback. * Remove unneeded include. * Make ActivationFactoryLoader internal. * Fix null-ref in WinRT-dependent-assembly loading * Remove extraneous "System." --- src/System.Private.CoreLib/ILLinkTrim.xml | 2 + .../System.Private.CoreLib.csproj | 1 + .../WindowsRuntime/ActivationFactoryLoader.cs | 74 ++++++++++++++++++++++ src/System.Private.CoreLib/src/System/RtType.cs | 7 +- .../Runtime/Loader/AssemblyLoadContext.CoreCLR.cs | 20 ++++++ src/vm/appdomain.cpp | 3 + src/vm/assemblynative.cpp | 20 ++++++ src/vm/assemblynative.hpp | 3 + src/vm/assemblyspec.cpp | 12 +++- src/vm/clrprivbinderwinrt.cpp | 3 +- src/vm/clrprivbinderwinrt.h | 11 ++++ src/vm/corhost.cpp | 2 +- src/vm/ecalllist.h | 3 + src/vm/interoputil.cpp | 8 +-- src/vm/interoputil.h | 2 +- src/vm/runtimecallablewrapper.cpp | 4 +- src/vm/runtimehandles.cpp | 2 + src/vm/runtimehandles.h | 4 +- src/vm/stdinterfaces.cpp | 2 +- src/vm/stubhelpers.cpp | 8 ++- src/vm/winrttypenameconverter.cpp | 16 ++--- src/vm/winrttypenameconverter.h | 7 +- 22 files changed, 187 insertions(+), 27 deletions(-) create mode 100644 src/System.Private.CoreLib/src/Internal/Runtime/InteropServices/WindowsRuntime/ActivationFactoryLoader.cs (limited to 'src') diff --git a/src/System.Private.CoreLib/ILLinkTrim.xml b/src/System.Private.CoreLib/ILLinkTrim.xml index e334c3703e..5820e2be13 100644 --- a/src/System.Private.CoreLib/ILLinkTrim.xml +++ b/src/System.Private.CoreLib/ILLinkTrim.xml @@ -50,5 +50,7 @@ + + diff --git a/src/System.Private.CoreLib/System.Private.CoreLib.csproj b/src/System.Private.CoreLib/System.Private.CoreLib.csproj index defcc7a6f6..93d24e4ef6 100644 --- a/src/System.Private.CoreLib/System.Private.CoreLib.csproj +++ b/src/System.Private.CoreLib/System.Private.CoreLib.csproj @@ -294,6 +294,7 @@ + diff --git a/src/System.Private.CoreLib/src/Internal/Runtime/InteropServices/WindowsRuntime/ActivationFactoryLoader.cs b/src/System.Private.CoreLib/src/Internal/Runtime/InteropServices/WindowsRuntime/ActivationFactoryLoader.cs new file mode 100644 index 0000000000..eb1c584b6c --- /dev/null +++ b/src/System.Private.CoreLib/src/Internal/Runtime/InteropServices/WindowsRuntime/ActivationFactoryLoader.cs @@ -0,0 +1,74 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.IO; +using System.Reflection; +using System.Runtime.InteropServices; +using System.Runtime.InteropServices.WindowsRuntime; +using System.Runtime.Loader; + +namespace Internal.Runtime.InteropServices.WindowsRuntime +{ + internal static class ActivationFactoryLoader + { + // Collection of all ALCs used for WinRT activation. + // Since each of the assemblies that act as the "key" here are WinRT assemblies + // we don't need to share this dictionary with the COM activation dictionary + // since there will be no overlap. + private static Dictionary s_AssemblyLoadContexts = new Dictionary(StringComparer.InvariantCultureIgnoreCase); + + private static AssemblyLoadContext GetALC(string assemblyPath) + { + AssemblyLoadContext alc; + + lock (s_AssemblyLoadContexts) + { + if (!s_AssemblyLoadContexts.TryGetValue(assemblyPath, out alc)) + { + alc = new IsolatedComponentLoadContext(assemblyPath); + s_AssemblyLoadContexts.Add(assemblyPath, alc); + } + } + + return alc; + } + + /// Get a WinRT activation factory for a given type name. + /// The path to the WinRT component that the type is expected to be defined in. + /// The name of the component type to activate + /// The activation factory + public unsafe static int GetActivationFactory( + char* componentPath, + [MarshalAs(UnmanagedType.HString)] string typeName, + [MarshalAs(UnmanagedType.Interface)] out IActivationFactory activationFactory) + { + activationFactory = null; + try + { + if (typeName is null) + { + throw new ArgumentNullException(nameof(typeName)); + } + + AssemblyLoadContext context = GetALC(Marshal.PtrToStringUni((IntPtr)componentPath)); + + Type winRTType = context.LoadTypeForWinRTTypeNameInContext(typeName); + + if (winRTType is null || !winRTType.IsExportedToWindowsRuntime) + { + throw new TypeLoadException(typeName); + } + activationFactory = WindowsRuntimeMarshal.GetManagedActivationFactory(winRTType); + } + catch (Exception ex) + { + return ex.HResult; + } + return 0; + } + } +} diff --git a/src/System.Private.CoreLib/src/System/RtType.cs b/src/System.Private.CoreLib/src/System/RtType.cs index 3d03771258..c3e8d09066 100644 --- a/src/System.Private.CoreLib/src/System/RtType.cs +++ b/src/System.Private.CoreLib/src/System/RtType.cs @@ -3364,14 +3364,15 @@ namespace System #if FEATURE_COMINTEROP internal override bool IsWindowsRuntimeObjectImpl() => IsWindowsRuntimeObjectType(this); - internal override bool IsExportedToWindowsRuntimeImpl() => IsTypeExportedToWindowsRuntime(this); - [MethodImplAttribute(MethodImplOptions.InternalCall)] private static extern bool IsWindowsRuntimeObjectType(RuntimeType type); +#if FEATURE_COMINTEROP_WINRT_MANAGED_ACTIVATION + internal override bool IsExportedToWindowsRuntimeImpl() => IsTypeExportedToWindowsRuntime(this); + [MethodImplAttribute(MethodImplOptions.InternalCall)] private static extern bool IsTypeExportedToWindowsRuntime(RuntimeType type); - +#endif // FEATURE_COMINTEROP_WINRT_MANAGED_ACTIVATION #endif // FEATURE_COMINTEROP internal bool IsDelegate() => GetBaseType() == typeof(MulticastDelegate); diff --git a/src/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs b/src/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs index 61bef8e478..5cabe5158e 100644 --- a/src/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs +++ b/src/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs @@ -218,6 +218,26 @@ namespace System.Runtime.Loader return IntPtr.Zero; } + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] + private static extern void LoadTypeForWinRTTypeNameInContextInternal(IntPtr ptrNativeAssemblyLoadContext, string typeName, ObjectHandleOnStack loadedType); + + internal Type LoadTypeForWinRTTypeNameInContext(string typeName) + { + if (typeName is null) + { + throw new ArgumentNullException(nameof(typeName)); + } + + lock (_unloadLock) + { + VerifyIsAlive(); + + Type type = null; + LoadTypeForWinRTTypeNameInContextInternal(_nativeAssemblyLoadContext, typeName, JitHelpers.GetObjectHandleOnStack(ref type)); + return type; + } + } + [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)] private static extern IntPtr GetLoadContextForAssembly(RuntimeAssembly assembly); diff --git a/src/vm/appdomain.cpp b/src/vm/appdomain.cpp index ea69f41ee6..abb9ac15d6 100644 --- a/src/vm/appdomain.cpp +++ b/src/vm/appdomain.cpp @@ -5298,6 +5298,9 @@ PEAssembly * AppDomain::BindAssemblySpec( hr = BindAssemblySpecForHostedBinder(pSpec, pAssemblyName, m_pWinRtBinder, &pAssembly); if (FAILED(hr)) goto EndTry2; // Goto end of try block. + + PTR_CLRPrivAssemblyWinRT assem = dac_cast(pAssembly->GetHostAssembly()); + assem->SetFallbackBinder(pSpec->GetHostBinder()); EndTry2:; } // The combination of this conditional catch/ the following if statement which will throw reduces the count of exceptions diff --git a/src/vm/assemblynative.cpp b/src/vm/assemblynative.cpp index eed310aaa6..9c1e467f2f 100644 --- a/src/vm/assemblynative.cpp +++ b/src/vm/assemblynative.cpp @@ -426,6 +426,26 @@ void QCALLTYPE AssemblyNative::GetLocation(QCall::AssemblyHandle pAssembly, QCal END_QCALL; } + +#ifdef FEATURE_COMINTEROP_WINRT_MANAGED_ACTIVATION +void QCALLTYPE AssemblyNative::LoadTypeForWinRTTypeNameInContext(INT_PTR ptrAssemblyLoadContext, LPCWSTR pwzTypeName, QCall::ObjectHandleOnStack retType) +{ + QCALL_CONTRACT; + + BEGIN_QCALL; + + TypeHandle loadedType = WinRTTypeNameConverter::LoadManagedTypeForWinRTTypeName(pwzTypeName, (ICLRPrivBinder*)ptrAssemblyLoadContext, /* pbIsPrimitive */ nullptr); + + if (!loadedType.IsNull()) + { + GCX_COOP(); + retType.Set(loadedType.GetManagedClassObject()); + } + + END_QCALL; +} +#endif + void QCALLTYPE AssemblyNative::GetType(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, BOOL bThrowOnError, BOOL bIgnoreCase, QCall::ObjectHandleOnStack retType, QCall::ObjectHandleOnStack keepAlive) { CONTRACTL diff --git a/src/vm/assemblynative.hpp b/src/vm/assemblynative.hpp index 13db261359..0ce2fb2327 100644 --- a/src/vm/assemblynative.hpp +++ b/src/vm/assemblynative.hpp @@ -124,6 +124,9 @@ public: static void QCALLTYPE LoadFromInMemoryModule(INT_PTR ptrNativeAssemblyLoadContext, INT_PTR hModule, QCall::ObjectHandleOnStack retLoadedAssembly); #endif static Assembly* LoadFromPEImage(ICLRPrivBinder* pBinderContext, PEImage *pILImage, PEImage *pNIImage); +#ifdef FEATURE_COMINTEROP_WINRT_MANAGED_ACTIVATION + static void QCALLTYPE LoadTypeForWinRTTypeNameInContext(INT_PTR ptrAssemblyLoadContext, LPCWSTR pwzTypeName, QCall::ObjectHandleOnStack retType); +#endif static INT_PTR QCALLTYPE GetLoadContextForAssembly(QCall::AssemblyHandle pAssembly); static BOOL QCALLTYPE InternalTryGetRawMetadata(QCall::AssemblyHandle assembly, UINT8 **blobRef, INT32 *lengthRef); diff --git a/src/vm/assemblyspec.cpp b/src/vm/assemblyspec.cpp index a2323afe6b..a044456ff9 100644 --- a/src/vm/assemblyspec.cpp +++ b/src/vm/assemblyspec.cpp @@ -870,8 +870,18 @@ ICLRPrivBinder* AssemblySpec::GetBindingContextFromParentAssembly(AppDomain *pDo // types being referenced from Windows.Foundation.Winmd). // // If the AssemblySpec does not correspond to WinRT type but our parent assembly binder is a WinRT binder, - // then such an assembly will not be found by the binder. In such a case, we reset our binder reference. + // then such an assembly will not be found by the binder. + // In such a case, the parent binder should be the fallback binder for the WinRT assembly if one exists. + ICLRPrivBinder* pParentWinRTBinder = pParentAssemblyBinder; pParentAssemblyBinder = NULL; + ReleaseHolder assembly; + if (SUCCEEDED(pParentWinRTBinder->QueryInterface(&assembly))) + { + pParentAssemblyBinder = dac_cast(assembly.GetValue())->GetFallbackBinder(); + + // The fallback binder should not be a WinRT binder. + _ASSERTE(!AreSameBinderInstance(pWinRTBinder, pParentAssemblyBinder)); + } } } #endif // defined(FEATURE_COMINTEROP) diff --git a/src/vm/clrprivbinderwinrt.cpp b/src/vm/clrprivbinderwinrt.cpp index 2441dae399..83cdf88473 100644 --- a/src/vm/clrprivbinderwinrt.cpp +++ b/src/vm/clrprivbinderwinrt.cpp @@ -985,7 +985,8 @@ CLRPrivAssemblyWinRT::CLRPrivAssemblyWinRT( m_pIResourceNI(nullptr), m_pIBindResult(nullptr), m_fShareable(fShareable), - m_dwImageTypes(0) + m_dwImageTypes(0), + m_FallbackBinder(nullptr) { STANDARD_VM_CONTRACT; VALIDATE_ARG_THROW((pBinder != nullptr) && (pResourceIL != nullptr) && (pIBindResult != nullptr)); diff --git a/src/vm/clrprivbinderwinrt.h b/src/vm/clrprivbinderwinrt.h index e9cc1dfe9a..da6f0d53f7 100644 --- a/src/vm/clrprivbinderwinrt.h +++ b/src/vm/clrprivbinderwinrt.h @@ -323,6 +323,16 @@ public: DWORD dwImageType, DWORD * pdwImageType, ICLRPrivResource ** ppIResource); + + void SetFallbackBinder(ICLRPrivBinder* fallbackBinder) + { + m_FallbackBinder = clr::SafeAddRef(fallbackBinder); + } + + ICLRPrivBinder* GetFallbackBinder() + { + return m_FallbackBinder; + } private: //============================================================================================= @@ -336,4 +346,5 @@ private: ReleaseHolder m_pIBindResult; BOOL m_fShareable; Volatile m_dwImageTypes; + ReleaseHolder m_FallbackBinder; }; // class CLRPrivAssemblyWinRT diff --git a/src/vm/corhost.cpp b/src/vm/corhost.cpp index 8255f9aa4b..b42fc28a85 100644 --- a/src/vm/corhost.cpp +++ b/src/vm/corhost.cpp @@ -2410,7 +2410,7 @@ HRESULT STDMETHODCALLTYPE DllGetActivationFactoryImpl(LPCWSTR wszAssemblyName, GCX_COOP(); bool bIsPrimitive; - TypeHandle typeHandle = WinRTTypeNameConverter::GetManagedTypeFromWinRTTypeName(wszTypeName, &bIsPrimitive); + TypeHandle typeHandle = WinRTTypeNameConverter::LoadManagedTypeForWinRTTypeName(wszTypeName, /* pLoadBinder */ nullptr, &bIsPrimitive); if (!bIsPrimitive && !typeHandle.IsNull() && !typeHandle.IsTypeDesc() && typeHandle.AsMethodTable()->IsExportedToWinRT()) { struct _gc { diff --git a/src/vm/ecalllist.h b/src/vm/ecalllist.h index ae98cff196..7f617caca5 100644 --- a/src/vm/ecalllist.h +++ b/src/vm/ecalllist.h @@ -520,6 +520,9 @@ FCFuncStart(gAssemblyLoadContextFuncs) QCFuncElement("LoadFromPath", AssemblyNative::LoadFromPath) QCFuncElement("InternalLoadUnmanagedDllFromPath", AssemblyNative::InternalLoadUnmanagedDllFromPath) QCFuncElement("LoadFromStream", AssemblyNative::LoadFromStream) +#ifdef FEATURE_COMINTEROP_WINRT_MANAGED_ACTIVATION + QCFuncElement("LoadTypeForWinRTTypeNameInContextInternal", AssemblyNative::LoadTypeForWinRTTypeNameInContext) +#endif #ifndef FEATURE_PAL QCFuncElement("LoadFromInMemoryModuleInternal", AssemblyNative::LoadFromInMemoryModule) #endif diff --git a/src/vm/interoputil.cpp b/src/vm/interoputil.cpp index 5c000569d6..7cca714a14 100644 --- a/src/vm/interoputil.cpp +++ b/src/vm/interoputil.cpp @@ -5103,7 +5103,7 @@ void InitializeComInterop() } // Try to load a WinRT type. -TypeHandle GetWinRTType(SString* ssTypeName, BOOL bThrowIfNotFound) +TypeHandle LoadWinRTType(SString* ssTypeName, BOOL bThrowIfNotFound, ICLRPrivBinder* loadBinder /* =nullptr */) { CONTRACT (TypeHandle) { @@ -5116,8 +5116,8 @@ TypeHandle GetWinRTType(SString* ssTypeName, BOOL bThrowIfNotFound) TypeHandle typeHandle; SString ssAssemblyName(SString::Utf8Literal, "WindowsRuntimeAssemblyName, ContentType=WindowsRuntime"); - DomainAssembly *pAssembly = LoadDomainAssembly(&ssAssemblyName, NULL, - NULL, + DomainAssembly *pAssembly = LoadDomainAssembly(&ssAssemblyName, nullptr, + loadBinder, bThrowIfNotFound, ssTypeName); if (pAssembly != NULL) { @@ -6669,7 +6669,7 @@ TypeHandle GetClassFromIInspectable(IUnknown* pUnk, bool *pfSupportsIInspectable EX_TRY { LPCWSTR pszWinRTTypeName = (ssTmpClassName.IsEmpty() ? ssClassName : ssTmpClassName); - classTypeHandle = WinRTTypeNameConverter::GetManagedTypeFromWinRTTypeName(pszWinRTTypeName, /*pbIsPrimitive = */ NULL); + classTypeHandle = WinRTTypeNameConverter::LoadManagedTypeForWinRTTypeName(pszWinRTTypeName, /* pLoadBinder */ nullptr, /*pbIsPrimitive = */ nullptr); } EX_CATCH { diff --git a/src/vm/interoputil.h b/src/vm/interoputil.h index 872848b9df..311cedd102 100644 --- a/src/vm/interoputil.h +++ b/src/vm/interoputil.h @@ -443,7 +443,7 @@ MethodTable* GetClassFromIProvideClassInfo(IUnknown* pUnk); //-------------------------------------------------------------------------------- // Try to load a WinRT type. -TypeHandle GetWinRTType(SString* ssTypeName, BOOL bThrowIfNotFound); +TypeHandle LoadWinRTType(SString* ssTypeName, BOOL bThrowIfNotFound, ICLRPrivBinder* loadBinder = nullptr); //-------------------------------------------------------------------------------- // Try to get the class from IInspectable. diff --git a/src/vm/runtimecallablewrapper.cpp b/src/vm/runtimecallablewrapper.cpp index 48554086da..540536ef5f 100644 --- a/src/vm/runtimecallablewrapper.cpp +++ b/src/vm/runtimecallablewrapper.cpp @@ -911,7 +911,7 @@ void WinRTClassFactory::Init() IfFailThrow(cap.GetNonNullString(&szFactoryInterfaceName, &cbFactoryInterfaceName)); StackSString strFactoryInterface(SString::Utf8, szFactoryInterfaceName, cbFactoryInterfaceName); - MethodTable *pMTFactoryInterface = GetWinRTType(&strFactoryInterface, /* bThrowIfNotFound = */ TRUE).GetMethodTable(); + MethodTable *pMTFactoryInterface = LoadWinRTType(&strFactoryInterface, /* bThrowIfNotFound = */ TRUE).GetMethodTable(); _ASSERTE(pMTFactoryInterface); m_factoryInterfaces.Append(pMTFactoryInterface); @@ -951,7 +951,7 @@ void WinRTClassFactory::Init() // copy the name to a temporary buffer and NULL terminate it StackSString ss(SString::Utf8, szName, cbName); - TypeHandle th = GetWinRTType(&ss, /* bThrowIfNotFound = */ TRUE); + TypeHandle th = LoadWinRTType(&ss, /* bThrowIfNotFound = */ TRUE); MethodTable *pMTStaticInterface = th.GetMethodTable(); m_staticInterfaces.Append(pMTStaticInterface); diff --git a/src/vm/runtimehandles.cpp b/src/vm/runtimehandles.cpp index 083423b025..9acb47f195 100644 --- a/src/vm/runtimehandles.cpp +++ b/src/vm/runtimehandles.cpp @@ -384,6 +384,7 @@ FCIMPL1(FC_BOOL_RET, RuntimeTypeHandle::IsWindowsRuntimeObjectType, ReflectClass } FCIMPLEND +#ifdef FEATURE_COMINTEROP_WINRT_MANAGED_ACTIVATION FCIMPL1(FC_BOOL_RET, RuntimeTypeHandle::IsTypeExportedToWindowsRuntime, ReflectClassBaseObject *rtTypeUNSAFE) { FCALL_CONTRACT; @@ -401,6 +402,7 @@ FCIMPL1(FC_BOOL_RET, RuntimeTypeHandle::IsTypeExportedToWindowsRuntime, ReflectC FC_RETURN_BOOL(isExportedToWinRT); } FCIMPLEND +#endif #endif // FEATURE_COMINTEROP NOINLINE static MethodDesc * RestoreMethodHelper(MethodDesc * pMethod, LPVOID __me) diff --git a/src/vm/runtimehandles.h b/src/vm/runtimehandles.h index 1db16917fc..4c2ebdf52d 100644 --- a/src/vm/runtimehandles.h +++ b/src/vm/runtimehandles.h @@ -160,8 +160,10 @@ public: #ifdef FEATURE_COMINTEROP static FCDECL1(FC_BOOL_RET, IsWindowsRuntimeObjectType, ReflectClassBaseObject *rtTypeUNSAFE); +#ifdef FEATURE_COMINTEROP_WINRT_MANAGED_ACTIVATION static FCDECL1(FC_BOOL_RET, IsTypeExportedToWindowsRuntime, ReflectClassBaseObject *rtTypeUNSAFE); -#endif // FEATURE_COMINTEROP +#endif +#endif //FEATURE_COMINTEROP static void QCALLTYPE PrepareMemberInfoCache(EnregisteredTypeHandle pMemberInfoCache); diff --git a/src/vm/stdinterfaces.cpp b/src/vm/stdinterfaces.cpp index 1a9d0e2db1..15da1c8c22 100644 --- a/src/vm/stdinterfaces.cpp +++ b/src/vm/stdinterfaces.cpp @@ -3121,7 +3121,7 @@ HRESULT __stdcall IStringable_ToString(IUnknown* pStringable, // Get the MethodTable for Windows.Foundation.IStringable. StackSString strIStringable(SString::Utf8, W("Windows.Foundation.IStringable")); - MethodTable *pMTIStringable = GetWinRTType(&strIStringable, /* bThrowIfNotFound = */ FALSE).GetMethodTable(); + MethodTable *pMTIStringable = LoadWinRTType(&strIStringable, /* bThrowIfNotFound = */ FALSE).GetMethodTable(); if (pMT != NULL && pMTIStringable != NULL && pMT->ImplementsInterface(pMTIStringable)) { diff --git a/src/vm/stubhelpers.cpp b/src/vm/stubhelpers.cpp index 72265b0584..9cd2cf927c 100644 --- a/src/vm/stubhelpers.cpp +++ b/src/vm/stubhelpers.cpp @@ -705,6 +705,9 @@ FCIMPL4(IUnknown*, StubHelpers::InterfaceMarshaler__ConvertToNative, Object* pOb // This is only called in IL stubs which are in CER, so we don't need to worry about ThreadAbort HELPER_METHOD_FRAME_BEGIN_RET_ATTRIB_1(Frame::FRAME_ATTR_NO_THREAD_ABORT, pObj); + // We're going to be making some COM calls, better initialize COM. + EnsureComStarted(); + pIntf = MarshalObjectToInterface(&pObj, pItfMT, pClsMT, dwFlags); // No exception will be thrown here (including thread abort as it is delayed in IL stubs) @@ -725,6 +728,9 @@ FCIMPL4(Object*, StubHelpers::InterfaceMarshaler__ConvertToManaged, IUnknown **p OBJECTREF pObj = NULL; HELPER_METHOD_FRAME_BEGIN_RET_1(pObj); + + // We're going to be making some COM calls, better initialize COM. + EnsureComStarted(); UnmarshalObjectFromInterface(&pObj, ppUnk, pItfMT, pClsMT, dwFlags); @@ -893,7 +899,7 @@ FCIMPL2(ReflectClassBaseObject *, StubHelpers::WinRTTypeNameConverter__GetTypeFr HELPER_METHOD_FRAME_BEGIN_RET_2(refClass, refString); bool isPrimitive; - TypeHandle th = WinRTTypeNameConverter::GetManagedTypeFromWinRTTypeName(refString->GetBuffer(), &isPrimitive); + TypeHandle th = WinRTTypeNameConverter::LoadManagedTypeForWinRTTypeName(refString->GetBuffer(), /* pLoadBinder */ nullptr, &isPrimitive); *pbIsPrimitive = isPrimitive; refClass = th.GetManagedClassObject(); diff --git a/src/vm/winrttypenameconverter.cpp b/src/vm/winrttypenameconverter.cpp index e30128b5df..e9fd3c7ea0 100644 --- a/src/vm/winrttypenameconverter.cpp +++ b/src/vm/winrttypenameconverter.cpp @@ -828,7 +828,7 @@ bool WinRTTypeNameConverter::IsRedirectedWinRTSourceType(MethodTable *pMT) // Get TypeHandle from a WinRT type name // Parse the WinRT type name in the form of WinRTType=TypeName[] // -TypeHandle WinRTTypeNameConverter::GetManagedTypeFromWinRTTypeName(LPCWSTR wszWinRTTypeName, bool *pbIsPrimitive) +TypeHandle WinRTTypeNameConverter::LoadManagedTypeForWinRTTypeName(LPCWSTR wszWinRTTypeName, ICLRPrivBinder * loadBinder, bool *pbIsPrimitive) { CONTRACTL { @@ -842,7 +842,7 @@ TypeHandle WinRTTypeNameConverter::GetManagedTypeFromWinRTTypeName(LPCWSTR wszWi SString ssTypeName(SString::Literal, wszWinRTTypeName); - TypeHandle th = GetManagedTypeFromWinRTTypeNameInternal(&ssTypeName, pbIsPrimitive); + TypeHandle th = LoadManagedTypeForWinRTTypeNameInternal(&ssTypeName, loadBinder, pbIsPrimitive); if (th.IsNull()) { COMPlusThrowArgumentException(W("typeName"), NULL); @@ -900,7 +900,7 @@ extern "C" HRESULT WINAPI CrossgenRoParseTypeName(SString* typeName, DWORD *part // Return TypeHandle for the specified WinRT type name (supports generic type) // Updates wszWinRTTypeName pointer as it parse the string // -TypeHandle WinRTTypeNameConverter::GetManagedTypeFromWinRTTypeNameInternal(SString *ssTypeName, bool *pbIsPrimitive) +TypeHandle WinRTTypeNameConverter::LoadManagedTypeForWinRTTypeNameInternal(SString *ssTypeName, ICLRPrivBinder* loadBinder, bool *pbIsPrimitive) { CONTRACTL { @@ -944,7 +944,7 @@ TypeHandle WinRTTypeNameConverter::GetManagedTypeFromWinRTTypeNameInternal(SStri PCWSTR wszPart = WindowsGetStringRawBuffer(rhsPartNames[i], &cchPartLength); StackSString ssPartName(wszPart, cchPartLength); - rqPartTypes[i] = GetManagedTypeFromSimpleWinRTNameInternal(&ssPartName, NULL); + rqPartTypes[i] = GetManagedTypeFromSimpleWinRTNameInternal(&ssPartName, loadBinder, nullptr); } #else //CROSSGEN_COMPILE @@ -963,7 +963,7 @@ TypeHandle WinRTTypeNameConverter::GetManagedTypeFromWinRTTypeNameInternal(SStri // load the components for (DWORD i = 0; i < dwPartsCount; i++) { - rqPartTypes[i] = GetManagedTypeFromSimpleWinRTNameInternal(&rhsPartNames[i], NULL); + rqPartTypes[i] = GetManagedTypeFromSimpleWinRTNameInternal(&rhsPartNames[i], loadBinder, NULL); } delete[] rhsPartNames; @@ -980,7 +980,7 @@ TypeHandle WinRTTypeNameConverter::GetManagedTypeFromWinRTTypeNameInternal(SStri } else { - return GetManagedTypeFromSimpleWinRTNameInternal(ssTypeName, pbIsPrimitive); + return GetManagedTypeFromSimpleWinRTNameInternal(ssTypeName, loadBinder, pbIsPrimitive); } } @@ -988,7 +988,7 @@ TypeHandle WinRTTypeNameConverter::GetManagedTypeFromWinRTTypeNameInternal(SStri // Return MethodTable* for the specified WinRT primitive type name (non-generic type) // Updates wszWinRTTypeName pointer as it parse the string // -TypeHandle WinRTTypeNameConverter::GetManagedTypeFromSimpleWinRTNameInternal(SString *ssTypeName, bool *pbIsPrimitive) +TypeHandle WinRTTypeNameConverter::GetManagedTypeFromSimpleWinRTNameInternal(SString *ssTypeName, ICLRPrivBinder* loadBinder, bool *pbIsPrimitive) { CONTRACTL { @@ -1042,7 +1042,7 @@ TypeHandle WinRTTypeNameConverter::GetManagedTypeFromSimpleWinRTNameInternal(SSt // // A regular WinRT type // - return GetWinRTType(ssTypeName, TRUE); + return LoadWinRTType(ssTypeName, TRUE, loadBinder); } } diff --git a/src/vm/winrttypenameconverter.h b/src/vm/winrttypenameconverter.h index c3d139d87a..28dd3b6f7c 100644 --- a/src/vm/winrttypenameconverter.h +++ b/src/vm/winrttypenameconverter.h @@ -17,6 +17,7 @@ #pragma once #include "..\md\winmd\inc\adapter.h" +#include "clrprivbinding.h" struct WinRTTypeNameInfo; @@ -90,7 +91,7 @@ public : // Get TypeHandle from a WinRT type name // Parse the WinRT type name in the form of WinRTType=TypeName[] // - static TypeHandle GetManagedTypeFromWinRTTypeName(LPCWSTR wszWinRTTypeName, bool *pbIsPrimitive); + static TypeHandle LoadManagedTypeForWinRTTypeName(LPCWSTR wszWinRTTypeName, ICLRPrivBinder * loadBinder, bool *pbIsPrimitive); private : @@ -108,13 +109,13 @@ private : // Return TypeHandle for the specified WinRT type name (supports generic type) // Updates wszWinRTTypeName pointer as it parse the string // - static TypeHandle GetManagedTypeFromWinRTTypeNameInternal(SString *ssTypeName, bool *pbIsPrimitive); + static TypeHandle LoadManagedTypeForWinRTTypeNameInternal(SString *ssTypeName, ICLRPrivBinder* loadBinder, bool *pbIsPrimitive); // // Return MethodTable* for the specified WinRT primitive type name (non-generic type) // Updates wszWinRTTypeName pointer as it parse the string // - static TypeHandle GetManagedTypeFromSimpleWinRTNameInternal(SString *ssTypeName, bool *pbIsPrimitive); + static TypeHandle GetManagedTypeFromSimpleWinRTNameInternal(SString *ssTypeName, ICLRPrivBinder* loadBinder, bool *pbIsPrimitive); static bool AppendWinRTTypeNameForManagedType( TypeHandle thManagedType, -- cgit v1.2.3