content/child/scheduler/webthread_impl_for_worker_scheduler_unittest.cc

   1 // Copyright 2015 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 "content/child/scheduler/webthread_impl_for_worker_scheduler.h"
   6
   7 #include "base/synchronization/waitable_event.h"
   8 #include "content/child/scheduler/worker_scheduler_impl.h"
   9 #include "testing/gmock/include/gmock/gmock.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11 #include "third_party/WebKit/public/platform/WebTraceLocation.h"
  12
  13 using testing::_;
  14 using testing::AnyOf;
  15 using testing::ElementsAre;
  16 using testing::Invoke;
  17
  18 namespace content {
  19 namespace {
  20
  21 class NopTask : public blink::WebThread::Task {
  22  public:
  23   ~NopTask() override {}
  24
  25   void run() {}
  26 };
  27
  28 class MockTask : public blink::WebThread::Task {
  29  public:
  30   ~MockTask() override {}
  31
  32   MOCK_METHOD0(run, void());
  33 };
  34
  35 class MockIdleTask : public blink::WebThread::IdleTask {
  36  public:
  37   ~MockIdleTask() override {}
  38
  39   MOCK_METHOD1(run, void(double deadline));
  40 };
  41
  42 class TestObserver : public blink::WebThread::TaskObserver {
  43  public:
  44   explicit TestObserver(std::string* calls) : calls_(calls) {}
  45
  46   ~TestObserver() override {}
  47
  48   void willProcessTask() override { calls_->append(" willProcessTask"); }
  49
  50   void didProcessTask() override { calls_->append(" didProcessTask"); }
  51
  52  private:
  53   std::string* calls_;  // NOT OWNED
  54 };
  55
  56 class TestTask : public blink::WebThread::Task {
  57  public:
  58   explicit TestTask(std::string* calls) : calls_(calls) {}
  59
  60   ~TestTask() override {}
  61
  62   void run() override { calls_->append(" run"); }
  63
  64  private:
  65   std::string* calls_;  // NOT OWNED
  66 };
  67
  68 void addTaskObserver(WebThreadImplForWorkerScheduler* thread,
  69                      TestObserver* observer) {
  70   thread->addTaskObserver(observer);
  71 }
  72
  73 void removeTaskObserver(WebThreadImplForWorkerScheduler* thread,
  74                         TestObserver* observer) {
  75   thread->removeTaskObserver(observer);
  76 }
  77
  78 }  // namespace
  79
  80 class WebThreadImplForWorkerSchedulerTest : public testing::Test {
  81  public:
  82   WebThreadImplForWorkerSchedulerTest() {}
  83
  84   ~WebThreadImplForWorkerSchedulerTest() override {}
  85
  86   void SetUp() override {
  87     thread_.reset(new WebThreadImplForWorkerScheduler("test thread"));
  88   }
  89
  90   void RunOnWorkerThread(const tracked_objects::Location& from_here,
  91                          const base::Closure& task) {
  92     base::WaitableEvent completion(false, false);
  93     thread_->TaskRunner()->PostTask(
  94         from_here,
  95         base::Bind(&WebThreadImplForWorkerSchedulerTest::RunOnWorkerThreadTask,
  96                    base::Unretained(this), task, &completion));
  97     completion.Wait();
  98   }
  99
 100  protected:
 101   void RunOnWorkerThreadTask(const base::Closure& task,
 102                              base::WaitableEvent* completion) {
 103     task.Run();
 104     completion->Signal();
 105   }
 106
 107   scoped_ptr<WebThreadImplForWorkerScheduler> thread_;
 108
 109   DISALLOW_COPY_AND_ASSIGN(WebThreadImplForWorkerSchedulerTest);
 110 };
 111
 112 TEST_F(WebThreadImplForWorkerSchedulerTest, TestDefaultTask) {
 113   scoped_ptr<MockTask> task(new MockTask());
 114   base::WaitableEvent completion(false, false);
 115
 116   EXPECT_CALL(*task, run());
 117   ON_CALL(*task, run())
 118       .WillByDefault(Invoke([&completion]() { completion.Signal(); }));
 119
 120   thread_->postTask(blink::WebTraceLocation(), task.release());
 121   completion.Wait();
 122 }
 123
 124 TEST_F(WebThreadImplForWorkerSchedulerTest,
 125        TestTaskExecutedBeforeThreadDeletion) {
 126   scoped_ptr<MockTask> task(new MockTask());
 127   base::WaitableEvent completion(false, false);
 128
 129   EXPECT_CALL(*task, run());
 130   ON_CALL(*task, run())
 131       .WillByDefault(Invoke([&completion]() { completion.Signal(); }));
 132
 133   thread_->postTask(blink::WebTraceLocation(), task.release());
 134   thread_.reset();
 135 }
 136
 137 TEST_F(WebThreadImplForWorkerSchedulerTest, TestIdleTask) {
 138   scoped_ptr<MockIdleTask> task(new MockIdleTask());
 139   base::WaitableEvent completion(false, false);
 140
 141   EXPECT_CALL(*task, run(_));
 142   ON_CALL(*task, run(_))
 143       .WillByDefault(Invoke([&completion](double) { completion.Signal(); }));
 144
 145   thread_->postIdleTask(blink::WebTraceLocation(), task.release());
 146   // We need to post a wakeup task or idle work will never happen.
 147   thread_->postDelayedTask(blink::WebTraceLocation(), new NopTask(), 50ul);
 148
 149   completion.Wait();
 150 }
 151
 152 TEST_F(WebThreadImplForWorkerSchedulerTest, TestTaskObserver) {
 153   std::string calls;
 154   TestObserver observer(&calls);
 155
 156   RunOnWorkerThread(FROM_HERE,
 157                     base::Bind(&addTaskObserver, thread_.get(), &observer));
 158   thread_->postTask(blink::WebTraceLocation(), new TestTask(&calls));
 159   RunOnWorkerThread(FROM_HERE,
 160                     base::Bind(&removeTaskObserver, thread_.get(), &observer));
 161
 162   // We need to be careful what we test here.  We want to make sure the
 163   // observers are un in the expected order before and after the task.
 164   // Sometimes we get an internal scheduler task running before or after
 165   // TestTask as well. This is not a bug, and we need to make sure the test
 166   // doesn't fail when that happens.
 167   EXPECT_THAT(calls, testing::HasSubstr("willProcessTask run didProcessTask"));
 168 }
 169
 170 }  // namespace content