[cc] Plumb BeginFrameAcks through SurfaceManager to DisplayScheduler.

cc/surfaces/surface_synchronization_unittest.cc

 // Copyright 2017 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 "base/containers/flat_set.h"
 #include "cc/surfaces/compositor_frame_sink_support.h"
 #include "cc/surfaces/surface_id.h"
 #include "cc/surfaces/surface_manager.h"
-#include "cc/surfaces/surface_observer.h"
 #include "cc/test/begin_frame_args_test.h"
 #include "cc/test/compositor_frame_helpers.h"
 #include "cc/test/fake_external_begin_frame_source.h"
+#include "cc/test/fake_surface_observer.h"
 #include "cc/test/mock_compositor_frame_sink_support_client.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::Eq;
 using testing::IsEmpty;
 using testing::UnorderedElementsAre;
 
 namespace cc {
@@ skipping 15 matching lines @@
 }
 
 SurfaceId MakeSurfaceId(const FrameSinkId& frame_sink_id, uint32_t local_id) {
   return SurfaceId(
       frame_sink_id,
       LocalSurfaceId(local_id, base::UnguessableToken::Deserialize(0, 1u)));
 }
 
 }  // namespace
 
-class SurfaceSynchronizationTest : public testing::Test,
-                                   public SurfaceObserver {
+class SurfaceSynchronizationTest : public testing::Test {
  public:
   SurfaceSynchronizationTest()
-      : surface_manager_(SurfaceManager::LifetimeType::REFERENCES) {}
+      : surface_manager_(SurfaceManager::LifetimeType::REFERENCES),
+        surface_observer_(false) {}
   ~SurfaceSynchronizationTest() override {}
 
   CompositorFrameSinkSupport& display_support() { return *supports_[0]; }
   Surface* display_surface() {
     return display_support().current_surface_for_testing();
   }
 
   CompositorFrameSinkSupport& parent_support() { return *supports_[1]; }
   Surface* parent_surface() {
     return parent_support().current_surface_for_testing();
@@ skipping 31 matching lines @@
   }
 
   SurfaceDependencyTracker& dependency_tracker() {
     return *surface_manager_.dependency_tracker();
   }
 
   FakeExternalBeginFrameSource* begin_frame_source() {
     return begin_frame_source_.get();
   }
 
+  FakeSurfaceObserver& surface_observer() { return surface_observer_; }
+
   // testing::Test:
   void SetUp() override {
     testing::Test::SetUp();
 
     begin_frame_source_ =
         base::MakeUnique<FakeExternalBeginFrameSource>(0.f, false);
     dependency_tracker_ = base::MakeUnique<SurfaceDependencyTracker>(
         &surface_manager_, begin_frame_source_.get());
     surface_manager_.SetDependencyTracker(dependency_tracker_.get());
-    surface_manager_.AddObserver(this);
+    surface_manager_.AddObserver(&surface_observer_);
     supports_.push_back(CompositorFrameSinkSupport::Create(
         &support_client_, &surface_manager_, kDisplayFrameSink, kIsRoot,
         kHandlesFrameSinkIdInvalidation, kNeedsSyncPoints));
     supports_.push_back(CompositorFrameSinkSupport::Create(
         &support_client_, &surface_manager_, kParentFrameSink, kIsChildRoot,
         kHandlesFrameSinkIdInvalidation, kNeedsSyncPoints));
     supports_.push_back(CompositorFrameSinkSupport::Create(
         &support_client_, &surface_manager_, kChildFrameSink1, kIsChildRoot,
         kHandlesFrameSinkIdInvalidation, kNeedsSyncPoints));
     supports_.push_back(CompositorFrameSinkSupport::Create(
         &support_client_, &surface_manager_, kChildFrameSink2, kIsChildRoot,
         kHandlesFrameSinkIdInvalidation, kNeedsSyncPoints));
 
     // Normally, the BeginFrameSource would be registered by the Display. We
     // register it here so that BeginFrames are received by the display support,
     // for use in the PassesOnBeginFrameAcks test. Other supports do not receive
     // BeginFrames, since the frame sink hierarchy is not set up in this test.
     surface_manager_.RegisterBeginFrameSource(begin_frame_source_.get(),
                                               kDisplayFrameSink);
   }
 
   void TearDown() override {
-    surface_manager_.RemoveObserver(this);
+    surface_manager_.RemoveObserver(&surface_observer_);
     surface_manager_.SetDependencyTracker(nullptr);
     surface_manager_.UnregisterBeginFrameSource(begin_frame_source_.get());
 
     dependency_tracker_.reset();
 
     // SurfaceDependencyTracker depends on this BeginFrameSource and so it must
     // be destroyed AFTER the dependency tracker is destroyed.
     begin_frame_source_.reset();
 
     supports_.clear();
 
-    damaged_surfaces_.clear();
+    surface_observer_.Reset();
   }
 
-  bool IsSurfaceDamaged(const SurfaceId& surface_id) const {
-    return damaged_surfaces_.count(surface_id) > 0;
-  }
-
-  // SurfaceObserver implementation:
-  void OnSurfaceCreated(const SurfaceInfo& surface_info) override {}
-  void OnSurfaceDamaged(const SurfaceId& surface_id, bool* changed) override {
-    damaged_surfaces_.insert(surface_id);
-  }
-  void OnSurfaceDiscarded(const SurfaceId& surface_id) override {}
-
  protected:
   testing::NiceMock<MockCompositorFrameSinkSupportClient> support_client_;
 
  private:
-  base::flat_set<SurfaceId> damaged_surfaces_;
   SurfaceManager surface_manager_;
+  FakeSurfaceObserver surface_observer_;
   std::unique_ptr<FakeExternalBeginFrameSource> begin_frame_source_;
   std::unique_ptr<SurfaceDependencyTracker> dependency_tracker_;
   std::vector<std::unique_ptr<CompositorFrameSinkSupport>> supports_;
 
   DISALLOW_COPY_AND_ASSIGN(SurfaceSynchronizationTest);
 };
 
 // The display root surface should have a surface reference from the top-level
 // root added/removed when a CompositorFrame is submitted with a new SurfaceId.
 TEST_F(SurfaceSynchronizationTest, RootSurfaceReceivesReferences) {
@@ skipping 75 matching lines @@
       MakeCompositorFrame({child_id1}, empty_surface_ids(),
                           TransferableResourceArray()));
 
   // parent_support is blocked on |child_id1|.
   EXPECT_TRUE(dependency_tracker().has_deadline());
   EXPECT_FALSE(parent_surface()->HasActiveFrame());
   EXPECT_TRUE(parent_surface()->HasPendingFrame());
   EXPECT_THAT(parent_surface()->blocking_surfaces(),
               UnorderedElementsAre(child_id1));
   // The parent should not report damage until it activates.
-  EXPECT_FALSE(IsSurfaceDamaged(parent_id));
+  EXPECT_FALSE(surface_observer().IsSurfaceDamaged(parent_id));
 
   child_support1().SubmitCompositorFrame(
       child_id1.local_surface_id(),
       MakeCompositorFrame({child_id2}, empty_surface_ids(),
                           TransferableResourceArray()));
 
   // child_support1 should now be blocked on |child_id2|.
   EXPECT_TRUE(dependency_tracker().has_deadline());
   EXPECT_FALSE(child_surface1()->HasActiveFrame());
   EXPECT_TRUE(child_surface1()->HasPendingFrame());
   EXPECT_THAT(child_surface1()->blocking_surfaces(),
               UnorderedElementsAre(child_id2));
   // The parent and child should not report damage until they activate.
-  EXPECT_FALSE(IsSurfaceDamaged(parent_id));
-  EXPECT_FALSE(IsSurfaceDamaged(child_id1));
+  EXPECT_FALSE(surface_observer().IsSurfaceDamaged(parent_id));
+  EXPECT_FALSE(surface_observer().IsSurfaceDamaged(child_id1));
 
   // The parent should still be blocked on |child_id1| because it's pending.
   EXPECT_THAT(parent_surface()->blocking_surfaces(),
               UnorderedElementsAre(child_id1));
 
   // Submit a CompositorFrame without any dependencies to |child_id2|.
   // parent_support should be activated.
   child_support2().SubmitCompositorFrame(
       child_id2.local_surface_id(),
       MakeCompositorFrame(empty_surface_ids(), empty_surface_ids(),
                           TransferableResourceArray()));
 
   EXPECT_FALSE(dependency_tracker().has_deadline());
 
   // child_surface1 should now be active.
   EXPECT_TRUE(child_surface1()->HasActiveFrame());
   EXPECT_FALSE(child_surface1()->HasPendingFrame());
   EXPECT_THAT(child_surface1()->blocking_surfaces(), IsEmpty());
 
   // parent_surface should now be active.
   EXPECT_TRUE(parent_surface()->HasActiveFrame());
   EXPECT_FALSE(parent_surface()->HasPendingFrame());
   EXPECT_THAT(parent_surface()->blocking_surfaces(), IsEmpty());
 
   // All three surfaces |parent_id|, |child_id1|, and |child_id2| should
   // now report damage. This would trigger a new display frame.
-  EXPECT_TRUE(IsSurfaceDamaged(parent_id));
-  EXPECT_TRUE(IsSurfaceDamaged(child_id1));
-  EXPECT_TRUE(IsSurfaceDamaged(child_id2));
+  EXPECT_TRUE(surface_observer().IsSurfaceDamaged(parent_id));
+  EXPECT_TRUE(surface_observer().IsSurfaceDamaged(child_id1));
+  EXPECT_TRUE(surface_observer().IsSurfaceDamaged(child_id2));
 }
 
 // parent_surface and child_surface1 are blocked on |child_id2|.
 TEST_F(SurfaceSynchronizationTest, TwoBlockedOnOne) {
   const SurfaceId parent_id = MakeSurfaceId(kParentFrameSink, 1);
   const SurfaceId child_id1 = MakeSurfaceId(kChildFrameSink1, 1);
   const SurfaceId child_id2 = MakeSurfaceId(kChildFrameSink2, 1);
 
   parent_support().SubmitCompositorFrame(
       parent_id.local_surface_id(),
@@ skipping 654 matching lines @@
   ui::LatencyInfo::LatencyComponent comp1;
   EXPECT_TRUE(
       aggregated_latency_info.FindLatency(latency_type1, latency_id1, &comp1));
   EXPECT_EQ(latency_sequence_number1, comp1.sequence_number);
   EXPECT_TRUE(
       aggregated_latency_info.FindLatency(latency_type2, latency_id2, nullptr));
   EXPECT_TRUE(aggregated_latency_info.FindLatency(
       ui::DISPLAY_COMPOSITOR_RECEIVED_FRAME_COMPONENT, nullptr));
 }
 
-// TODO(eseckler): Add back tests for BeginFrameAck forwarding through
-// CompositorFrameSinkSupport when we add plumbing of BeginFrameAcks through
-// SurfaceObservers.
-
 // Checks that resources and ack are sent together if possible.
 TEST_F(SurfaceSynchronizationTest, ReturnResourcesWithAck) {
   const SurfaceId parent_id = MakeSurfaceId(kParentFrameSink, 1);
   TransferableResource resource;
   resource.id = 1234;
   parent_support().SubmitCompositorFrame(
       parent_id.local_surface_id(),
       MakeCompositorFrame(empty_surface_ids(), empty_surface_ids(),
                           {resource}));
   ReturnedResourceArray returned_resources;
@@ skipping 362 matching lines @@
               DidReceiveCompositorFrameAck(Eq(returned_resources2)));
   child_support1().SubmitCompositorFrame(
       child_id1.local_surface_id(),
       MakeCompositorFrame(empty_surface_ids(), empty_surface_ids(),
                           {resource2}));
   testing::Mock::VerifyAndClearExpectations(&support_client_);
 }
 
 }  // namespace test
 }  // namespace cc