xpcom/base/nsISupportsImpl.cpp

   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 #include "nsISupportsImpl.h"
   8
   9 #include "mozilla/Assertions.h"
  10 #ifndef XPCOM_GLUE_AVOID_NSPR
  11 #  include "nsPrintfCString.h"
  12 #  include "nsThreadUtils.h"
  13 #endif
  14
  15 using namespace mozilla;
  16
  17 nsresult NS_FASTCALL NS_TableDrivenQI(void* aThis, REFNSIID aIID,
  18                                       void** aInstancePtr,
  19                                       const QITableEntry* aEntries) {
  20   do {
  21     if (aIID.Equals(*aEntries->iid)) {
  22       nsISupports* r = reinterpret_cast<nsISupports*>(
  23           reinterpret_cast<char*>(aThis) + aEntries->offset);
  24       NS_ADDREF(r);
  25       *aInstancePtr = r;
  26       return NS_OK;
  27     }
  28
  29     ++aEntries;
  30   } while (aEntries->iid);
  31
  32   *aInstancePtr = nullptr;
  33   return NS_ERROR_NO_INTERFACE;
  34 }
  35
  36 #ifndef XPCOM_GLUE_AVOID_NSPR
  37 #  ifdef MOZ_THREAD_SAFETY_OWNERSHIP_CHECKS_SUPPORTED
  38 nsAutoOwningThread::nsAutoOwningThread() : mThread(PR_GetCurrentThread()) {}
  39
  40 void nsAutoOwningThread::AssertCurrentThreadOwnsMe(const char* msg) const {
  41   if (MOZ_UNLIKELY(!IsCurrentThread())) {
  42     // `msg` is a string literal by construction.
  43     MOZ_CRASH_UNSAFE(msg);
  44   }
  45 }
  46
  47 bool nsAutoOwningThread::IsCurrentThread() const {
  48   return mThread == PR_GetCurrentThread();
  49 }
  50
  51 nsAutoOwningEventTarget::nsAutoOwningEventTarget()
  52     : mTarget(GetCurrentSerialEventTarget()) {
  53   mTarget->AddRef();
  54 }
  55
  56 nsAutoOwningEventTarget::~nsAutoOwningEventTarget() {
  57   nsCOMPtr<nsISerialEventTarget> target = dont_AddRef(mTarget);
  58 }
  59
  60 void nsAutoOwningEventTarget ::AssertCurrentThreadOwnsMe(
  61     const char* msg) const {
  62   if (MOZ_UNLIKELY(!IsCurrentThread())) {
  63     // `msg` is a string literal by construction.
  64     MOZ_CRASH_UNSAFE(msg);
  65   }
  66 }
  67
  68 bool nsAutoOwningEventTarget::IsCurrentThread() const {
  69   return mTarget->IsOnCurrentThread();
  70 }
  71
  72 #  endif
  73
  74 namespace mozilla::detail {
  75 class ProxyDeleteVoidRunnable final : public CancelableRunnable {
  76  public:
  77   ProxyDeleteVoidRunnable(const char* aName, void* aPtr,
  78                           DeleteVoidFunction* aDeleteFunc)
  79       : CancelableRunnable(aName), mPtr(aPtr), mDeleteFunc(aDeleteFunc) {}
  80
  81   NS_IMETHOD Run() override {
  82     if (mPtr) {
  83       mDeleteFunc(mPtr);
  84       mPtr = nullptr;
  85     }
  86     return NS_OK;
  87   }
  88
  89   // Mimics the behaviour in `ProxyRelease`, freeing the resource when
  90   // cancelled.
  91   nsresult Cancel() override { return Run(); }
  92
  93 #  ifdef MOZ_COLLECTING_RUNNABLE_TELEMETRY
  94   NS_IMETHOD GetName(nsACString& aName) override {
  95     if (mName) {
  96       aName.Append(mName);
  97     } else {
  98       aName.AssignLiteral("ProxyDeleteVoidRunnable");
  99     }
 100     return NS_OK;
 101   }
 102 #  endif
 103
 104  private:
 105   ~ProxyDeleteVoidRunnable() {
 106     if (mPtr) {
 107 #  ifdef MOZ_COLLECTING_RUNNABLE_TELEMETRY
 108       NS_WARNING(
 109           nsPrintfCString(
 110               "ProxyDeleteVoidRunnable for '%s' never run, leaking!", mName)
 111               .get());
 112 #  else
 113       NS_WARNING("ProxyDeleteVoidRunnable never run, leaking!");
 114 #  endif
 115     }
 116   }
 117
 118   void* mPtr;
 119   DeleteVoidFunction* mDeleteFunc;
 120 };
 121
 122 void ProxyDeleteVoid(const char* aName, nsISerialEventTarget* aTarget,
 123                      void* aPtr, DeleteVoidFunction* aDeleteFunc) {
 124   MOZ_ASSERT(aName);
 125   MOZ_ASSERT(aPtr);
 126   MOZ_ASSERT(aDeleteFunc);
 127   if (!aTarget) {
 128     NS_WARNING(nsPrintfCString("no target for '%s', leaking!", aName).get());
 129     return;
 130   }
 131
 132   if (aTarget->IsOnCurrentThread()) {
 133     aDeleteFunc(aPtr);
 134     return;
 135   }
 136   nsresult rv = aTarget->Dispatch(
 137       MakeAndAddRef<ProxyDeleteVoidRunnable>(aName, aPtr, aDeleteFunc),
 138       NS_DISPATCH_NORMAL);
 139   if (NS_FAILED(rv)) {
 140     NS_WARNING(nsPrintfCString("failed to post '%s', leaking!", aName).get());
 141   }
 142 }
 143 }  // namespace mozilla::detail
 144 #endif