usb_service.cc 5.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164
  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. #include "services/device/usb/usb_service.h"
  5. #include <utility>
  6. #include "base/bind.h"
  7. #include "base/containers/contains.h"
  8. #include "base/feature_list.h"
  9. #include "base/location.h"
  10. #include "base/memory/ptr_util.h"
  11. #include "base/observer_list.h"
  12. #include "base/task/thread_pool.h"
  13. #include "base/threading/sequenced_task_runner_handle.h"
  14. #include "build/build_config.h"
  15. #include "components/device_event_log/device_event_log.h"
  16. #include "device/base/features.h"
  17. #include "services/device/usb/usb_device.h"
  18. #include "services/device/usb/usb_device_handle.h"
  19. #if BUILDFLAG(IS_ANDROID)
  20. #include "services/device/usb/usb_service_android.h"
  21. #elif defined(USE_UDEV)
  22. #include "services/device/usb/usb_service_linux.h"
  23. #elif BUILDFLAG(IS_MAC)
  24. #include "services/device/usb/usb_service_impl.h"
  25. #include "services/device/usb/usb_service_mac.h"
  26. #elif BUILDFLAG(IS_WIN)
  27. #include "services/device/usb/usb_service_win.h"
  28. #endif
  29. namespace device {
  30. UsbService::Observer::~Observer() = default;
  31. void UsbService::Observer::OnDeviceAdded(scoped_refptr<UsbDevice> device) {}
  32. void UsbService::Observer::OnDeviceRemoved(scoped_refptr<UsbDevice> device) {}
  33. void UsbService::Observer::OnDeviceRemovedCleanup(
  34. scoped_refptr<UsbDevice> device) {}
  35. void UsbService::Observer::WillDestroyUsbService() {}
  36. // Declare storage for this constexpr.
  37. constexpr base::TaskTraits UsbService::kBlockingTaskTraits;
  38. // static
  39. std::unique_ptr<UsbService> UsbService::Create() {
  40. #if BUILDFLAG(IS_ANDROID)
  41. return base::WrapUnique(new UsbServiceAndroid());
  42. #elif defined(USE_UDEV)
  43. return base::WrapUnique(new UsbServiceLinux());
  44. #elif BUILDFLAG(IS_WIN)
  45. return base::WrapUnique(new UsbServiceWin());
  46. #elif BUILDFLAG(IS_MAC)
  47. if (base::FeatureList::IsEnabled(kNewUsbBackend))
  48. return base::WrapUnique(new UsbServiceMac());
  49. else
  50. return base::WrapUnique(new UsbServiceImpl());
  51. #else
  52. return nullptr;
  53. #endif
  54. }
  55. // static
  56. scoped_refptr<base::SequencedTaskRunner>
  57. UsbService::CreateBlockingTaskRunner() {
  58. return base::ThreadPool::CreateSequencedTaskRunner(kBlockingTaskTraits);
  59. }
  60. UsbService::~UsbService() {
  61. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  62. }
  63. UsbService::UsbService() {}
  64. scoped_refptr<UsbDevice> UsbService::GetDevice(const std::string& guid) {
  65. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  66. auto it = devices_.find(guid);
  67. if (it == devices_.end())
  68. return nullptr;
  69. return it->second;
  70. }
  71. void UsbService::GetDevices(GetDevicesCallback callback) {
  72. std::vector<scoped_refptr<UsbDevice>> devices;
  73. devices.reserve(devices_.size());
  74. for (const auto& map_entry : devices_)
  75. devices.push_back(map_entry.second);
  76. base::SequencedTaskRunnerHandle::Get()->PostTask(
  77. FROM_HERE, base::BindOnce(std::move(callback), devices));
  78. }
  79. void UsbService::AddObserver(Observer* observer) {
  80. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  81. observer_list_.AddObserver(observer);
  82. }
  83. void UsbService::RemoveObserver(Observer* observer) {
  84. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  85. observer_list_.RemoveObserver(observer);
  86. }
  87. void UsbService::AddDeviceForTesting(scoped_refptr<UsbDevice> device) {
  88. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  89. DCHECK(!base::Contains(devices_, device->guid()));
  90. devices_[device->guid()] = device;
  91. testing_devices_.insert(device->guid());
  92. NotifyDeviceAdded(device);
  93. }
  94. void UsbService::RemoveDeviceForTesting(const std::string& device_guid) {
  95. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  96. // Allow only devices added with AddDeviceForTesting to be removed with this
  97. // method.
  98. auto testing_devices_it = testing_devices_.find(device_guid);
  99. if (testing_devices_it != testing_devices_.end()) {
  100. auto devices_it = devices_.find(device_guid);
  101. DCHECK(devices_it != devices_.end());
  102. scoped_refptr<UsbDevice> device = devices_it->second;
  103. devices_.erase(devices_it);
  104. testing_devices_.erase(testing_devices_it);
  105. NotifyDeviceRemoved(device);
  106. }
  107. }
  108. void UsbService::GetTestDevices(
  109. std::vector<scoped_refptr<UsbDevice>>* devices) {
  110. devices->clear();
  111. devices->reserve(testing_devices_.size());
  112. for (const std::string& guid : testing_devices_) {
  113. auto it = devices_.find(guid);
  114. DCHECK(it != devices_.end());
  115. devices->push_back(it->second);
  116. }
  117. }
  118. void UsbService::NotifyDeviceAdded(scoped_refptr<UsbDevice> device) {
  119. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  120. for (auto& observer : observer_list_)
  121. observer.OnDeviceAdded(device);
  122. }
  123. void UsbService::NotifyDeviceRemoved(scoped_refptr<UsbDevice> device) {
  124. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  125. for (auto& observer : observer_list_)
  126. observer.OnDeviceRemoved(device);
  127. device->NotifyDeviceRemoved();
  128. for (auto& observer : observer_list_)
  129. observer.OnDeviceRemovedCleanup(device);
  130. }
  131. void UsbService::NotifyWillDestroyUsbService() {
  132. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  133. for (auto& observer : observer_list_)
  134. observer.WillDestroyUsbService();
  135. }
  136. } // namespace device