Deletes mojo::Callback

device/usb/mojo/device_impl.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 "device/usb/mojo/device_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
 #include <numeric>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "device/usb/mojo/type_converters.h"
 #include "device/usb/usb_descriptors.h"
 #include "device/usb/usb_device.h"
 #include "net/base/io_buffer.h"
 
 namespace device {
 namespace usb {
 
 namespace {
 
 using MojoTransferInCallback =
-    mojo::Callback<void(TransferStatus, mojo::Array<uint8_t>)>;
+    base::Callback<void(TransferStatus, mojo::Array<uint8_t>)>;
 
-using MojoTransferOutCallback = mojo::Callback<void(TransferStatus)>;
-
-template <typename... Args>
-void CallMojoCallback(std::unique_ptr<mojo::Callback<void(Args...)>> callback,
-                      Args... args) {
-  callback->Run(args...);
-}
-
-// Generic wrapper to convert a Mojo callback to something we can rebind and
-// pass around. This is only usable for callbacks with no move-only arguments.
-template <typename... Args>
-base::Callback<void(Args...)> WrapMojoCallback(
-    const mojo::Callback<void(Args...)>& callback) {
-  // mojo::Callback is not thread safe. By wrapping |callback| in a scoped_ptr
-  // we guarantee that it will be freed when CallMojoCallback is run and not
-  // retained until the base::Callback is destroyed, which could happen on any
-  // thread. This pattern is also used below in places where this generic
-  // wrapper is not used.
-  auto callback_ptr =
-      base::WrapUnique(new mojo::Callback<void(Args...)>(callback));
-  return base::Bind(&CallMojoCallback<Args...>, base::Passed(&callback_ptr));
-}
+using MojoTransferOutCallback = base::Callback<void(TransferStatus)>;
 
 scoped_refptr<net::IOBuffer> CreateTransferBuffer(size_t size) {
   scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(
       std::max(static_cast<size_t>(1u), static_cast<size_t>(size)));
   return buffer;
 }
 
 void OnTransferIn(std::unique_ptr<MojoTransferInCallback> callback,
                   UsbTransferStatus status,
                   scoped_refptr<net::IOBuffer> buffer,
@@ skipping 186 matching lines @@
 
 void DeviceImpl::SetConfiguration(uint8_t value,
                                   const SetConfigurationCallback& callback) {
   if (!device_handle_) {
     callback.Run(false);
     return;
   }
 
   if (permission_provider_ &&
       permission_provider_->HasConfigurationPermission(value, device_)) {
-    device_handle_->SetConfiguration(value, WrapMojoCallback(callback));
+    device_handle_->SetConfiguration(value, callback);
   } else {
     callback.Run(false);
   }
 }
 
 void DeviceImpl::ClaimInterface(uint8_t interface_number,
                                 const ClaimInterfaceCallback& callback) {
   if (!device_handle_) {
     callback.Run(false);
     return;
@@ skipping 12 matching lines @@
                    });
   if (interface_it == config->interfaces.end()) {
     callback.Run(false);
     return;
   }
 
   if (permission_provider_ &&
       permission_provider_->HasFunctionPermission(interface_it->first_interface,
                                                   config->configuration_value,
                                                   device_)) {
-    device_handle_->ClaimInterface(interface_number,
-                                   WrapMojoCallback(callback));
+    device_handle_->ClaimInterface(interface_number, callback);
   } else {
     callback.Run(false);
   }
 }
 
 void DeviceImpl::ReleaseInterface(uint8_t interface_number,
                                   const ReleaseInterfaceCallback& callback) {
   if (!device_handle_) {
     callback.Run(false);
     return;
   }
 
-  device_handle_->ReleaseInterface(interface_number,
-                                   WrapMojoCallback(callback));
+  device_handle_->ReleaseInterface(interface_number, callback);
 }
 
 void DeviceImpl::SetInterfaceAlternateSetting(
     uint8_t interface_number,
     uint8_t alternate_setting,
     const SetInterfaceAlternateSettingCallback& callback) {
   if (!device_handle_) {
     callback.Run(false);
     return;
   }
 
-  device_handle_->SetInterfaceAlternateSetting(
-      interface_number, alternate_setting, WrapMojoCallback(callback));
+  device_handle_->SetInterfaceAlternateSetting(interface_number,
+                                               alternate_setting, callback);
 }
 
 void DeviceImpl::Reset(const ResetCallback& callback) {
   if (!device_handle_) {
     callback.Run(false);
     return;
   }
 
-  device_handle_->ResetDevice(WrapMojoCallback(callback));
+  device_handle_->ResetDevice(callback);
 }
 
 void DeviceImpl::ClearHalt(uint8_t endpoint,
                            const ClearHaltCallback& callback) {
   if (!device_handle_) {
     callback.Run(false);
     return;
   }
 
-  device_handle_->ClearHalt(endpoint, WrapMojoCallback(callback));
+  device_handle_->ClearHalt(endpoint, callback);
 }
 
 void DeviceImpl::ControlTransferIn(ControlTransferParamsPtr params,
                                    uint32_t length,
                                    uint32_t timeout,
                                    const ControlTransferInCallback& callback) {
   if (!device_handle_) {
     callback.Run(TransferStatus::TRANSFER_ERROR, mojo::Array<uint8_t>());
     return;
   }
@@ skipping 124 matching lines @@
       base::Bind(&OnIsochronousTransferOut, base::Passed(&callback_ptr)));
 }
 
 void DeviceImpl::OnDeviceRemoved(scoped_refptr<UsbDevice> device) {
   DCHECK_EQ(device_, device);
   delete this;
 }
 
 }  // namespace usb
 }  // namespace device