Remove after wakeup logic and replace PumpTask with Fences

third_party/WebKit/Source/platform/scheduler/renderer/throttling_helper_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 "platform/scheduler/renderer/throttling_helper.h"
 
 #include <stddef.h>
 
 #include <memory>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "cc/test/ordered_simple_task_runner.h"
 #include "platform/scheduler/base/test_time_source.h"
+#include "platform/scheduler/base/real_time_domain.h"
 #include "platform/scheduler/child/scheduler_tqm_delegate_for_test.h"
 #include "platform/scheduler/renderer/auto_advancing_virtual_time_domain.h"
 #include "platform/scheduler/renderer/renderer_scheduler_impl.h"
 #include "platform/scheduler/renderer/web_frame_scheduler_impl.h"
 #include "platform/scheduler/renderer/web_view_scheduler_impl.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::ElementsAre;
 
 namespace blink {
 namespace scheduler {
 
 namespace {
-void CountingTask(size_t* count, scoped_refptr<TaskQueue> timer_queue) {
+void RunTenTimesTask(size_t* count, scoped_refptr<TaskQueue> timer_queue) {
   if (++(*count) < 10) {
     timer_queue->PostTask(FROM_HERE,
-                          base::Bind(&CountingTask, count, timer_queue));
+                          base::Bind(&RunTenTimesTask, count, timer_queue));
   }
 }
 }
 
 class ThrottlingHelperTest : public testing::Test {
  public:
   ThrottlingHelperTest() {}
   ~ThrottlingHelperTest() override {}
 
   void SetUp() override {
     clock_.reset(new base::SimpleTestTickClock());
     clock_->Advance(base::TimeDelta::FromMicroseconds(5000));
     mock_task_runner_ =
         make_scoped_refptr(new cc::OrderedSimpleTaskRunner(clock_.get(), true));
     delegate_ = SchedulerTqmDelegateForTest::Create(
         mock_task_runner_, base::MakeUnique<TestTimeSource>(clock_.get()));
     scheduler_.reset(new RendererSchedulerImpl(delegate_));
     throttling_helper_ = scheduler_->throttling_helper();
     timer_queue_ = scheduler_->NewTimerTaskRunner("test_queue");
   }
 
   void TearDown() override {
     scheduler_->Shutdown();
     scheduler_.reset();
   }
 
   void ExpectThrottled(scoped_refptr<TaskQueue> timer_queue) {
     size_t count = 0;
     timer_queue->PostTask(FROM_HERE,
-                          base::Bind(&CountingTask, &count, timer_queue));
+                          base::Bind(&RunTenTimesTask, &count, timer_queue));
 
     mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1));
-    EXPECT_LT(count, 10u);
-    mock_task_runner_->RunUntilIdle();
+    EXPECT_LE(count, 1u);
+
+    // Make sure the rest of the tasks run or we risk a UAF on |count|.
+    mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(10));
+    EXPECT_EQ(10u, count);
   }
 
   void ExpectUnthrottled(scoped_refptr<TaskQueue> timer_queue) {
     size_t count = 0;
     timer_queue->PostTask(FROM_HERE,
-                          base::Bind(&CountingTask, &count, timer_queue));
+                          base::Bind(&RunTenTimesTask, &count, timer_queue));
 
     mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1));
-    EXPECT_EQ(count, 10u);
+    EXPECT_EQ(10u, count);
     mock_task_runner_->RunUntilIdle();
   }
 
  protected:
   std::unique_ptr<base::SimpleTestTickClock> clock_;
   scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_;
   scoped_refptr<SchedulerTqmDelegate> delegate_;
   std::unique_ptr<RendererSchedulerImpl> scheduler_;
   scoped_refptr<TaskQueue> timer_queue_;
   ThrottlingHelper* throttling_helper_;  // NOT OWNED
@@ skipping 179 matching lines @@
 }
 
 namespace {
 bool MessageLoopTaskCounter(size_t* count) {
   *count = *count + 1;
   return true;
 }
 
 void NopTask() {}
 
+void AddOneTask(size_t* count) {
+  (*count)++;
+}
+
 }  // namespace
 
 TEST_F(ThrottlingHelperTest,
        SingleThrottledTaskPumpedAndRunWithNoExtraneousMessageLoopTasks) {
   throttling_helper_->IncreaseThrottleRefCount(timer_queue_.get());
 
   base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10));
   timer_queue_->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay);
 
   size_t task_count = 0;
   mock_task_runner_->RunTasksWhile(
       base::Bind(&MessageLoopTaskCounter, &task_count));
 
-  EXPECT_EQ(1u, task_count);
+  // Run the task and ThrottlingHelperTest::MaybeDisableQueue.
+  EXPECT_EQ(2u, task_count);
 }
 
 TEST_F(ThrottlingHelperTest,
        SingleFutureThrottledTaskPumpedAndRunWithNoExtraneousMessageLoopTasks) {
   throttling_helper_->IncreaseThrottleRefCount(timer_queue_.get());
 
   base::TimeDelta delay(base::TimeDelta::FromSecondsD(15.5));
   timer_queue_->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay);
 
   size_t task_count = 0;
   mock_task_runner_->RunTasksWhile(
       base::Bind(&MessageLoopTaskCounter, &task_count));
 
