Plumb SetVisible from ui::Compositor to the DirectRenderer.

cc/surfaces/display_scheduler_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 "cc/surfaces/display_scheduler.h"
 
 #include "base/logging.h"
 #include "base/test/null_task_runner.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 91 matching lines @@
   FakeDisplaySchedulerClient client_;
   TestDisplayScheduler scheduler_;
 };
 
 TEST_F(DisplaySchedulerTest, ResizeHasLateDeadlineUntilNewRootSurface) {
   SurfaceId root_surface_id1(0, 1, 0);
   SurfaceId root_surface_id2(0, 2, 0);
   SurfaceId sid1(0, 3, 0);
   base::TimeTicks late_deadline;
 
+  scheduler_.SetVisible(true);
+
   // Go trough an initial BeginFrame cycle with the root surface.
   BeginFrameForTest();
   scheduler_.SetNewRootSurface(root_surface_id1);
   scheduler_.BeginFrameDeadlineForTest();
 
   // Resize on the next begin frame cycle should cause the deadline to wait
   // for a new root surface.
   late_deadline = now_src().NowTicks() + BeginFrameArgs::DefaultInterval();
   BeginFrameForTest();
   scheduler_.SurfaceDamaged(sid1);
@@ skipping 14 matching lines @@
   EXPECT_GE(now_src().NowTicks(),
             scheduler_.DesiredBeginFrameDeadlineTimeForTest());
   scheduler_.BeginFrameDeadlineForTest();
 }
 
 TEST_F(DisplaySchedulerTest, ResizeHasLateDeadlineUntilDamagedSurface) {
   SurfaceId root_surface_id(0, 1, 0);
   SurfaceId sid1(0, 2, 0);
   base::TimeTicks late_deadline;
 
+  scheduler_.SetVisible(true);
+
   // Go trough an initial BeginFrame cycle with the root surface.
   BeginFrameForTest();
   scheduler_.SetNewRootSurface(root_surface_id);
   scheduler_.BeginFrameDeadlineForTest();
 
   // Resize on the next begin frame cycle should cause the deadline to wait
   // for a new root surface.
   late_deadline = now_src().NowTicks() + BeginFrameArgs::DefaultInterval();
   BeginFrameForTest();
   scheduler_.SurfaceDamaged(sid1);
@@ skipping 14 matching lines @@
   EXPECT_GE(now_src().NowTicks(),
             scheduler_.DesiredBeginFrameDeadlineTimeForTest());
   scheduler_.BeginFrameDeadlineForTest();
 }
 
 TEST_F(DisplaySchedulerTest, SurfaceDamaged) {
   SurfaceId root_surface_id(0, 0, 0);
   SurfaceId sid1(0, 1, 0);
   SurfaceId sid2(0, 2, 0);
 
+  scheduler_.SetVisible(true);
+
   // Set the root surface
   scheduler_.SetNewRootSurface(root_surface_id);
 
   // Get scheduler to detect surface 1 as active by drawing
   // two frames in a row with damage from surface 1.
   BeginFrameForTest();
   scheduler_.SurfaceDamaged(sid1);
   scheduler_.BeginFrameDeadlineForTest();
   BeginFrameForTest();
   scheduler_.SurfaceDamaged(sid1);
@@ skipping 43 matching lines @@
   scheduler_.SurfaceDamaged(root_surface_id);
   EXPECT_GE(now_src().NowTicks(),
             scheduler_.DesiredBeginFrameDeadlineTimeForTest());
   scheduler_.BeginFrameDeadlineForTest();
 }
 
 TEST_F(DisplaySchedulerTest, OutputSurfaceLost) {
   SurfaceId root_surface_id(0, 0, 0);
   SurfaceId sid1(0, 1, 0);
 
+  scheduler_.SetVisible(true);
+
   // Set the root surface
   scheduler_.SetNewRootSurface(root_surface_id);
 
   // DrawAndSwap normally.
   BeginFrameForTest();
   EXPECT_LT(now_src().NowTicks(),
             scheduler_.DesiredBeginFrameDeadlineTimeForTest());
   EXPECT_EQ(0, client_.draw_and_swap_count());
   scheduler_.SurfaceDamaged(sid1);
   scheduler_.BeginFrameDeadlineForTest();
   EXPECT_EQ(1, client_.draw_and_swap_count());
 
   // Deadline triggers immediately on OutputSurfaceLost.
   BeginFrameForTest();
   EXPECT_LT(now_src().NowTicks(),
             scheduler_.DesiredBeginFrameDeadlineTimeForTest());
   scheduler_.OutputSurfaceLost();
   EXPECT_GE(now_src().NowTicks(),
             scheduler_.DesiredBeginFrameDeadlineTimeForTest());
 
   // Deadline does not DrawAndSwap after OutputSurfaceLost.
   EXPECT_EQ(1, client_.draw_and_swap_count());
   scheduler_.SurfaceDamaged(sid1);
   scheduler_.BeginFrameDeadlineForTest();
   EXPECT_EQ(1, client_.draw_and_swap_count());
 }
 
