modules/plugin/sdk/samples/npthread/windows/thread.cpp

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *
  24  * Alternatively, the contents of this file may be used under the terms of
  25  * either the GNU General Public License Version 2 or later (the "GPL"), or
  26  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27  * in which case the provisions of the GPL or the LGPL are applicable instead
  28  * of those above. If you wish to allow use of your version of this file only
  29  * under the terms of either the GPL or the LGPL, and not to allow others to
  30  * use your version of this file under the terms of the MPL, indicate your
  31  * decision by deleting the provisions above and replace them with the notice
  32  * and other provisions required by the GPL or the LGPL. If you do not delete
  33  * the provisions above, a recipient may use your version of this file under
  34  * the terms of any one of the MPL, the GPL or the LGPL.
  35  *
  36  * ***** END LICENSE BLOCK ***** */
  37
  38 #include <windows.h>
  39 #include <windowsx.h>
  40 #include <process.h>
  41
  42 #include "thread.h"
  43 #include "dbg.h"
  44
  45 static DWORD WINAPI ThreadFunction(void * lp)
  46 {
  47   if (lp == NULL)
  48     return 0L;
  49
  50   CThread * thread = (CThread *)lp;
  51   BOOL res = thread->init();
  52   thread->setInitEvent();
  53
  54   if(res)
  55     thread->run();
  56
  57   thread->shut();
  58   DWORD ret;
  59   GetExitCodeThread(thread->getHandle(), &ret);
  60   thread->setShutEvent();
  61   return ret;
  62 }
  63
  64 CThread::CThread(DWORD aInitTimeOut, DWORD aShutTimeOut) :
  65   mThread(NULL),
  66   mID(0),
  67   mState(ts_dead),
  68   mEventThreadInitializationFinished(NULL),
  69   mEventThreadShutdownFinished(NULL),
  70   mInitTimeOut(aInitTimeOut),
  71   mShutTimeOut(aShutTimeOut),
  72   mEventDo(NULL),
  73   mAction(0)
  74 {
  75   dbgOut1("CThread::CThread");
  76 }
  77
  78 CThread::~CThread()
  79 {
  80   dbgOut1("CThread::~CThread");
  81 }
  82
  83 BOOL CThread::open(CThread * aThread)
  84 {
  85   dbgOut1("CThread::open");
  86
  87   mEventThreadInitializationFinished = CreateEvent(NULL, TRUE, FALSE, NULL);
  88   mEventThreadShutdownFinished = CreateEvent(NULL, TRUE, FALSE, NULL);
  89   mEventDo = CreateEvent(NULL, TRUE, FALSE, NULL);
  90
  91   mThread = (HANDLE)::_beginthreadex(0, 1024, (UINT (__stdcall *)(void *))ThreadFunction, aThread, 0L, (UINT *)&mID);
  92
  93   if(mThread == NULL)
  94     return FALSE;
  95
  96   SetThreadPriority(mThread, THREAD_PRIORITY_NORMAL);
  97
  98   if(mEventThreadInitializationFinished != NULL)
  99     WaitForSingleObject(mEventThreadInitializationFinished, mInitTimeOut);
 100
 101   return TRUE;
 102 }
 103
 104 void CThread::close(CThread * aThread)
 105 {
 106   switch (mState) {
 107     case ts_dead:
 108       break;
 109     case ts_ready:
 110       mState = ts_dead;
 111       SetEvent(mEventDo);
 112       if(mEventThreadShutdownFinished != NULL)
 113         WaitForSingleObject(mEventThreadShutdownFinished, mShutTimeOut);
 114       break;
 115     case ts_busy:
 116     {
 117       aThread->shut();
 118       DWORD ret;
 119       GetExitCodeThread(aThread->getHandle(), &ret);
 120       TerminateThread(mThread, ret);
 121       mState = ts_dead;
 122       break;
 123     }
 124     default:
 125       break;
 126   }
 127
 128   mThread = NULL;
 129   CloseHandle(mEventThreadInitializationFinished);
 130   CloseHandle(mEventThreadShutdownFinished);
 131   CloseHandle(mEventDo);
 132   dbgOut1("CThread::close");
 133 }
 134
 135 BOOL CThread::setInitEvent()
 136 {
 137   return SetEvent(mEventThreadInitializationFinished);
 138 }
 139
 140 BOOL CThread::setShutEvent()
 141 {
 142   return SetEvent(mEventThreadShutdownFinished);
 143 }
 144
 145 BOOL CThread::isAlive()
 146 {
 147   return (mThread != NULL);
 148 }
 149
 150 BOOL CThread::isBusy()
 151 {
 152   return (mState == ts_busy);
 153 }
 154
 155 HANDLE CThread::getHandle()
 156 {
 157   return mThread;
 158 }
 159
 160 void CThread::run()
 161 {
 162   mState = ts_ready;
 163
 164   while(mState != ts_dead) {
 165     WaitForSingleObject(mEventDo, INFINITE);
 166     //dbgOut2("CThread::run(): Do event signalled, %u", mState);
 167     ResetEvent(mEventDo);
 168     if(mState == ts_dead)
 169       return;
 170     mState = ts_busy;
 171     dispatch();
 172     mState = ts_ready;
 173   }
 174   mState = ts_dead;
 175 }
 176
 177 BOOL CThread::tryAction(int aAction)
 178 {
 179   if(mState != ts_ready)
 180     return FALSE;
 181
 182   mAction = aAction;
 183   SetEvent(mEventDo);
 184
 185   return TRUE;
 186 }
 187
 188 BOOL CThread::doAction(int aAction)
 189 {
 190   while(mState != ts_ready) {
 191     //dbgOut2("CThread::doAction %i -- waiting...", aAction);
 192     if(mState == ts_dead)
 193       return FALSE;
 194     Sleep(0);
 195   }
 196
 197   mState = ts_busy;
 198   mAction = aAction;
 199   //dbgOut2("CThread::doAction -- about to signal %i", aAction);
 200   SetEvent(mEventDo);
 201
 202   return TRUE;
 203 }