[cc] BackToBackBFS: Disable time source if all pending observers removed

cc/scheduler/begin_frame_source_unittest.cc

 // Copyright 2011 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 "cc/scheduler/begin_frame_source.h"
 
 #include <stdint.h>
 
 #include "base/memory/ptr_util.h"
 #include "base/test/test_simple_task_runner.h"
@@ skipping 13 matching lines @@
   static const int64_t kDeadline;
   static const int64_t kInterval;
 
   void SetUp() override {
     now_src_.reset(new base::SimpleTestTickClock());
     now_src_->Advance(base::TimeDelta::FromMicroseconds(1000));
     task_runner_ =
         make_scoped_refptr(new OrderedSimpleTaskRunner(now_src_.get(), false));
     std::unique_ptr<TestDelayBasedTimeSource> time_source(
         new TestDelayBasedTimeSource(now_src_.get(), task_runner_.get()));
+    delay_based_time_source_ = time_source.get();
     source_.reset(new BackToBackBeginFrameSource(std::move(time_source)));
     obs_ = base::WrapUnique(new ::testing::StrictMock<MockBeginFrameObserver>);
   }
 
   void TearDown() override { obs_.reset(); }
 
   std::unique_ptr<base::SimpleTestTickClock> now_src_;
   scoped_refptr<OrderedSimpleTaskRunner> task_runner_;
   std::unique_ptr<BackToBackBeginFrameSource> source_;
   std::unique_ptr<MockBeginFrameObserver> obs_;
+  TestDelayBasedTimeSource* delay_based_time_source_;  // Owned by |now_src_|.
 };
 
 const int64_t BackToBackBeginFrameSourceTest::kDeadline =
     BeginFrameArgs::DefaultInterval().ToInternalValue();
 
 const int64_t BackToBackBeginFrameSourceTest::kInterval =
     BeginFrameArgs::DefaultInterval().ToInternalValue();
 
 TEST_F(BackToBackBeginFrameSourceTest, AddObserverSendsBeginFrame) {
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
@@ skipping 204 matching lines @@
   EXPECT_BEGIN_FRAME_USED(obs2, 1100, 1100 + kDeadline, kInterval);
   task_runner_->RunPendingTasks();
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
   source_->DidFinishFrame(&obs1, 0);
   EXPECT_BEGIN_FRAME_USED(obs1, 1200, 1200 + kDeadline, kInterval);
   task_runner_->RunPendingTasks();
 
   source_->DidFinishFrame(&obs1, 0);
   source_->RemoveObserver(&obs1);
+  // Removing all finished observers should disable the time source.
+  EXPECT_FALSE(delay_based_time_source_->Active());
   // Finishing the frame for |obs1| posts a begin frame task, which will be
   // aborted since |obs1| is removed. Clear that from the task runner.
   task_runner_->RunPendingTasks();
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
   source_->DidFinishFrame(&obs2, 0);
   EXPECT_BEGIN_FRAME_USED(obs2, 1300, 1300 + kDeadline, kInterval);
   task_runner_->RunPendingTasks();
 
   source_->DidFinishFrame(&obs2, 0);
@@ skipping 215 matching lines @@
                                    base::TimeDelta::FromInternalValue(10000));
   now_src_->Advance(base::TimeDelta::FromInternalValue(5000));
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs, false);
   EXPECT_BEGIN_FRAME_USED_MISSED(obs, 10000, 20000, 10000);
   source_->AddObserver(&obs);
   source_->RemoveObserver(&obs);
 }
 
 }  // namespace
 }  // namespace cc