-  EXPECT_EQ(1u, task_count);
+  // Run the delayed task and ThrottlingHelperTest::MaybeDisableQueue.
+  EXPECT_EQ(2u, task_count);
 }
 
 TEST_F(ThrottlingHelperTest,
        TwoFutureThrottledTaskPumpedAndRunWithNoExtraneousMessageLoopTasks) {
   throttling_helper_->IncreaseThrottleRefCount(timer_queue_.get());
   std::vector<base::TimeTicks> run_times;
 
   base::TimeDelta delay(base::TimeDelta::FromSecondsD(15.5));
   timer_queue_->PostDelayedTask(
       FROM_HERE, base::Bind(&TestTask, &run_times, clock_.get()), delay);
 
   base::TimeDelta delay2(base::TimeDelta::FromSecondsD(5.5));
   timer_queue_->PostDelayedTask(
       FROM_HERE, base::Bind(&TestTask, &run_times, clock_.get()), delay2);
 
   size_t task_count = 0;
   mock_task_runner_->RunTasksWhile(
       base::Bind(&MessageLoopTaskCounter, &task_count));
 
-  EXPECT_EQ(2u, task_count);  // There are two since the cancelled task runs in
-  // the same DoWork batch.
+  // Run both delayed tasks and 2x ThrottlingHelperTest::MaybeDisableQueue.
+  EXPECT_EQ(4u, task_count);
 
   EXPECT_THAT(
       run_times,
       ElementsAre(base::TimeTicks() + base::TimeDelta::FromSeconds(6),
                   base::TimeTicks() + base::TimeDelta::FromSeconds(16)));
 }
 
 TEST_F(ThrottlingHelperTest, TaskDelayIsBasedOnRealTime) {
   std::vector<base::TimeTicks> run_times;
 
@@ skipping 30 matching lines @@
   throttling_helper_->IncreaseThrottleRefCount(timer_queue_.get());
   EXPECT_EQ(timer_queue_->GetTimeDomain()->Now(), clock_->NowTicks());
 
   clock_->Advance(base::TimeDelta::FromMilliseconds(250));
   // Make sure the throttled time domain's Now() reports the same as the
   // underlying clock.
   EXPECT_EQ(timer_queue_->GetTimeDomain()->Now(), clock_->NowTicks());
 }
 
 TEST_F(ThrottlingHelperTest, TaskQueueDisabledTillPump) {
-  timer_queue_->PostTask(FROM_HERE, base::Bind(&NopTask));
+  size_t count = 0;
+  timer_queue_->PostTask(FROM_HERE, base::Bind(&AddOneTask, &count));
 
   EXPECT_TRUE(timer_queue_->IsQueueEnabled());
   throttling_helper_->IncreaseThrottleRefCount(timer_queue_.get());
   EXPECT_FALSE(timer_queue_->IsQueueEnabled());
 
   mock_task_runner_->RunUntilIdle();  // Wait until the pump.
-  EXPECT_TRUE(timer_queue_->IsQueueEnabled());
+  // The queue must have been enabled for the task to run but after the pump it
+  // gets disabled again.
+  EXPECT_EQ(1u, count);
+  EXPECT_FALSE(timer_queue_->IsQueueEnabled());
 }
 
 TEST_F(ThrottlingHelperTest, TaskQueueUnthrottle_InitiallyEnabled) {
   timer_queue_->PostTask(FROM_HERE, base::Bind(&NopTask));
 
   timer_queue_->SetQueueEnabled(true);  // NOP
   throttling_helper_->IncreaseThrottleRefCount(timer_queue_.get());
   EXPECT_FALSE(timer_queue_->IsQueueEnabled());
 
   throttling_helper_->DecreaseThrottleRefCount(timer_queue_.get());
@@ skipping 26 matching lines @@
 
   throttling_helper_->IncreaseThrottleRefCount(timer_queue_.get());
   EXPECT_FALSE(timer_queue_->IsQueueEnabled());
 
   throttling_helper_->SetQueueEnabled(timer_queue_.get(), false);
   throttling_helper_->DecreaseThrottleRefCount(timer_queue_.get());
   EXPECT_FALSE(timer_queue_->IsQueueEnabled());
 }
 
 TEST_F(ThrottlingHelperTest, TaskQueueDisabledTillPump_ThenManuallyDisabled) {
-  timer_queue_->PostTask(FROM_HERE, base::Bind(&NopTask));
+  size_t count = 0;
+  timer_queue_->PostTask(FROM_HERE, base::Bind(&AddOneTask, &count));
 
   EXPECT_TRUE(timer_queue_->IsQueueEnabled());
   throttling_helper_->IncreaseThrottleRefCount(timer_queue_.get());
   EXPECT_FALSE(timer_queue_->IsQueueEnabled());
 
   mock_task_runner_->RunUntilIdle();  // Wait until the pump.
-  EXPECT_TRUE(timer_queue_->IsQueueEnabled());
+  // The queue must have been enabled for the task to run but after the pump it
+  // gets disabled again.
+  EXPECT_EQ(1u, count);
+  EXPECT_FALSE(timer_queue_->IsQueueEnabled());
 
   throttling_helper_->SetQueueEnabled(timer_queue_.get(), false);
   EXPECT_FALSE(timer_queue_->IsQueueEnabled());
 }
 
 TEST_F(ThrottlingHelperTest, DoubleIncrementDoubleDecrement) {
   timer_queue_->PostTask(FROM_HERE, base::Bind(&NopTask));
 
   EXPECT_TRUE(timer_queue_->IsQueueEnabled());
   throttling_helper_->IncreaseThrottleRefCount(timer_queue_.get());
@@ skipping 23 matching lines @@
   throttling_helper_->IncreaseThrottleRefCount(timer_queue_.get());
   EXPECT_FALSE(timer_queue_->IsQueueEnabled());
 
   scheduler_->EnableVirtualTime();
   EXPECT_TRUE(timer_queue_->IsQueueEnabled());
   EXPECT_EQ(timer_queue_->GetTimeDomain(), scheduler_->GetVirtualTimeDomain());
 }
 
 }  // namespace scheduler
 }  // namespace blink