Replace DeviceManager::GetDeviceChanges with a client interface.

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 "base/location.h"
-#include "base/stl_util.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/public/cpp/bindings/array.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
@@ skipping 31 matching lines @@
   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::GetDeviceChanges(
-    const GetDeviceChangesCallback& callback) {
-  device_change_callbacks_.push(callback);
-  MaybeRunDeviceChangesCallback();
-}
-
 void DeviceManagerImpl::GetDevice(
     const mojo::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)) {
     new DeviceImpl(device, DeviceInfo::From(*device), permission_provider_,
                    std::move(device_request));
   }
 }
 
+void DeviceManagerImpl::SetClient(DeviceManagerClientPtr client) {
+  client_ = std::move(client);
+}
+
 void DeviceManagerImpl::OnGetDevices(
     EnumerationOptionsPtr options,
     const GetDevicesCallback& callback,
     const std::vector<scoped_refptr<UsbDevice>>& devices) {
   std::vector<UsbDeviceFilter> filters;
   if (options)
     filters = options->filters.To<std::vector<UsbDeviceFilter>>();
 
   mojo::Array<DeviceInfoPtr> device_infos;
   for (const auto& device : devices) {
     if (filters.empty() || UsbDeviceFilter::MatchesAny(device, filters)) {
       if (permission_provider_ &&
           permission_provider_->HasDevicePermission(device)) {
         device_infos.push_back(DeviceInfo::From(*device));
       }
     }
   }
 
   callback.Run(std::move(device_infos));
 }
 
 void DeviceManagerImpl::OnDeviceAdded(scoped_refptr<UsbDevice> device) {
-  if (permission_provider_ &&
-      permission_provider_->HasDevicePermission(device)) {
-    devices_added_[device->guid()] = DeviceInfo::From(*device);
-    MaybeRunDeviceChangesCallback();
-  }
+  if (client_ && permission_provider_ &&
+      permission_provider_->HasDevicePermission(device))
+    client_->OnDeviceAdded(DeviceInfo::From(*device));
 }
 
 void DeviceManagerImpl::OnDeviceRemoved(scoped_refptr<UsbDevice> device) {
-  if (devices_added_.erase(device->guid()) == 0) {
-    if (permission_provider_ &&
-        permission_provider_->HasDevicePermission(device)) {
-      devices_removed_.push_back(DeviceInfo::From(*device));
-      MaybeRunDeviceChangesCallback();
-    }
-  }
+  if (client_ && permission_provider_ &&
+      permission_provider_->HasDevicePermission(device))
+    client_->OnDeviceRemoved(DeviceInfo::From(*device));
 }
 
 void DeviceManagerImpl::WillDestroyUsbService() {
   delete this;
 }
 
-void DeviceManagerImpl::MaybeRunDeviceChangesCallback() {
-  if (!device_change_callbacks_.empty() &&
-      !(devices_added_.empty() && devices_removed_.empty())) {
-    DeviceChangeNotificationPtr notification = DeviceChangeNotification::New();
-    notification->devices_added.SetToEmpty();
-    notification->devices_removed.SetToEmpty();
-    for (auto& map_entry : devices_added_)
-      notification->devices_added.push_back(std::move(map_entry.second));
-    devices_added_.clear();
-    notification->devices_removed.Swap(&devices_removed_);
-
-    device_change_callbacks_.front().Run(std::move(notification));
-    device_change_callbacks_.pop();
-  }
-}
-
 }  // namespace usb
 }  // namespace device