Convert ozone/drm to OnceCallback

ui/ozone/platform/drm/gpu/drm_thread_message_proxy.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_message_proxy.h"
 
 #include "base/threading/thread_task_runner_handle.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_sender.h"
 #include "ui/ozone/common/gpu/ozone_gpu_messages.h"
@@ skipping 91 matching lines @@
   drm_thread_->task_runner()->PostTask(
       FROM_HERE, base::Bind(&DrmThread::MoveCursor,
                             base::Unretained(drm_thread_), widget, location));
 }
 
 void DrmThreadMessageProxy::OnCheckOverlayCapabilities(
     gfx::AcceleratedWidget widget,
     const std::vector<OverlayCheck_Params>& overlays) {
   DCHECK(drm_thread_->IsRunning());
   auto callback =
-      base::Bind(&DrmThreadMessageProxy::OnCheckOverlayCapabilitiesCallback,
-                 weak_ptr_factory_.GetWeakPtr());
+      base::BindOnce(&DrmThreadMessageProxy::OnCheckOverlayCapabilitiesCallback,
+                     weak_ptr_factory_.GetWeakPtr());
+
+  auto safe_callback = CreateSafeOnceCallback(std::move(callback));
   drm_thread_->task_runner()->PostTask(
-      FROM_HERE, base::Bind(&DrmThread::CheckOverlayCapabilities,
-                            base::Unretained(drm_thread_), widget, overlays,
-                            CreateSafeCallback(callback)));
+      FROM_HERE, base::BindOnce(&DrmThread::CheckOverlayCapabilities,
+                                base::Unretained(drm_thread_), widget, overlays,
+                                std::move(safe_callback)));
 }
 
 void DrmThreadMessageProxy::OnRefreshNativeDisplays() {
   DCHECK(drm_thread_->IsRunning());
   auto callback =
-      base::Bind(&DrmThreadMessageProxy::OnRefreshNativeDisplaysCallback,
-                 weak_ptr_factory_.GetWeakPtr());
+      base::BindOnce(&DrmThreadMessageProxy::OnRefreshNativeDisplaysCallback,
+                     weak_ptr_factory_.GetWeakPtr());
+  auto safe_callback = CreateSafeOnceCallback(std::move(callback));
   drm_thread_->task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(&DrmThread::RefreshNativeDisplays,
-                 base::Unretained(drm_thread_), CreateSafeCallback(callback)));
+      base::BindOnce(&DrmThread::RefreshNativeDisplays,
+                     base::Unretained(drm_thread_), std::move(safe_callback)));
 }
 
 void DrmThreadMessageProxy::OnConfigureNativeDisplay(
     int64_t id,
     const DisplayMode_Params& mode,
     const gfx::Point& origin) {
   DCHECK(drm_thread_->IsRunning());
   auto callback =
-      base::Bind(&DrmThreadMessageProxy::OnConfigureNativeDisplayCallback,
-                 weak_ptr_factory_.GetWeakPtr());
+      base::BindOnce(&DrmThreadMessageProxy::OnConfigureNativeDisplayCallback,
+                     weak_ptr_factory_.GetWeakPtr());
+  auto safe_callback = CreateSafeOnceCallback(std::move(callback));
   drm_thread_->task_runner()->PostTask(
-      FROM_HERE, base::Bind(&DrmThread::ConfigureNativeDisplay,
-                            base::Unretained(drm_thread_), id, mode, origin,
-                            CreateSafeCallback(callback)));
+      FROM_HERE, base::BindOnce(&DrmThread::ConfigureNativeDisplay,
+                                base::Unretained(drm_thread_), id, mode, origin,
+                                std::move(safe_callback)));
 }
 
 void DrmThreadMessageProxy::OnDisableNativeDisplay(int64_t id) {
   DCHECK(drm_thread_->IsRunning());
   auto callback =
-      base::Bind(&DrmThreadMessageProxy::OnDisableNativeDisplayCallback,
-                 weak_ptr_factory_.GetWeakPtr());
+      base::BindOnce(&DrmThreadMessageProxy::OnDisableNativeDisplayCallback,
+                     weak_ptr_factory_.GetWeakPtr());
+  auto safe_callback = CreateSafeOnceCallback(std::move(callback));
   drm_thread_->task_runner()->PostTask(
-      FROM_HERE, base::Bind(&DrmThread::DisableNativeDisplay,
-                            base::Unretained(drm_thread_), id,
-                            CreateSafeCallback(callback)));
+      FROM_HERE, base::BindOnce(&DrmThread::DisableNativeDisplay,
+                                base::Unretained(drm_thread_), id,
+                                std::move(safe_callback)));
 }
 
 void DrmThreadMessageProxy::OnTakeDisplayControl() {
   DCHECK(drm_thread_->IsRunning());
   auto callback =
-      base::Bind(&DrmThreadMessageProxy::OnTakeDisplayControlCallback,
-                 weak_ptr_factory_.GetWeakPtr());
+      base::BindOnce(&DrmThreadMessageProxy::OnTakeDisplayControlCallback,
+                     weak_ptr_factory_.GetWeakPtr());
+  auto safe_callback = CreateSafeOnceCallback(std::move(callback));
   drm_thread_->task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(&DrmThread::TakeDisplayControl, base::Unretained(drm_thread_),
-                 CreateSafeCallback(callback)));
+      base::BindOnce(&DrmThread::TakeDisplayControl,
+                     base::Unretained(drm_thread_), std::move(safe_callback)));
 }
 
 void DrmThreadMessageProxy::OnRelinquishDisplayControl() {
   DCHECK(drm_thread_->IsRunning());
   auto callback =
-      base::Bind(&DrmThreadMessageProxy::OnRelinquishDisplayControlCallback,
-                 weak_ptr_factory_.GetWeakPtr());
+      base::BindOnce(&DrmThreadMessageProxy::OnRelinquishDisplayControlCallback,
+                     weak_ptr_factory_.GetWeakPtr());
+  auto safe_callback = CreateSafeOnceCallback(std::move(callback));
   drm_thread_->task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(&DrmThread::RelinquishDisplayControl,
-                 base::Unretained(drm_thread_), CreateSafeCallback(callback)));
+      base::BindOnce(&DrmThread::RelinquishDisplayControl,
+                     base::Unretained(drm_thread_), std::move(safe_callback)));
 }
 
 void DrmThreadMessageProxy::OnAddGraphicsDevice(
     const base::FilePath& path,
     const base::FileDescriptor& fd) {
   DCHECK(drm_thread_->IsRunning());
   drm_thread_->task_runner()->PostTask(
       FROM_HERE, base::Bind(&DrmThread::AddGraphicsDevice,
                             base::Unretained(drm_thread_), path, fd));
 }
 
 void DrmThreadMessageProxy::OnRemoveGraphicsDevice(const base::FilePath& path) {
   DCHECK(drm_thread_->IsRunning());
   drm_thread_->task_runner()->PostTask(
       FROM_HERE, base::Bind(&DrmThread::RemoveGraphicsDevice,
                             base::Unretained(drm_thread_), path));
 }
 
 void DrmThreadMessageProxy::OnGetHDCPState(int64_t display_id) {
   DCHECK(drm_thread_->IsRunning());
-  auto callback = base::Bind(&DrmThreadMessageProxy::OnGetHDCPStateCallback,
-                             weak_ptr_factory_.GetWeakPtr());
+  auto callback = base::BindOnce(&DrmThreadMessageProxy::OnGetHDCPStateCallback,
+                                 weak_ptr_factory_.GetWeakPtr());
+  auto safe_callback = CreateSafeOnceCallback(std::move(callback));
   drm_thread_->task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(&DrmThread::GetHDCPState, base::Unretained(drm_thread_),
-                 display_id, CreateSafeCallback(callback)));
+      base::BindOnce(&DrmThread::GetHDCPState, base::Unretained(drm_thread_),
+                     display_id, std::move(safe_callback)));
 }
 
 void DrmThreadMessageProxy::OnSetHDCPState(int64_t display_id,
                                            display::HDCPState state) {
   DCHECK(drm_thread_->IsRunning());
-  auto callback = base::Bind(&DrmThreadMessageProxy::OnSetHDCPStateCallback,
-                             weak_ptr_factory_.GetWeakPtr());
+  auto callback = base::BindOnce(&DrmThreadMessageProxy::OnSetHDCPStateCallback,
+                                 weak_ptr_factory_.GetWeakPtr());
+  auto safe_callback = CreateSafeOnceCallback(std::move(callback));
   drm_thread_->task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(&DrmThread::SetHDCPState, base::Unretained(drm_thread_),
-                 display_id, state, CreateSafeCallback(callback)));
+      base::BindOnce(&DrmThread::SetHDCPState, base::Unretained(drm_thread_),
+                     display_id, state, std::move(safe_callback)));
 }
 
 void DrmThreadMessageProxy::OnSetColorCorrection(
     int64_t id,
     const std::vector<display::GammaRampRGBEntry>& degamma_lut,
     const std::vector<display::GammaRampRGBEntry>& gamma_lut,
     const std::vector<float>& correction_matrix) {
   DCHECK(drm_thread_->IsRunning());
   drm_thread_->task_runner()->PostTask(
       FROM_HERE,
@@ skipping 38 matching lines @@
     display::HDCPState state) const {
   sender_->Send(new OzoneHostMsg_HDCPStateReceived(display_id, success, state));
 }
 
 void DrmThreadMessageProxy::OnSetHDCPStateCallback(int64_t display_id,
                                                    bool success) const {
   sender_->Send(new OzoneHostMsg_HDCPStateUpdated(display_id, success));
 }
 
 }  // namespace ui