Surface synchronization: Introduce flag for default deadline

In order to experiment with different deadlines on different machines,
this CL introduces a command line flag to set the default deadline to
synchronize.

Bug: 672962
TBR: sky@chromium.org for services/ui.
Cq-Include-Trybots: master.tryserver.chromium.android:android_optional_gpu_tests_rel
Change-Id: I58e8fd8431c439bca35ca0a3cb400046bf0dc2b6
Reviewed-on: https://chromium-review.googlesource.com/828123
Commit-Queue: Fady Samuel <fsamuel@chromium.org>
Reviewed-by: Antoine Labour <piman@chromium.org>
Reviewed-by: Ken Buchanan <kenrb@chromium.org>
Cr-Commit-Position: refs/heads/master@{#524427}

components/viz/common/switches.cc

@@ -4,8 +4,15 @@
 
 #include "components/viz/common/switches.h"
 
+#include "base/command_line.h"
+#include "base/strings/string_number_conversions.h"
+
 namespace switches {
 
+namespace {
+constexpr uint32_t kDefaultNumberOfFramesToDeadline = 4;
+}
+
 // Disable surface lifetime management using surface references. This enables
 // adding surface sequences and disables adding temporary references.
 const char kDisableSurfaceReferences[] = "disable-surface-references";
@@ -19,4 +26,21 @@ const char kEnableSurfaceSynchronization[] = "enable-surface-synchronization";
 // in the viz process instead of the browser process.
 const char kEnableViz[] = "enable-viz";
 
+// The default number of the BeginFrames to wait to activate a surface with
+// dependencies.
+const char kDeadlineToSynchronizeSurfaces[] =
+    "deadline-to-synchronize-surfaces";
+
+uint32_t GetDeadlineToSynchronizeSurfaces() {
+  std::string deadline_to_synchronize_surfaces_string =
+      base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+          switches::kDeadlineToSynchronizeSurfaces);
+  uint32_t number_of_frames_to_activation_deadline;
+  if (!base::StringToUint(deadline_to_synchronize_surfaces_string,
+                          &number_of_frames_to_activation_deadline)) {
+    return kDefaultNumberOfFramesToDeadline;
+  }
+  return number_of_frames_to_activation_deadline;
+}
+
 }  // namespace switches

components/viz/common/switches.h

@@ -5,6 +5,9 @@
 #ifndef COMPONENTS_VIZ_COMMON_SWITCHES_H_
 #define COMPONENTS_VIZ_COMMON_SWITCHES_H_
 