+TEST_F(DisplaySchedulerTest, VisibleWithoutDamageNoTicks) {
+  SurfaceId root_surface_id(0, 0, 0);
+  SurfaceId sid1(0, 1, 0);
+
+  EXPECT_EQ(0u, fake_begin_frame_source_.num_observers());
+  scheduler_.SetVisible(true);
+
+  // When becoming visible, don't start listening for begin frames until there
+  // is some damage.
+  EXPECT_EQ(0u, fake_begin_frame_source_.num_observers());
+  scheduler_.SetNewRootSurface(root_surface_id);
+
+  EXPECT_EQ(1u, fake_begin_frame_source_.num_observers());
+}
+
+TEST_F(DisplaySchedulerTest, VisibleWithDamageTicks) {
+  SurfaceId root_surface_id(0, 0, 0);
+  SurfaceId sid1(0, 1, 0);
+
+  scheduler_.SetNewRootSurface(root_surface_id);
+
+  // When there is damage, start listening for begin frames once becoming
+  // visible.
+  EXPECT_EQ(0u, fake_begin_frame_source_.num_observers());
+  scheduler_.SetVisible(true);
+
+  EXPECT_EQ(1u, fake_begin_frame_source_.num_observers());
+}
+
+TEST_F(DisplaySchedulerTest, Visibility) {
+  SurfaceId root_surface_id(0, 0, 0);
+  SurfaceId sid1(0, 1, 0);
+
+  scheduler_.SetNewRootSurface(root_surface_id);
+  scheduler_.SetVisible(true);
+  EXPECT_EQ(1u, fake_begin_frame_source_.num_observers());
+
+  // DrawAndSwap normally.
+  BeginFrameForTest();
+  EXPECT_LT(now_src().NowTicks(),
+            scheduler_.DesiredBeginFrameDeadlineTimeForTest());
+  EXPECT_EQ(0, client_.draw_and_swap_count());
+  scheduler_.SurfaceDamaged(sid1);
+  scheduler_.BeginFrameDeadlineForTest();
+  EXPECT_EQ(1, client_.draw_and_swap_count());
+
+  BeginFrameForTest();
+  EXPECT_LT(now_src().NowTicks(),
+            scheduler_.DesiredBeginFrameDeadlineTimeForTest());
+
+  // Become not visible.
+  scheduler_.SetVisible(false);
+
+  // It will stop listening for begin frames after the current deadline.
+  EXPECT_EQ(1u, fake_begin_frame_source_.num_observers());
+
+  // Deadline does not DrawAndSwap when not visible.
+  EXPECT_EQ(1, client_.draw_and_swap_count());
+  scheduler_.BeginFrameDeadlineForTest();
+  EXPECT_EQ(1, client_.draw_and_swap_count());
+  // Now it stops listening for begin frames.
+  EXPECT_EQ(0u, fake_begin_frame_source_.num_observers());
+
+  // Does not start listening for begin frames when becoming visible without
+  // damage.
+  scheduler_.SetVisible(true);
+  EXPECT_EQ(0u, fake_begin_frame_source_.num_observers());
+  scheduler_.SetVisible(false);
+
+  // Does not start listening for begin frames when damage arrives.
+  scheduler_.SurfaceDamaged(sid1);
+  EXPECT_EQ(0u, fake_begin_frame_source_.num_observers());
+
+  // But does when becoming visible with damage again.
+  scheduler_.SetVisible(true);
+  EXPECT_EQ(1u, fake_begin_frame_source_.num_observers());
+}
+
 TEST_F(DisplaySchedulerTest, ResizeCausesSwap) {
   SurfaceId root_surface_id(0, 0, 0);
   SurfaceId sid1(0, 1, 0);
 
+  scheduler_.SetVisible(true);
+
   // Set the root surface
   scheduler_.SetNewRootSurface(root_surface_id);
 
   // DrawAndSwap normally.
   BeginFrameForTest();
   EXPECT_LT(now_src().NowTicks(),
             scheduler_.DesiredBeginFrameDeadlineTimeForTest());
   EXPECT_EQ(0, client_.draw_and_swap_count());
   scheduler_.SurfaceDamaged(sid1);
   scheduler_.BeginFrameDeadlineForTest();
   EXPECT_EQ(1, client_.draw_and_swap_count());
 
   scheduler_.DisplayResized();
   BeginFrameForTest();
   // DisplayResized should trigger a swap to happen.
   scheduler_.BeginFrameDeadlineForTest();
   EXPECT_EQ(2, client_.draw_and_swap_count());
 }
 
 TEST_F(DisplaySchedulerTest, RootSurfaceResourcesLocked) {
   SurfaceId root_surface_id(0, 0, 0);
   SurfaceId sid1(0, 1, 0);
   base::TimeTicks late_deadline;
 
+  scheduler_.SetVisible(true);
+
   // Set the root surface
   scheduler_.SetNewRootSurface(root_surface_id);
 
   // DrawAndSwap normally.
   BeginFrameForTest();
   EXPECT_LT(now_src().NowTicks(),
             scheduler_.DesiredBeginFrameDeadlineTimeForTest());
   EXPECT_EQ(0, client_.draw_and_swap_count());
   scheduler_.SurfaceDamaged(sid1);
   scheduler_.BeginFrameDeadlineForTest();
@@ skipping 26 matching lines @@
   EXPECT_EQ(1, client_.draw_and_swap_count());
   scheduler_.BeginFrameDeadlineForTest();
   EXPECT_EQ(2, client_.draw_and_swap_count());
 }
 
 TEST_F(DisplaySchedulerTest, DidSwapBuffers) {
   SurfaceId root_surface_id(0, 0, 0);
   SurfaceId sid1(0, 1, 0);
   SurfaceId sid2(0, 2, 0);
 
+  scheduler_.SetVisible(true);
+
   // Set the root surface
   scheduler_.SetNewRootSurface(root_surface_id);
 
   // Get scheduler to detect surface 1 and 2 as active.
   BeginFrameForTest();
   scheduler_.SurfaceDamaged(sid1);
   scheduler_.SurfaceDamaged(sid2);
   scheduler_.BeginFrameDeadlineForTest();
   BeginFrameForTest();
   scheduler_.SurfaceDamaged(sid1);
@@ skipping 44 matching lines @@
   scheduler_.BeginFrameDeadlineForTest();
   EXPECT_EQ(4, client_.draw_and_swap_count());
 }
 
 // This test verfies that we try to reschedule the deadline
 // after any event that may change what deadline we want.
 TEST_F(DisplaySchedulerTest, ScheduleBeginFrameDeadline) {
   SurfaceId root_surface_id(0, 1, 0);
   SurfaceId sid1(0, 2, 0);
   int count = 1;
-  EXPECT_EQ(count++, scheduler_.scheduler_begin_frame_deadline_count());
+  EXPECT_EQ(count, scheduler_.scheduler_begin_frame_deadline_count());

[sunnyps, 2016/08/16 20:18:13]

This isn't related to your CL but I think this test isn't useful. This only
tests the number of times ScheduleBeginFrameDeadline is called but NOT the
number of times a deadline was actually scheduled.

[danakj, 2016/08/16 20:33:06]

Ya it's just making sure each function calls ScheduleBeginFrameDeadline,
basically a mock test. I think it's okay? I'm not sure what I'd replace it with.

 
-  // Set the root surface
+  scheduler_.SetVisible(true);
+  EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count());
+
+  scheduler_.SetVisible(true);
+  EXPECT_EQ(count, scheduler_.scheduler_begin_frame_deadline_count());
+
+  scheduler_.SetVisible(false);
+  EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count());
+
+  // Set the root surface while not visible.
   scheduler_.SetNewRootSurface(root_surface_id);
