Revert of Update ozone/drm proxy_helpers.h to support move-only types.

ui/ozone/platform/drm/gpu/proxy_helpers.h

 // 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.
 
 #ifndef UI_OZONE_PLATFORM_DRM_GPU_PROXY_HELPERS_H_
 #define UI_OZONE_PLATFORM_DRM_GPU_PROXY_HELPERS_H_
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/threading/thread_task_runner_handle.h"
 
 namespace ui {
 
 namespace internal {
 
 template <typename... Args>
 void PostAsyncTask(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     const base::Callback<void(Args...)>& callback,
     Args... args) {
   task_runner->PostTask(FROM_HERE, base::Bind(callback, args...));
 }
 
-template <typename... Args>
-void PostAsyncTaskOnce(
-    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
-    base::OnceCallback<void(Args...)> callback,
-    Args... args) {
-  auto closure = base::BindOnce(std::move(callback), std::move(args)...);
-  task_runner->PostTask(FROM_HERE, std::move(closure));
-}
-
 }  // namespace internal
 
 // Posts a task to a different thread and blocks waiting for the task to finish
 // executing.
 void PostSyncTask(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     const base::Closure& callback);
 
 // Creates a callback that will run |callback| on the calling thread. Useful
 // when posting a task on a different thread and expecting a callback when the
 // task finished (and the callback needs to run on the original thread).
 template <typename... Args>
 base::Callback<void(Args...)> CreateSafeCallback(
     const base::Callback<void(Args...)>& callback) {
   return base::Bind(&internal::PostAsyncTask<Args...>,
                     base::ThreadTaskRunnerHandle::Get(), callback);
 }
 
-// Creates a OnceCallback that will run |callback| on the calling thread. Useful
-// when posting a task on a different thread and expecting a callback when the
-// task finished (and the callback needs to run on the original thread).
-template <typename... Args>
-base::OnceCallback<void(Args...)> CreateSafeOnceCallback(
-    base::OnceCallback<void(Args...)> callback) {
-  return base::BindOnce(&internal::PostAsyncTaskOnce<Args...>,
-                        base::ThreadTaskRunnerHandle::Get(),
-                        std::move(callback));
-}
-
 }  // namespace ui
 
 #endif  // UI_OZONE_PLATFORM_DRM_GPU_PROXY_HELPERS_H_