xpcom/tests/TestTimers.cpp

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "TestHarness.h"
   7
   8 #include "nsIThread.h"
   9 #include "nsITimer.h"
  10
  11 #include "nsCOMPtr.h"
  12 #include "nsComponentManagerUtils.h"
  13 #include "nsServiceManagerUtils.h"
  14 #include "nsThreadUtils.h"
  15 #include "prinrval.h"
  16 #include "prmon.h"
  17 #include "prthread.h"
  18 #include "mozilla/Attributes.h"
  19
  20 #include "mozilla/ReentrantMonitor.h"
  21 using namespace mozilla;
  22
  23 typedef nsresult(*TestFuncPtr)();
  24
  25 class AutoTestThread
  26 {
  27 public:
  28   AutoTestThread() {
  29     nsCOMPtr<nsIThread> newThread;
  30     nsresult rv = NS_NewThread(getter_AddRefs(newThread));
  31     if (NS_FAILED(rv))
  32       return;
  33
  34     newThread.swap(mThread);
  35   }
  36
  37   ~AutoTestThread() {
  38     mThread->Shutdown();
  39   }
  40
  41   operator nsIThread*() const {
  42     return mThread;
  43   }
  44
  45   nsIThread* operator->() const MOZ_NO_ADDREF_RELEASE_ON_RETURN {
  46     return mThread;
  47   }
  48
  49 private:
  50   nsCOMPtr<nsIThread> mThread;
  51 };
  52
  53 class AutoCreateAndDestroyReentrantMonitor
  54 {
  55 public:
  56   AutoCreateAndDestroyReentrantMonitor() {
  57     mReentrantMonitor = new ReentrantMonitor("TestTimers::AutoMon");
  58     NS_ASSERTION(mReentrantMonitor, "Out of memory!");
  59   }
  60
  61   ~AutoCreateAndDestroyReentrantMonitor() {
  62     delete mReentrantMonitor;
  63   }
  64
  65   operator ReentrantMonitor* () {
  66     return mReentrantMonitor;
  67   }
  68
  69 private:
  70   ReentrantMonitor* mReentrantMonitor;
  71 };
  72
  73 class TimerCallback MOZ_FINAL : public nsITimerCallback
  74 {
  75 public:
  76   NS_DECL_THREADSAFE_ISUPPORTS
  77
  78   TimerCallback(nsIThread** aThreadPtr, ReentrantMonitor* aReentrantMonitor)
  79   : mThreadPtr(aThreadPtr), mReentrantMonitor(aReentrantMonitor) { }
  80
  81   NS_IMETHOD Notify(nsITimer* aTimer) MOZ_OVERRIDE {
  82     NS_ASSERTION(mThreadPtr, "Callback was not supposed to be called!");
  83     nsCOMPtr<nsIThread> current(do_GetCurrentThread());
  84
  85     ReentrantMonitorAutoEnter mon(*mReentrantMonitor);
  86
  87     NS_ASSERTION(!*mThreadPtr, "Timer called back more than once!");
  88     *mThreadPtr = current;
  89
  90     mon.Notify();
  91
  92     return NS_OK;
  93   }
  94 private:
  95   ~TimerCallback() {}
  96
  97   nsIThread** mThreadPtr;
  98   ReentrantMonitor* mReentrantMonitor;
  99 };
 100
 101 NS_IMPL_ISUPPORTS(TimerCallback, nsITimerCallback)
 102
 103 nsresult
 104 TestTargetedTimers()
 105 {
 106   AutoCreateAndDestroyReentrantMonitor newMon;
 107   NS_ENSURE_TRUE(newMon, NS_ERROR_OUT_OF_MEMORY);
 108
 109   AutoTestThread testThread;
 110   NS_ENSURE_TRUE(testThread, NS_ERROR_OUT_OF_MEMORY);
 111
 112   nsresult rv;
 113   nsCOMPtr<nsITimer> timer = do_CreateInstance(NS_TIMER_CONTRACTID, &rv);
 114   NS_ENSURE_SUCCESS(rv, rv);
 115
 116   nsIEventTarget* target = static_cast<nsIEventTarget*>(testThread);
 117
 118   rv = timer->SetTarget(target);
 119   NS_ENSURE_SUCCESS(rv, rv);
 120
 121   nsIThread* notifiedThread = nullptr;
 122
 123   nsCOMPtr<nsITimerCallback> callback =
 124     new TimerCallback(&notifiedThread, newMon);
 125   NS_ENSURE_TRUE(callback, NS_ERROR_OUT_OF_MEMORY);
 126
 127   rv = timer->InitWithCallback(callback, PR_MillisecondsToInterval(2000),
 128                                nsITimer::TYPE_ONE_SHOT);
 129   NS_ENSURE_SUCCESS(rv, rv);
 130
 131   ReentrantMonitorAutoEnter mon(*newMon);
 132   while (!notifiedThread) {
 133     mon.Wait();
 134   }
 135   NS_ENSURE_TRUE(notifiedThread == testThread, NS_ERROR_FAILURE);
 136
 137   return NS_OK;
 138 }
 139
 140 nsresult
 141 TestTimerWithStoppedTarget()
 142 {
 143   AutoTestThread testThread;
 144   NS_ENSURE_TRUE(testThread, NS_ERROR_OUT_OF_MEMORY);
 145
 146   nsresult rv;
 147   nsCOMPtr<nsITimer> timer = do_CreateInstance(NS_TIMER_CONTRACTID, &rv);
 148   NS_ENSURE_SUCCESS(rv, rv);
 149
 150   nsIEventTarget* target = static_cast<nsIEventTarget*>(testThread);
 151
 152   rv = timer->SetTarget(target);
 153   NS_ENSURE_SUCCESS(rv, rv);
 154
 155   // If this is called, we'll assert
 156   nsCOMPtr<nsITimerCallback> callback =
 157     new TimerCallback(nullptr, nullptr);
 158   NS_ENSURE_TRUE(callback, NS_ERROR_OUT_OF_MEMORY);
 159
 160   rv = timer->InitWithCallback(callback, PR_MillisecondsToInterval(100),
 161                                nsITimer::TYPE_ONE_SHOT);
 162   NS_ENSURE_SUCCESS(rv, rv);
 163
 164   testThread->Shutdown();
 165
 166   PR_Sleep(400);
 167
 168   return NS_OK;
 169 }
 170
 171 int main(int argc, char** argv)
 172 {
 173   ScopedXPCOM xpcom("TestTimers");
 174   NS_ENSURE_FALSE(xpcom.failed(), 1);
 175
 176   static TestFuncPtr testsToRun[] = {
 177     TestTargetedTimers,
 178     TestTimerWithStoppedTarget
 179   };
 180   static uint32_t testCount = sizeof(testsToRun) / sizeof(testsToRun[0]);
 181
 182   for (uint32_t i = 0; i < testCount; i++) {
 183     nsresult rv = testsToRun[i]();
 184     NS_ENSURE_SUCCESS(rv, 1);
 185   }
 186
 187   return 0;
 188 }