Convert ozone/drm to OnceCallback

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

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/ozone/platform/drm/gpu/drm_thread.h"
 
 #include <gbm.h>
 #include <utility>
 
 #include "base/command_line.h"
@@ skipping 199 matching lines @@
 }
 
 void DrmThread::MoveCursor(const gfx::AcceleratedWidget& widget,
                            const gfx::Point& location) {
   screen_manager_->GetWindow(widget)->MoveCursor(location);
 }
 
 void DrmThread::CheckOverlayCapabilities(
     gfx::AcceleratedWidget widget,
     const std::vector<OverlayCheck_Params>& overlays,
-    const base::Callback<void(gfx::AcceleratedWidget,
-                              const std::vector<OverlayCheck_Params>&)>&
+    base::OnceCallback<void(gfx::AcceleratedWidget,
+                            const std::vector<OverlayCheck_Params>&)>
         callback) {
-  callback.Run(widget,
-               screen_manager_->GetWindow(widget)->TestPageFlip(overlays));
+  std::move(callback).Run(

[dnicoara, 2017/05/12 14:35:25]

Just wondering why does the callback need to be moved?

+      widget, screen_manager_->GetWindow(widget)->TestPageFlip(overlays));
 }
 
 void DrmThread::RefreshNativeDisplays(
-    const base::Callback<void(const std::vector<DisplaySnapshot_Params>&)>&
+    base::OnceCallback<void(const std::vector<DisplaySnapshot_Params>&)>
         callback) {
-  callback.Run(display_manager_->GetDisplays());
+  std::move(callback).Run(display_manager_->GetDisplays());
 }
 
 void DrmThread::ConfigureNativeDisplay(
     int64_t id,
     const DisplayMode_Params& mode,
     const gfx::Point& origin,
-    const base::Callback<void(int64_t, bool)>& callback) {
-  callback.Run(id, display_manager_->ConfigureDisplay(id, mode, origin));
+    base::OnceCallback<void(int64_t, bool)> callback) {
+  std::move(callback).Run(id,
+                          display_manager_->ConfigureDisplay(id, mode, origin));
 }
 
 void DrmThread::DisableNativeDisplay(
     int64_t id,
-    const base::Callback<void(int64_t, bool)>& callback) {
-  callback.Run(id, display_manager_->DisableDisplay(id));
+    base::OnceCallback<void(int64_t, bool)> callback) {
+  std::move(callback).Run(id, display_manager_->DisableDisplay(id));
 }
 
-void DrmThread::TakeDisplayControl(const base::Callback<void(bool)>& callback) {
-  callback.Run(display_manager_->TakeDisplayControl());
+void DrmThread::TakeDisplayControl(base::OnceCallback<void(bool)> callback) {
+  std::move(callback).Run(display_manager_->TakeDisplayControl());
 }
 
 void DrmThread::RelinquishDisplayControl(
-    const base::Callback<void(bool)>& callback) {
+    base::OnceCallback<void(bool)> callback) {
   display_manager_->RelinquishDisplayControl();
-  callback.Run(true);
+  std::move(callback).Run(true);
 }
 
 void DrmThread::AddGraphicsDevice(const base::FilePath& path,
                                   const base::FileDescriptor& fd) {
   device_manager_->AddDrmDevice(path, fd);
 }
 
 void DrmThread::RemoveGraphicsDevice(const base::FilePath& path) {
   device_manager_->RemoveDrmDevice(path);
 }
 
 void DrmThread::GetHDCPState(
     int64_t display_id,
-    const base::Callback<void(int64_t, bool, display::HDCPState)>& callback) {
+    base::OnceCallback<void(int64_t, bool, display::HDCPState)> callback) {
   display::HDCPState state = display::HDCP_STATE_UNDESIRED;
   bool success = display_manager_->GetHDCPState(display_id, &state);
-  callback.Run(display_id, success, state);
+  std::move(callback).Run(display_id, success, state);
 }
 
-void DrmThread::SetHDCPState(
-    int64_t display_id,
-    display::HDCPState state,
-    const base::Callback<void(int64_t, bool)>& callback) {
-  callback.Run(display_id, display_manager_->SetHDCPState(display_id, state));
+void DrmThread::SetHDCPState(int64_t display_id,
+                             display::HDCPState state,
+                             base::OnceCallback<void(int64_t, bool)> callback) {
+  std::move(callback).Run(display_id,
+                          display_manager_->SetHDCPState(display_id, state));
 }
 
 void DrmThread::SetColorCorrection(
     int64_t display_id,
     const std::vector<display::GammaRampRGBEntry>& degamma_lut,
     const std::vector<display::GammaRampRGBEntry>& gamma_lut,
     const std::vector<float>& correction_matrix) {
   display_manager_->SetColorCorrection(display_id, degamma_lut, gamma_lut,
                                        correction_matrix);
 }
 
 // DrmThread requires a BindingSet instead of a simple Binding because it will
 // be used from multiple threads in multiple processes.
 void DrmThread::AddBinding(ozone::mojom::DeviceCursorRequest request) {
   bindings_.AddBinding(this, std::move(request));
 }
 
 }  // namespace ui