ui/display: Convert display callbacks to OnceCallback

This cleans up ui/display to use base::OnceCallback instead of
base::Callback where appropriate.

Bug: 714018
Test: CQ & run chrome on eve

Change-Id: I4231d9266f2d7df41701fe70fa8ef4a9b42b34c4
Reviewed-on: https://chromium-review.googlesource.com/1026553Reviewed-by: Daniel Nicoara <dnicoara@chromium.org>
Reviewed-by: kylechar <kylechar@chromium.org>
Commit-Queue: Michael Spang <spang@chromium.org>
Cr-Commit-Position: refs/heads/master@{#553643}

services/ui/display/screen_manager_forwarding.cc

@@ -94,7 +94,7 @@ void ScreenManagerForwarding::OnDisplaySnapshotsInvalidated() {
 
 void ScreenManagerForwarding::Initialize(
     mojom::NativeDisplayObserverPtr observer,
-    const InitializeCallback& callback) {
+    InitializeCallback callback) {
   DCHECK(!native_display_delegate_);
   observer_ = std::move(observer);
 
@@ -112,42 +112,41 @@ void ScreenManagerForwarding::Initialize(
   // Provide the list of display snapshots initially. ForwardingDisplayDelegate
   // will wait synchronously for this.
   native_display_delegate_->GetDisplays(
-      base::Bind(&ScreenManagerForwarding::ForwardGetDisplays,
-                 base::Unretained(this), callback));
-
+      base::BindOnce(&ScreenManagerForwarding::ForwardGetDisplays,
+                     base::Unretained(this), std::move(callback)));
   // When ForwardingDisplayDelegate receives this it will start asynchronous
   // operation and redo any configuration that was skipped.
   observer_->OnConfigurationChanged();
 }
 
 void ScreenManagerForwarding::TakeDisplayControl(
-    const TakeDisplayControlCallback& callback) {
+    TakeDisplayControlCallback callback) {
   DCHECK(native_display_delegate_);
-  native_display_delegate_->TakeDisplayControl(callback);
+  native_display_delegate_->TakeDisplayControl(std::move(callback));
 }
 
 void ScreenManagerForwarding::RelinquishDisplayControl(
-    const RelinquishDisplayControlCallback& callback) {
+    RelinquishDisplayControlCallback callback) {
   DCHECK(native_display_delegate_);
-  native_display_delegate_->RelinquishDisplayControl(callback);
+  native_display_delegate_->RelinquishDisplayControl(std::move(callback));
 }
 
-void ScreenManagerForwarding::GetDisplays(const GetDisplaysCallback& callback) {
+void ScreenManagerForwarding::GetDisplays(GetDisplaysCallback callback) {
   DCHECK(native_display_delegate_);
   native_display_delegate_->GetDisplays(
-      base::Bind(&ScreenManagerForwarding::ForwardGetDisplays,
-                 base::Unretained(this), callback));
+      base::BindOnce(&ScreenManagerForwarding::ForwardGetDisplays,
+                     base::Unretained(this), std::move(callback)));
 }
 
 void ScreenManagerForwarding::Configure(
     int64_t display_id,
     base::Optional<std::unique_ptr<display::DisplayMode>> mode,
     const gfx::Point& origin,
-    const ConfigureCallback& callback) {
+    ConfigureCallback callback) {
   DCHECK(native_display_delegate_);
   DisplaySnapshot* snapshot = snapshot_map_[display_id];
   if (!snapshot) {
-    callback.Run(false);
+    std::move(callback).Run(false);
     return;
   }
 
@@ -157,36 +156,34 @@ void ScreenManagerForwarding::Configure(
       mode ? GetCorrespondingMode(*snapshot, mode->get()) : nullptr;
   native_display_delegate_->Configure(
       *snapshot, snapshot_mode, origin,
-      base::Bind(&ScreenManagerForwarding::ForwardConfigure,
-                 base::Unretained(this), snapshot, snapshot_mode, origin,
-                 callback));
+      base::BindOnce(&ScreenManagerForwarding::ForwardConfigure,
+                     base::Unretained(this), snapshot, snapshot_mode, origin,
+                     std::move(callback)));
 }
 
-void ScreenManagerForwarding::GetHDCPState(
-    int64_t display_id,
-    const GetHDCPStateCallback& callback) {
+void ScreenManagerForwarding::GetHDCPState(int64_t display_id,
+                                           GetHDCPStateCallback callback) {
   DCHECK(native_display_delegate_);
   const DisplaySnapshot* snapshot = snapshot_map_[display_id];
   if (!snapshot) {
-    callback.Run(false, HDCP_STATE_UNDESIRED);
+    std::move(callback).Run(false, HDCP_STATE_UNDESIRED);
     return;
   }
 
-  native_display_delegate_->GetHDCPState(*snapshot, callback);
+  native_display_delegate_->GetHDCPState(*snapshot, std::move(callback));
 }
 
-void ScreenManagerForwarding::SetHDCPState(
-    int64_t display_id,
-    display::HDCPState state,
-    const SetHDCPStateCallback& callback) {
+void ScreenManagerForwarding::SetHDCPState(int64_t display_id,
+                                           display::HDCPState state,
+                                           SetHDCPStateCallback callback) {
   DCHECK(native_display_delegate_);
   const DisplaySnapshot* snapshot = snapshot_map_[display_id];
   if (!snapshot) {
-    callback.Run(false);
+    std::move(callback).Run(false);
     return;
   }
 
-  native_display_delegate_->SetHDCPState(*snapshot, state, callback);
+  native_display_delegate_->SetHDCPState(*snapshot, state, std::move(callback));
 }
 
 void ScreenManagerForwarding::SetColorCorrection(
@@ -243,7 +240,7 @@ void ScreenManagerForwarding::BindDevDisplayControllerRequest(
 }
 
 void ScreenManagerForwarding::ForwardGetDisplays(
-    const GetDisplaysCallback& callback,
+    GetDisplaysCallback callback,
     const std::vector<DisplaySnapshot*>& snapshots) {
   snapshot_map_.clear();
 
@@ -255,14 +252,14 @@ void ScreenManagerForwarding::ForwardGetDisplays(
     snapshot_clones.push_back(snapshot->Clone());
   }
 
-  callback.Run(std::move(snapshot_clones));
+  std::move(callback).Run(std::move(snapshot_clones));
 }
 
 void ScreenManagerForwarding::ForwardConfigure(
     DisplaySnapshot* snapshot,
     const DisplayMode* mode,
     const gfx::Point& origin,
-    const mojom::NativeDisplayDelegate::ConfigureCallback& callback,
+    mojom::NativeDisplayDelegate::ConfigureCallback callback,
     bool status) {
   if (status) {
     // Modify display snapshot similar to how ConfigureDisplaysTask would. Ozone
@@ -270,7 +267,7 @@ void ScreenManagerForwarding::ForwardConfigure(
     snapshot->set_current_mode(mode);
     snapshot->set_origin(origin);
   }
-  callback.Run(status);
+  std::move(callback).Run(status);
 }
 
 }  // namespace display

services/ui/display/screen_manager_forwarding.h

@@ -53,20 +53,19 @@ class ScreenManagerForwarding : public ScreenManager,
 
   // mojom::NativeDisplayDelegate:
   void Initialize(mojom::NativeDisplayObserverPtr observer,
-                  const InitializeCallback& callback) override;
-  void TakeDisplayControl(const TakeDisplayControlCallback& callback) override;
+                  InitializeCallback callback) override;
+  void TakeDisplayControl(TakeDisplayControlCallback callback) override;
   void RelinquishDisplayControl(
-      const RelinquishDisplayControlCallback& callback) override;
-  void GetDisplays(const GetDisplaysCallback& callback) override;
+      RelinquishDisplayControlCallback callback) override;
+  void GetDisplays(GetDisplaysCallback callback) override;
   void Configure(int64_t display_id,
                  base::Optional<std::unique_ptr<display::DisplayMode>> mode,
                  const gfx::Point& origin,
-                 const ConfigureCallback& callback) override;
-  void GetHDCPState(int64_t display_id,
-                    const GetHDCPStateCallback& callback) override;
+                 ConfigureCallback callback) override;
+  void GetHDCPState(int64_t display_id, GetHDCPStateCallback callback) override;
   void SetHDCPState(int64_t display_id,
                     display::HDCPState state,
-                    const SetHDCPStateCallback& callback) override;
+                    SetHDCPStateCallback callback) override;
   void SetColorCorrection(
       int64_t display_id,
       const std::vector<display::GammaRampRGBEntry>& degamma_lut,
@@ -85,7 +84,7 @@ class ScreenManagerForwarding : public ScreenManager,
       const service_manager::BindSourceInfo& source_info);
 
   // Forwards results from GetDisplays() back with |callback|.
-  void ForwardGetDisplays(const GetDisplaysCallback& callback,
+  void ForwardGetDisplays(GetDisplaysCallback callback,
                           const std::vector<DisplaySnapshot*>& displays);
 
   // Forwards results from call to Configure() back with |callback|.
@@ -93,7 +92,7 @@ class ScreenManagerForwarding : public ScreenManager,
       DisplaySnapshot* snapshot,
       const DisplayMode* mode,
       const gfx::Point& origin,
-      const mojom::NativeDisplayDelegate::ConfigureCallback& callback,
+      mojom::NativeDisplayDelegate::ConfigureCallback callback,
       bool status);
 
   // True if the UI Service runs inside WM's process, false if it runs inside

ui/display/manager/fake_display_delegate.cc

@@ -104,27 +104,26 @@ void FakeDisplayDelegate::Initialize() {
   initialized_ = true;
 }
 
-void FakeDisplayDelegate::TakeDisplayControl(
-    const DisplayControlCallback& callback) {
-  callback.Run(false);
+void FakeDisplayDelegate::TakeDisplayControl(DisplayControlCallback callback) {
+  std::move(callback).Run(false);
 }
 
 void FakeDisplayDelegate::RelinquishDisplayControl(
-    const DisplayControlCallback& callback) {
-  callback.Run(false);
+    DisplayControlCallback callback) {
+  std::move(callback).Run(false);
 }
 
-void FakeDisplayDelegate::GetDisplays(const GetDisplaysCallback& callback) {
+void FakeDisplayDelegate::GetDisplays(GetDisplaysCallback callback) {
   std::vector<DisplaySnapshot*> displays;
   for (auto& display : displays_)
     displays.push_back(display.get());
-  callback.Run(displays);
+  std::move(callback).Run(displays);
 }
 
 void FakeDisplayDelegate::Configure(const DisplaySnapshot& output,
                                     const DisplayMode* mode,
                                     const gfx::Point& origin,
-                                    const ConfigureCallback& callback) {
+                                    ConfigureCallback callback) {
   bool configure_success = false;
 
   if (!mode) {
@@ -140,7 +139,8 @@ void FakeDisplayDelegate::Configure(const DisplaySnapshot& output,
     }
   }
 
-  configure_callbacks_.push(base::Bind(callback, configure_success));
+  configure_callbacks_.push(
+      base::BindOnce(std::move(callback), configure_success));
 
   // Start the timer if it's not already running. If there are multiple queued
   // configuration requests then ConfigureDone() will handle starting the
@@ -152,14 +152,14 @@ void FakeDisplayDelegate::Configure(const DisplaySnapshot& output,
 }
 
 void FakeDisplayDelegate::GetHDCPState(const DisplaySnapshot& output,
-                                       const GetHDCPStateCallback& callback) {
-  callback.Run(false, HDCP_STATE_UNDESIRED);
+                                       GetHDCPStateCallback callback) {
+  std::move(callback).Run(false, HDCP_STATE_UNDESIRED);
 }
 
 void FakeDisplayDelegate::SetHDCPState(const DisplaySnapshot& output,
                                        HDCPState state,
-                                       const SetHDCPStateCallback& callback) {
-  callback.Run(false);
+                                       SetHDCPStateCallback callback) {
+  std::move(callback).Run(false);
 }
 
 bool FakeDisplayDelegate::SetColorCorrection(
@@ -213,7 +213,7 @@ void FakeDisplayDelegate::OnConfigurationChanged() {
 
 void FakeDisplayDelegate::ConfigureDone() {
   DCHECK(!configure_callbacks_.empty());
-  configure_callbacks_.front().Run();
+  std::move(configure_callbacks_.front()).Run();
   configure_callbacks_.pop();
 
   // If there are more configuration requests waiting then restart the timer.

ui/display/manager/fake_display_delegate.h

@@ -82,19 +82,18 @@ class DISPLAY_MANAGER_EXPORT FakeDisplayDelegate
 
   // NativeDisplayDelegate overrides:
   void Initialize() override;
-  void TakeDisplayControl(const DisplayControlCallback& callback) override;
-  void RelinquishDisplayControl(
-      const DisplayControlCallback& callback) override;
-  void GetDisplays(const GetDisplaysCallback& callback) override;
+  void TakeDisplayControl(DisplayControlCallback callback) override;
+  void RelinquishDisplayControl(DisplayControlCallback callback) override;
+  void GetDisplays(GetDisplaysCallback callback) override;
   void Configure(const DisplaySnapshot& output,
                  const DisplayMode* mode,
                  const gfx::Point& origin,
-                 const ConfigureCallback& callback) override;
+                 ConfigureCallback callback) override;
   void GetHDCPState(const DisplaySnapshot& output,
-                    const GetHDCPStateCallback& callback) override;
+                    GetHDCPStateCallback callback) override;
   void SetHDCPState(const DisplaySnapshot& output,
                     HDCPState state,
-                    const SetHDCPStateCallback& callback) override;
+                    SetHDCPStateCallback callback) override;
   bool SetColorCorrection(const DisplaySnapshot& output,
                           const std::vector<GammaRampRGBEntry>& degamma_lut,
                           const std::vector<GammaRampRGBEntry>& gamma_lut,
@@ -120,7 +119,7 @@ class DISPLAY_MANAGER_EXPORT FakeDisplayDelegate
 
   // Add delay before finishing Configure() and running callback.
   base::OneShotTimer configure_timer_;
-  base::queue<base::Closure> configure_callbacks_;
+  base::queue<base::OnceClosure> configure_callbacks_;
 
   // If Initialize() has been called.
   bool initialized_ = false;

ui/display/manager/forwarding_display_delegate.cc

@@ -32,35 +32,34 @@ void ForwardingDisplayDelegate::Initialize() {
 }
 
 void ForwardingDisplayDelegate::TakeDisplayControl(
-    const DisplayControlCallback& callback) {
-  delegate_->TakeDisplayControl(callback);
+    DisplayControlCallback callback) {
+  delegate_->TakeDisplayControl(std::move(callback));
 }
 
 void ForwardingDisplayDelegate::RelinquishDisplayControl(
-    const DisplayControlCallback& callback) {
-  delegate_->RelinquishDisplayControl(callback);
+    DisplayControlCallback callback) {
+  delegate_->RelinquishDisplayControl(std::move(callback));
 }
 
-void ForwardingDisplayDelegate::GetDisplays(
-    const GetDisplaysCallback& callback) {
+void ForwardingDisplayDelegate::GetDisplays(GetDisplaysCallback callback) {
   if (!use_delegate_) {
-    ForwardDisplays(callback);
+    ForwardDisplays(std::move(callback));
     return;
   }
 
   delegate_->GetDisplays(
-      base::Bind(&ForwardingDisplayDelegate::StoreAndForwardDisplays,
-                 base::Unretained(this), callback));
+      base::BindOnce(&ForwardingDisplayDelegate::StoreAndForwardDisplays,
+                     base::Unretained(this), std::move(callback)));
 }
 
 void ForwardingDisplayDelegate::Configure(const DisplaySnapshot& snapshot,
                                           const DisplayMode* mode,
                                           const gfx::Point& origin,
-                                          const ConfigureCallback& callback) {
+                                          ConfigureCallback callback) {
   if (!use_delegate_) {
     // Pretend configuration succeeded. When the first OnConfigurationChanged()
     // is received this will run again and actually happen.
-    callback.Run(true);
+    std::move(callback).Run(true);
     return;
   }
 
@@ -68,20 +67,18 @@ void ForwardingDisplayDelegate::Configure(const DisplaySnapshot& snapshot,
   if (mode)
     transport_mode = mode->Clone();
   delegate_->Configure(snapshot.display_id(), std::move(transport_mode), origin,
-                       callback);
+                       std::move(callback));
 }
 
-void ForwardingDisplayDelegate::GetHDCPState(
-    const DisplaySnapshot& snapshot,
-    const GetHDCPStateCallback& callback) {
-  delegate_->GetHDCPState(snapshot.display_id(), callback);
+void ForwardingDisplayDelegate::GetHDCPState(const DisplaySnapshot& snapshot,
+                                             GetHDCPStateCallback callback) {
+  delegate_->GetHDCPState(snapshot.display_id(), std::move(callback));
 }
 
-void ForwardingDisplayDelegate::SetHDCPState(
-    const DisplaySnapshot& snapshot,
-    HDCPState state,
-    const SetHDCPStateCallback& callback) {
-  delegate_->SetHDCPState(snapshot.display_id(), state, callback);
+void ForwardingDisplayDelegate::SetHDCPState(const DisplaySnapshot& snapshot,
+                                             HDCPState state,
+                                             SetHDCPStateCallback callback) {
+  delegate_->SetHDCPState(snapshot.display_id(), state, std::move(callback));
 }
 
 bool ForwardingDisplayDelegate::SetColorCorrection(
@@ -120,21 +117,20 @@ void ForwardingDisplayDelegate::OnConfigurationChanged() {
 }
 
 void ForwardingDisplayDelegate::StoreAndForwardDisplays(
-    const GetDisplaysCallback& callback,
+    GetDisplaysCallback callback,
     std::vector<std::unique_ptr<DisplaySnapshot>> snapshots) {
   for (auto& observer : observers_)
     observer.OnDisplaySnapshotsInvalidated();
   snapshots_ = std::move(snapshots);
 
-  ForwardDisplays(callback);
+  ForwardDisplays(std::move(callback));
 }
 
-void ForwardingDisplayDelegate::ForwardDisplays(
-    const GetDisplaysCallback& callback) {
+void ForwardingDisplayDelegate::ForwardDisplays(GetDisplaysCallback callback) {
   std::vector<DisplaySnapshot*> snapshot_ptrs;
   for (auto& snapshot : snapshots_)
     snapshot_ptrs.push_back(snapshot.get());
-  callback.Run(snapshot_ptrs);
+  std::move(callback).Run(snapshot_ptrs);
 }
 
 }  // namespace display

ui/display/manager/forwarding_display_delegate.h

@@ -33,19 +33,18 @@ class DISPLAY_MANAGER_EXPORT ForwardingDisplayDelegate
 
   // display::NativeDisplayDelegate:
   void Initialize() override;
-  void TakeDisplayControl(const DisplayControlCallback& callback) override;
-  void RelinquishDisplayControl(
-      const DisplayControlCallback& callback) override;
-  void GetDisplays(const GetDisplaysCallback& callback) override;
+  void TakeDisplayControl(DisplayControlCallback callback) override;
+  void RelinquishDisplayControl(DisplayControlCallback callback) override;
+  void GetDisplays(GetDisplaysCallback callback) override;
   void Configure(const DisplaySnapshot& output,
                  const DisplayMode* mode,
                  const gfx::Point& origin,
-                 const ConfigureCallback& callback) override;
+                 ConfigureCallback callback) override;
   void GetHDCPState(const DisplaySnapshot& output,
-                    const GetHDCPStateCallback& callback) override;
+                    GetHDCPStateCallback callback) override;
   void SetHDCPState(const DisplaySnapshot& output,
                     HDCPState state,
-                    const SetHDCPStateCallback& callback) override;
+                    SetHDCPStateCallback callback) override;
   bool SetColorCorrection(const DisplaySnapshot& output,
                           const std::vector<GammaRampRGBEntry>& degamma_lut,
                           const std::vector<GammaRampRGBEntry>& gamma_lut,
@@ -60,11 +59,11 @@ class DISPLAY_MANAGER_EXPORT ForwardingDisplayDelegate
  private:
   // Stores display snapshots and forwards pointers to |callback|.
   void StoreAndForwardDisplays(
-      const GetDisplaysCallback& callback,
+      GetDisplaysCallback callback,
       std::vector<std::unique_ptr<DisplaySnapshot>> snapshots);
 
   // Forwards display snapshot pointers to |callback|.
-  void ForwardDisplays(const GetDisplaysCallback& callback);
+  void ForwardDisplays(GetDisplaysCallback callback);
 
   // True if we should use |delegate_|. This will be false if synchronous
   // GetDisplays() and Configure() are required.

ui/display/manager/test/test_native_display_delegate.cc

@@ -30,28 +30,27 @@ void TestNativeDisplayDelegate::Initialize() {
 }
 
 void TestNativeDisplayDelegate::TakeDisplayControl(
-    const DisplayControlCallback& callback) {
+    DisplayControlCallback callback) {
   log_->AppendAction(kTakeDisplayControl);
-  callback.Run(true);
+  std::move(callback).Run(true);
 }
 
 void TestNativeDisplayDelegate::RelinquishDisplayControl(
-    const DisplayControlCallback& callback) {
+    DisplayControlCallback callback) {
   log_->AppendAction(kRelinquishDisplayControl);
-  callback.Run(true);
+  std::move(callback).Run(true);
 }
 
-void TestNativeDisplayDelegate::GetDisplays(
-    const GetDisplaysCallback& callback) {
+void TestNativeDisplayDelegate::GetDisplays(GetDisplaysCallback callback) {
   // This mimics the behavior of Ozone DRM when new display state arrives.
   for (NativeDisplayObserver& observer : observers_)
     observer.OnDisplaySnapshotsInvalidated();
 
   if (run_async_) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::BindOnce(callback, outputs_));
+        FROM_HERE, base::BindOnce(std::move(callback), outputs_));
   } else {
-    callback.Run(outputs_);
+    std::move(callback).Run(outputs_);
   }
 }
 
@@ -72,28 +71,26 @@ bool TestNativeDisplayDelegate::Configure(const DisplaySnapshot& output,
 void TestNativeDisplayDelegate::Configure(const DisplaySnapshot& output,
                                           const DisplayMode* mode,
                                           const gfx::Point& origin,
-                                          const ConfigureCallback& callback) {
+                                          ConfigureCallback callback) {
   bool result = Configure(output, mode, origin);
   if (run_async_) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::BindOnce(callback, result));
+        FROM_HERE, base::BindOnce(std::move(callback), result));
   } else {
-    callback.Run(result);
+    std::move(callback).Run(result);
   }
 }
 
-void TestNativeDisplayDelegate::GetHDCPState(
-    const DisplaySnapshot& output,
-    const GetHDCPStateCallback& callback) {
-  callback.Run(get_hdcp_expectation_, hdcp_state_);
+void TestNativeDisplayDelegate::GetHDCPState(const DisplaySnapshot& output,
+                                             GetHDCPStateCallback callback) {
+  std::move(callback).Run(get_hdcp_expectation_, hdcp_state_);
 }
 
-void TestNativeDisplayDelegate::SetHDCPState(
-    const DisplaySnapshot& output,
-    HDCPState state,
-    const SetHDCPStateCallback& callback) {
+void TestNativeDisplayDelegate::SetHDCPState(const DisplaySnapshot& output,
+                                             HDCPState state,
+                                             SetHDCPStateCallback callback) {
   log_->AppendAction(GetSetHDCPStateAction(output, state));
-  callback.Run(set_hdcp_expectation_);
+  std::move(callback).Run(set_hdcp_expectation_);
 }
 
 bool TestNativeDisplayDelegate::SetColorCorrection(

ui/display/manager/test/test_native_display_delegate.h

@@ -53,19 +53,18 @@ class TestNativeDisplayDelegate : public NativeDisplayDelegate {
 
   // NativeDisplayDelegate overrides:
   void Initialize() override;
-  void TakeDisplayControl(const DisplayControlCallback& callback) override;
-  void RelinquishDisplayControl(
-      const DisplayControlCallback& callback) override;
-  void GetDisplays(const GetDisplaysCallback& callback) override;
+  void TakeDisplayControl(DisplayControlCallback callback) override;
+  void RelinquishDisplayControl(DisplayControlCallback callback) override;
+  void GetDisplays(GetDisplaysCallback callback) override;
   void Configure(const DisplaySnapshot& output,
                  const DisplayMode* mode,
                  const gfx::Point& origin,
-                 const ConfigureCallback& callback) override;
+                 ConfigureCallback callback) override;
   void GetHDCPState(const DisplaySnapshot& output,
-                    const GetHDCPStateCallback& callback) override;
+                    GetHDCPStateCallback callback) override;
   void SetHDCPState(const DisplaySnapshot& output,
                     HDCPState state,
-                    const SetHDCPStateCallback& callback) override;
+                    SetHDCPStateCallback callback) override;
   bool SetColorCorrection(const DisplaySnapshot& output,
                           const std::vector<GammaRampRGBEntry>& degamma_lut,
                           const std::vector<GammaRampRGBEntry>& gamma_lut,

ui/display/mojo/BUILD.gn

@@ -22,6 +22,5 @@ mojom("interfaces") {
     "//ui/gfx/mojo",
   ]
 
-  # TODO(crbug.com/714018): Convert the implementation to use OnceCallback.
-  use_once_callback = false
+  use_once_callback = true
 }

ui/display/types/native_display_delegate.h

@@ -26,11 +26,11 @@ class NativeDisplayObserver;
 struct GammaRampRGBEntry;
 
 using GetDisplaysCallback =
-    base::Callback<void(const std::vector<DisplaySnapshot*>&)>;
-using ConfigureCallback = base::Callback<void(bool)>;
-using GetHDCPStateCallback = base::Callback<void(bool, HDCPState)>;
-using SetHDCPStateCallback = base::Callback<void(bool)>;
-using DisplayControlCallback = base::Callback<void(bool)>;
+    base::OnceCallback<void(const std::vector<DisplaySnapshot*>&)>;
+using ConfigureCallback = base::OnceCallback<void(bool)>;
+using GetHDCPStateCallback = base::OnceCallback<void(bool, HDCPState)>;
+using SetHDCPStateCallback = base::OnceCallback<void(bool)>;
+using DisplayControlCallback = base::OnceCallback<void(bool)>;
 
 // Interface for classes that perform display configuration actions on behalf
 // of DisplayConfigurator.
@@ -45,15 +45,14 @@ class DISPLAY_TYPES_EXPORT NativeDisplayDelegate {
   virtual void Initialize() = 0;
 
   // Take control of the display from any other controlling process.
-  virtual void TakeDisplayControl(const DisplayControlCallback& callback) = 0;
+  virtual void TakeDisplayControl(DisplayControlCallback callback) = 0;
 
   // Let others control the display.
-  virtual void RelinquishDisplayControl(
-      const DisplayControlCallback& callback) = 0;
+  virtual void RelinquishDisplayControl(DisplayControlCallback callback) = 0;
 
   // Queries for a list of fresh displays and returns them via |callback|.
   // Note the query operation may be expensive and take over 60 milliseconds.
-  virtual void GetDisplays(const GetDisplaysCallback& callback) = 0;
+  virtual void GetDisplays(GetDisplaysCallback callback) = 0;
 
   // Configures the display represented by |output| to use |mode| and positions
   // the display to |origin| in the framebuffer. |mode| can be NULL, which
@@ -62,16 +61,16 @@ class DISPLAY_TYPES_EXPORT NativeDisplayDelegate {
   virtual void Configure(const DisplaySnapshot& output,
                          const DisplayMode* mode,
                          const gfx::Point& origin,
-                         const ConfigureCallback& callback) = 0;
+                         ConfigureCallback callback) = 0;
 
   // Gets HDCP state of output.
   virtual void GetHDCPState(const DisplaySnapshot& output,
-                            const GetHDCPStateCallback& callback) = 0;
+                            GetHDCPStateCallback callback) = 0;
 
   // Sets HDCP state of output.
   virtual void SetHDCPState(const DisplaySnapshot& output,
                             HDCPState state,
-                            const SetHDCPStateCallback& callback) = 0;
+                            SetHDCPStateCallback callback) = 0;
 
   // Set the gamma tables and corection matrix for the display.
   virtual bool SetColorCorrection(

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

@@ -33,13 +33,13 @@ void DrmDisplayHost::UpdateDisplaySnapshot(
 
 void DrmDisplayHost::Configure(const display::DisplayMode* mode,
                                const gfx::Point& origin,
-                               const display::ConfigureCallback& callback) {
+                               display::ConfigureCallback callback) {
   if (is_dummy_) {
-    callback.Run(true);
+    std::move(callback).Run(true);
     return;
   }
 
-  configure_callback_ = callback;
+  configure_callback_ = std::move(callback);
   bool status = false;
   if (mode) {
     status = sender_->GpuConfigureNativeDisplay(
@@ -55,7 +55,7 @@ void DrmDisplayHost::Configure(const display::DisplayMode* mode,
 void DrmDisplayHost::OnDisplayConfigured(bool status) {
   if (!configure_callback_.is_null()) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::BindOnce(configure_callback_, status));
+        FROM_HERE, base::BindOnce(std::move(configure_callback_), status));
   } else {
     LOG(ERROR) << "Got unexpected event for display "
                << snapshot_->display_id();
@@ -64,9 +64,8 @@ void DrmDisplayHost::OnDisplayConfigured(bool status) {
   configure_callback_.Reset();
 }
 
-void DrmDisplayHost::GetHDCPState(
-    const display::GetHDCPStateCallback& callback) {
-  get_hdcp_callback_ = callback;
+void DrmDisplayHost::GetHDCPState(display::GetHDCPStateCallback callback) {
+  get_hdcp_callback_ = std::move(callback);
   if (!sender_->GpuGetHDCPState(snapshot_->display_id()))
     OnHDCPStateReceived(false, display::HDCP_STATE_UNDESIRED);
 }
@@ -75,7 +74,8 @@ void DrmDisplayHost::OnHDCPStateReceived(bool status,
                                          display::HDCPState state) {
   if (!get_hdcp_callback_.is_null()) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::BindOnce(get_hdcp_callback_, status, state));
+        FROM_HERE,
+        base::BindOnce(std::move(get_hdcp_callback_), status, state));
   } else {
     LOG(ERROR) << "Got unexpected event for display "
                << snapshot_->display_id();
@@ -84,10 +84,9 @@ void DrmDisplayHost::OnHDCPStateReceived(bool status,
   get_hdcp_callback_.Reset();
 }
 
-void DrmDisplayHost::SetHDCPState(
-    display::HDCPState state,
-    const display::SetHDCPStateCallback& callback) {
-  set_hdcp_callback_ = callback;
+void DrmDisplayHost::SetHDCPState(display::HDCPState state,
+                                  display::SetHDCPStateCallback callback) {
+  set_hdcp_callback_ = std::move(callback);
   if (!sender_->GpuSetHDCPState(snapshot_->display_id(), state))
     OnHDCPStateUpdated(false);
 }
@@ -95,7 +94,7 @@ void DrmDisplayHost::SetHDCPState(
 void DrmDisplayHost::OnHDCPStateUpdated(bool status) {
   if (!set_hdcp_callback_.is_null()) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::BindOnce(set_hdcp_callback_, status));
+        FROM_HERE, base::BindOnce(std::move(set_hdcp_callback_), status));
   } else {
     LOG(ERROR) << "Got unexpected event for display "
                << snapshot_->display_id();

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

@@ -32,10 +32,10 @@ class DrmDisplayHost : public GpuThreadObserver {
   void UpdateDisplaySnapshot(std::unique_ptr<display::DisplaySnapshot> params);
   void Configure(const display::DisplayMode* mode,
                  const gfx::Point& origin,
-                 const display::ConfigureCallback& callback);
-  void GetHDCPState(const display::GetHDCPStateCallback& callback);
+                 display::ConfigureCallback callback);
+  void GetHDCPState(display::GetHDCPStateCallback callback);
   void SetHDCPState(display::HDCPState state,
-                    const display::SetHDCPStateCallback& callback);
+                    display::SetHDCPStateCallback callback);
   void SetColorCorrection(
       const std::vector<display::GammaRampRGBEntry>& degamma_lut,
       const std::vector<display::GammaRampRGBEntry>& gamma_lut,

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

@@ -180,20 +180,20 @@ void DrmDisplayHostManager::RemoveDelegate(DrmNativeDisplayDelegate* delegate) {
 }
 
 void DrmDisplayHostManager::TakeDisplayControl(
-    const display::DisplayControlCallback& callback) {
+    display::DisplayControlCallback callback) {
   if (display_control_change_pending_) {
     LOG(ERROR) << "TakeDisplayControl called while change already pending";
-    callback.Run(false);
+    std::move(callback).Run(false);
     return;
   }
 
   if (!display_externally_controlled_) {
     LOG(ERROR) << "TakeDisplayControl called while display already owned";
-    callback.Run(true);
+    std::move(callback).Run(true);
     return;
   }
 
-  take_display_control_callback_ = callback;
+  take_display_control_callback_ = std::move(callback);
   display_control_change_pending_ = true;
 
   if (!proxy_->GpuTakeDisplayControl())
@@ -201,21 +201,21 @@ void DrmDisplayHostManager::TakeDisplayControl(
 }
 
 void DrmDisplayHostManager::RelinquishDisplayControl(
-    const display::DisplayControlCallback& callback) {
+    display::DisplayControlCallback callback) {
   if (display_control_change_pending_) {
     LOG(ERROR)
         << "RelinquishDisplayControl called while change already pending";
-    callback.Run(false);
+    std::move(callback).Run(false);
     return;
   }
 
   if (display_externally_controlled_) {
     LOG(ERROR) << "RelinquishDisplayControl called while display not owned";
-    callback.Run(true);
+    std::move(callback).Run(true);
     return;
   }
 
-  relinquish_display_control_callback_ = callback;
+  relinquish_display_control_callback_ = std::move(callback);
   display_control_change_pending_ = true;
 
   if (!proxy_->GpuRelinquishDisplayControl())
@@ -223,11 +223,11 @@ void DrmDisplayHostManager::RelinquishDisplayControl(
 }
 
 void DrmDisplayHostManager::UpdateDisplays(
-    const display::GetDisplaysCallback& callback) {
-  get_displays_callback_ = callback;
+    display::GetDisplaysCallback callback) {
+  get_displays_callback_ = std::move(callback);
   if (!proxy_->GpuRefreshNativeDisplays()) {
+    RunUpdateDisplaysCallback(std::move(get_displays_callback_));
     get_displays_callback_.Reset();
-    RunUpdateDisplaysCallback(callback);
   }
 }
 
@@ -346,7 +346,8 @@ void DrmDisplayHostManager::OnGpuThreadReady() {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::BindOnce(&DrmDisplayHostManager::RunUpdateDisplaysCallback,
-                       weak_ptr_factory_.GetWeakPtr(), get_displays_callback_));
+                       weak_ptr_factory_.GetWeakPtr(),
+                       std::move(get_displays_callback_)));
     get_displays_callback_.Reset();
   }
 
@@ -387,7 +388,8 @@ void DrmDisplayHostManager::GpuHasUpdatedNativeDisplays(
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::BindOnce(&DrmDisplayHostManager::RunUpdateDisplaysCallback,
-                       weak_ptr_factory_.GetWeakPtr(), get_displays_callback_));
+                       weak_ptr_factory_.GetWeakPtr(),
+                       std::move(get_displays_callback_)));
     get_displays_callback_.Reset();
   }
 }
@@ -437,7 +439,8 @@ void DrmDisplayHostManager::GpuTookDisplayControl(bool status) {
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::BindOnce(take_display_control_callback_, status));
+      FROM_HERE,
+      base::BindOnce(std::move(take_display_control_callback_), status));
   take_display_control_callback_.Reset();
   display_control_change_pending_ = false;
 }
@@ -457,18 +460,19 @@ void DrmDisplayHostManager::GpuRelinquishedDisplayControl(bool status) {
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::BindOnce(relinquish_display_control_callback_, status));
+      FROM_HERE,
+      base::BindOnce(std::move(relinquish_display_control_callback_), status));
   relinquish_display_control_callback_.Reset();
   display_control_change_pending_ = false;
 }
 
 void DrmDisplayHostManager::RunUpdateDisplaysCallback(
-    const display::GetDisplaysCallback& callback) const {
+    display::GetDisplaysCallback callback) const {
   std::vector<display::DisplaySnapshot*> snapshots;
   for (const auto& display : displays_)
     snapshots.push_back(display->snapshot());
 
-  callback.Run(snapshots);
+  std::move(callback).Run(snapshots);
 }
 
 void DrmDisplayHostManager::NotifyDisplayDelegate() const {

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

@@ -49,10 +49,9 @@ class DrmDisplayHostManager : public DeviceEventObserver, GpuThreadObserver {
   // External API.
   void AddDelegate(DrmNativeDisplayDelegate* delegate);
   void RemoveDelegate(DrmNativeDisplayDelegate* delegate);
-  void TakeDisplayControl(const display::DisplayControlCallback& callback);
-  void RelinquishDisplayControl(
-      const display::DisplayControlCallback& callback);
-  void UpdateDisplays(const display::GetDisplaysCallback& callback);
+  void TakeDisplayControl(display::DisplayControlCallback callback);
+  void RelinquishDisplayControl(display::DisplayControlCallback callback);
+  void UpdateDisplays(display::GetDisplaysCallback callback);
 
   // DeviceEventObserver overrides:
   void OnDeviceEvent(const DeviceEvent& event) override;
@@ -95,8 +94,7 @@ class DrmDisplayHostManager : public DeviceEventObserver, GpuThreadObserver {
   void OnUpdateGraphicsDevice();
   void OnRemoveGraphicsDevice(const base::FilePath& path);
 
-  void RunUpdateDisplaysCallback(
-      const display::GetDisplaysCallback& callback) const;
+  void RunUpdateDisplaysCallback(display::GetDisplaysCallback callback) const;
 
   void NotifyDisplayDelegate() const;
 

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

@@ -35,42 +35,41 @@ void DrmNativeDisplayDelegate::Initialize() {
 }
 
 void DrmNativeDisplayDelegate::TakeDisplayControl(
-    const display::DisplayControlCallback& callback) {
-  display_manager_->TakeDisplayControl(callback);
+    display::DisplayControlCallback callback) {
+  display_manager_->TakeDisplayControl(std::move(callback));
 }
 
 void DrmNativeDisplayDelegate::RelinquishDisplayControl(
-    const display::DisplayControlCallback& callback) {
-  display_manager_->RelinquishDisplayControl(callback);
+    display::DisplayControlCallback callback) {
+  display_manager_->RelinquishDisplayControl(std::move(callback));
 }
 
 void DrmNativeDisplayDelegate::GetDisplays(
-    const display::GetDisplaysCallback& callback) {
-  display_manager_->UpdateDisplays(callback);
+    display::GetDisplaysCallback callback) {
+  display_manager_->UpdateDisplays(std::move(callback));
 }
 
-void DrmNativeDisplayDelegate::Configure(
-    const display::DisplaySnapshot& output,
-    const display::DisplayMode* mode,
-    const gfx::Point& origin,
-    const display::ConfigureCallback& callback) {
+void DrmNativeDisplayDelegate::Configure(const display::DisplaySnapshot& output,
+                                         const display::DisplayMode* mode,
+                                         const gfx::Point& origin,
+                                         display::ConfigureCallback callback) {
   DrmDisplayHost* display = display_manager_->GetDisplay(output.display_id());
-  display->Configure(mode, origin, callback);
+  display->Configure(mode, origin, std::move(callback));
 }
 
 void DrmNativeDisplayDelegate::GetHDCPState(
     const display::DisplaySnapshot& output,
-    const display::GetHDCPStateCallback& callback) {
+    display::GetHDCPStateCallback callback) {
   DrmDisplayHost* display = display_manager_->GetDisplay(output.display_id());
-  display->GetHDCPState(callback);
+  display->GetHDCPState(std::move(callback));
 }
 
 void DrmNativeDisplayDelegate::SetHDCPState(
     const display::DisplaySnapshot& output,
     display::HDCPState state,
-    const display::SetHDCPStateCallback& callback) {
+    display::SetHDCPStateCallback callback) {
   DrmDisplayHost* display = display_manager_->GetDisplay(output.display_id());
-  display->SetHDCPState(state, callback);
+  display->SetHDCPState(state, std::move(callback));
 }
 
 bool DrmNativeDisplayDelegate::SetColorCorrection(

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

@@ -25,20 +25,19 @@ class DrmNativeDisplayDelegate : public display::NativeDisplayDelegate {
 
   // display::NativeDisplayDelegate overrides:
   void Initialize() override;
-  void TakeDisplayControl(
-      const display::DisplayControlCallback& callback) override;
+  void TakeDisplayControl(display::DisplayControlCallback callback) override;
   void RelinquishDisplayControl(
-      const display::DisplayControlCallback& callback) override;
-  void GetDisplays(const display::GetDisplaysCallback& callback) override;
+      display::DisplayControlCallback callback) override;
+  void GetDisplays(display::GetDisplaysCallback callback) override;
   void Configure(const display::DisplaySnapshot& output,
                  const display::DisplayMode* mode,
                  const gfx::Point& origin,
-                 const display::ConfigureCallback& callback) override;
+                 display::ConfigureCallback callback) override;
   void GetHDCPState(const display::DisplaySnapshot& output,
-                    const display::GetHDCPStateCallback& callback) override;
+                    display::GetHDCPStateCallback callback) override;
   void SetHDCPState(const display::DisplaySnapshot& output,
                     display::HDCPState state,
-                    const display::SetHDCPStateCallback& callback) override;
+                    display::SetHDCPStateCallback callback) override;
   bool SetColorCorrection(
       const display::DisplaySnapshot& output,
       const std::vector<display::GammaRampRGBEntry>& degamma_lut,