LCOV - code coverage report
Current view: directory - security/manager/ssl/src - nsPSMBackgroundThread.cpp (source / functions) Found Hit Coverage
Test: app.info Lines: 36 35 97.2 %
Date: 2012-06-02 Functions: 8 7 87.5 %

       1                 : /* ***** BEGIN LICENSE BLOCK *****
       2                 :  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
       3                 :  *
       4                 :  * The contents of this file are subject to the Mozilla Public License Version
       5                 :  * 1.1 (the "License"); you may not use this file except in compliance with
       6                 :  * the License. You may obtain a copy of the License at
       7                 :  * http://www.mozilla.org/MPL/
       8                 :  *
       9                 :  * Software distributed under the License is distributed on an "AS IS" basis,
      10                 :  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
      11                 :  * for the specific language governing rights and limitations under the
      12                 :  * License.
      13                 :  *
      14                 :  * The Original Code is mozilla.org code.
      15                 :  *
      16                 :  * The Initial Developer of the Original Code is
      17                 :  * Red Hat, Inc.
      18                 :  * Portions created by the Initial Developer are Copyright (C) 2006
      19                 :  * the Initial Developer. All Rights Reserved.
      20                 :  *
      21                 :  * Contributor(s):
      22                 :  *   Kai Engert <kengert@redhat.com>
      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 "nsPSMBackgroundThread.h"
      39                 : #include "nsThreadUtils.h"
      40                 : 
      41                 : using namespace mozilla;
      42                 : 
      43             328 : void PR_CALLBACK nsPSMBackgroundThread::nsThreadRunner(void *arg)
      44                 : {
      45             328 :   nsPSMBackgroundThread *self = static_cast<nsPSMBackgroundThread *>(arg);
      46             328 :   self->Run();
      47             328 : }
      48                 : 
      49             328 : nsPSMBackgroundThread::nsPSMBackgroundThread()
      50                 : : mThreadHandle(nsnull),
      51                 :   mMutex("nsPSMBackgroundThread.mMutex"),
      52                 :   mCond(mMutex, "nsPSMBackgroundThread.mCond"),
      53             328 :   mExitState(ePSMThreadRunning)
      54                 : {
      55             328 : }
      56                 : 
      57             328 : nsresult nsPSMBackgroundThread::startThread()
      58                 : {
      59                 :   mThreadHandle = PR_CreateThread(PR_USER_THREAD, nsThreadRunner, static_cast<void*>(this), 
      60             328 :     PR_PRIORITY_NORMAL, PR_LOCAL_THREAD, PR_JOINABLE_THREAD, 0);
      61                 : 
      62             328 :   NS_ASSERTION(mThreadHandle, "Could not create nsPSMBackgroundThread\n");
      63                 :   
      64             328 :   if (!mThreadHandle)
      65               0 :     return NS_ERROR_OUT_OF_MEMORY;
      66                 : 
      67             328 :   return NS_OK;
      68                 : }
      69                 : 
      70             328 : nsPSMBackgroundThread::~nsPSMBackgroundThread()
      71                 : {
      72             656 : }
      73                 : 
      74                 : bool
      75             984 : nsPSMBackgroundThread::exitRequested(const MutexAutoLock & /*proofOfLock*/) const
      76                 : {
      77             984 :   return exitRequestedNoLock();
      78                 : }
      79                 : 
      80                 : nsresult
      81             328 : nsPSMBackgroundThread::postStoppedEventToMainThread(
      82                 :     MutexAutoLock const & /*proofOfLock*/)
      83                 : {
      84             328 :   NS_ASSERTION(PR_GetCurrentThread() == mThreadHandle,
      85                 :                "Background thread stopped from another thread");
      86                 : 
      87             328 :   mExitState = ePSMThreadStopped;
      88                 :   // requestExit is waiting for an event, so give it one.
      89             328 :   return NS_DispatchToMainThread(new nsRunnable());
      90                 : }
      91                 : 
      92             643 : void nsPSMBackgroundThread::requestExit()
      93                 : {
      94             643 :   NS_ASSERTION(NS_IsMainThread(),
      95                 :                "nsPSMBackgroundThread::requestExit called off main thread.");
      96                 : 
      97             643 :   if (!mThreadHandle)
      98             315 :     return;
      99                 : 
     100                 :   {
     101             656 :     MutexAutoLock threadLock(mMutex);
     102             328 :     if (mExitState < ePSMThreadStopRequested) {
     103             328 :       mExitState = ePSMThreadStopRequested;
     104             328 :       mCond.NotifyAll();
     105                 :     }
     106                 :   }
     107                 :   
     108             656 :   nsCOMPtr<nsIThread> mainThread = do_GetCurrentThread();
     109            2902 :   for (;;) {
     110                 :     {
     111            6460 :       MutexAutoLock threadLock(mMutex);
     112            3230 :       if (mExitState == ePSMThreadStopped)
     113                 :         break;
     114                 :     }
     115            2902 :     NS_ProcessPendingEvents(mainThread, PR_MillisecondsToInterval(50));
     116                 :   }
     117                 : 
     118             328 :   PR_JoinThread(mThreadHandle);
     119             328 :   mThreadHandle = nsnull;
     120                 : }

Generated by: LCOV version 1.7