-  EXPECT_EQ(count++, scheduler_.scheduler_begin_frame_deadline_count());
+  EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count());
+
+  scheduler_.SetVisible(true);
+  EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count());
+
+  // Set the root surface while visible.
+  scheduler_.SetNewRootSurface(root_surface_id);
+  EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count());
 
   BeginFrameForTest();
-  EXPECT_EQ(count++, scheduler_.scheduler_begin_frame_deadline_count());
+  EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count());
 
   scheduler_.BeginFrameDeadlineForTest();
   scheduler_.DidSwapBuffers();
   BeginFrameForTest();
-  EXPECT_EQ(count++, scheduler_.scheduler_begin_frame_deadline_count());
+  EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count());
 
   scheduler_.DidSwapBuffersComplete();
-  EXPECT_EQ(count++, scheduler_.scheduler_begin_frame_deadline_count());
+  EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count());
 
   scheduler_.DisplayResized();
-  EXPECT_EQ(count++, scheduler_.scheduler_begin_frame_deadline_count());
+  EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count());
 
   scheduler_.SetNewRootSurface(root_surface_id);
-  EXPECT_EQ(count++, scheduler_.scheduler_begin_frame_deadline_count());
+  EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count());
 
   scheduler_.SurfaceDamaged(sid1);
-  EXPECT_EQ(count++, scheduler_.scheduler_begin_frame_deadline_count());
+  EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count());
 
   scheduler_.SetRootSurfaceResourcesLocked(true);
-  EXPECT_EQ(count++, scheduler_.scheduler_begin_frame_deadline_count());
+  EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count());
 
   scheduler_.OutputSurfaceLost();
-  EXPECT_EQ(count++, scheduler_.scheduler_begin_frame_deadline_count());
+  EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count());
 }
 
 }  // namespace
 }  // namespace cc