ipc/mscom/AgileReference.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef mozilla_mscom_AgileReference_h
   8 #define mozilla_mscom_AgileReference_h
   9
  10 #include "mozilla/Attributes.h"
  11 #include "mozilla/RefPtr.h"
  12 #include "nsISupportsImpl.h"
  13
  14 #include <objidl.h>
  15
  16 namespace mozilla {
  17 namespace mscom {
  18 namespace detail {
  19
  20 class MOZ_HEAP_CLASS GlobalInterfaceTableCookie final {
  21  public:
  22   GlobalInterfaceTableCookie(IUnknown* aObject, REFIID aIid,
  23                              HRESULT& aOutHResult);
  24
  25   bool IsValid() const { return !!mCookie; }
  26   HRESULT GetInterface(REFIID aIid, void** aOutInterface) const;
  27
  28   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(GlobalInterfaceTableCookie)
  29
  30   GlobalInterfaceTableCookie(const GlobalInterfaceTableCookie&) = delete;
  31   GlobalInterfaceTableCookie(GlobalInterfaceTableCookie&&) = delete;
  32
  33   GlobalInterfaceTableCookie& operator=(const GlobalInterfaceTableCookie&) =
  34       delete;
  35   GlobalInterfaceTableCookie& operator=(GlobalInterfaceTableCookie&&) = delete;
  36
  37  private:
  38   ~GlobalInterfaceTableCookie();
  39
  40  private:
  41   DWORD mCookie;
  42
  43  private:
  44   static IGlobalInterfaceTable* ObtainGit();
  45 };
  46
  47 }  // namespace detail
  48
  49 /**
  50  * This class encapsulates an "agile reference." These are references that
  51  * allow you to pass COM interfaces between apartments. When you have an
  52  * interface that you would like to pass between apartments, you wrap that
  53  * interface in an AgileReference and pass the agile reference instead. Then
  54  * you unwrap the interface by calling AgileReference::Resolve.
  55  *
  56  * Sample usage:
  57  *
  58  * // In the multithreaded apartment, foo is an IFoo*
  59  * auto myAgileRef = MakeUnique<AgileReference>(IID_IFoo, foo);
  60  *
  61  * // myAgileRef is passed to our main thread, which runs in a single-threaded
  62  * // apartment:
  63  *
  64  * RefPtr<IFoo> foo;
  65  * HRESULT hr = myAgileRef->Resolve(IID_IFoo, getter_AddRefs(foo));
  66  * // Now foo may be called from the main thread
  67  */
  68 class AgileReference final {
  69  public:
  70   AgileReference();
  71
  72   template <typename InterfaceT>
  73   explicit AgileReference(RefPtr<InterfaceT>& aObject)
  74       : AgileReference(__uuidof(InterfaceT), aObject) {}
  75
  76   AgileReference(REFIID aIid, IUnknown* aObject);
  77
  78   AgileReference(const AgileReference& aOther) = default;
  79   AgileReference(AgileReference&& aOther);
  80
  81   ~AgileReference();
  82
  83   explicit operator bool() const {
  84     return mAgileRef || (mGitCookie && mGitCookie->IsValid());
  85   }
  86
  87   HRESULT GetHResult() const { return mHResult; }
  88
  89   template <typename T>
  90   void Assign(const RefPtr<T>& aOther) {
  91     Assign(__uuidof(T), aOther);
  92   }
  93
  94   template <typename T>
  95   AgileReference& operator=(const RefPtr<T>& aOther) {
  96     Assign(aOther);
  97     return *this;
  98   }
  99
 100   HRESULT Resolve(REFIID aIid, void** aOutInterface) const;
 101
 102   AgileReference& operator=(const AgileReference& aOther);
 103   AgileReference& operator=(AgileReference&& aOther);
 104
 105   AgileReference& operator=(decltype(nullptr)) {
 106     Clear();
 107     return *this;
 108   }
 109
 110   void Clear();
 111
 112  private:
 113   void Assign(REFIID aIid, IUnknown* aObject);
 114   void AssignInternal(IUnknown* aObject);
 115
 116  private:
 117   IID mIid;
 118   RefPtr<IAgileReference> mAgileRef;
 119   RefPtr<detail::GlobalInterfaceTableCookie> mGitCookie;
 120   HRESULT mHResult;
 121 };
 122
 123 }  // namespace mscom
 124 }  // namespace mozilla
 125
 126 template <typename T>
 127 RefPtr<T>::RefPtr(const mozilla::mscom::AgileReference& aAgileRef)
 128     : mRawPtr(nullptr) {
 129   (*this) = aAgileRef;
 130 }
 131
 132 template <typename T>
 133 RefPtr<T>& RefPtr<T>::operator=(
 134     const mozilla::mscom::AgileReference& aAgileRef) {
 135   void* newRawPtr;
 136   if (FAILED(aAgileRef.Resolve(__uuidof(T), &newRawPtr))) {
 137     newRawPtr = nullptr;
 138   }
 139   assign_assuming_AddRef(static_cast<T*>(newRawPtr));
 140   return *this;
 141 }
 142
 143 #endif  // mozilla_mscom_AgileReference_h