cc: Force a redraw on initializing a new output surface for remote compositor.

When the output surface is lost, the LTHI drops all resources and tiles, and
waits for the next commit for the next draw. This commit might early out with
no updates in which case we will never perform raster new tiles and redraw.

Schedule a draw when a new output is surface is initialized to avoid this.

BUG=597710
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

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

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

5 files changed, 40 insertions, 8 deletions

diff --git a/cc/test/layer_tree_test.cc b/cc/test/layer_tree_test.cc
index ca6e54d..87a79de 100644
--- a/cc/test/layer_tree_test.cc
+++ b/cc/test/layer_tree_test.cc
@@ -1000,6 +1000,13 @@ LayerTreeHost* LayerTreeTest::layer_tree_host() {
   return layer_tree_host_.get();
 }
 
+LayerTreeHost* LayerTreeTest::remote_client_layer_tree_host() {
+  DCHECK(!task_runner_provider() || task_runner_provider()->IsMainThread() ||
+         task_runner_provider()->IsMainThreadBlocked());
+  DCHECK(IsRemoteTest());
+  return remote_client_layer_tree_host_.get();
+}
+
 ProxyMainForTest* LayerTreeTest::GetProxyMainForTest() const {
   DCHECK(HasImplThread());
   return static_cast<ProxyMainForTest*>(proxy());
diff --git a/cc/test/layer_tree_test.h b/cc/test/layer_tree_test.h
index b396630..5641357 100644
--- a/cc/test/layer_tree_test.h
+++ b/cc/test/layer_tree_test.h
@@ -146,6 +146,7 @@ class LayerTreeTest : public testing::Test, public TestHooks {
   bool TestEnded() const { return ended_; }
 
   LayerTreeHost* layer_tree_host();
+  LayerTreeHost* remote_client_layer_tree_host();
   bool delegating_renderer() const { return delegating_renderer_; }
   FakeOutputSurface* output_surface() { return output_surface_; }
 
diff --git a/cc/trees/remote_channel_impl.cc b/cc/trees/remote_channel_impl.cc
index 5d98369..a55dc97 100644
--- a/cc/trees/remote_channel_impl.cc
+++ b/cc/trees/remote_channel_impl.cc
@@ -139,9 +139,7 @@ void RemoteChannelImpl::HandleProto(
           proto.set_needs_redraw_message();
       gfx::Rect damaged_rect =
           ProtoToRect(set_needs_redraw_message.damaged_rect());
-      ImplThreadTaskRunner()->PostTask(
-          FROM_HERE, base::Bind(&ProxyImpl::SetNeedsRedrawOnImpl,
-                                proxy_impl_weak_ptr_, damaged_rect));
+      PostSetNeedsRedrawToImpl(damaged_rect);
     } break;
   }
 }
@@ -428,6 +426,11 @@ void RemoteChannelImpl::DidInitializeOutputSurfaceOnMain(
     HandleProto(main().pending_messages.front());
     main().pending_messages.pop();
   }
+
+  // The commit after a new output surface can early out, in which case we will
+  // never redraw. Schedule one just to be safe.
+  PostSetNeedsRedrawToImpl(
+      gfx::Rect(main().layer_tree_host->device_viewport_size()));
 }
 
 void RemoteChannelImpl::SendMessageProtoOnMain(
@@ -437,6 +440,15 @@ void RemoteChannelImpl::SendMessageProtoOnMain(
   main().remote_proto_channel->SendCompositorProto(*proto);
 }
 
+void RemoteChannelImpl::PostSetNeedsRedrawToImpl(
+    const gfx::Rect& damaged_rect) {
+  DCHECK(task_runner_provider_->IsMainThread());
+
+  ImplThreadTaskRunner()->PostTask(
+      FROM_HERE, base::Bind(&ProxyImpl::SetNeedsRedrawOnImpl,
+                            proxy_impl_weak_ptr_, damaged_rect));
+}
+
 void RemoteChannelImpl::InitializeImplOnImpl(CompletionEvent* completion,
                                              LayerTreeHost* layer_tree_host) {
   DCHECK(task_runner_provider_->IsMainThreadBlocked());
diff --git a/cc/trees/remote_channel_impl.h b/cc/trees/remote_channel_impl.h
index 8989776..acd44aa 100644
--- a/cc/trees/remote_channel_impl.h
+++ b/cc/trees/remote_channel_impl.h
@@ -196,6 +196,7 @@ class CC_EXPORT RemoteChannelImpl : public ChannelImpl,
       bool success,
       const RendererCapabilities& capabilities);
   void SendMessageProtoOnMain(scoped_ptr<proto::CompositorMessage> proto);
+  void PostSetNeedsRedrawToImpl(const gfx::Rect& damaged_rect);
 
   void InitializeImplOnImpl(CompletionEvent* completion,
                             LayerTreeHost* layer_tree_host);
diff --git a/cc/trees/remote_channel_unittest.cc b/cc/trees/remote_channel_unittest.cc
index a9c7595..e33f580 100644
--- a/cc/trees/remote_channel_unittest.cc
+++ b/cc/trees/remote_channel_unittest.cc
@@ -79,21 +79,32 @@ class RemoteChannelTestDeferCommits : public RemoteChannelTest {
 REMOTE_DIRECT_RENDERER_TEST_F(RemoteChannelTestDeferCommits);
 
 class RemoteChannelTestNeedsRedraw : public RemoteChannelTest {
+ public:
+  RemoteChannelTestNeedsRedraw()
+      : damaged_rect_(4, 5), device_viewport_size_(0, 0) {}
+
   void BeginChannelTest() override {
-    damaged_rect_.set_width(4);
-    damaged_rect_.set_height(5);
+    device_viewport_size_ =
+        gfx::Rect(remote_client_layer_tree_host()->device_viewport_size());
     layer_tree_host()->SetNeedsRedrawRect(damaged_rect_);
   }
 
   void SetNeedsRedrawOnImpl(const gfx::Rect& damage_rect) override {
-    EXPECT_EQ(damage_rect, damaged_rect_);
     calls_received_++;
-    EndTest();
+    if (calls_received_ == 1) {
+      EXPECT_EQ(damaged_rect_, damage_rect);
+    } else {
+      // The second call is received after the output surface is successfully
+      // initialized.
+      EXPECT_EQ(device_viewport_size_, damage_rect);
+      EndTest();
+    }
   }
 
-  void AfterTest() override { EXPECT_EQ(1, calls_received_); }
+  void AfterTest() override { EXPECT_EQ(2, calls_received_); }
 
   gfx::Rect damaged_rect_;
+  gfx::Rect device_viewport_size_;
 };
 
 REMOTE_DIRECT_RENDERER_TEST_F(RemoteChannelTestNeedsRedraw);