netwerk/ipc/ChannelEventQueue.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * vim: set sw=2 ts=8 et tw=80 :
   3  */
   4 /* This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   7
   8 #ifndef mozilla_net_ChannelEventQueue_h
   9 #define mozilla_net_ChannelEventQueue_h
  10
  11 #include "nsTArray.h"
  12 #include "nsIEventTarget.h"
  13 #include "nsThreadUtils.h"
  14 #include "nsXULAppAPI.h"
  15 #include "mozilla/DebugOnly.h"
  16 #include "mozilla/Mutex.h"
  17 #include "mozilla/RecursiveMutex.h"
  18 #include "mozilla/UniquePtr.h"
  19 #include "mozilla/Unused.h"
  20
  21 class nsISupports;
  22
  23 namespace mozilla {
  24 namespace net {
  25
  26 class ChannelEvent {
  27  public:
  28   MOZ_COUNTED_DEFAULT_CTOR(ChannelEvent)
  29   MOZ_COUNTED_DTOR_VIRTUAL(ChannelEvent) virtual void Run() = 0;
  30   virtual already_AddRefed<nsIEventTarget> GetEventTarget() = 0;
  31 };
  32
  33 // Note that MainThreadChannelEvent should not be used in child process since
  34 // GetEventTarget() directly returns an unlabeled event target.
  35 class MainThreadChannelEvent : public ChannelEvent {
  36  public:
  37   MOZ_COUNTED_DEFAULT_CTOR(MainThreadChannelEvent)
  38   MOZ_COUNTED_DTOR_OVERRIDE(MainThreadChannelEvent)
  39
  40   already_AddRefed<nsIEventTarget> GetEventTarget() override {
  41     MOZ_ASSERT(XRE_IsParentProcess());
  42
  43     return do_AddRef(GetMainThreadEventTarget());
  44   }
  45 };
  46
  47 class ChannelFunctionEvent : public ChannelEvent {
  48  public:
  49   ChannelFunctionEvent(
  50       std::function<already_AddRefed<nsIEventTarget>()>&& aGetEventTarget,
  51       std::function<void()>&& aCallback)
  52       : mGetEventTarget(std::move(aGetEventTarget)),
  53         mCallback(std::move(aCallback)) {}
  54
  55   void Run() override { mCallback(); }
  56   already_AddRefed<nsIEventTarget> GetEventTarget() override {
  57     return mGetEventTarget();
  58   }
  59
  60  private:
  61   const std::function<already_AddRefed<nsIEventTarget>()> mGetEventTarget;
  62   const std::function<void()> mCallback;
  63 };
  64
  65 // UnsafePtr is a work-around our static analyzer that requires all
  66 // ref-counted objects to be captured in lambda via a RefPtr
  67 // The ChannelEventQueue makes it safe to capture "this" by pointer only.
  68 // This is required as work-around to prevent cycles until bug 1596295
  69 // is resolved.
  70 template <typename T>
  71 class UnsafePtr {
  72  public:
  73   explicit UnsafePtr(T* aPtr) : mPtr(aPtr) {}
  74
  75   T& operator*() const { return *mPtr; }
  76   T* operator->() const {
  77     MOZ_ASSERT(mPtr, "dereferencing a null pointer");
  78     return mPtr;
  79   }
  80   operator T*() const& { return mPtr; }
  81   explicit operator bool() const { return mPtr != nullptr; }
  82
  83  private:
  84   T* const mPtr;
  85 };
  86
  87 class NeckoTargetChannelFunctionEvent : public ChannelFunctionEvent {
  88  public:
  89   template <typename T>
  90   NeckoTargetChannelFunctionEvent(T* aChild, std::function<void()>&& aCallback)
  91       : ChannelFunctionEvent(
  92             [child = UnsafePtr<T>(aChild)]() {
  93               MOZ_ASSERT(child);
  94               return child->GetNeckoTarget();
  95             },
  96             std::move(aCallback)) {}
  97 };
  98
  99 // Workaround for Necko re-entrancy dangers. We buffer IPDL messages in a
 100 // queue if still dispatching previous one(s) to listeners/observers.
 101 // Otherwise synchronous XMLHttpRequests and/or other code that spins the
 102 // event loop (ex: IPDL rpc) could cause listener->OnDataAvailable (for
 103 // instance) to be dispatched and called before mListener->OnStartRequest has
 104 // completed.
 105
 106 class ChannelEventQueue final {
 107   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(ChannelEventQueue)
 108
 109  public:
 110   explicit ChannelEventQueue(nsISupports* owner)
 111       : mSuspendCount(0),
 112         mSuspended(false),
 113         mForcedCount(0),
 114         mFlushing(false),
 115         mHasCheckedForXMLHttpRequest(false),
 116         mForXMLHttpRequest(false),
 117         mOwner(owner),
 118         mMutex("ChannelEventQueue::mMutex"),
 119         mRunningMutex("ChannelEventQueue::mRunningMutex") {}
 120
 121   // Puts IPDL-generated channel event into queue, to be run later
 122   // automatically when EndForcedQueueing and/or Resume is called.
 123   //
 124   // @param aCallback - the ChannelEvent
 125   // @param aAssertionWhenNotQueued - this optional param will be used in an
 126   //   assertion when the event is executed directly.
 127   inline void RunOrEnqueue(ChannelEvent* aCallback,
 128                            bool aAssertionWhenNotQueued = false);
 129
 130   // Append ChannelEvent in front of the event queue.
 131   inline void PrependEvent(UniquePtr<ChannelEvent>&& aEvent);
 132   inline void PrependEvents(nsTArray<UniquePtr<ChannelEvent>>& aEvents);
 133
 134   // After StartForcedQueueing is called, RunOrEnqueue() will start enqueuing
 135   // events that will be run/flushed when EndForcedQueueing is called.
 136   // - Note: queueing may still be required after EndForcedQueueing() (if the
 137   //   queue is suspended, etc):  always call RunOrEnqueue() to avoid race
 138   //   conditions.
 139   inline void StartForcedQueueing();
 140   inline void EndForcedQueueing();
 141
 142   // Suspend/resume event queue.  RunOrEnqueue() will start enqueuing
 143   // events and they will be run/flushed when resume is called.  These should be
 144   // called when the channel owning the event queue is suspended/resumed.
 145   void Suspend();
 146   // Resume flushes the queue asynchronously, i.e. items in queue will be
 147   // dispatched in a new event on the current thread.
 148   void Resume();
 149
 150 #ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
 151   bool IsEmpty() const { return mEventQueue.IsEmpty(); }
 152 #endif
 153
 154  private:
 155   // Private destructor, to discourage deletion outside of Release():
 156   ~ChannelEventQueue() = default;
 157
 158   void SuspendInternal();
 159   void ResumeInternal();
 160
 161   bool MaybeSuspendIfEventsAreSuppressed();
 162
 163   inline void MaybeFlushQueue();
 164   void FlushQueue();
 165   inline void CompleteResume();
 166
 167   ChannelEvent* TakeEvent();
 168
 169   nsTArray<UniquePtr<ChannelEvent>> mEventQueue;
 170
 171   uint32_t mSuspendCount;
 172   bool mSuspended;
 173   uint32_t mForcedCount;  // Support ForcedQueueing on multiple thread.
 174   bool mFlushing;
 175
 176   // Whether the queue is associated with an XHR. This is lazily instantiated
 177   // the first time it is needed.
 178   bool mHasCheckedForXMLHttpRequest;
 179   bool mForXMLHttpRequest;
 180
 181   // Keep ptr to avoid refcount cycle: only grab ref during flushing.
 182   nsISupports* mOwner;
 183
 184   // For atomic mEventQueue operation and state update
 185   Mutex mMutex;
 186
 187   // To guarantee event execution order among threads
 188   RecursiveMutex mRunningMutex;
 189
 190   friend class AutoEventEnqueuer;
 191 };
 192
 193 inline void ChannelEventQueue::RunOrEnqueue(ChannelEvent* aCallback,
 194                                             bool aAssertionWhenNotQueued) {
 195   MOZ_ASSERT(aCallback);
 196
 197   // Events execution could be a destruction of the channel (and our own
 198   // destructor) unless we make sure its refcount doesn't drop to 0 while this
 199   // method is running.
 200   nsCOMPtr<nsISupports> kungFuDeathGrip(mOwner);
 201   Unused << kungFuDeathGrip;  // Not used in this function
 202
 203   // To avoid leaks.
 204   UniquePtr<ChannelEvent> event(aCallback);
 205
 206   // To guarantee that the running event and all the events generated within
 207   // it will be finished before events on other threads.
 208   RecursiveMutexAutoLock lock(mRunningMutex);
 209
 210   {
 211     MutexAutoLock lock(mMutex);
 212
 213     bool enqueue = !!mForcedCount || mSuspended || mFlushing ||
 214                    !mEventQueue.IsEmpty() ||
 215                    MaybeSuspendIfEventsAreSuppressed();
 216
 217     if (enqueue) {
 218       mEventQueue.AppendElement(std::move(event));
 219       return;
 220     }
 221
 222     nsCOMPtr<nsIEventTarget> target = event->GetEventTarget();
 223     MOZ_ASSERT(target);
 224
 225     bool isCurrentThread = false;
 226     DebugOnly<nsresult> rv = target->IsOnCurrentThread(&isCurrentThread);
 227     MOZ_ASSERT(NS_SUCCEEDED(rv));
 228
 229     if (!isCurrentThread) {
 230       // Leverage Suspend/Resume mechanism to trigger flush procedure without
 231       // creating a new one.
 232       SuspendInternal();
 233       mEventQueue.AppendElement(std::move(event));
 234       ResumeInternal();
 235       return;
 236     }
 237   }
 238
 239   MOZ_RELEASE_ASSERT(!aAssertionWhenNotQueued);
 240   event->Run();
 241 }
 242
 243 inline void ChannelEventQueue::StartForcedQueueing() {
 244   MutexAutoLock lock(mMutex);
 245   ++mForcedCount;
 246 }
 247
 248 inline void ChannelEventQueue::EndForcedQueueing() {
 249   bool tryFlush = false;
 250   {
 251     MutexAutoLock lock(mMutex);
 252     MOZ_ASSERT(mForcedCount > 0);
 253     if (!--mForcedCount) {
 254       tryFlush = true;
 255     }
 256   }
 257
 258   if (tryFlush) {
 259     MaybeFlushQueue();
 260   }
 261 }
 262
 263 inline void ChannelEventQueue::PrependEvent(UniquePtr<ChannelEvent>&& aEvent) {
 264   MutexAutoLock lock(mMutex);
 265
 266   // Prepending event while no queue flush foreseen might cause the following
 267   // channel events not run. This assertion here guarantee there must be a
 268   // queue flush, either triggered by Resume or EndForcedQueueing, to execute
 269   // the added event.
 270   MOZ_ASSERT(mSuspended || !!mForcedCount);
 271
 272   mEventQueue.InsertElementAt(0, std::move(aEvent));
 273 }
 274
 275 inline void ChannelEventQueue::PrependEvents(
 276     nsTArray<UniquePtr<ChannelEvent>>& aEvents) {
 277   MutexAutoLock lock(mMutex);
 278
 279   // Prepending event while no queue flush foreseen might cause the following
 280   // channel events not run. This assertion here guarantee there must be a
 281   // queue flush, either triggered by Resume or EndForcedQueueing, to execute
 282   // the added events.
 283   MOZ_ASSERT(mSuspended || !!mForcedCount);
 284
 285   mEventQueue.InsertElementsAt(0, aEvents.Length());
 286
 287   for (uint32_t i = 0; i < aEvents.Length(); i++) {
 288     mEventQueue[i] = std::move(aEvents[i]);
 289   }
 290 }
 291
 292 inline void ChannelEventQueue::CompleteResume() {
 293   bool tryFlush = false;
 294   {
 295     MutexAutoLock lock(mMutex);
 296
 297     // channel may have been suspended again since Resume fired event to call
 298     // this.
 299     if (!mSuspendCount) {
 300       // we need to remain logically suspended (for purposes of queuing incoming
 301       // messages) until this point, else new incoming messages could run before
 302       // queued ones.
 303       mSuspended = false;
 304       tryFlush = true;
 305     }
 306   }
 307
 308   if (tryFlush) {
 309     MaybeFlushQueue();
 310   }
 311 }
 312
 313 inline void ChannelEventQueue::MaybeFlushQueue() {
 314   // Don't flush if forced queuing on, we're already being flushed, or
 315   // suspended, or there's nothing to flush
 316   bool flushQueue = false;
 317
 318   {
 319     MutexAutoLock lock(mMutex);
 320     flushQueue = !mForcedCount && !mFlushing && !mSuspended &&
 321                  !mEventQueue.IsEmpty() && !MaybeSuspendIfEventsAreSuppressed();
 322
 323     // Only one thread is allowed to run FlushQueue at a time.
 324     if (flushQueue) {
 325       mFlushing = true;
 326     }
 327   }
 328
 329   if (flushQueue) {
 330     FlushQueue();
 331   }
 332 }
 333
 334 // Ensures that RunOrEnqueue() will be collecting events during its lifetime
 335 // (letting caller know incoming IPDL msgs should be queued). Flushes the queue
 336 // when it goes out of scope.
 337 class MOZ_STACK_CLASS AutoEventEnqueuer {
 338  public:
 339   explicit AutoEventEnqueuer(ChannelEventQueue* queue)
 340       : mEventQueue(queue), mOwner(queue->mOwner) {
 341     mEventQueue->StartForcedQueueing();
 342   }
 343   ~AutoEventEnqueuer() { mEventQueue->EndForcedQueueing(); }
 344
 345  private:
 346   RefPtr<ChannelEventQueue> mEventQueue;
 347   // Ensure channel object lives longer than ChannelEventQueue.
 348   nsCOMPtr<nsISupports> mOwner;
 349 };
 350
 351 }  // namespace net
 352 }  // namespace mozilla
 353
 354 #endif