Privatize StrongBinding lifetime management

device/usb/mojo/device_manager_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_manager_impl.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "device/core/device_client.h"
 #include "device/usb/mojo/device_impl.h"
 #include "device/usb/mojo/permission_provider.h"
 #include "device/usb/mojo/type_converters.h"
 #include "device/usb/public/interfaces/device.mojom.h"
 #include "device/usb/usb_device.h"
 #include "device/usb/usb_device_filter.h"
 #include "device/usb/usb_service.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/public/cpp/bindings/array.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
+#include "mojo/public/cpp/bindings/strong_binding.h"
 
 namespace device {
 namespace usb {
 
 // static
 void DeviceManagerImpl::Create(
     base::WeakPtr<PermissionProvider> permission_provider,
     mojo::InterfaceRequest<DeviceManager> request) {
   DCHECK(DeviceClient::Get());
   UsbService* usb_service = DeviceClient::Get()->GetUsbService();
   if (usb_service) {
-    new DeviceManagerImpl(permission_provider, usb_service, std::move(request));
+    mojo::MakeStrongBinding(
+        base::MakeUnique<DeviceManagerImpl>(permission_provider, usb_service),
+        std::move(request));
   }
 }
 
 DeviceManagerImpl::DeviceManagerImpl(
     base::WeakPtr<PermissionProvider> permission_provider,
-    UsbService* usb_service,
-    mojo::InterfaceRequest<DeviceManager> request)
+    UsbService* usb_service)
     : permission_provider_(permission_provider),
       usb_service_(usb_service),
       observer_(this),
-      binding_(this, std::move(request)),
       weak_factory_(this) {
   // This object owns itself and will be destroyed if the message pipe it is
   // bound to is closed, the message loop is destructed, or the UsbService is
   // shut down.
   observer_.Add(usb_service_);
 }
 
 DeviceManagerImpl::~DeviceManagerImpl() {
   if (!connection_error_handler_.is_null())
     connection_error_handler_.Run();
 }
 
 void DeviceManagerImpl::GetDevices(EnumerationOptionsPtr options,
                                    const GetDevicesCallback& callback) {
   usb_service_->GetDevices(base::Bind(&DeviceManagerImpl::OnGetDevices,
                                       weak_factory_.GetWeakPtr(),
                                       base::Passed(&options), callback));
 }
 
 void DeviceManagerImpl::GetDevice(
     const std::string& guid,
     mojo::InterfaceRequest<Device> device_request) {
   scoped_refptr<UsbDevice> device = usb_service_->GetDevice(guid);
   if (!device)
     return;
 
   if (permission_provider_ &&
       permission_provider_->HasDevicePermission(device)) {
+    // Owns itself.
     new DeviceImpl(device, DeviceInfo::From(*device), permission_provider_,
                    std::move(device_request));
   }
 }
 
 void DeviceManagerImpl::SetClient(DeviceManagerClientPtr client) {
   client_ = std::move(client);
 }
 
 void DeviceManagerImpl::OnGetDevices(
@@ skipping 28 matching lines @@
       permission_provider_->HasDevicePermission(device))
     client_->OnDeviceRemoved(DeviceInfo::From(*device));
 }
 
 void DeviceManagerImpl::WillDestroyUsbService() {
   delete this;
 }
 
 }  // namespace usb
 }  // namespace device