Convert additional ozone/drm callbacks to OnceCallback

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

 // Copyright 2014 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/hardware_display_controller.h"
 
 #include <drm.h>
 #include <string.h>
 #include <xf86drm.h>
 #include <utility>
@@ skipping 59 matching lines @@
 void HardwareDisplayController::Disable() {
   TRACE_EVENT0("drm", "HDC::Disable");
   for (const auto& controller : crtc_controllers_)
     controller->Disable();
 
   is_disabled_ = true;
 }
 
 void HardwareDisplayController::SchedulePageFlip(
     const OverlayPlaneList& plane_list,
-    const PageFlipCallback& callback) {
-  ActualSchedulePageFlip(plane_list, false /* test_only */, callback);
+    SwapCompletionOnceCallback callback) {
+  ActualSchedulePageFlip(plane_list, false /* test_only */,
+                         std::move(callback));
 }
 
 bool HardwareDisplayController::TestPageFlip(
     const OverlayPlaneList& plane_list) {
   return ActualSchedulePageFlip(plane_list, true /* test_only */,
-                                base::Bind(&EmptyFlipCallback));
+                                base::BindOnce(&EmptyFlipCallback));
 }
 
 bool HardwareDisplayController::ActualSchedulePageFlip(
     const OverlayPlaneList& plane_list,
     bool test_only,
-    const PageFlipCallback& callback) {
+    SwapCompletionOnceCallback callback) {
   TRACE_EVENT0("drm", "HDC::SchedulePageFlip");
 
   DCHECK(!is_disabled_);
 
   // Ignore requests with no planes to schedule.
   if (plane_list.empty()) {
-    callback.Run(gfx::SwapResult::SWAP_ACK);
+    std::move(callback).Run(gfx::SwapResult::SWAP_ACK);
     return true;
   }
 
   scoped_refptr<PageFlipRequest> page_flip_request =
-      new PageFlipRequest(crtc_controllers_.size(), callback);
+      new PageFlipRequest(crtc_controllers_.size(), std::move(callback));
 
   OverlayPlaneList pending_planes = plane_list;
   std::sort(pending_planes.begin(), pending_planes.end(),
             [](const OverlayPlane& l, const OverlayPlane& r) {
               return l.z_order < r.z_order;
             });
   if (pending_planes.front().z_order != 0) {
-    callback.Run(gfx::SwapResult::SWAP_FAILED);
+    std::move(callback).Run(gfx::SwapResult::SWAP_FAILED);
     return false;
   }
 
   for (const auto& planes : owned_hardware_planes_)
     planes.first->plane_manager()->BeginFrame(planes.second.get());
 
   bool status = true;
   for (const auto& controller : crtc_controllers_) {
     status &= controller->SchedulePageFlip(
         owned_hardware_planes_[controller->drm().get()].get(), pending_planes,
@@ skipping 171 matching lines @@
 
 scoped_refptr<DrmDevice> HardwareDisplayController::GetAllocationDrmDevice()
     const {
   DCHECK(!crtc_controllers_.empty());
   // TODO(dnicoara) When we support mirroring across DRM devices, figure out
   // which device should be used for allocations.
   return crtc_controllers_[0]->drm();
 }
 
 }  // namespace ui