mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-30 05:35:31 +00:00
68316b419c
CLOSED TREE Backed out changeset 729a1b8c7e47 (bug1303060) Backed out changeset 604605ca738c (bug1303060)
126 lines
4.3 KiB
C++
126 lines
4.3 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* 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/. */
|
|
|
|
#ifndef mozilla_mscom_interceptor_h
|
|
#define mozilla_mscom_interceptor_h
|
|
|
|
#include "mozilla/Move.h"
|
|
#include "mozilla/Mutex.h"
|
|
#include "nsTArray.h"
|
|
#include "mozilla/mscom/Ptr.h"
|
|
#include "mozilla/mscom/WeakRef.h"
|
|
#include "mozilla/RefPtr.h"
|
|
|
|
#include <callobj.h>
|
|
|
|
namespace mozilla {
|
|
namespace mscom {
|
|
|
|
// {8831EB53-A937-42BC-9921-B3E1121FDF86}
|
|
DEFINE_GUID(IID_IInterceptorSink,
|
|
0x8831eb53, 0xa937, 0x42bc, 0x99, 0x21, 0xb3, 0xe1, 0x12, 0x1f, 0xdf, 0x86);
|
|
|
|
struct IInterceptorSink : public ICallFrameEvents
|
|
{
|
|
virtual STDMETHODIMP SetInterceptor(IWeakReference* aInterceptor) = 0;
|
|
};
|
|
|
|
// {3710799B-ECA2-4165-B9B0-3FA1E4A9B230}
|
|
DEFINE_GUID(IID_IInterceptor,
|
|
0x3710799b, 0xeca2, 0x4165, 0xb9, 0xb0, 0x3f, 0xa1, 0xe4, 0xa9, 0xb2, 0x30);
|
|
|
|
struct IInterceptor : public IUnknown
|
|
{
|
|
virtual STDMETHODIMP GetTargetForIID(REFIID aIid, InterceptorTargetPtr& aTarget) = 0;
|
|
virtual STDMETHODIMP GetInterceptorForIID(REFIID aIid,
|
|
void** aOutInterceptor) = 0;
|
|
};
|
|
|
|
/**
|
|
* The COM interceptor is the core functionality in mscom that allows us to
|
|
* redirect method calls to different threads. It emulates the vtable of a
|
|
* target interface. When a call is made on this emulated vtable, the call is
|
|
* packaged up into an instance of the ICallFrame interface which may be passed
|
|
* to other contexts for execution.
|
|
*
|
|
* In order to accomplish this, COM itself provides the CoGetInterceptor
|
|
* function, which instantiates an ICallInterceptor. Note, however, that
|
|
* ICallInterceptor only works on a single interface; we need to be able to
|
|
* interpose QueryInterface calls so that we can instantiate a new
|
|
* ICallInterceptor for each new interface that is requested.
|
|
*
|
|
* We accomplish this by using COM aggregation, which means that the
|
|
* ICallInterceptor delegates its IUnknown implementation to its outer object
|
|
* (the mscom::Interceptor we implement and control).
|
|
*/
|
|
class Interceptor final : public WeakReferenceSupport
|
|
, public IInterceptor
|
|
{
|
|
public:
|
|
static HRESULT Create(STAUniquePtr<IUnknown> aTarget, IInterceptorSink* aSink,
|
|
REFIID aIid, void** aOutput);
|
|
|
|
// IUnknown
|
|
STDMETHODIMP QueryInterface(REFIID riid, void** ppv) override;
|
|
STDMETHODIMP_(ULONG) AddRef() override;
|
|
STDMETHODIMP_(ULONG) Release() override;
|
|
|
|
// IInterceptor
|
|
STDMETHODIMP GetTargetForIID(REFIID aIid, InterceptorTargetPtr& aTarget) override;
|
|
STDMETHODIMP GetInterceptorForIID(REFIID aIid, void** aOutInterceptor) override;
|
|
|
|
private:
|
|
struct MapEntry
|
|
{
|
|
MapEntry(REFIID aIid, IUnknown* aInterceptor, IUnknown* aTargetInterface)
|
|
: mIID(aIid)
|
|
, mInterceptor(aInterceptor)
|
|
, mTargetInterface(aTargetInterface)
|
|
{}
|
|
IID mIID;
|
|
RefPtr<IUnknown> mInterceptor;
|
|
IUnknown* mTargetInterface;
|
|
};
|
|
|
|
private:
|
|
Interceptor(STAUniquePtr<IUnknown> aTarget, IInterceptorSink* aSink);
|
|
~Interceptor();
|
|
MapEntry* Lookup(REFIID aIid);
|
|
HRESULT QueryInterfaceTarget(REFIID aIid, void** aOutput);
|
|
HRESULT ThreadSafeQueryInterface(REFIID aIid,
|
|
IUnknown** aOutInterface) override;
|
|
HRESULT CreateInterceptor(REFIID aIid, IUnknown* aOuter, IUnknown** aOutput);
|
|
|
|
private:
|
|
STAUniquePtr<IUnknown> mTarget;
|
|
RefPtr<IInterceptorSink> mEventSink;
|
|
mozilla::Mutex mMutex; // Guards mInterceptorMap
|
|
// Using a nsTArray since the # of interfaces is not going to be very high
|
|
nsTArray<MapEntry> mInterceptorMap;
|
|
};
|
|
|
|
template <typename InterfaceT>
|
|
inline HRESULT
|
|
CreateInterceptor(STAUniquePtr<InterfaceT> aTargetInterface,
|
|
IInterceptorSink* aEventSink,
|
|
InterfaceT** aOutInterface)
|
|
{
|
|
if (!aTargetInterface || !aEventSink) {
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
REFIID iidTarget = __uuidof(aTargetInterface);
|
|
|
|
STAUniquePtr<IUnknown> targetUnknown(aTargetInterface.release());
|
|
return Interceptor::Create(Move(targetUnknown), aEventSink, iidTarget,
|
|
(void**)aOutInterface);
|
|
}
|
|
|
|
} // namespace mscom
|
|
} // namespace mozilla
|
|
|
|
#endif // mozilla_mscom_interceptor_h
|