tor-browser

rcthread.cpp (5446B)

---

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/* RCThread.cpp - C++ wrapper on NSPR */

#include "rcthread.h"
#include "rcinrval.h"

#include <prmem.h>
#include <prlog.h>
#include <stdio.h>
#include <prinit.h>

static RCPrimordialThread *primordial = NULL;

void nas_Root(void *arg)
{
   RCThread *him = (RCThread*)arg;
   while (RCThread::ex_unstarted == him->execution) {
       (void)PR_Sleep(PR_INTERVAL_NO_TIMEOUT);    /* wait for Start() */
   }
   him->RootFunction();  /* he gets a self reference */
   if (PR_UNJOINABLE_THREAD == PR_GetThreadState(him->identity)) {
       delete him;
   }
}  /* nas_Root */

RCThread::~RCThread() { }

RCThread::RCThread(): RCBase() { }

RCThread::RCThread(const RCThread&): RCBase()
{
   PR_NOT_REACHED("Cannot call thread copy constructor");
}  /* RCThread::RCThread */

RCThread::RCThread(
   RCThread::Scope scope, RCThread::State join, PRUint32 stackSize):
   RCBase()
{
   execution = ex_unstarted;
   identity = PR_CreateThread(
                  PR_USER_THREAD, nas_Root, this,
                  PR_GetThreadPriority(PR_GetCurrentThread()),
                  (PRThreadScope)scope, (PRThreadState)join, stackSize);
}  /* RCThread::RCThread */

void RCThread::operator=(const RCThread&)
{
   PR_NOT_REACHED("Cannot call thread assignment operator");
}  /* RCThread::operator= */


PRStatus RCThread::Start()
{
   PRStatus rv;
   /* This is an unsafe check, but not too critical */
   if (RCThread::ex_unstarted == execution)
   {
       execution = RCThread::ex_started;
       rv = PR_Interrupt(identity);
       PR_ASSERT(PR_SUCCESS == rv);
   }
   else
   {
       rv = PR_FAILURE;
       PR_SetError(PR_INVALID_STATE_ERROR, 0);
   }
   return rv;
}  /* RCThread::Start */

PRStatus RCThread::Join()
{
   PRStatus rv;
   if (RCThread::ex_unstarted == execution)
   {
       rv = PR_FAILURE;
       PR_SetError(PR_INVALID_STATE_ERROR, 0);
   }
   else {
       rv = PR_JoinThread(identity);
   }
   if (PR_SUCCESS == rv) {
       delete this;
   }
   return rv;
}  /* RCThread::Join */

PRStatus RCThread::Interrupt()
{
   PRStatus rv;
   if (RCThread::ex_unstarted == execution)
   {
       rv = PR_FAILURE;
       PR_SetError(PR_INVALID_STATE_ERROR, 0);
   }
   else {
       rv = PR_Interrupt(identity);
   }
   return rv;
}  /* RCThread::Interrupt */

void RCThread::ClearInterrupt() {
   PR_ClearInterrupt();
}

void RCThread::SetPriority(RCThread::Priority new_priority)
{
   PR_SetThreadPriority(identity, (PRThreadPriority)new_priority);
}

PRThread *RCThread::Self()
{
   return PR_GetCurrentThread();
}

RCThread::Scope RCThread::GetScope() const
{
   return (RCThread::Scope)PR_GetThreadScope(identity);
}

RCThread::State RCThread::GetState() const
{
   return (RCThread::State)PR_GetThreadState(identity);
}

RCThread::Priority RCThread::GetPriority() const
{
   return (RCThread::Priority)PR_GetThreadPriority(identity);
}

static void _rc_PDDestructor(RCThreadPrivateData* privateData)
{
   PR_ASSERT(NULL != privateData);
   privateData->Release();
}

static PRThreadPrivateDTOR _tpd_dtor = (PRThreadPrivateDTOR)_rc_PDDestructor;

PRStatus RCThread::NewPrivateIndex(PRUintn* index)
{
   return PR_NewThreadPrivateIndex(index, _tpd_dtor);
}

PRStatus RCThread::SetPrivateData(PRUintn index)
{
   return PR_SetThreadPrivate(index, NULL);
}

PRStatus RCThread::SetPrivateData(PRUintn index, RCThreadPrivateData* data)
{
   return PR_SetThreadPrivate(index, data);
}

RCThreadPrivateData* RCThread::GetPrivateData(PRUintn index)
{
   return (RCThreadPrivateData*)PR_GetThreadPrivate(index);
}

PRStatus RCThread::Sleep(const RCInterval& ticks)
{
   PRIntervalTime tmo = ticks;
   return PR_Sleep(tmo);
}

RCPrimordialThread *RCThread::WrapPrimordialThread()
{
   /*
   ** This needs to take more care in insuring that the thread
   ** being wrapped is really the primordial thread. This code
   ** is assuming that the caller is the primordial thread, and
   ** there's nothing to insure that.
   */
   if (NULL == primordial)
   {
       /* it doesn't have to be perfect */
       RCPrimordialThread *me = new RCPrimordialThread();
       PR_ASSERT(NULL != me);
       if (NULL == primordial)
       {
           primordial = me;
           me->execution = RCThread::ex_started;
           me->identity = PR_GetCurrentThread();
       }
       else {
           delete me;    /* somebody beat us to it */
       }
   }
   return primordial;
}  /* RCThread::WrapPrimordialThread */

RCPrimordialThread::RCPrimordialThread(): RCThread() { }

RCPrimordialThread::~RCPrimordialThread() { }

void RCPrimordialThread::RootFunction()
{
   PR_NOT_REACHED("Primordial thread calling root function");
}  /* RCPrimordialThread::RootFunction */

PRStatus RCPrimordialThread::Cleanup() {
   return PR_Cleanup();
}

PRStatus RCPrimordialThread::SetVirtualProcessors(PRIntn count)
{
   PR_SetConcurrency(count);
   return PR_SUCCESS;
}  /* SetVirutalProcessors */

RCThreadPrivateData::RCThreadPrivateData() { }

RCThreadPrivateData::RCThreadPrivateData(
   const RCThreadPrivateData& him) { }

RCThreadPrivateData::~RCThreadPrivateData() { }

/* RCThread.c */