Support Closure in ALL the loops!

base/threading/worker_pool_posix_unittest.cc

 // Copyright (c) 2010 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/worker_pool_posix.h"
 
 #include <set>
 
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/task.h"
 #include "base/threading/platform_thread.h"
 #include "base/synchronization/waitable_event.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 
 // Peer class to provide passthrough access to PosixDynamicThreadPool internals.
 class PosixDynamicThreadPool::PosixDynamicThreadPoolPeer {
  public:
   explicit PosixDynamicThreadPoolPeer(PosixDynamicThreadPool* pool)
       : pool_(pool) {}
 
   Lock* lock() { return &pool_->lock_; }
-  ConditionVariable* tasks_available_cv() {
-    return &pool_->tasks_available_cv_;
+  ConditionVariable* pending_tasks_available_cv() {
+    return &pool_->pending_tasks_available_cv_;
   }
-  const std::queue<Task*>& tasks() const { return pool_->tasks_; }
+  const std::queue<PendingTask>& pending_tasks() const {
+    return pool_->pending_tasks_;
+  }
   int num_idle_threads() const { return pool_->num_idle_threads_; }
   ConditionVariable* num_idle_threads_cv() {
     return pool_->num_idle_threads_cv_.get();
   }
   void set_num_idle_threads_cv(ConditionVariable* cv) {
     pool_->num_idle_threads_cv_.reset(cv);
   }
 
  private:
   PosixDynamicThreadPool* pool_;
@@ skipping 134 matching lines @@
   int num_waiting_to_start_;
   ConditionVariable num_waiting_to_start_cv_;
   base::WaitableEvent start_;
 };
 
 }  // namespace
 
 TEST_F(PosixDynamicThreadPoolTest, Basic) {
   EXPECT_EQ(0, peer_.num_idle_threads());
   EXPECT_EQ(0U, unique_threads_.size());
-  EXPECT_EQ(0U, peer_.tasks().size());
+  EXPECT_EQ(0U, peer_.pending_tasks().size());
 
   // Add one task and wait for it to be completed.
-  pool_->PostTask(CreateNewIncrementingTask());
+  pool_->PostTask(FROM_HERE, CreateNewIncrementingTask());
 
   WaitForIdleThreads(1);
 
   EXPECT_EQ(1U, unique_threads_.size()) <<
       "There should be only one thread allocated for one task.";
   EXPECT_EQ(1, peer_.num_idle_threads());
   EXPECT_EQ(1, counter_);
 }
 
 TEST_F(PosixDynamicThreadPoolTest, ReuseIdle) {
   // Add one task and wait for it to be completed.
-  pool_->PostTask(CreateNewIncrementingTask());
+  pool_->PostTask(FROM_HERE, CreateNewIncrementingTask());
 
   WaitForIdleThreads(1);
 
   // Add another 2 tasks.  One should reuse the existing worker thread.
-  pool_->PostTask(CreateNewBlockingIncrementingTask());
-  pool_->PostTask(CreateNewBlockingIncrementingTask());
+  pool_->PostTask(FROM_HERE, CreateNewBlockingIncrementingTask());
+  pool_->PostTask(FROM_HERE, CreateNewBlockingIncrementingTask());
 
   WaitForTasksToStart(2);
   start_.Signal();
   WaitForIdleThreads(2);
 
   EXPECT_EQ(2U, unique_threads_.size());
   EXPECT_EQ(2, peer_.num_idle_threads());
   EXPECT_EQ(3, counter_);
 }
 
 TEST_F(PosixDynamicThreadPoolTest, TwoActiveTasks) {
   // Add two blocking tasks.
-  pool_->PostTask(CreateNewBlockingIncrementingTask());
-  pool_->PostTask(CreateNewBlockingIncrementingTask());
+  pool_->PostTask(FROM_HERE, CreateNewBlockingIncrementingTask());
+  pool_->PostTask(FROM_HERE, CreateNewBlockingIncrementingTask());
 
   EXPECT_EQ(0, counter_) << "Blocking tasks should not have started yet.";
 
   WaitForTasksToStart(2);
   start_.Signal();
   WaitForIdleThreads(2);
 
   EXPECT_EQ(2U, unique_threads_.size());
   EXPECT_EQ(2, peer_.num_idle_threads()) << "Existing threads are now idle.";
   EXPECT_EQ(2, counter_);
 }
 
 TEST_F(PosixDynamicThreadPoolTest, Complex) {
   // Add two non blocking tasks and wait for them to finish.
-  pool_->PostTask(CreateNewIncrementingTask());
+  pool_->PostTask(FROM_HERE, CreateNewIncrementingTask());
 
   WaitForIdleThreads(1);
 
   // Add two blocking tasks, start them simultaneously, and wait for them to
   // finish.
-  pool_->PostTask(CreateNewBlockingIncrementingTask());
-  pool_->PostTask(CreateNewBlockingIncrementingTask());
+  pool_->PostTask(FROM_HERE, CreateNewBlockingIncrementingTask());
+  pool_->PostTask(FROM_HERE, CreateNewBlockingIncrementingTask());
 
   WaitForTasksToStart(2);
   start_.Signal();
   WaitForIdleThreads(2);
 
   EXPECT_EQ(3, counter_);
   EXPECT_EQ(2, peer_.num_idle_threads());
   EXPECT_EQ(2U, unique_threads_.size());
 
   // Wake up all idle threads so they can exit.
   {
     base::AutoLock locked(*peer_.lock());
     while (peer_.num_idle_threads() > 0) {
-      peer_.tasks_available_cv()->Signal();
+      peer_.pending_tasks_available_cv()->Signal();
       peer_.num_idle_threads_cv()->Wait();
     }
   }
 
   // Add another non blocking task.  There are no threads to reuse.
-  pool_->PostTask(CreateNewIncrementingTask());
+  pool_->PostTask(FROM_HERE, CreateNewIncrementingTask());
   WaitForIdleThreads(1);
 
   EXPECT_EQ(3U, unique_threads_.size());
   EXPECT_EQ(1, peer_.num_idle_threads());
   EXPECT_EQ(4, counter_);
 }
 
 }  // namespace base