LCOV - app.info - ipc/chromium/src/base/simple_thread.cc

LCOV - code coverage report
| Current view: | directory - ipc/chromium/src/base - simple_thread.cc (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 71 | 0 | 0.0 %
| Date: | 2012-04-21 | Functions: | 12 | 0 | 0.0 %

           1                 : // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
           2                 : // Use of this source code is governed by a BSD-style license that can be
           3                 : // found in the LICENSE file.
           4                 :
           5                 : #include "base/simple_thread.h"
           6                 :
           7                 : #include "base/waitable_event.h"
           8                 : #include "base/logging.h"
           9                 : #include "base/platform_thread.h"
          10                 : #include "base/string_util.h"
          11                 :
          12                 : namespace base {
          13                 :
          14               0 : void SimpleThread::Start() {
          15               0 :   DCHECK(!HasBeenStarted()) << "Tried to Start a thread multiple times.";
          16               0 :   bool success = PlatformThread::Create(options_.stack_size(), this, &thread_);
          17               0 :   CHECK(success);
          18               0 :   event_.Wait();  // Wait for the thread to complete initialization.
          19               0 : }
          20                 :
          21               0 : void SimpleThread::Join() {
          22               0 :   DCHECK(HasBeenStarted()) << "Tried to Join a never-started thread.";
          23               0 :   DCHECK(!HasBeenJoined()) << "Tried to Join a thread multiple times.";
          24               0 :   PlatformThread::Join(thread_);
          25               0 :   joined_ = true;
          26               0 : }
          27                 :
          28               0 : void SimpleThread::ThreadMain() {
          29               0 :   tid_ = PlatformThread::CurrentId();
          30                 :   // Construct our full name of the form "name_prefix_/TID".
          31               0 :   name_.push_back('/');
          32               0 :   name_.append(IntToString(tid_));
          33               0 :   PlatformThread::SetName(name_.c_str());
          34                 :
          35                 :   // We've initialized our new thread, signal that we're done to Start().
          36               0 :   event_.Signal();
          37                 :
          38               0 :   Run();
          39               0 : }
          40                 :
          41               0 : SimpleThread::~SimpleThread() {
          42               0 :   DCHECK(HasBeenStarted()) << "SimpleThread was never started.";
          43               0 :   DCHECK(HasBeenJoined()) << "SimpleThread destroyed without being Join()ed.";
          44               0 : }
          45                 :
          46               0 : void DelegateSimpleThread::Run() {
          47               0 :   DCHECK(delegate_) << "Tried to call Run without a delegate (called twice?)";
          48               0 :   delegate_->Run();
          49               0 :   delegate_ = NULL;
          50               0 : }
          51                 :
          52               0 : DelegateSimpleThreadPool::~DelegateSimpleThreadPool() {
          53               0 :   DCHECK(threads_.empty());
          54               0 :   DCHECK(delegates_.empty());
          55               0 :   DCHECK(!dry_.IsSignaled());
          56               0 : }
          57                 :
          58               0 : void DelegateSimpleThreadPool::Start() {
          59               0 :   DCHECK(threads_.empty()) << "Start() called with outstanding threads.";
          60               0 :   for (int i = 0; i < num_threads_; ++i) {
          61               0 :     DelegateSimpleThread* thread = new DelegateSimpleThread(this, name_prefix_);
          62               0 :     thread->Start();
          63               0 :     threads_.push_back(thread);
          64                 :   }
          65               0 : }
          66                 :
          67               0 : void DelegateSimpleThreadPool::JoinAll() {
          68               0 :   DCHECK(!threads_.empty()) << "JoinAll() called with no outstanding threads.";
          69                 :
          70                 :   // Tell all our threads to quit their worker loop.
          71               0 :   AddWork(NULL, num_threads_);
          72                 :
          73                 :   // Join and destroy all the worker threads.
          74               0 :   for (int i = 0; i < num_threads_; ++i) {
          75               0 :     threads_[i]->Join();
          76               0 :     delete threads_[i];
          77                 :   }
          78               0 :   threads_.clear();
          79               0 :   DCHECK(delegates_.empty());
          80               0 : }
          81                 :
          82               0 : void DelegateSimpleThreadPool::AddWork(Delegate* delegate, int repeat_count) {
          83               0 :   AutoLock locked(lock_);
          84               0 :   for (int i = 0; i < repeat_count; ++i)
          85               0 :     delegates_.push(delegate);
          86                 :   // If we were empty, signal that we have work now.
          87               0 :   if (!dry_.IsSignaled())
          88               0 :     dry_.Signal();
          89               0 : }
          90                 :
          91               0 : void DelegateSimpleThreadPool::Run() {
          92                 :   Delegate* work;
          93                 :
          94               0 :   while (true) {
          95               0 :     dry_.Wait();
          96                 :     {
          97               0 :       AutoLock locked(lock_);
          98               0 :       if (!dry_.IsSignaled())
          99               0 :         continue;
         100                 :
         101               0 :       DCHECK(!delegates_.empty());
         102               0 :       work = delegates_.front();
         103               0 :       delegates_.pop();
         104                 :
         105                 :       // Signal to any other threads that we're currently out of work.
         106               0 :       if (delegates_.empty())
         107               0 :         dry_.Reset();
         108                 :     }
         109                 :
         110                 :     // A NULL delegate pointer signals us to quit.
         111               0 :     if (!work)
         112                 :       break;
         113                 :
         114               0 :     work->Run();
         115                 :   }
         116               0 : }
         117                 :
         118                 : }  // namespace base

Generated by: LCOV version 1.7