Move work signal count tracking from SequencedWorkerPool to the test file

base/threading/sequenced_worker_pool.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/threading/sequenced_worker_pool.h"
 
 #include <list>
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 54 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(Worker);
 };
 
 // Inner ----------------------------------------------------------------------
 
 class SequencedWorkerPool::Inner {
  public:
   // Take a raw pointer to |worker| to avoid cycles (since we're owned
   // by it).
   Inner(SequencedWorkerPool* worker_pool, size_t max_threads,
-        const std::string& thread_name_prefix);
+        const std::string& thread_name_prefix,
+        TestingObserver* observer);
 
   ~Inner();
 
   SequenceToken GetSequenceToken();
 
   SequenceToken GetNamedSequenceToken(const std::string& name);
 
   // This function accepts a name and an ID. If the name is null, the
   // token ID is used. This allows us to implement the optional name lookup
   // from a single function without having to enter the lock a separate time.
   bool PostTask(const std::string* optional_token_name,
                 SequenceToken sequence_token,
                 WorkerShutdown shutdown_behavior,
                 const tracked_objects::Location& from_here,
                 const Closure& task);
 
   bool RunsTasksOnCurrentThread() const;
 
   void FlushForTesting();
 
-  void TriggerSpuriousWorkSignalForTesting();
+  void SignalHasWorkForTesting();
 
   int GetWorkSignalCountForTesting() const;
 
   void Shutdown();
 
-  void SetTestingObserver(TestingObserver* observer);
-
   // Runs the worker loop on the background thread.
   void ThreadLoop(Worker* this_worker);
 
  private:
   // Returns whether there are no more pending tasks and all threads
   // are idle.  Must be called under lock.
   bool IsIdle() const;
 
   // Called from within the lock, this converts the given token name into a
   // token ID, creating a new one if necessary.
@@ skipping 52 matching lines @@
 
   // This lock protects |everything in this class|. Do not read or modify
   // anything without holding this lock. Do not block while holding this
   // lock.
   mutable Lock lock_;
 
   // Condition variable that is waited on by worker threads until new
   // tasks are posted or shutdown starts.
   ConditionVariable has_work_cv_;
 
-  // Number of times |has_work_| has been signalled.  Used for testing.
-  int has_work_signal_count_;
-
   // Condition variable that is waited on by non-worker threads (in
   // FlushForTesting()) until IsIdle() goes to true.
   ConditionVariable is_idle_cv_;
 
   // Condition variable that is waited on by non-worker threads (in
   // Shutdown()) until CanShutdown() goes to true.
   ConditionVariable can_shutdown_cv_;
 
   // The maximum number of worker threads we'll create.
   const size_t max_threads_;
@@ skipping 32 matching lines @@
   // shutdown.
   size_t blocking_shutdown_pending_task_count_;
 
   // Lists all sequence tokens currently executing.
   std::set<int> current_sequences_;
 
   // Set when Shutdown is called and no further tasks should be
   // allowed, though we may still be running existing tasks.
   bool shutdown_called_;
 
-  TestingObserver* testing_observer_;
+  TestingObserver* const testing_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(Inner);
 };
 
 // Worker definitions ---------------------------------------------------------
 
 SequencedWorkerPool::Worker::Worker(
     const scoped_refptr<SequencedWorkerPool>& worker_pool,
     int thread_number,
     const std::string& prefix)
@@ skipping 15 matching lines @@
   worker_pool_->inner_->ThreadLoop(this);
   // Release our cyclic reference once we're done.
   worker_pool_ = NULL;
 }
 
 // Inner definitions ---------------------------------------------------------
 
 SequencedWorkerPool::Inner::Inner(
     SequencedWorkerPool* worker_pool,
     size_t max_threads,
-    const std::string& thread_name_prefix)
+    const std::string& thread_name_prefix,
+    TestingObserver* observer)
     : worker_pool_(worker_pool),
       last_sequence_number_(0),
       lock_(),
       has_work_cv_(&lock_),
