cc::SurfaceDependencyTracker should not crash when a Display goes away

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"
 #include "cc/test/begin_frame_args_test.h"
 #include "cc/test/begin_frame_source_test.h"
 #include "cc/test/scheduler_test_common.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using testing::StrictMock;
+using testing::NiceMock;
 
 namespace cc {
 namespace {
 
 // BeginFrameSource testing ----------------------------------------------------
 TEST(BeginFrameSourceTest, SourceIdsAreUnique) {
   StubBeginFrameSource source1;
   StubBeginFrameSource source2;
   StubBeginFrameSource source3;
   EXPECT_NE(source1.source_id(), source2.source_id());
   EXPECT_NE(source1.source_id(), source3.source_id());
   EXPECT_NE(source2.source_id(), source3.source_id());
 }
 
 // BackToBackBeginFrameSource testing ------------------------------------------
 class BackToBackBeginFrameSourceTest : public ::testing::Test {
  protected:
   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>);
+    obs_ = base::WrapUnique(new ::testing::NiceMock<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_|.
 };
@@ skipping 165 matching lines @@
   // Ticks at the time the last frame finished, so ignores the last change to
   // "now".
   EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1100,
                           1100 + kDeadline, kInterval);
 
   EXPECT_TRUE(task_runner_->HasPendingTasks());
   task_runner_->RunPendingTasks();
 }
 
 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversSynchronized) {
-  StrictMock<MockBeginFrameObserver> obs1, obs2;
+  NiceMock<MockBeginFrameObserver> obs1, obs2;
 
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false);
   source_->AddObserver(&obs1);
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false);
   source_->AddObserver(&obs2);
 
   EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 1, 1000, 1000 + kDeadline,
                           kInterval);
   EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 1, 1000, 1000 + kDeadline,
                           kInterval);
@@ skipping 15 matching lines @@
                           BeginFrameAck(source_->source_id(), 2, 2, true));
   source_->DidFinishFrame(&obs2,
                           BeginFrameAck(source_->source_id(), 2, 2, true));
   EXPECT_TRUE(task_runner_->HasPendingTasks());
   source_->RemoveObserver(&obs1);
   source_->RemoveObserver(&obs2);
   task_runner_->RunPendingTasks();
 }
 
 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversInterleaved) {
-  StrictMock<MockBeginFrameObserver> obs1, obs2;
+  NiceMock<MockBeginFrameObserver> obs1, obs2;
 
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false);
   source_->AddObserver(&obs1);
   EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 1, 1000, 1000 + kDeadline,
                           kInterval);
   task_runner_->RunPendingTasks();
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false);
   source_->AddObserver(&obs2);
@@ skipping 23 matching lines @@
   EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 4, 1300, 1300 + kDeadline,
                           kInterval);
   task_runner_->RunPendingTasks();
 
   source_->DidFinishFrame(&obs2,
                           BeginFrameAck(source_->source_id(), 4, 4, true));
   source_->RemoveObserver(&obs2);
 }
 
 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversAtOnce) {
-  StrictMock<MockBeginFrameObserver> obs1, obs2;
+  NiceMock<MockBeginFrameObserver> obs1, obs2;
 
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false);
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false);
   source_->AddObserver(&obs1);
   source_->AddObserver(&obs2);
   EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 1, 1000, 1000 + kDeadline,
                           kInterval);
   EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 1, 1000, 1000 + kDeadline,
                           kInterval);
   task_runner_->RunPendingTasks();
@@ skipping 131 matching lines @@
 
   // Change the vsync params, but the new interval will be ignored.
   source_->OnUpdateVSyncParameters(base::TimeTicks::FromInternalValue(400),
                                    base::TimeDelta::FromMicroseconds(1));
   EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 6, 50495, 60394, 9999);
   EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 7, 60394, 70393, 9999);
   task_runner_->RunUntilTime(base::TimeTicks::FromInternalValue(60395));
 }
 
 TEST_F(DelayBasedBeginFrameSourceTest, MultipleObservers) {
-  StrictMock<MockBeginFrameObserver> obs1, obs2;
+  NiceMock<MockBeginFrameObserver> obs1, obs2;
 
   // now_src_ starts off at 1000.
   task_runner_->RunForPeriod(base::TimeDelta::FromMicroseconds(9010));
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false);
   EXPECT_BEGIN_FRAME_USED_MISSED(obs1, source_->source_id(), 1, 10000, 20000,
                                  10000);
   source_->AddObserver(&obs1);  // Should cause the last tick to be sent
   // No tasks should need to be run for this to occur.
 
   EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 2, 20000, 30000, 10000);
@@ skipping 14 matching lines @@
 
   EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 4, 40000, 50000, 10000);
   task_runner_->RunForPeriod(base::TimeDelta::FromMicroseconds(10000));
 
   source_->RemoveObserver(&obs2);
   task_runner_->RunUntilTime(base::TimeTicks::FromInternalValue(50000));
   EXPECT_FALSE(task_runner_->HasPendingTasks());
 }
 
 TEST_F(DelayBasedBeginFrameSourceTest, DoubleTick) {
-  StrictMock<MockBeginFrameObserver> obs;
+  NiceMock<MockBeginFrameObserver> obs;
 
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs, false);
   EXPECT_BEGIN_FRAME_USED_MISSED(obs, source_->source_id(), 1, 0, 10000, 10000);
   source_->AddObserver(&obs);
 
   source_->OnUpdateVSyncParameters(base::TimeTicks::FromInternalValue(5000),
                                    base::TimeDelta::FromInternalValue(10000));
   now_src_->Advance(base::TimeDelta::FromInternalValue(4000));
 
   // No begin frame received.
   task_runner_->RunPendingTasks();
 
   // Begin frame received.
   source_->OnUpdateVSyncParameters(base::TimeTicks::FromInternalValue(10000),
                                    base::TimeDelta::FromInternalValue(10000));
   now_src_->Advance(base::TimeDelta::FromInternalValue(5000));
   EXPECT_BEGIN_FRAME_USED(obs, source_->source_id(), 2, 10000, 20000, 10000);
   task_runner_->RunPendingTasks();
 }
 
 TEST_F(DelayBasedBeginFrameSourceTest, DoubleTickMissedFrame) {
-  StrictMock<MockBeginFrameObserver> obs;
+  NiceMock<MockBeginFrameObserver> obs;
 
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs, false);
   EXPECT_BEGIN_FRAME_USED_MISSED(obs, source_->source_id(), 1, 0, 10000, 10000);
   source_->AddObserver(&obs);
   source_->RemoveObserver(&obs);
 
   source_->OnUpdateVSyncParameters(base::TimeTicks::FromInternalValue(5000),
                                    base::TimeDelta::FromInternalValue(10000));
   now_src_->Advance(base::TimeDelta::FromInternalValue(4000));
 
@@ skipping 60 matching lines @@
   // not notify observer.
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
   EXPECT_CALL((*client_), OnNeedsBeginFrames(true)).Times(1);
   ExternalBeginFrameSource source2(client_.get());
   source2.AddObserver(obs_.get());
   source2.OnBeginFrame(args);
 }
 
 }  // namespace
 }  // namespace cc