[Surfaces]: Introduce infinite deadline as a DeadlinePolicy choice.

This patch introduces an infinite deadline as a possible DeadlinePolicy
choice. This would be used in the future when a forced surface
synchronization is requested.

R=fsamuel@chromium.org, piman@chromium.org

Bug: 667551
Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel;master.tryserver.blink:linux_trusty_blink_rel
Change-Id: Iad25d2fd7a8c65e5b53034b448029f463ed717a3
Reviewed-on: https://chromium-review.googlesource.com/996762Reviewed-by: Antoine Labour <piman@chromium.org>
Reviewed-by: Fady Samuel <fsamuel@chromium.org>
Commit-Queue: vmpstr <vmpstr@chromium.org>
Cr-Commit-Position: refs/heads/master@{#548295}

cc/layers/deadline_policy.cc

@@ -4,6 +4,8 @@
 
 #include "cc/layers/deadline_policy.h"
 
+#include <limits>
+
 namespace cc {
 
 // static
@@ -19,17 +21,18 @@ DeadlinePolicy DeadlinePolicy::UseDefaultDeadline() {
 // static
 DeadlinePolicy DeadlinePolicy::UseSpecifiedDeadline(
     uint32_t deadline_in_frames) {
-  return DeadlinePolicy(deadline_in_frames);
+  return DeadlinePolicy(Type::kUseSpecifiedDeadline, deadline_in_frames);
 }
 
-DeadlinePolicy::DeadlinePolicy(Type policy_type)
-    : policy_type_(policy_type), deadline_in_frames_(base::nullopt) {
-  DCHECK_NE(Type::kUseSpecifiedDeadline, policy_type_);
+// static
+DeadlinePolicy DeadlinePolicy::UseInfiniteDeadline() {
+  return DeadlinePolicy(Type::kUseInfiniteDeadline,
+                        std::numeric_limits<uint32_t>::max());
 }
 
-DeadlinePolicy::DeadlinePolicy(uint32_t deadline_in_frames)
-    : policy_type_(Type::kUseSpecifiedDeadline),
-      deadline_in_frames_(deadline_in_frames) {}
+DeadlinePolicy::DeadlinePolicy(Type policy_type,
+                               base::Optional<uint32_t> deadline_in_frames)
+    : policy_type_(policy_type), deadline_in_frames_(deadline_in_frames) {}
 
 DeadlinePolicy::DeadlinePolicy(const DeadlinePolicy& other) = default;
 

cc/layers/deadline_policy.h

@@ -18,7 +18,8 @@ class CC_EXPORT DeadlinePolicy {
   enum Type {
     kUseExistingDeadline,
     kUseDefaultDeadline,
-    kUseSpecifiedDeadline
+    kUseSpecifiedDeadline,
+    kUseInfiniteDeadline
   };
 
   static DeadlinePolicy UseExistingDeadline();
@@ -27,6 +28,8 @@ class CC_EXPORT DeadlinePolicy {
 
   static DeadlinePolicy UseSpecifiedDeadline(uint32_t deadline_in_frames);
 
+  static DeadlinePolicy UseInfiniteDeadline();
+
   DeadlinePolicy(const DeadlinePolicy& other);
 
   DeadlinePolicy& operator=(const DeadlinePolicy& other) = default;
@@ -39,7 +42,8 @@ class CC_EXPORT DeadlinePolicy {
 
   base::Optional<uint32_t> deadline_in_frames() const {
     DCHECK(policy_type_ == Type::kUseDefaultDeadline ||
-           policy_type_ == Type::kUseSpecifiedDeadline);
+           policy_type_ == Type::kUseSpecifiedDeadline ||
+           policy_type_ == Type::kUseInfiniteDeadline);
     return deadline_in_frames_;
   }
 
@@ -55,9 +59,9 @@ class CC_EXPORT DeadlinePolicy {
   }
 
  private:
-  explicit DeadlinePolicy(Type policy_type);
-
-  explicit DeadlinePolicy(uint32_t deadline_in_frames);
+  explicit DeadlinePolicy(
+      Type policy_type,
+      base::Optional<uint32_t> deadline_in_frames = base::nullopt);
 
   Type policy_type_;
   base::Optional<uint32_t> deadline_in_frames_;

cc/layers/surface_layer_unittest.cc

@@ -86,6 +86,18 @@ TEST_F(SurfaceLayerTest, UseExistingDeadlineForNewSurfaceLayer) {
   EXPECT_EQ(0u, layer->deadline_in_frames());
 }
 
+// This test verifies that if UseInfiniteDeadline() is used on a new
+// SurfaceLayer then the deadline will be max number of frames.
+TEST_F(SurfaceLayerTest, UseInfiniteDeadlineForNewSurfaceLayer) {
+  scoped_refptr<SurfaceLayer> layer = SurfaceLayer::Create();
+  layer_tree_host_->SetRootLayer(layer);
+  viz::SurfaceId primary_id(
+      kArbitraryFrameSinkId,
+      viz::LocalSurfaceId(1, base::UnguessableToken::Create()));
+  layer->SetPrimarySurfaceId(primary_id, DeadlinePolicy::UseInfiniteDeadline());
+  EXPECT_EQ(std::numeric_limits<uint32_t>::max(), layer->deadline_in_frames());
+}
+
 // This test verifies that SurfaceLayer properties are pushed across to
 // SurfaceLayerImpl.
 TEST_F(SurfaceLayerTest, PushProperties) {

content/browser/renderer_host/delegated_frame_host.cc

@@ -302,8 +302,13 @@ void DelegatedFrameHost::WasResized(
       // On Windows and Linux, we would like to produce new content as soon as
       // possible or the OS will create an additional black gutter. Until we can
       // block resize on surface synchronization on these platforms, we will not
-      // block UI on the top-level renderer.
-      deadline_policy = cc::DeadlinePolicy::UseSpecifiedDeadline(0u);
+      // block UI on the top-level renderer. The exception to this is if we're
+      // using an infinite deadline, in which case we should respect the
+      // specified deadline and block UI since that's what was requested.
+      if (deadline_policy.policy_type() !=
+          cc::DeadlinePolicy::kUseInfiniteDeadline) {
+        deadline_policy = cc::DeadlinePolicy::UseSpecifiedDeadline(0u);
+      }
 #endif
       client_->DelegatedFrameHostGetLayer()->SetShowPrimarySurface(
           surface_id, current_frame_size_in_dip_, GetGutterColor(),

content/renderer/browser_plugin/browser_plugin.cc

@@ -148,8 +148,9 @@ void BrowserPlugin::OnSetChildFrameSurface(
     return;
 
   if (!enable_surface_synchronization_) {
-    compositing_helper_->SetPrimarySurfaceId(surface_info.id(),
-                                             screen_space_rect().size());
+    compositing_helper_->SetPrimarySurfaceId(
+        surface_info.id(), screen_space_rect().size(),
+        cc::DeadlinePolicy::UseDefaultDeadline());
   }
   compositing_helper_->SetFallbackSurfaceId(surface_info.id(),
                                             screen_space_rect().size());
@@ -272,9 +273,11 @@ void BrowserPlugin::WasResized() {
     parent_local_surface_id_allocator_.GenerateId();
 
   if (enable_surface_synchronization_ && frame_sink_id_.is_valid()) {
+    // TODO(vmpstr): When capture_sequence_number is available, the deadline
+    // should be infinite if the sequence number has changed.
     compositing_helper_->SetPrimarySurfaceId(
         viz::SurfaceId(frame_sink_id_, GetLocalSurfaceId()),
-        screen_space_rect().size());
+        screen_space_rect().size(), cc::DeadlinePolicy::UseDefaultDeadline());
   }
 
   bool position_changed = !sent_resize_params_ ||

content/renderer/child_frame_compositing_helper.cc

@@ -72,7 +72,8 @@ void ChildFrameCompositingHelper::ChildFrameGone(
 
 void ChildFrameCompositingHelper::SetPrimarySurfaceId(
     const viz::SurfaceId& surface_id,
-    const gfx::Size& frame_size_in_dip) {
+    const gfx::Size& frame_size_in_dip,
+    const cc::DeadlinePolicy& deadline) {
   if (primary_surface_id_ == surface_id)
     return;
 
@@ -83,8 +84,7 @@ void ChildFrameCompositingHelper::SetPrimarySurfaceId(
   surface_layer_->SetHitTestable(true);
   surface_layer_->SetBackgroundColor(SK_ColorTRANSPARENT);
 
-  surface_layer_->SetPrimarySurfaceId(surface_id,
-                                      cc::DeadlinePolicy::UseDefaultDeadline());
+  surface_layer_->SetPrimarySurfaceId(surface_id, deadline);
   surface_layer_->SetFallbackSurfaceId(fallback_surface_id_);
 
   std::unique_ptr<cc_blink::WebLayerImpl> layer(
@@ -111,7 +111,8 @@ void ChildFrameCompositingHelper::SetFallbackSurfaceId(
   fallback_surface_id_ = surface_id;
 
   if (!surface_layer_) {
-    SetPrimarySurfaceId(surface_id, frame_size_in_dip);
+    SetPrimarySurfaceId(surface_id, frame_size_in_dip,
+                        cc::DeadlinePolicy::UseDefaultDeadline());
     return;
   }
 

content/renderer/child_frame_compositing_helper.h

@@ -36,7 +36,8 @@ class CONTENT_EXPORT ChildFrameCompositingHelper {
   virtual ~ChildFrameCompositingHelper();
 
   void SetPrimarySurfaceId(const viz::SurfaceId& surface_id,
-                           const gfx::Size& frame_size_in_dip);
+                           const gfx::Size& frame_size_in_dip,
+                           const cc::DeadlinePolicy& deadline);
   void SetFallbackSurfaceId(const viz::SurfaceId& surface_id,
                             const gfx::Size& frame_size_in_dip);
   void UpdateVisibility(bool visible);

content/renderer/render_frame_proxy.cc

@@ -369,8 +369,9 @@ void RenderFrameProxy::SetChildFrameSurface(
     return;
 
   if (!enable_surface_synchronization_) {
-    compositing_helper_->SetPrimarySurfaceId(surface_info.id(),
-                                             local_frame_size());
+    compositing_helper_->SetPrimarySurfaceId(
+        surface_info.id(), local_frame_size(),
+        cc::DeadlinePolicy::UseDefaultDeadline());
   }
   compositing_helper_->SetFallbackSurfaceId(surface_info.id(),
                                             local_frame_size());
@@ -612,8 +613,13 @@ void RenderFrameProxy::WasResized() {
     local_surface_id_ = parent_local_surface_id_allocator_.GenerateId();
 
   viz::SurfaceId surface_id(frame_sink_id_, local_surface_id_);
-  if (enable_surface_synchronization_)
-    compositing_helper_->SetPrimarySurfaceId(surface_id, local_frame_size());
+  if (enable_surface_synchronization_) {
+    // TODO(vmpstr): When capture_sequence_number is available, the deadline
+    // should be infinite if the sequence number has changed.
+    compositing_helper_->SetPrimarySurfaceId(
+        surface_id, local_frame_size(),
+        cc::DeadlinePolicy::UseDefaultDeadline());
+  }
 
   bool rect_changed =
       !sent_resize_params_ || sent_resize_params_->screen_space_rect !=