Ozone: Combine all display configuration requests together.

Put all config requests into a vector and move them together.
Change the callbacks to handle all displays configured together rather than one display at a time.

BUG=1082882
TEST=no changes enabling and disabling displays, display_unittests.

Change-Id: I36859414e1e31e8411f67bac0c3609696cabeece
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2237653Reviewed-by: Robert Sesek <rsesek@chromium.org>
Reviewed-by: Avi Drissman <avi@chromium.org>
Reviewed-by: Daniel Nicoara <dnicoara@chromium.org>
Commit-Queue: Robert Sesek <rsesek@chromium.org>
Commit-Queue: Mark Yacoub <markyacoub@google.com>
Auto-Submit: Mark Yacoub <markyacoub@google.com>
Cr-Commit-Position: refs/heads/master@{#789275}

chromecast/browser/cast_display_configurator.cc

@@ -133,7 +133,10 @@ void CastDisplayConfigurator::EnableDisplay(
 
   display::DisplayConfigurationParams display_config_params(
       display_->display_id(), gfx::Point(), display_->native_mode());
-  delegate_->Configure(display_config_params, std::move(callback));
+  std::vector<display::DisplayConfigurationParams> config_request;
+  config_request.push_back(std::move(display_config_params));
+
+  delegate_->Configure(config_request, std::move(callback));
 }
 
 void CastDisplayConfigurator::DisableDisplay(
@@ -143,7 +146,10 @@ void CastDisplayConfigurator::DisableDisplay(
 
   display::DisplayConfigurationParams display_config_params(
       display_->display_id(), gfx::Point(), nullptr);
-  delegate_->Configure(display_config_params, std::move(callback));
+  std::vector<display::DisplayConfigurationParams> config_request;
+  config_request.push_back(std::move(display_config_params));
+
+  delegate_->Configure(config_request, std::move(callback));
 }
 
 void CastDisplayConfigurator::ConfigureDisplayFromCommandLine() {
@@ -210,8 +216,11 @@ void CastDisplayConfigurator::OnDisplaysAcquired(
 
   display::DisplayConfigurationParams display_config_params(
       display_->display_id(), origin, display_->native_mode());
+  std::vector<display::DisplayConfigurationParams> config_request;
+  config_request.push_back(std::move(display_config_params));
+
   delegate_->Configure(
-      display_config_params,
+      config_request,
       base::BindRepeating(&CastDisplayConfigurator::OnDisplayConfigured,
                           weak_factory_.GetWeakPtr(), display_,
                           display_->native_mode(), origin));
@@ -221,12 +230,14 @@ void CastDisplayConfigurator::OnDisplayConfigured(
     display::DisplaySnapshot* display,
     const display::DisplayMode* mode,
     const gfx::Point& origin,
-    bool success) {
+    const base::flat_map<int64_t, bool>& statuses) {
   DCHECK(display);
   DCHECK(mode);
   DCHECK_EQ(display, display_);
+  DCHECK_EQ(statuses.size(), 1UL);
 
   const gfx::Rect bounds(origin, mode->size());
+  bool success = statuses.at(display_->display_id());
   DVLOG(1) << __func__ << " success=" << success
            << " bounds=" << bounds.ToString();
   if (success) {

chromecast/browser/cast_display_configurator.h

@@ -8,9 +8,11 @@
 #include <memory>
 #include <vector>
 
+#include "base/containers/flat_map.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "ui/display/display.h"
+#include "ui/display/types/display_configuration_params.h"
 #include "ui/display/types/native_display_delegate.h"
 #include "ui/display/types/native_display_observer.h"
 
@@ -62,7 +64,7 @@ class CastDisplayConfigurator : public display::NativeDisplayObserver {
   void OnDisplayConfigured(display::DisplaySnapshot* display,
                            const display::DisplayMode* mode,
                            const gfx::Point& origin,
-                           bool success);
+                           const base::flat_map<int64_t, bool>& statuses);
   void UpdateScreen(int64_t display_id,
                     const gfx::Rect& bounds,
                     float device_scale_factor,

ui/display/fake/fake_display_delegate.cc

@@ -130,22 +130,23 @@ void FakeDisplayDelegate::GetDisplays(GetDisplaysCallback callback) {
 }
 
 void FakeDisplayDelegate::Configure(
-    const display::DisplayConfigurationParams& display_config_params,
+    const std::vector<display::DisplayConfigurationParams>& config_requests,
     ConfigureCallback callback) {
+  base::flat_map<int64_t, bool> statuses;
+  for (const auto& config : config_requests) {
     bool configure_success = false;
 
-  if (display_config_params.mode.has_value()) {
+    if (config.mode.has_value()) {
       // Find display snapshot of display ID.
-    auto snapshot = find_if(
-        displays_.begin(), displays_.end(),
-        [&display_config_params](std::unique_ptr<DisplaySnapshot>& snapshot) {
-          return snapshot->display_id() == display_config_params.id;
+      auto snapshot =
+          find_if(displays_.begin(), displays_.end(),
+                  [&config](std::unique_ptr<DisplaySnapshot>& snapshot) {
+                    return snapshot->display_id() == config.id;
                   });
       if (snapshot != displays_.end()) {
         // Check that config mode is appropriate for the display snapshot.
         for (const auto& existing_mode : snapshot->get()->modes()) {
-        if (AreModesEqual(*existing_mode.get(),
-                          *display_config_params.mode.value().get())) {
+          if (AreModesEqual(*existing_mode.get(), *config.mode.value().get())) {
             configure_success = true;
             break;
           }
@@ -155,9 +156,10 @@ void FakeDisplayDelegate::Configure(
       // This is a request to turn off the display.
       configure_success = true;
     }
+    statuses.insert(std::make_pair(config.id, configure_success));
+  }
 
-  configure_callbacks_.push(
-      base::BindOnce(std::move(callback), configure_success));
+  configure_callbacks_.push(base::BindOnce(std::move(callback), statuses));
 
   // Start the timer if it's not already running. If there are multiple queued
   // configuration requests then ConfigureDone() will handle starting the

ui/display/fake/fake_display_delegate.h

@@ -84,7 +84,7 @@ class FAKE_DISPLAY_EXPORT FakeDisplayDelegate : public NativeDisplayDelegate,
   void RelinquishDisplayControl(DisplayControlCallback callback) override;
   void GetDisplays(GetDisplaysCallback callback) override;
   void Configure(
-      const display::DisplayConfigurationParams& display_config_params,
+      const std::vector<display::DisplayConfigurationParams>& config_requests,
       ConfigureCallback callback) override;
   void GetHDCPState(const DisplaySnapshot& output,
                     GetHDCPStateCallback callback) override;

ui/display/manager/configure_displays_task.cc

@@ -73,6 +73,15 @@ int ComputeDisplayResolutionEnum(const DisplayMode* mode) {
   return width_idx * base::size(kDisplayResolutionSamples) + height_idx + 1;
 }
 
+std::__wrap_iter<const DisplayConfigureRequest*> GetRequestForDisplayId(
+    int64_t display_id,
+    const std::vector<DisplayConfigureRequest>& requests) {
+  return find_if(requests.begin(), requests.end(),
+                 [display_id](const DisplayConfigureRequest& request) {
+                   return request.display->display_id() == display_id;
+                 });
+}
+
 }  // namespace
 
 DisplayConfigureRequest::DisplayConfigureRequest(DisplaySnapshot* display,
@@ -110,9 +119,14 @@ void ConfigureDisplaysTask::Run() {
   {
     base::AutoReset<bool> recursivity_guard(&is_configuring_, true);
     while (!pending_request_indexes_.empty()) {
+      // Loop over all the current requests, then it will loop again making sure
+      // no new requests were added and are pending.
+      std::vector<display::DisplayConfigurationParams> config_requests;
+      for (size_t i = 0; i < pending_request_indexes_.size(); ++i) {
         size_t index = pending_request_indexes_.front();
         DisplayConfigureRequest* request = &requests_[index];
         pending_request_indexes_.pop();
+
         const bool internal =
             request->display->type() == DISPLAY_CONNECTION_TYPE_INTERNAL;
         base::UmaHistogramExactLinear(
@@ -122,7 +136,6 @@ void ConfigureDisplaysTask::Run() {
             base::size(kDisplayResolutionSamples) *
                     base::size(kDisplayResolutionSamples) +
                 2);
-
         base::HistogramBase* histogram = base::LinearHistogram::FactoryGet(
             internal ? "ConfigureDisplays.Internal.Modeset.RefreshRate"
                      : "ConfigureDisplays.External.Modeset.RefreshRate",
@@ -132,10 +145,14 @@ void ConfigureDisplaysTask::Run() {
 
         display::DisplayConfigurationParams display_config_params(
             request->display->display_id(), request->origin, request->mode);
+        config_requests.push_back(std::move(display_config_params));
+      }
+      if (!config_requests.empty()) {
         delegate_->Configure(
-          display_config_params,
+            config_requests,
             base::BindOnce(&ConfigureDisplaysTask::OnConfigured,
-                         weak_ptr_factory_.GetWeakPtr(), index));
+                           weak_ptr_factory_.GetWeakPtr()));
+      }
     }
   }
 
@@ -156,44 +173,83 @@ void ConfigureDisplaysTask::OnDisplaySnapshotsInvalidated() {
   Run();
 }
 
-void ConfigureDisplaysTask::OnConfigured(size_t index, bool success) {
-  DisplayConfigureRequest* request = &requests_[index];
-  VLOG(2) << "Configured status=" << success
+void ConfigureDisplaysTask::OnConfigured(
+    const base::flat_map<int64_t, bool>& statuses) {
+  bool config_success = true;
+
+  // Check if all displays are successfully configured.
+  for (const auto& status : statuses) {
+    int64_t display_id = status.first;
+    bool display_success = status.second;
+    config_success &= display_success;
+
+    auto request = GetRequestForDisplayId(display_id, requests_);
+    DCHECK(request != requests_.end());
+
+    VLOG(2) << "Configured status=" << display_success
             << " display=" << request->display->display_id()
             << " origin=" << request->origin.ToString()
             << " mode=" << (request->mode ? request->mode->ToString() : "null");
 
-  const bool internal =
+    bool internal =
         request->display->type() == DISPLAY_CONNECTION_TYPE_INTERNAL;
     base::UmaHistogramBoolean(
         internal ? "ConfigureDisplays.Internal.Modeset.AttemptSucceeded"
                  : "ConfigureDisplays.External.Modeset.AttemptSucceeded",
-      success);
+        display_success);
+  }
 
-  if (!success) {
-    request->mode = FindNextMode(*request->display, request->mode);
-    if (request->mode) {
+  if (config_success) {
+    for (const auto& status : statuses) {
+      auto request = GetRequestForDisplayId(status.first, requests_);
+      request->display->set_current_mode(request->mode);
+      request->display->set_origin(request->origin);
+    }
+  } else {
+    bool should_reconfigure = false;
+    // For the failing config, check if there is another mode to be requested.
+    // If there is one, attempt to reconfigure everything again.
+    for (const auto& status : statuses) {
+      int64_t display_id = status.first;
+      bool display_success = status.second;
+      if (!display_success) {
+        const DisplayConfigureRequest* request =
+            GetRequestForDisplayId(display_id, requests_).base();
+        const_cast<DisplayConfigureRequest*>(request)->mode =
+            FindNextMode(*request->display, request->mode);
+        should_reconfigure = !!request->mode;
+      }
+    }
+    // When reconfiguring, reconfigure all displays, not only the failing ones
+    // as they could potentially depend on each other.
+    if (should_reconfigure) {
+      for (const auto& status : statuses) {
+        auto const_iterator = GetRequestForDisplayId(status.first, requests_);
+        auto request = requests_.erase(const_iterator, const_iterator);
+        size_t index = std::distance(requests_.begin(), request);
         pending_request_indexes_.push(index);
+      }
       if (task_status_ == SUCCESS)
         task_status_ = PARTIAL_SUCCESS;
-
       Run();
       return;
     }
-  } else {
-    request->display->set_current_mode(request->mode);
-    request->display->set_origin(request->origin);
   }
 
-  num_displays_configured_++;
-
+  // If no reconfigurations are happening, update the final state.
+  for (const auto& status : statuses) {
+    auto request = GetRequestForDisplayId(status.first, requests_);
+    bool internal =
+        request->display->type() == DISPLAY_CONNECTION_TYPE_INTERNAL;
     base::UmaHistogramBoolean(
         internal ? "ConfigureDisplays.Internal.Modeset.FinalStatus"
                  : "ConfigureDisplays.External.Modeset.FinalStatus",
-      success);
-  if (!success)
-    task_status_ = ERROR;
+        config_success);
+  }
 
+  num_displays_configured_ += statuses.size();
+  if (!config_success)
+    task_status_ = ERROR;
   Run();
 }
 

ui/display/manager/configure_displays_task.h

@@ -11,6 +11,7 @@
 #include <vector>
 
 #include "base/callback.h"
+#include "base/containers/flat_map.h"
 #include "base/containers/queue.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
@@ -65,7 +66,7 @@ class DISPLAY_MANAGER_EXPORT ConfigureDisplaysTask
   void OnDisplaySnapshotsInvalidated() override;
 
  private:
-  void OnConfigured(size_t index, bool success);
+  void OnConfigured(const base::flat_map<int64_t, bool>& statuses);
 
   NativeDisplayDelegate* delegate_;  // Not owned.
 

ui/display/manager/test/test_native_display_delegate.cc

@@ -70,14 +70,17 @@ bool TestNativeDisplayDelegate::Configure(
 }
 
 void TestNativeDisplayDelegate::Configure(
-    const display::DisplayConfigurationParams& display_config_params,
+    const std::vector<display::DisplayConfigurationParams>& config_requests,
     ConfigureCallback callback) {
-  bool result = Configure(display_config_params);
+  base::flat_map<int64_t, bool> statuses;
+  for (const auto& config : config_requests)
+    statuses.insert(std::make_pair(config.id, Configure(config)));
+
   if (run_async_) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::BindOnce(std::move(callback), result));
+        FROM_HERE, base::BindOnce(std::move(callback), statuses));
   } else {
-    std::move(callback).Run(result);
+    std::move(callback).Run(statuses);
   }
 }
 

ui/display/manager/test/test_native_display_delegate.h

@@ -58,7 +58,7 @@ class TestNativeDisplayDelegate : public NativeDisplayDelegate {
   void RelinquishDisplayControl(DisplayControlCallback callback) override;
   void GetDisplays(GetDisplaysCallback callback) override;
   void Configure(
-      const display::DisplayConfigurationParams& display_config_params,
+      const std::vector<display::DisplayConfigurationParams>& config_requests,
       ConfigureCallback callback) override;
   void GetHDCPState(const DisplaySnapshot& output,
                     GetHDCPStateCallback callback) override;

ui/display/types/display_configuration_params.cc

@@ -7,6 +7,20 @@
 namespace display {
 
 DisplayConfigurationParams::DisplayConfigurationParams() = default;
+DisplayConfigurationParams::DisplayConfigurationParams(
+    DisplayConfigurationParams& other)
+    : id(other.id), origin(other.origin) {
+  if (other.mode)
+    mode = other.mode->get()->Clone();
+}
+
+DisplayConfigurationParams::DisplayConfigurationParams(
+    DisplayConfigurationParams&& other)
+    : id(other.id), origin(other.origin) {
+  if (other.mode)
+    mode = other.mode->get()->Clone();
+}
+
 DisplayConfigurationParams::DisplayConfigurationParams(
     int64_t id,
     const gfx::Point& origin,

ui/display/types/display_configuration_params.h

@@ -16,6 +16,8 @@ namespace display {
 
 struct DISPLAY_TYPES_EXPORT DisplayConfigurationParams {
   DisplayConfigurationParams();
+  DisplayConfigurationParams(DisplayConfigurationParams& other);
+  DisplayConfigurationParams(DisplayConfigurationParams&& other);
   DisplayConfigurationParams(int64_t id,
                              const gfx::Point& origin,
                              const display::DisplayMode* pmode);

ui/display/types/native_display_delegate.h

@@ -10,6 +10,7 @@
 #include <vector>
 
 #include "base/callback.h"
+#include "base/containers/flat_map.h"
 #include "ui/display/types/display_configuration_params.h"
 #include "ui/display/types/display_constants.h"
 #include "ui/display/types/display_types_export.h"
@@ -24,7 +25,8 @@ struct DisplayConfigurationParams;
 
 using GetDisplaysCallback =
     base::OnceCallback<void(const std::vector<DisplaySnapshot*>&)>;
-using ConfigureCallback = base::OnceCallback<void(bool)>;
+using ConfigureCallback =
+    base::OnceCallback<void(const base::flat_map<int64_t, bool>&)>;
 using GetHDCPStateCallback = base::OnceCallback<void(bool, HDCPState)>;
 using SetHDCPStateCallback = base::OnceCallback<void(bool)>;
 using DisplayControlCallback = base::OnceCallback<void(bool)>;
@@ -56,7 +58,7 @@ class DISPLAY_TYPES_EXPORT NativeDisplayDelegate {
   // represents disabling the display. The callback will return the status of
   // the operation.
   virtual void Configure(
-      const display::DisplayConfigurationParams& display_config_params,
+      const std::vector<display::DisplayConfigurationParams>& config_requests,
       ConfigureCallback callback) = 0;
 
   // Gets HDCP state of output.

ui/ozone/demo/window_manager.cc

@@ -89,10 +89,12 @@ void WindowManager::OnDisplaysAcquired(
 
     display::DisplayConfigurationParams display_config_params(
         display->display_id(), origin, display->native_mode());
+    std::vector<display::DisplayConfigurationParams> config_request;
+    config_request.push_back(std::move(display_config_params));
     delegate_->Configure(
-        display_config_params,
+        config_request,
         base::BindOnce(&WindowManager::OnDisplayConfigured,
-                       base::Unretained(this),
+                       base::Unretained(this), display->display_id(),
                        gfx::Rect(origin, display->native_mode()->size())));
     origin.Offset(display->native_mode()->size().width(), 0);
   }
@@ -106,8 +108,13 @@ void WindowManager::OnDisplaysAcquired(
   }
 }
 
-void WindowManager::OnDisplayConfigured(const gfx::Rect& bounds, bool success) {
-  if (success) {
+void WindowManager::OnDisplayConfigured(
+    const int64_t display_id,
+    const gfx::Rect& bounds,
+    const base::flat_map<int64_t, bool>& statuses) {
+  DCHECK_EQ(statuses.size(), 1UL);
+
+  if (statuses.at(display_id)) {
     std::unique_ptr<DemoWindow> window(
         new DemoWindow(this, renderer_factory_.get(), bounds));
     window->Start();

ui/ozone/demo/window_manager.h

@@ -9,6 +9,7 @@
 #include <vector>
 
 #include "base/callback.h"
+#include "base/containers/flat_map.h"
 #include "ui/display/types/native_display_observer.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/ozone/demo/renderer_factory.h"
@@ -38,7 +39,9 @@ class WindowManager : public display::NativeDisplayObserver {
  private:
   void OnDisplaysAcquired(
       const std::vector<display::DisplaySnapshot*>& displays);
-  void OnDisplayConfigured(const gfx::Rect& bounds, bool success);
+  void OnDisplayConfigured(const int64_t display_id,
+                           const gfx::Rect& bounds,
+                           const base::flat_map<int64_t, bool>& statuses);
 
   // display::NativeDisplayDelegate:
   void OnConfigurationChanged() override;

ui/ozone/platform/drm/gpu/drm_thread.cc

@@ -325,19 +325,23 @@ void DrmThread::RefreshNativeDisplays(
   std::move(callback).Run(display_manager_->GetDisplays());
 }
 
-void DrmThread::ConfigureNativeDisplay(
-    const display::DisplayConfigurationParams& display_config_params,
-    base::OnceCallback<void(bool)> callback) {
-  TRACE_EVENT0("drm", "DrmThread::ConfigureNativeDisplay");
-
-  if (display_config_params.mode) {
-    std::move(callback).Run(display_manager_->ConfigureDisplay(
-        display_config_params.id, *display_config_params.mode.value(),
-        display_config_params.origin));
+void DrmThread::ConfigureNativeDisplays(
+    const std::vector<display::DisplayConfigurationParams>& config_requests,
+    base::OnceCallback<void(const base::flat_map<int64_t, bool>&)> callback) {
+  TRACE_EVENT0("drm", "DrmThread::ConfigureNativeDisplays");
+
+  base::flat_map<int64_t, bool> statuses;
+  for (const auto& config : config_requests) {
+    bool status = false;
+    if (config.mode) {
+      status = display_manager_->ConfigureDisplay(
+          config.id, *config.mode.value(), config.origin);
     } else {
-    std::move(callback).Run(
-        display_manager_->DisableDisplay(display_config_params.id));
+      status = display_manager_->DisableDisplay(config.id);
+    }
+    statuses.insert(std::make_pair(config.id, status));
   }
+  std::move(callback).Run(statuses);
 }
 
 void DrmThread::TakeDisplayControl(base::OnceCallback<void(bool)> callback) {

ui/ozone/platform/drm/gpu/drm_thread.h

@@ -147,9 +147,9 @@ class DrmThread : public base::Thread,
       base::OnceCallback<void(MovableDisplaySnapshots)> callback) override;
   void AddGraphicsDevice(const base::FilePath& path, base::File file) override;
   void RemoveGraphicsDevice(const base::FilePath& path) override;
-  void ConfigureNativeDisplay(
-      const display::DisplayConfigurationParams& display_config_params,
-      base::OnceCallback<void(bool)> callback) override;
+  void ConfigureNativeDisplays(
+      const std::vector<display::DisplayConfigurationParams>& config_requests,
+      ConfigureNativeDisplaysCallback callback) override;
   void GetHDCPState(int64_t display_id,
                     base::OnceCallback<void(int64_t, bool, display::HDCPState)>
                         callback) override;

ui/ozone/platform/drm/host/drm_display_host.cc

@@ -35,18 +35,6 @@ void DrmDisplayHost::UpdateDisplaySnapshot(
   snapshot_ = std::move(params);
 }
 
-void DrmDisplayHost::Configure(
-    const display::DisplayConfigurationParams& display_config_params,
-    display::ConfigureCallback callback) {
-  if (is_dummy_) {
-    std::move(callback).Run(true);
-    return;
-  }
-
-  sender_->GpuConfigureNativeDisplay(display_config_params,
-                                     std::move(callback));
-}
-
 void DrmDisplayHost::GetHDCPState(display::GetHDCPStateCallback callback) {
   get_hdcp_callback_ = std::move(callback);
   if (!sender_->GpuGetHDCPState(snapshot_->display_id()))

ui/ozone/platform/drm/host/drm_display_host.h

@@ -29,11 +29,9 @@ class DrmDisplayHost : public GpuThreadObserver {
   ~DrmDisplayHost() override;
 
   display::DisplaySnapshot* snapshot() const { return snapshot_.get(); }
+  bool is_dummy() const { return is_dummy_; }
 
   void UpdateDisplaySnapshot(std::unique_ptr<display::DisplaySnapshot> params);
-  void Configure(
-      const display::DisplayConfigurationParams& display_config_params,
-      display::ConfigureCallback callback);
   void GetHDCPState(display::GetHDCPStateCallback callback);
   void SetHDCPState(display::HDCPState state,
                     display::SetHDCPStateCallback callback);

ui/ozone/platform/drm/host/drm_display_host_manager.cc

@@ -234,6 +234,23 @@ void DrmDisplayHostManager::UpdateDisplays(
   }
 }
 
+void DrmDisplayHostManager::ConfigureDisplays(
+    const std::vector<display::DisplayConfigurationParams>& config_requests,
+    display::ConfigureCallback callback) {
+  base::flat_map<int64_t, bool> dummy_statuses;
+  bool is_any_dummy = false;
+  for (auto& config : config_requests) {
+    is_any_dummy |= GetDisplay(config.id)->is_dummy();
+    dummy_statuses.insert(std::make_pair(config.id, true));
+  }
+  if (is_any_dummy) {
+    std::move(callback).Run(dummy_statuses);
+    return;
+  }
+
+  proxy_->GpuConfigureNativeDisplays(config_requests, std::move(callback));
+}
+
 void DrmDisplayHostManager::OnDeviceEvent(const DeviceEvent& event) {
   if (event.device_type() != DeviceEvent::DISPLAY)
     return;

ui/ozone/platform/drm/host/drm_display_host_manager.h

@@ -51,6 +51,9 @@ class DrmDisplayHostManager : public DeviceEventObserver, GpuThreadObserver {
   void TakeDisplayControl(display::DisplayControlCallback callback);
   void RelinquishDisplayControl(display::DisplayControlCallback callback);
   void UpdateDisplays(display::GetDisplaysCallback callback);
+  void ConfigureDisplays(
+      const std::vector<display::DisplayConfigurationParams>& config_requests,
+      display::ConfigureCallback callback);
 
   // DeviceEventObserver overrides:
   void OnDeviceEvent(const DeviceEvent& event) override;

ui/ozone/platform/drm/host/drm_native_display_delegate.cc

@@ -51,11 +51,9 @@ void DrmNativeDisplayDelegate::GetDisplays(
 }
 
 void DrmNativeDisplayDelegate::Configure(
-    const display::DisplayConfigurationParams& display_config_params,
+    const std::vector<display::DisplayConfigurationParams>& config_requests,
     display::ConfigureCallback callback) {
-  DrmDisplayHost* display =
-      display_manager_->GetDisplay(display_config_params.id);
-  display->Configure(display_config_params, std::move(callback));
+  display_manager_->ConfigureDisplays(config_requests, std::move(callback));
 }
 
 void DrmNativeDisplayDelegate::GetHDCPState(

ui/ozone/platform/drm/host/drm_native_display_delegate.h

@@ -30,7 +30,7 @@ class DrmNativeDisplayDelegate : public display::NativeDisplayDelegate {
       display::DisplayControlCallback callback) override;
   void GetDisplays(display::GetDisplaysCallback callback) override;
   void Configure(
-      const display::DisplayConfigurationParams& display_config_params,
+      const std::vector<display::DisplayConfigurationParams>& config_requests,
       display::ConfigureCallback callback) override;
   void GetHDCPState(const display::DisplaySnapshot& output,
                     display::GetHDCPStateCallback callback) override;

ui/ozone/platform/drm/host/gpu_thread_adapter.h

@@ -44,8 +44,8 @@ class GpuThreadAdapter {
   virtual bool GpuRemoveGraphicsDevice(const base::FilePath& path) = 0;
 
   // Services needed by DrmDisplayHost
-  virtual void GpuConfigureNativeDisplay(
-      const display::DisplayConfigurationParams& display_config_params,
+  virtual void GpuConfigureNativeDisplays(
+      const std::vector<display::DisplayConfigurationParams>& config_requests,
       display::ConfigureCallback callback) = 0;
   virtual bool GpuGetHDCPState(int64_t display_id) = 0;
   virtual bool GpuSetHDCPState(int64_t display_id,

ui/ozone/platform/drm/host/host_drm_device.cc

@@ -128,15 +128,18 @@ bool HostDrmDevice::GpuRefreshNativeDisplays() {
   return true;
 }
 
-void HostDrmDevice::GpuConfigureNativeDisplay(
-    const display::DisplayConfigurationParams& display_config_params,
+void HostDrmDevice::GpuConfigureNativeDisplays(
+    const std::vector<display::DisplayConfigurationParams>& config_requests,
     display::ConfigureCallback callback) {
   DCHECK_CALLED_ON_VALID_THREAD(on_ui_thread_);
   if (IsConnected()) {
-    drm_device_->ConfigureNativeDisplay(display_config_params,
-                                        std::move(callback));
+    drm_device_->ConfigureNativeDisplays(config_requests, std::move(callback));
   } else {
-    std::move(callback).Run(false);
+    // If not connected, report failure to config.
+    base::flat_map<int64_t, bool> dummy_statuses;
+    for (const auto& config : config_requests)
+      dummy_statuses.insert(std::make_pair(config.id, false));
+    std::move(callback).Run(dummy_statuses);
   }
 }
 

ui/ozone/platform/drm/host/host_drm_device.h

@@ -65,8 +65,8 @@ class HostDrmDevice : public base::RefCountedThreadSafe<HostDrmDevice>,
   bool GpuRemoveGraphicsDevice(const base::FilePath& path) override;
 
   // Services needed by DrmDisplayHost
-  void GpuConfigureNativeDisplay(
-      const display::DisplayConfigurationParams& display_config_params,
+  void GpuConfigureNativeDisplays(
+      const std::vector<display::DisplayConfigurationParams>& config_requests,
       display::ConfigureCallback callback) override;
   bool GpuGetHDCPState(int64_t display_id) override;
   bool GpuSetHDCPState(int64_t display_id, display::HDCPState state) override;

ui/ozone/public/mojom/drm_device.mojom

@@ -51,10 +51,11 @@ interface DrmDevice {
   // Instructs the GPU to abandon a DRM device.
   RemoveGraphicsDevice(mojo_base.mojom.FilePath path);
 
-  // Configures (Enables/Disables) a DRM display, returning true on success.
-  ConfigureNativeDisplay(
-      display.mojom.DisplayConfigurationParams display_config_params) =>
-      (bool success);
+  // Configures (Enables/Disables) DRM displays, returns a map: each configured
+  // display ID to its status, true on success.
+  ConfigureNativeDisplays(
+      array<display.mojom.DisplayConfigurationParams> config_requests) =>
+    (map<int64, bool> statuses);
 
   // Gets or sets high-definition content protection (HDCP) (DRM as in
   // digital rights management) state.