Ensure surface swap happens after resize.

Resizing essentially damages the output, so ensure a resize causes a new draw to happen. Also, missing a draw that had damage should cause the next frame that's drawn to be completely damaged. This matters in particular if the window gets a resize event but the size doesn't actually change - in that case the browser compositor won't draw a new frame at a different size with full damage.

BUG=517035
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1298853002

Cr-Commit-Position: refs/heads/master@{#344403}

4 files changed, 48 insertions, 4 deletions

diff --git a/cc/surfaces/display.cc b/cc/surfaces/display.cc
index 6bb12dc..3d10173 100644
--- a/cc/surfaces/display.cc
+++ b/cc/surfaces/display.cc
@@ -243,6 +243,8 @@ bool Display::DrawAndSwap() {
     benchmark_instrumentation::IssueDisplayRenderingStatsEvent();
     renderer_->SwapBuffers(frame->metadata);
   } else {
+    if (have_damage && !size_matches)
+      aggregator_->SetFullDamageForSurface(current_surface_id_);
     TRACE_EVENT_INSTANT0("cc", "Swap skipped.", TRACE_EVENT_SCOPE_THREAD);
     stored_latency_info_.insert(stored_latency_info_.end(),
                                 frame->metadata.latency_info.begin(),
diff --git a/cc/surfaces/display_scheduler.cc b/cc/surfaces/display_scheduler.cc
index 0b40b3e..033632e 100644
--- a/cc/surfaces/display_scheduler.cc
+++ b/cc/surfaces/display_scheduler.cc
@@ -60,6 +60,7 @@ void DisplayScheduler::ForceImmediateSwapIfPossible() {
 void DisplayScheduler::DisplayResized() {
   expecting_root_surface_damage_because_of_resize_ = true;
   expect_damage_from_root_surface_ = true;
+  needs_draw_ = true;
   ScheduleBeginFrameDeadline();
 }
 
diff --git a/cc/surfaces/display_scheduler_unittest.cc b/cc/surfaces/display_scheduler_unittest.cc
index ffb0b43..0f2725d 100644
--- a/cc/surfaces/display_scheduler_unittest.cc
+++ b/cc/surfaces/display_scheduler_unittest.cc
@@ -267,6 +267,25 @@ TEST_F(DisplaySchedulerTest, OutputSurfaceLost) {
   EXPECT_EQ(1, client_->draw_and_swap_count());
 }
 
+TEST_F(DisplaySchedulerTest, ResizeCausesSwap) {
+  SurfaceId sid1(1);
+
+  // 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 sid1(1);
   base::TimeTicks late_deadline;
diff --git a/cc/surfaces/display_unittest.cc b/cc/surfaces/display_unittest.cc
index b7b50c3..facb40e9 100644
--- a/cc/surfaces/display_unittest.cc
+++ b/cc/surfaces/display_unittest.cc
@@ -253,6 +253,28 @@ TEST_F(DisplayTest, DisplayDamaged) {
   }
 
   {
+    // Previous frame wasn't swapped, so next swap should have full damage.
+    pass = RenderPass::Create();
+    pass->output_rect = gfx::Rect(0, 0, 100, 100);
+    pass->damage_rect = gfx::Rect(10, 10, 0, 0);
+    pass->id = RenderPassId(1, 1);
+
+    pass_list.push_back(pass.Pass());
+    scheduler.ResetDamageForTest();
+    SubmitFrame(&pass_list, surface_id);
+    EXPECT_TRUE(scheduler.damaged);
+    EXPECT_FALSE(scheduler.display_resized_);
+    EXPECT_FALSE(scheduler.has_new_root_surface);
+
+    scheduler.swapped = false;
+    display.DrawAndSwap();
+    EXPECT_TRUE(scheduler.swapped);
+    EXPECT_EQ(3u, output_surface_ptr_->num_sent_frames());
+    EXPECT_EQ(gfx::Rect(0, 0, 100, 100),
+              software_output_device_->damage_rect());
+  }
+
+  {
     // Pass has copy output request so should be swapped.
     pass = RenderPass::Create();
     pass->output_rect = gfx::Rect(0, 0, 100, 100);
@@ -272,7 +294,7 @@ TEST_F(DisplayTest, DisplayDamaged) {
     scheduler.swapped = false;
     display.DrawAndSwap();
     EXPECT_TRUE(scheduler.swapped);
-    EXPECT_EQ(3u, output_surface_ptr_->num_sent_frames());
+    EXPECT_EQ(4u, output_surface_ptr_->num_sent_frames());
     EXPECT_TRUE(copy_called);
   }
 
@@ -301,7 +323,7 @@ TEST_F(DisplayTest, DisplayDamaged) {
     scheduler.swapped = false;
     display.DrawAndSwap();
     EXPECT_TRUE(scheduler.swapped);
-    EXPECT_EQ(4u, output_surface_ptr_->num_sent_frames());
+    EXPECT_EQ(5u, output_surface_ptr_->num_sent_frames());
   }
 
   // Resize should cause a swap if no frame was swapped at the previous size.
@@ -309,7 +331,7 @@ TEST_F(DisplayTest, DisplayDamaged) {
     scheduler.swapped = false;
     display.Resize(gfx::Size(200, 200));
     EXPECT_FALSE(scheduler.swapped);
-    EXPECT_EQ(4u, output_surface_ptr_->num_sent_frames());
+    EXPECT_EQ(5u, output_surface_ptr_->num_sent_frames());
 
     pass = RenderPass::Create();
     pass->output_rect = gfx::Rect(0, 0, 200, 200);
@@ -333,7 +355,7 @@ TEST_F(DisplayTest, DisplayDamaged) {
     scheduler.swapped = false;
     display.Resize(gfx::Size(100, 100));
     EXPECT_TRUE(scheduler.swapped);
-    EXPECT_EQ(5u, output_surface_ptr_->num_sent_frames());
+    EXPECT_EQ(6u, output_surface_ptr_->num_sent_frames());
   }
 
   factory_.Destroy(surface_id);