+#include <stdint.h>
+#include <string>
+
 #include "components/viz/common/viz_common_export.h"
 
 namespace switches {
@@ -13,6 +16,9 @@ namespace switches {
 VIZ_COMMON_EXPORT extern const char kDisableSurfaceReferences[];
 VIZ_COMMON_EXPORT extern const char kEnableSurfaceSynchronization[];
 VIZ_COMMON_EXPORT extern const char kEnableViz[];
+VIZ_COMMON_EXPORT extern const char kDeadlineToSynchronizeSurfaces[];
+
+VIZ_COMMON_EXPORT uint32_t GetDeadlineToSynchronizeSurfaces();
 
 }  // namespace switches
 

components/viz/service/display/display_scheduler_unittest.cc

@@ -123,6 +123,7 @@ class DisplaySchedulerTest : public testing::Test {
   explicit DisplaySchedulerTest(bool wait_for_all_surfaces_before_draw = false)
       : fake_begin_frame_source_(0.f, false),
         task_runner_(new base::NullTaskRunner),
+        surface_manager_(SurfaceManager::LifetimeType::REFERENCES, 4u),
         scheduler_(&fake_begin_frame_source_,
                    &surface_manager_,
                    task_runner_.get(),

components/viz/service/frame_sinks/frame_sink_manager_impl.cc

@@ -47,9 +47,10 @@ operator=(SinkAndSupport&& other) = default;
 
 FrameSinkManagerImpl::FrameSinkManagerImpl(
     SurfaceManager::LifetimeType lifetime_type,
+    uint32_t number_of_frames_to_activation_deadline,
     DisplayProvider* display_provider)
     : display_provider_(display_provider),
-      surface_manager_(lifetime_type),
+      surface_manager_(lifetime_type, number_of_frames_to_activation_deadline),
       hit_test_manager_(this),
       binding_(this) {
   surface_manager_.AddObserver(&hit_test_manager_);

components/viz/service/frame_sinks/frame_sink_manager_impl.h

@@ -40,6 +40,7 @@ class VIZ_SERVICE_EXPORT FrameSinkManagerImpl : public SurfaceObserver,
  public:
   FrameSinkManagerImpl(SurfaceManager::LifetimeType lifetime_type =
                            SurfaceManager::LifetimeType::REFERENCES,
+                       uint32_t number_of_frames_to_activation_deadline = 4u,
                        DisplayProvider* display_provider = nullptr);
   ~FrameSinkManagerImpl() override;
 

components/viz/service/main/viz_main_impl.cc

@@ -276,7 +276,8 @@ void VizMainImpl::CreateFrameSinkManagerOnCompositorThread(
   mojom::FrameSinkManagerClientPtr client(
       std::move(params->frame_sink_manager_client));
   frame_sink_manager_ = std::make_unique<FrameSinkManagerImpl>(
-      SurfaceManager::LifetimeType::REFERENCES, display_provider_.get());
+      SurfaceManager::LifetimeType::REFERENCES,
+      params->number_of_frames_to_activation_deadline, display_provider_.get());
   frame_sink_manager_->BindAndSetClient(std::move(params->frame_sink_manager),
                                         nullptr, std::move(client));
 }

components/viz/service/surfaces/surface_dependency_tracker.cc

@@ -10,13 +10,11 @@
 
 namespace viz {
 
-namespace {
-constexpr uint32_t kDefaultNumberOfFramesToDeadline = 4;
-}
-
 SurfaceDependencyTracker::SurfaceDependencyTracker(
-    SurfaceManager* surface_manager)
-    : surface_manager_(surface_manager) {}
+    SurfaceManager* surface_manager,
+    uint32_t number_of_frames_to_deadline)
+    : surface_manager_(surface_manager),
+      number_of_frames_to_deadline_(number_of_frames_to_deadline) {}
 
 SurfaceDependencyTracker::~SurfaceDependencyTracker() = default;
 
@@ -150,7 +148,7 @@ void SurfaceDependencyTracker::UpdateSurfaceDeadline(Surface* surface) {
   // If there are no CompositorFrames currently blocked on this surface, then
   // set a default deadline for this surface.
   if (!surface->has_deadline()) {
-    surface->SetActivationDeadline(kDefaultNumberOfFramesToDeadline);
+    surface->SetActivationDeadline(number_of_frames_to_deadline_);
     deadline_changed = true;
   }
 

components/viz/service/surfaces/surface_dependency_tracker.h

@@ -27,7 +27,8 @@ class SurfaceManager;
 // BeginFrames.
 class VIZ_SERVICE_EXPORT SurfaceDependencyTracker {
  public:
-  explicit SurfaceDependencyTracker(SurfaceManager* surface_manager);
+  SurfaceDependencyTracker(SurfaceManager* surface_manager,
+                           uint32_t number_of_frames_to_deadline);
   ~SurfaceDependencyTracker();
 
   // Called when |surface| has a pending CompositorFrame and it wishes to be
@@ -62,6 +63,8 @@ class VIZ_SERVICE_EXPORT SurfaceDependencyTracker {
 
   SurfaceManager* const surface_manager_;
 
+  const uint32_t number_of_frames_to_deadline_;
+
   // A map from a FrameSinkId to the set of Surfaces that are blocked on
   // surfaces associated with that FrameSinkId.
   std::unordered_map<FrameSinkId, base::flat_set<SurfaceId>, FrameSinkIdHash>

components/viz/service/surfaces/surface_manager.cc

@@ -44,9 +44,10 @@ SurfaceManager::TemporaryReferenceData::TemporaryReferenceData() = default;
 
 SurfaceManager::TemporaryReferenceData::~TemporaryReferenceData() = default;
 
-SurfaceManager::SurfaceManager(LifetimeType lifetime_type)
+SurfaceManager::SurfaceManager(LifetimeType lifetime_type,
+                               uint32_t number_of_frames_to_activation_deadline)
     : lifetime_type_(lifetime_type),
-      dependency_tracker_(this),
+      dependency_tracker_(this, number_of_frames_to_activation_deadline),
       root_surface_id_(FrameSinkId(0u, 0u),
                        LocalSurfaceId(1u, base::UnguessableToken::Create())),
       weak_factory_(this) {

components/viz/service/surfaces/surface_manager.h

@@ -50,7 +50,8 @@ class VIZ_SERVICE_EXPORT SurfaceManager {
     SEQUENCES,
   };
 
-  explicit SurfaceManager(LifetimeType lifetime_type = LifetimeType::SEQUENCES);
+  SurfaceManager(LifetimeType lifetime_type,
+                 uint32_t number_of_frames_to_activation_deadline);
   ~SurfaceManager();
 
 #if DCHECK_IS_ON()

content/browser/browser_main_loop.cc

@@ -1516,8 +1516,8 @@ int BrowserMainLoop::BrowserThreadsStarted() {
           parsed_command_line_.HasSwitch(switches::kDisableSurfaceReferences)
               ? viz::SurfaceManager::LifetimeType::SEQUENCES
               : viz::SurfaceManager::LifetimeType::REFERENCES;
-      frame_sink_manager_impl_ =
-          std::make_unique<viz::FrameSinkManagerImpl>(surface_lifetime_type);
+      frame_sink_manager_impl_ = std::make_unique<viz::FrameSinkManagerImpl>(
+          surface_lifetime_type, switches::GetDeadlineToSynchronizeSurfaces());
 
       surface_utils::ConnectWithLocalFrameSinkManager(
           host_frame_sink_manager_.get(), frame_sink_manager_impl_.get());

content/browser/gpu/gpu_process_host.cc

@@ -773,6 +773,8 @@ void GpuProcessHost::ConnectFrameSinkManager(
   viz::mojom::FrameSinkManagerParamsPtr params =
       viz::mojom::FrameSinkManagerParams::New();
   params->restart_id = host_id_;
+  params->number_of_frames_to_activation_deadline =
+      switches::GetDeadlineToSynchronizeSurfaces();
   params->frame_sink_manager = std::move(request);
   params->frame_sink_manager_client = std::move(client);
   params->compositing_mode_watcher = std::move(mode_watcher);

services/ui/ws/window_server.cc

@@ -10,6 +10,7 @@
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
+#include "components/viz/common/switches.h"
 #include "services/ui/ws/display.h"
 #include "services/ui/ws/display_creation_config.h"
 #include "services/ui/ws/display_manager.h"
@@ -844,6 +845,8 @@ void WindowServer::CreateFrameSinkManager() {
   viz::mojom::FrameSinkManagerParamsPtr params =
       viz::mojom::FrameSinkManagerParams::New();
   params->restart_id = viz_restart_id_++;
+  params->number_of_frames_to_activation_deadline =
+      switches::GetDeadlineToSynchronizeSurfaces();
   params->frame_sink_manager = std::move(frame_sink_manager_request);
   params->frame_sink_manager_client = frame_sink_manager_client.PassInterface();
   gpu_host_->CreateFrameSinkManager(std::move(params));

services/viz/privileged/interfaces/viz_main.mojom

@@ -12,10 +12,16 @@ import "services/viz/privileged/interfaces/gl/gpu_service.mojom";
 struct FrameSinkManagerParams {
   // An id that changes for each viz process restart.
   uint32 restart_id;
+
+  // Default number of frames to CompositorFrame activation deadline.
+  uint32 number_of_frames_to_activation_deadline = 4;
+
   // Host to viz interface.
   FrameSinkManager& frame_sink_manager;
+
   // Viz to host interface.
   FrameSinkManagerClient frame_sink_manager_client;
+
   // Mojo pointer of the host's CompositingModeWatcher. This can be omitted on
   // systems that will never fallback to software compositing, as there's no
   // need to watch then.