Replace TestSurfaceReferenceFactory in surface_layer_unittests.cc with a mock implementation

cc/layers/surface_layer_unittest.cc

Index: cc/layers/surface_layer_unittest.cc
diff --git a/cc/layers/surface_layer_unittest.cc b/cc/layers/surface_layer_unittest.cc
index 0ee4e8365008bb523c6fb02da258eb9eed5637c0..45a94f9c4f8a044f9148b25ee66344cc6d405743 100644
--- a/cc/layers/surface_layer_unittest.cc
+++ b/cc/layers/surface_layer_unittest.cc
@@ -32,6 +32,9 @@
 namespace cc {
 namespace {
 
+using testing::_;
+using testing::Eq;
+
 static constexpr FrameSinkId kArbitraryFrameSinkId(1, 1);
 
 class SurfaceLayerTest : public testing::Test {
@@ -63,33 +66,20 @@ class SurfaceLayerTest : public testing::Test {
   FakeLayerTreeHostImpl host_impl_;
 };
 
-class TestSurfaceReferenceFactory : public SequenceSurfaceReferenceFactory {
- protected:
-  void SatisfySequence(const SurfaceSequence& seq) const override {
-    *out_seq_ = seq;
-  }
-
-  void RequireSequence(const SurfaceId& id,
-                       const SurfaceSequence& seq) const override {
-    *out_id_ = id;
-    out_set_->insert(seq);
-  }
-
+class MockSurfaceReferenceFactory : public SequenceSurfaceReferenceFactory {
  public:
-  TestSurfaceReferenceFactory(SurfaceSequence* out_seq,
-                              SurfaceId* out_id,
-                              std::set<SurfaceSequence>* out_set)
-      : out_seq_(out_seq), out_id_(out_id), out_set_(out_set) {}
+  MockSurfaceReferenceFactory() {}
+
+  // SequenceSurfaceReferenceFactory implementation.
+  MOCK_CONST_METHOD1(SatisfySequence, void(const SurfaceSequence&));
+  MOCK_CONST_METHOD2(RequireSequence,
+                     void(const SurfaceId&, const SurfaceSequence&));
 
  protected:
-  ~TestSurfaceReferenceFactory() override = default;
+  ~MockSurfaceReferenceFactory() override = default;
 
  private:
-  SurfaceSequence* out_seq_;
-  SurfaceId* out_id_;
-  std::set<SurfaceSequence>* out_set_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestSurfaceReferenceFactory);
+  DISALLOW_COPY_AND_ASSIGN(MockSurfaceReferenceFactory);
 };
 
 // Check that one surface can be referenced by multiple LayerTreeHosts, and
@@ -97,17 +87,26 @@ class TestSurfaceReferenceFactory : public SequenceSurfaceReferenceFactory {
 TEST_F(SurfaceLayerTest, MultipleFramesOneSurface) {
   const base::UnguessableToken kArbitraryToken =
       base::UnguessableToken::Create();
-  SurfaceSequence blank_change;  // Receives sequence if commit doesn't happen.
-
-  SurfaceId required_id;
-  std::set<SurfaceSequence> required_seq;
-  scoped_refptr<SurfaceReferenceFactory> ref_factory =
-      new TestSurfaceReferenceFactory(&blank_change, &required_id,
-                                      &required_seq);
-  auto layer = SurfaceLayer::Create(ref_factory);
-  SurfaceInfo info(
+  const SurfaceInfo info(
       SurfaceId(kArbitraryFrameSinkId, LocalSurfaceId(1, kArbitraryToken)), 1.f,
       gfx::Size(1, 1));
+  const SurfaceSequence expected_seq1(FrameSinkId(1, 1), 1u);
+  const SurfaceSequence expected_seq2(FrameSinkId(2, 2), 1u);
+  const SurfaceId expected_id(kArbitraryFrameSinkId,
+                              LocalSurfaceId(1, kArbitraryToken));
+
+  scoped_refptr<MockSurfaceReferenceFactory> ref_factory =
+      new testing::StrictMock<MockSurfaceReferenceFactory>();
+
+  // We are going to set up the SurfaceLayers and LayerTreeHosts. Each layer
+  // will require a sequence and no sequence should be satisfied for now.
+  EXPECT_CALL(*ref_factory, RequireSequence(Eq(expected_id), Eq(expected_seq1)))
+      .Times(1);
+  EXPECT_CALL(*ref_factory, RequireSequence(Eq(expected_id), Eq(expected_seq2)))
+      .Times(1);
+  EXPECT_CALL(*ref_factory, SatisfySequence(_)).Times(0);
+
+  auto layer = SurfaceLayer::Create(ref_factory);
   layer->SetPrimarySurfaceInfo(info);
   layer_tree_host_->GetSurfaceSequenceGenerator()->set_frame_sink_id(
       FrameSinkId(1, 1));
@@ -117,57 +116,40 @@ TEST_F(SurfaceLayerTest, MultipleFramesOneSurface) {
   std::unique_ptr<FakeLayerTreeHost> layer_tree_host2 =
       FakeLayerTreeHost::Create(&fake_client_, &task_graph_runner_,
                                 animation_host2.get());
-  auto layer2 = SurfaceLayer::Create(std::move(ref_factory));
+  auto layer2 = SurfaceLayer::Create(ref_factory);
   layer2->SetPrimarySurfaceInfo(info);
   layer_tree_host2->GetSurfaceSequenceGenerator()->set_frame_sink_id(
       FrameSinkId(2, 2));
   layer_tree_host2->SetRootLayer(layer2);
 
-  // Layers haven't been removed, so no sequence should be satisfied.
-  EXPECT_FALSE(blank_change.is_valid());
-
-  SurfaceSequence expected1(FrameSinkId(1, 1), 1u);
-  SurfaceSequence expected2(FrameSinkId(2, 2), 1u);
+  testing::Mock::VerifyAndClearExpectations(ref_factory.get());
 
+  // Destroy the second LayerTreeHost. The sequence generated by its
+  // SurfaceLayer must be satisfied and no new sequences must be required.
+  EXPECT_CALL(*ref_factory, SatisfySequence(Eq(expected_seq2))).Times(1);
   layer_tree_host2->SetRootLayer(nullptr);
   layer_tree_host2.reset();
   animation_host2 = nullptr;
-
-  // Layer was removed so sequence from second LayerTreeHost should be
-  // satisfied.
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(blank_change == expected2);
-
-  // Set of sequences that need to be satisfied should include sequences from
-  // both trees.
-  EXPECT_TRUE(required_id == SurfaceId(kArbitraryFrameSinkId,
-                                       LocalSurfaceId(1, kArbitraryToken)));
-  EXPECT_EQ(2u, required_seq.size());
-  EXPECT_TRUE(required_seq.count(expected1));
-  EXPECT_TRUE(required_seq.count(expected2));
+  testing::Mock::VerifyAndClearExpectations(ref_factory.get());
 
+  // Destroy the first LayerTreeHost. The sequence generated by its
+  // SurfaceLayer must be satisfied and no new sequences must be required.
+  EXPECT_CALL(*ref_factory, SatisfySequence(expected_seq1)).Times(1);
+  EXPECT_CALL(*ref_factory, RequireSequence(_, _)).Times(0);
   layer_tree_host_->SetRootLayer(nullptr);
   layer_tree_host_.reset();
-
-  // Layer was removed so sequence from first LayerTreeHost should be
-  // satisfied.
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(blank_change == expected1);
-
-  // No more SurfaceSequences should have been generated that need to have be
-  // satisfied.
-  EXPECT_EQ(2u, required_seq.size());
+  testing::Mock::VerifyAndClearExpectations(ref_factory.get());
 }
 
 // This test verifies that the primary and fallback SurfaceInfo are pushed
 // across from SurfaceLayer to SurfaceLayerImpl.
 TEST_F(SurfaceLayerTest, SurfaceInfoPushProperties) {
-  SurfaceSequence blank_change;
-  SurfaceId required_id;
-  std::set<SurfaceSequence> required_sequences;
+  // We use a nice mock here because we are not really interested in calls to
+  // MockSurfaceReferenceFactory and we don't want warnings printed.
   scoped_refptr<SurfaceReferenceFactory> ref_factory =
-      new TestSurfaceReferenceFactory(&blank_change, &required_id,
-                                      &required_sequences);
+      new testing::NiceMock<MockSurfaceReferenceFactory>();
 
   scoped_refptr<SurfaceLayer> layer = SurfaceLayer::Create(ref_factory);
   layer_tree_host_->SetRootLayer(layer);
@@ -208,24 +190,34 @@ class SurfaceLayerSwapPromise : public LayerTreeTest {
   void BeginTest() override {
     layer_tree_host()->GetSurfaceSequenceGenerator()->set_frame_sink_id(
         FrameSinkId(1, 1));
-    layer_ = SurfaceLayer::Create(new TestSurfaceReferenceFactory(
-        &satisfied_sequence_, &required_id_, &required_set_));
+    ref_factory_ = new testing::StrictMock<MockSurfaceReferenceFactory>();
+
+    // Create a SurfaceLayer but don't add it to the tree yet. No sequence
+    // should be required / satisfied.
+    EXPECT_CALL(*ref_factory_, SatisfySequence(_)).Times(0);
+    EXPECT_CALL(*ref_factory_, RequireSequence(_, _)).Times(0);
+    layer_ = SurfaceLayer::Create(ref_factory_);
     SurfaceInfo info(
         SurfaceId(kArbitraryFrameSinkId, LocalSurfaceId(1, kArbitraryToken)),
         1.f, gfx::Size(1, 1));
     layer_->SetPrimarySurfaceInfo(info);
-
-    // Layer hasn't been added to tree so no SurfaceSequence generated yet.
-    EXPECT_EQ(0u, required_set_.size());
-
+    testing::Mock::VerifyAndClearExpectations(ref_factory_.get());
+
+    // Add the layer to the tree. A sequence must be required.
+    SurfaceSequence expected_seq(kArbitraryFrameSinkId, 1u);
+    SurfaceId expected_id(kArbitraryFrameSinkId,
+                          LocalSurfaceId(1, kArbitraryToken));
+    EXPECT_CALL(*ref_factory_, SatisfySequence(_)).Times(0);
+    EXPECT_CALL(*ref_factory_,
+                RequireSequence(Eq(expected_id), Eq(expected_seq)))
+        .Times(1);
     layer_tree_host()->SetRootLayer(layer_);
+    testing::Mock::VerifyAndClearExpectations(ref_factory_.get());
 
-    // Should have SurfaceSequence from first tree.
-    SurfaceSequence expected(kArbitraryFrameSinkId, 1u);
-    EXPECT_TRUE(required_id_ == SurfaceId(kArbitraryFrameSinkId,
-                                          LocalSurfaceId(1, kArbitraryToken)));
-    EXPECT_EQ(1u, required_set_.size());
-    EXPECT_TRUE(required_set_.count(expected));
+    // By the end of the test, the required sequence must be satisfied and no
+    // more sequence must be required.
+    EXPECT_CALL(*ref_factory_, SatisfySequence(Eq(expected_seq))).Times(1);
+    EXPECT_CALL(*ref_factory_, RequireSequence(_, _)).Times(0);
 
     gfx::Size bounds(100, 100);
     layer_tree_host()->SetViewportSize(bounds);
@@ -245,15 +237,17 @@ class SurfaceLayerSwapPromise : public LayerTreeTest {
                                   base::Unretained(this)));
   }
 
+  void AfterTest() override {
+    testing::Mock::VerifyAndClearExpectations(ref_factory_.get());

[danakj, 2017/04/20 21:40:36]

Tests will verify mocks implicitly when the mock is destroyed, so I think you
can omit this

+  }
+
  protected:
   int commit_count_;
   bool sequence_was_satisfied_;
   scoped_refptr<SurfaceLayer> layer_;
   scoped_refptr<Layer> blank_layer_;
-  SurfaceSequence satisfied_sequence_;
+  scoped_refptr<MockSurfaceReferenceFactory> ref_factory_;
 
-  SurfaceId required_id_;
-  std::set<SurfaceSequence> required_set_;
   const base::UnguessableToken kArbitraryToken =
       base::UnguessableToken::Create();
 };
@@ -276,14 +270,6 @@ class SurfaceLayerSwapPromiseWithDraw : public SurfaceLayerSwapPromise {
         break;
     }
   }
-
-  void AfterTest() override {
-    EXPECT_TRUE(required_id_ == SurfaceId(kArbitraryFrameSinkId,
-                                          LocalSurfaceId(1, kArbitraryToken)));
-    EXPECT_EQ(1u, required_set_.size());
-    EXPECT_TRUE(satisfied_sequence_ ==
-                SurfaceSequence(kArbitraryFrameSinkId, 1u));
-  }
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(SurfaceLayerSwapPromiseWithDraw);
@@ -315,14 +301,6 @@ class SurfaceLayerSwapPromiseWithoutDraw : public SurfaceLayerSwapPromise {
         break;
     }
   }
-
-  void AfterTest() override {
-    EXPECT_TRUE(required_id_ == SurfaceId(kArbitraryFrameSinkId,
-                                          LocalSurfaceId(1, kArbitraryToken)));
-    EXPECT_EQ(1u, required_set_.size());
-    EXPECT_TRUE(satisfied_sequence_ ==
-                SurfaceSequence(kArbitraryFrameSinkId, 1u));
-  }
 };
 
 MULTI_THREAD_TEST_F(SurfaceLayerSwapPromiseWithoutDraw);