device/usb/usb_service.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "device/usb/usb_service.h"
   6
   7 #include "base/message_loop/message_loop.h"
   8 #include "components/device_event_log/device_event_log.h"
   9 #include "device/usb/usb_device.h"
  10 #include "device/usb/usb_service_impl.h"
  11
  12 namespace device {
  13
  14 namespace {
  15
  16 UsbService* g_service;
  17
  18 }  // namespace
  19
  20 // This class manages the lifetime of the global UsbService instance so that
  21 // it is destroyed when the current message loop is destroyed. A lazy instance
  22 // cannot be used because this object does not live on the main thread.
  23 class UsbService::Destroyer : private base::MessageLoop::DestructionObserver {
  24  public:
  25   explicit Destroyer(UsbService* usb_service) : usb_service_(usb_service) {
  26     base::MessageLoop::current()->AddDestructionObserver(this);
  27   }
  28   ~Destroyer() override {}
  29
  30  private:
  31   // base::MessageLoop::DestructionObserver implementation.
  32   void WillDestroyCurrentMessageLoop() override {
  33     base::MessageLoop::current()->RemoveDestructionObserver(this);
  34     delete usb_service_;
  35     delete this;
  36     g_service = nullptr;
  37   }
  38
  39   UsbService* usb_service_;
  40 };
  41
  42 void UsbService::Observer::OnDeviceAdded(scoped_refptr<UsbDevice> device) {
  43 }
  44
  45 void UsbService::Observer::OnDeviceRemoved(scoped_refptr<UsbDevice> device) {
  46 }
  47
  48 void UsbService::Observer::OnDeviceRemovedCleanup(
  49     scoped_refptr<UsbDevice> device) {
  50 }
  51
  52 // static
  53 UsbService* UsbService::GetInstance(
  54     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
  55   if (!g_service) {
  56     g_service = UsbServiceImpl::Create(ui_task_runner);
  57     // This object will clean itself up when the message loop is destroyed.
  58     new Destroyer(g_service);
  59   }
  60   return g_service;
  61 }
  62
  63 // static
  64 void UsbService::SetInstanceForTest(UsbService* instance) {
  65   g_service = instance;
  66   new Destroyer(instance);
  67 }
  68
  69 UsbService::UsbService() {
  70 }
  71
  72 UsbService::~UsbService() {
  73 }
  74
  75 void UsbService::AddObserver(Observer* observer) {
  76   DCHECK(CalledOnValidThread());
  77   observer_list_.AddObserver(observer);
  78 }
  79
  80 void UsbService::RemoveObserver(Observer* observer) {
  81   DCHECK(CalledOnValidThread());
  82   observer_list_.RemoveObserver(observer);
  83 }
  84
  85 void UsbService::NotifyDeviceAdded(scoped_refptr<UsbDevice> device) {
  86   DCHECK(CalledOnValidThread());
  87
  88   USB_LOG(USER) << "USB device added: vendorId = " << device->vendor_id()
  89                 << ", productId = " << device->product_id()
  90                 << ", uniqueId = " << device->unique_id();
  91
  92   FOR_EACH_OBSERVER(Observer, observer_list_, OnDeviceAdded(device));
  93 }
  94
  95 void UsbService::NotifyDeviceRemoved(scoped_refptr<UsbDevice> device) {
  96   DCHECK(CalledOnValidThread());
  97
  98   USB_LOG(USER) << "USB device removed: uniqueId = " << device->unique_id();
  99
 100   FOR_EACH_OBSERVER(Observer, observer_list_, OnDeviceRemoved(device));
 101   FOR_EACH_OBSERVER(Observer, observer_list_, OnDeviceRemovedCleanup(device));
 102 }
 103
 104 }  // namespace device