Convert ozone/drm to OnceCallback

ui/ozone/platform/drm/mus_thread_proxy.cc

 // Copyright 2016 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/mus_thread_proxy.h"
 
 #include "base/bind.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 168 matching lines @@
   DCHECK(on_window_server_thread_.CalledOnValidThread());
   overlay_manager_ = nullptr;
 }
 
 bool MusThreadProxy::GpuCheckOverlayCapabilities(
     gfx::AcceleratedWidget widget,
     const std::vector<OverlayCheck_Params>& overlays) {
   DCHECK(drm_thread_->IsRunning());
   DCHECK(on_window_server_thread_.CalledOnValidThread());
   auto callback =
-      base::Bind(&MusThreadProxy::GpuCheckOverlayCapabilitiesCallback,
-                 weak_ptr_factory_.GetWeakPtr());
+      base::BindOnce(&MusThreadProxy::GpuCheckOverlayCapabilitiesCallback,
+                     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)));
   return true;
 }
 
 bool MusThreadProxy::GpuRefreshNativeDisplays() {
   DCHECK(drm_thread_->IsRunning());
   DCHECK(on_window_server_thread_.CalledOnValidThread());
-  auto callback = base::Bind(&MusThreadProxy::GpuRefreshNativeDisplaysCallback,
-                             weak_ptr_factory_.GetWeakPtr());
+  auto callback =
+      base::BindOnce(&MusThreadProxy::GpuRefreshNativeDisplaysCallback,
+                     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)));
   return true;
 }
 
 bool MusThreadProxy::GpuConfigureNativeDisplay(int64_t id,
                                                const DisplayMode_Params& mode,
                                                const gfx::Point& origin) {
   DCHECK(drm_thread_->IsRunning());
   DCHECK(on_window_server_thread_.CalledOnValidThread());
 
-  auto callback = base::Bind(&MusThreadProxy::GpuConfigureNativeDisplayCallback,
-                             weak_ptr_factory_.GetWeakPtr());
+  auto callback =
+      base::BindOnce(&MusThreadProxy::GpuConfigureNativeDisplayCallback,
+                     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)));
   return true;
 }
 
 bool MusThreadProxy::GpuDisableNativeDisplay(int64_t id) {
   DCHECK(drm_thread_->IsRunning());
   DCHECK(on_window_server_thread_.CalledOnValidThread());
-  auto callback = base::Bind(&MusThreadProxy::GpuDisableNativeDisplayCallback,
-                             weak_ptr_factory_.GetWeakPtr());
+  auto callback =
+      base::BindOnce(&MusThreadProxy::GpuDisableNativeDisplayCallback,
+                     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)));
   return true;
 }
 
 bool MusThreadProxy::GpuTakeDisplayControl() {
   DCHECK(drm_thread_->IsRunning());
   DCHECK(on_window_server_thread_.CalledOnValidThread());
-  auto callback = base::Bind(&MusThreadProxy::GpuTakeDisplayControlCallback,
-                             weak_ptr_factory_.GetWeakPtr());
+  auto callback = base::BindOnce(&MusThreadProxy::GpuTakeDisplayControlCallback,
+                                 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)));
   return true;
 }
 
 bool MusThreadProxy::GpuRelinquishDisplayControl() {
   DCHECK(drm_thread_->IsRunning());
   DCHECK(on_window_server_thread_.CalledOnValidThread());
   auto callback =
-      base::Bind(&MusThreadProxy::GpuRelinquishDisplayControlCallback,
-                 weak_ptr_factory_.GetWeakPtr());
+      base::BindOnce(&MusThreadProxy::GpuRelinquishDisplayControlCallback,
+                     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)));
   return true;
 }
 
 bool MusThreadProxy::GpuAddGraphicsDevice(const base::FilePath& path,
                                           const base::FileDescriptor& fd) {
   DCHECK(drm_thread_->IsRunning());
   DCHECK(on_window_server_thread_.CalledOnValidThread());
   drm_thread_->task_runner()->PostTask(
       FROM_HERE, base::Bind(&DrmThread::AddGraphicsDevice,
                             base::Unretained(drm_thread_), path, fd));
   return true;
 }
 
 bool MusThreadProxy::GpuRemoveGraphicsDevice(const base::FilePath& path) {
   DCHECK(drm_thread_->IsRunning());
   DCHECK(on_window_server_thread_.CalledOnValidThread());
   drm_thread_->task_runner()->PostTask(
       FROM_HERE, base::Bind(&DrmThread::RemoveGraphicsDevice,
                             base::Unretained(drm_thread_), path));
   return true;
 }
 
 bool MusThreadProxy::GpuGetHDCPState(int64_t display_id) {
   DCHECK(drm_thread_->IsRunning());
   DCHECK(on_window_server_thread_.CalledOnValidThread());
-  auto callback = base::Bind(&MusThreadProxy::GpuGetHDCPStateCallback,
-                             weak_ptr_factory_.GetWeakPtr());
+  auto callback = base::BindOnce(&MusThreadProxy::GpuGetHDCPStateCallback,
+                                 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)));
   return true;
 }
 
 bool MusThreadProxy::GpuSetHDCPState(int64_t display_id,
                                      display::HDCPState state) {
   DCHECK(on_window_server_thread_.CalledOnValidThread());
   DCHECK(drm_thread_->IsRunning());
-  auto callback = base::Bind(&MusThreadProxy::GpuSetHDCPStateCallback,
-                             weak_ptr_factory_.GetWeakPtr());
+  auto callback = base::BindOnce(&MusThreadProxy::GpuSetHDCPStateCallback,
+                                 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)));
   return true;
 }
 
 bool MusThreadProxy::GpuSetColorCorrection(
     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());
   DCHECK(on_window_server_thread_.CalledOnValidThread());
@@ skipping 46 matching lines @@
   display_manager_->GpuReceivedHDCPState(display_id, success, state);
 }
 
 void MusThreadProxy::GpuSetHDCPStateCallback(int64_t display_id,
                                              bool success) const {
   DCHECK(on_window_server_thread_.CalledOnValidThread());
   display_manager_->GpuUpdatedHDCPState(display_id, success);
 }
 
 }  // namespace ui