-      has_work_signal_count_(0),
       is_idle_cv_(&lock_),
       can_shutdown_cv_(&lock_),
       max_threads_(max_threads),
       thread_name_prefix_(thread_name_prefix),
       thread_being_created_(false),
       waiting_thread_count_(0),
       blocking_shutdown_thread_count_(0),
       pending_task_count_(0),
       blocking_shutdown_pending_task_count_(0),
       shutdown_called_(false),
-      testing_observer_(NULL)  {}
+      testing_observer_(observer) {}
 
 SequencedWorkerPool::Inner::~Inner() {
   // You must call Shutdown() before destroying the pool.
   DCHECK(shutdown_called_);
 
   // Need to explicitly join with the threads before they're destroyed or else
   // they will be running when our object is half torn down.
   for (ThreadMap::iterator it = threads_.begin(); it != threads_.end(); ++it)
     it->second->Join();
   threads_.clear();
@@ skipping 59 matching lines @@
   AutoLock lock(lock_);
   return ContainsKey(threads_, PlatformThread::CurrentId());
 }
 
 void SequencedWorkerPool::Inner::FlushForTesting() {
   AutoLock lock(lock_);
   while (!IsIdle())
     is_idle_cv_.Wait();
 }
 
-void SequencedWorkerPool::Inner::TriggerSpuriousWorkSignalForTesting() {
+void SequencedWorkerPool::Inner::SignalHasWorkForTesting() {
   SignalHasWork();
 }
 
-int SequencedWorkerPool::Inner::GetWorkSignalCountForTesting() const {
-  AutoLock lock(lock_);
-  return has_work_signal_count_;
-}
-
 void SequencedWorkerPool::Inner::Shutdown() {
   // Mark us as terminated and go through and drop all tasks that aren't
   // required to run on shutdown. Since no new tasks will get posted once the
   // terminated flag is set, this ensures that all remaining tasks are required
   // for shutdown whenever the termianted_ flag is set.
   {
     AutoLock lock(lock_);
 
     if (shutdown_called_)
       return;
     shutdown_called_ = true;
 
     // Tickle the threads. This will wake up a waiting one so it will know that
     // it can exit, which in turn will wake up any other waiting ones.
-    has_work_cv_.Signal();
+    SignalHasWork();
 
     // There are no pending or running tasks blocking shutdown, we're done.
     if (CanShutdown())
       return;
   }
 
   // If we're here, then something is blocking shutdown.  So wait for
   // CanShutdown() to go to true.
 
   if (testing_observer_)
     testing_observer_->WillWaitForShutdown();
 
   TimeTicks shutdown_wait_begin = TimeTicks::Now();
 
   {
     AutoLock lock(lock_);
     while (!CanShutdown())
       can_shutdown_cv_.Wait();
   }
   UMA_HISTOGRAM_TIMES("SequencedWorkerPool.ShutdownDelayTime",
                       TimeTicks::Now() - shutdown_wait_begin);
 }
 
-void SequencedWorkerPool::Inner::SetTestingObserver(
-    TestingObserver* observer) {
-  AutoLock lock(lock_);
-  testing_observer_ = observer;
-}
-
 void SequencedWorkerPool::Inner::ThreadLoop(Worker* this_worker) {
   {
     AutoLock lock(lock_);
     DCHECK(thread_being_created_);
     thread_being_created_ = false;
     std::pair<ThreadMap::iterator, bool> result =
         threads_.insert(
             std::make_pair(this_worker->tid(), make_linked_ptr(this_worker)));
     DCHECK(result.second);
 
     while (true) {
       // See GetWork for what delete_these_outside_lock is doing.
       SequencedTask task;
       std::vector<Closure> delete_these_outside_lock;
       if (GetWork(&task, &delete_these_outside_lock)) {
         int new_thread_id = WillRunWorkerTask(task);
         {
           AutoUnlock unlock(lock_);
           // There may be more work available, so wake up another
           // worker thread. (Technically not required, since we
           // already get a signal for each new task, but it doesn't
           // hurt.)
-          has_work_cv_.Signal();
+          SignalHasWork();
           delete_these_outside_lock.clear();
 
           // Complete thread creation outside the lock if necessary.
           if (new_thread_id)
             FinishStartingAdditionalThread(new_thread_id);
 
           task.task.Run();
 
           // Make sure our task is erased outside the lock for the same reason
           // we do this with delete_these_oustide_lock.
@@ skipping 13 matching lines @@
         if (IsIdle())
           is_idle_cv_.Signal();
         has_work_cv_.Wait();
         waiting_thread_count_--;
       }
     }
   }  // Release lock_.
 
   // We noticed we should exit. Wake up the next worker so it knows it should
   // exit as well (because the Shutdown() code only signals once).
-  has_work_cv_.Signal();
+  SignalHasWork();
 
   // Possibly unblock shutdown.
   can_shutdown_cv_.Signal();
 }
 
 bool SequencedWorkerPool::Inner::IsIdle() const {
   lock_.AssertAcquired();
   return pending_task_count_ == 0 && waiting_thread_count_ == threads_.size();
 }
 
@@ skipping 196 matching lines @@
   // Called outside of the lock.
   DCHECK(thread_number > 0);
 
   // The worker is assigned to the list when the thread actually starts, which
   // will manage the memory of the pointer.
   new Worker(worker_pool_, thread_number, thread_name_prefix_);
 }
 
 void SequencedWorkerPool::Inner::SignalHasWork() {
   has_work_cv_.Signal();
-  {
-    AutoLock lock(lock_);
-    ++has_work_signal_count_;
+  if (testing_observer_) {
+    testing_observer_->OnHasWork();
   }
 }
 
 bool SequencedWorkerPool::Inner::CanShutdown() const {
   lock_.AssertAcquired();
   // See PrepareToStartAdditionalThreadIfHelpful for how thread creation works.
   return !thread_being_created_ &&
          blocking_shutdown_thread_count_ == 0 &&
          blocking_shutdown_pending_task_count_ == 0;
 }
 
 // SequencedWorkerPool --------------------------------------------------------
 
 SequencedWorkerPool::SequencedWorkerPool(
     size_t max_threads,
     const std::string& thread_name_prefix)
     : constructor_message_loop_(MessageLoopProxy::current()),
       inner_(new Inner(ALLOW_THIS_IN_INITIALIZER_LIST(this),
-                       max_threads, thread_name_prefix)) {
+                       max_threads, thread_name_prefix, NULL)) {
   DCHECK(constructor_message_loop_.get());
 }
 
+SequencedWorkerPool::SequencedWorkerPool(
+    size_t max_threads,
+    const std::string& thread_name_prefix,
+    TestingObserver* observer)
+    : constructor_message_loop_(MessageLoopProxy::current()),
+      inner_(new Inner(ALLOW_THIS_IN_INITIALIZER_LIST(this),
+                       max_threads, thread_name_prefix, observer)) {
+  DCHECK(constructor_message_loop_.get());
+}
+
 SequencedWorkerPool::~SequencedWorkerPool() {}
 
 void SequencedWorkerPool::OnDestruct() const {
   // TODO(akalin): Once we can easily check if we're on a worker
   // thread or not, use that instead of restricting destruction to
   // only the constructor message loop.
   if (constructor_message_loop_->BelongsToCurrentThread())
     delete this;
   else
     constructor_message_loop_->DeleteSoon(FROM_HERE, this);
@@ skipping 68 matching lines @@
 }
 
 bool SequencedWorkerPool::RunsTasksOnCurrentThread() const {
   return inner_->RunsTasksOnCurrentThread();
 }
 
 void SequencedWorkerPool::FlushForTesting() {
   inner_->FlushForTesting();
 }
 
-void SequencedWorkerPool::TriggerSpuriousWorkSignalForTesting() {
-  inner_->TriggerSpuriousWorkSignalForTesting();
-}
-
-int SequencedWorkerPool::GetWorkSignalCountForTesting() const {
-  return inner_->GetWorkSignalCountForTesting();
+void SequencedWorkerPool::SignalHasWorkForTesting() {
+  inner_->SignalHasWorkForTesting();
 }
 
 void SequencedWorkerPool::Shutdown() {
   DCHECK(constructor_message_loop_->BelongsToCurrentThread());
   inner_->Shutdown();
 }
 
-void SequencedWorkerPool::SetTestingObserver(TestingObserver* observer) {
-  inner_->SetTestingObserver(observer);
-}
-
 }  // namespace base