Adds a SHUTDOWN_TASK_QUEUE and a PreShutdown api to the scheduler.

components/scheduler/child/webthread_impl_for_worker_scheduler_unittest.cc

 // Copyright 2015 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 "components/scheduler/child/webthread_impl_for_worker_scheduler.h"
 
 #include "base/synchronization/waitable_event.h"
 #include "components/scheduler/child/worker_scheduler_impl.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/WebKit/public/platform/WebScheduler.h"
 #include "third_party/WebKit/public/platform/WebTraceLocation.h"
 
 using testing::_;
 using testing::AnyOf;
 using testing::ElementsAre;
 using testing::Invoke;
 
 namespace scheduler {
 namespace {
 
@@ skipping 96 matching lines @@
   ON_CALL(*task, run())
       .WillByDefault(Invoke([&completion]() { completion.Signal(); }));
 
   thread_->postTask(blink::WebTraceLocation(), task.release());
   completion.Wait();
 }
 
 TEST_F(WebThreadImplForWorkerSchedulerTest,
        TestTaskExecutedBeforeThreadDeletion) {
   scoped_ptr<MockTask> task(new MockTask());
-  base::WaitableEvent completion(false, false);
+  bool task_ran = false;
+  base::Lock lock;

[rmcilroy, 2015/04/28 09:51:10]

Can you not just use a WaitableEvent and check !completion.IsSignaled() in
TestThreadShutdownAfterPreShutdown?

[Sami, 2015/04/28 11:52:46]

Good idea, that's cleaner.

Also found out that these tests weren't actually being run anymore:
https://codereview.chromium.org/1112523003/ :P

 
   EXPECT_CALL(*task, run());
   ON_CALL(*task, run())
-      .WillByDefault(Invoke([&completion]() { completion.Signal(); }));
+      .WillByDefault(Invoke([&task_ran, &lock]() {
+        base::AutoLock auto_lock(lock);
+        task_ran = true;
+      }));
 
   thread_->postTask(blink::WebTraceLocation(), task.release());
   thread_.reset();
+  {
+    base::AutoLock auto_lock(lock);
+    EXPECT_TRUE(task_ran);
+  }
+}
+
+TEST_F(WebThreadImplForWorkerSchedulerTest,
+       TestThreadShutdownAfterPreShutdown) {
+  scoped_ptr<MockTask> task(new MockTask());
+  bool task_ran = false;
+  base::Lock lock;
+
+  ON_CALL(*task, run())
+      .WillByDefault(Invoke([&task_ran, &lock]() {
+        base::AutoLock auto_lock(lock);
+        task_ran = true;
+      }));
+
+  // preShutdown should block the postTask, but not the internal shutdown task.
+  thread_->scheduler()->preShutdown();
+  thread_->postTask(blink::WebTraceLocation(), task.release());
+  thread_.reset();
+
+  {
+    base::AutoLock auto_lock(lock);
+    EXPECT_FALSE(task_ran);
+  }
 }
 
 TEST_F(WebThreadImplForWorkerSchedulerTest, TestIdleTask) {
   scoped_ptr<MockIdleTask> task(new MockIdleTask());
   base::WaitableEvent completion(false, false);
 
   EXPECT_CALL(*task, run(_));
   ON_CALL(*task, run(_))
       .WillByDefault(Invoke([&completion](double) { completion.Signal(); }));
 
@@ skipping 16 matching lines @@
 
   // We need to be careful what we test here.  We want to make sure the
   // observers are un in the expected order before and after the task.
   // Sometimes we get an internal scheduler task running before or after
   // TestTask as well. This is not a bug, and we need to make sure the test
   // doesn't fail when that happens.
   EXPECT_THAT(calls, testing::HasSubstr("willProcessTask run didProcessTask"));
 }
 
 }  // namespace scheduler