TaskScheduler [13] TaskSchedulerImpl

base/task_scheduler/scheduler_thread_pool_impl_unittest.cc

 // Copyright 2016 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/task_scheduler/scheduler_thread_pool_impl.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <unordered_set>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/task_runner.h"
 #include "base/task_scheduler/delayed_task_manager.h"
 #include "base/task_scheduler/sequence.h"
 #include "base/task_scheduler/sequence_sort_key.h"
@@ skipping 94 matching lines @@
 
  private:
   void Run() override {
     EXPECT_FALSE(factory_.task_runner()->RunsTasksOnCurrentThread());
 
     for (size_t i = 0; i < kNumTasksPostedPerThread; ++i) {
       if (wait_before_post_task_ ==
           WaitBeforePostTask::WAIT_FOR_ALL_THREADS_IDLE) {
         thread_pool_->WaitForAllWorkerThreadsIdleForTesting();
       }
-      EXPECT_TRUE(factory_.PostTask(post_nested_task_, nullptr));
+      EXPECT_TRUE(factory_.PostTask(post_nested_task_, Closure()));
     }
   }
 
   SchedulerThreadPoolImpl* const thread_pool_;
   const scoped_refptr<TaskRunner> task_runner_;
   const WaitBeforePostTask wait_before_post_task_;
   const PostNestedTask post_nested_task_;
   test::TestTaskFactory factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadPostingTasks);
@@ skipping 72 matching lines @@
     thread_posting_tasks->Join();
     thread_posting_tasks->factory()->WaitForAllTasksToRun();
   }
 
   // Wait until all worker threads are idle to be sure that no task accesses
   // its TestTaskFactory after |thread_posting_tasks| is destroyed.
   thread_pool_->WaitForAllWorkerThreadsIdleForTesting();
 }
 
 TEST_P(TaskSchedulerThreadPoolImplTest, PostTasksWithOneAvailableThread) {
   // Post tasks to keep all threads busy except one until |event| is signaled.

[gab, 2016/04/27 19:15:28]

s/Post tasks/Post blocking tasks/ ? (since it's now no longer implicit in the
TestTaskFactory that it will block, it's instead a side-effect of the Closure
passed to it here)

[fdoray, 2016/04/28 18:36:31]

Done.

   // Use different factories so that tasks are added to different sequences and
   // can run simultaneously when the execution mode is SEQUENCED.
   WaitableEvent event(true, false);
   std::vector<std::unique_ptr<test::TestTaskFactory>> blocked_task_factories;
   for (size_t i = 0; i < (kNumThreadsInThreadPool - 1); ++i) {
     blocked_task_factories.push_back(WrapUnique(new test::TestTaskFactory(
         thread_pool_->CreateTaskRunnerWithTraits(TaskTraits(), GetParam()),
         GetParam())));
-    EXPECT_TRUE(
-        blocked_task_factories.back()->PostTask(PostNestedTask::NO, &event));
+    EXPECT_TRUE(blocked_task_factories.back()->PostTask(
+        PostNestedTask::NO, Bind(&WaitableEvent::Wait, Unretained(&event))));
     blocked_task_factories.back()->WaitForAllTasksToRun();
   }
 
   // Post |kNumTasksPostedPerThread| tasks that should all run despite the fact
   // that only one thread in |thread_pool_| isn't busy.
   test::TestTaskFactory short_task_factory(
       thread_pool_->CreateTaskRunnerWithTraits(TaskTraits(), GetParam()),
       GetParam());
   for (size_t i = 0; i < kNumTasksPostedPerThread; ++i)
-    EXPECT_TRUE(short_task_factory.PostTask(PostNestedTask::NO, nullptr));
+    EXPECT_TRUE(short_task_factory.PostTask(PostNestedTask::NO, Closure()));
   short_task_factory.WaitForAllTasksToRun();
 
   // Release tasks waiting on |event|.
   event.Signal();
 
   // Wait until all worker threads are idle to be sure that no task accesses
   // its TestTaskFactory after it is destroyed.
   thread_pool_->WaitForAllWorkerThreadsIdleForTesting();
 }
 
 TEST_P(TaskSchedulerThreadPoolImplTest, Saturate) {
   // Verify that it is possible to have |kNumThreadsInThreadPool|
   // tasks/sequences running simultaneously. Use different factories so that
   // tasks are added to different sequences and can run simultaneously when the

[gab, 2016/04/27 19:15:28]

s/tasks/the blocking tasks/

[fdoray, 2016/04/28 18:36:31]

Done.

   // execution mode is SEQUENCED.
   WaitableEvent event(true, false);
   std::vector<std::unique_ptr<test::TestTaskFactory>> factories;
   for (size_t i = 0; i < kNumThreadsInThreadPool; ++i) {
     factories.push_back(WrapUnique(new test::TestTaskFactory(
         thread_pool_->CreateTaskRunnerWithTraits(TaskTraits(), GetParam()),
         GetParam())));
-    EXPECT_TRUE(factories.back()->PostTask(PostNestedTask::NO, &event));
+    EXPECT_TRUE(factories.back()->PostTask(
+        PostNestedTask::NO, Bind(&WaitableEvent::Wait, Unretained(&event))));
     factories.back()->WaitForAllTasksToRun();
   }
 
   // Release tasks waiting on |event|.
   event.Signal();
 
   // Wait until all worker threads are idle to be sure that no task accesses
   // its TestTaskFactory after it is destroyed.
   thread_pool_->WaitForAllWorkerThreadsIdleForTesting();
 }
@@ skipping 35 matching lines @@
 
 INSTANTIATE_TEST_CASE_P(Parallel,
                         TaskSchedulerThreadPoolImplTest,
                         ::testing::Values(ExecutionMode::PARALLEL));
 INSTANTIATE_TEST_CASE_P(Sequenced,
                         TaskSchedulerThreadPoolImplTest,
                         ::testing::Values(ExecutionMode::SEQUENCED));
 
 }  // namespace internal
 }  // namespace base