Use USE_UDEV instead of OS_LINUX when trying to use Udev functionality

device/usb/usb_device_impl.cc

 // Copyright 2014 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/usb_device_impl.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "device/usb/usb_context.h"
 #include "device/usb/usb_descriptors.h"
 #include "device/usb/usb_device_handle_impl.h"
 #include "device/usb/usb_error.h"
 #include "third_party/libusb/src/libusb/libusb.h"
 
 #if defined(OS_CHROMEOS)
 #include "base/sys_info.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/permission_broker_client.h"
 #endif  // defined(OS_CHROMEOS)
 
-#if defined(OS_LINUX)
+#if defined(USE_UDEV)
 #include "device/udev_linux/udev.h"
-#endif  // defined(OS_LINUX)
+#endif  // defined(USE_UDEV)
 
 namespace device {
 
 namespace {
 
 #if defined(OS_CHROMEOS)
 void OnRequestUsbAccessReplied(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     const base::Callback<void(bool success)>& callback,
     bool success) {
@@ skipping 82 matching lines @@
     uint16 product_id,
     uint32 unique_id)
     : UsbDevice(vendor_id, product_id, unique_id),
       platform_device_(platform_device),
       current_configuration_cached_(false),
       context_(context),
       ui_task_runner_(ui_task_runner) {
   CHECK(platform_device) << "platform_device cannot be NULL";
   libusb_ref_device(platform_device);
 
-#if defined(OS_LINUX)
+#if defined(USE_UDEV)
   ScopedUdevPtr udev(udev_new());
   ScopedUdevEnumeratePtr enumerate(udev_enumerate_new(udev.get()));
 
   udev_enumerate_add_match_subsystem(enumerate.get(), "usb");
   if (udev_enumerate_scan_devices(enumerate.get()) != 0) {
     return;
   }
   std::string bus_number =
       base::IntToString(libusb_get_bus_number(platform_device));
   std::string device_address =
@@ skipping 171 matching lines @@
     libusb_free_config_descriptor(platform_config);
     current_configuration_cached_ = true;
   }
 
   return current_configuration_;
 }
 
 bool UsbDeviceImpl::GetManufacturer(base::string16* manufacturer) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-#if defined(OS_LINUX)
+#if defined(USE_UDEV)
   if (manufacturer_.empty()) {
     return false;
   }
   *manufacturer = base::UTF8ToUTF16(manufacturer_);
   return true;
 #else
   // This is a non-blocking call as libusb has the descriptor in memory.
   libusb_device_descriptor desc;
   const int rv = libusb_get_device_descriptor(platform_device_, &desc);
   if (rv != LIBUSB_SUCCESS) {
@@ skipping 10 matching lines @@
   if (device_handle.get()) {
     return device_handle->GetStringDescriptor(desc.iManufacturer, manufacturer);
   }
   return false;
 #endif
 }
 
 bool UsbDeviceImpl::GetProduct(base::string16* product) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-#if defined(OS_LINUX)
+#if defined(USE_UDEV)
   if (product_.empty()) {
     return false;
   }
   *product = base::UTF8ToUTF16(product_);
   return true;
 #else
   // This is a non-blocking call as libusb has the descriptor in memory.
   libusb_device_descriptor desc;
   const int rv = libusb_get_device_descriptor(platform_device_, &desc);
   if (rv != LIBUSB_SUCCESS) {
@@ skipping 10 matching lines @@
   if (device_handle.get()) {
     return device_handle->GetStringDescriptor(desc.iProduct, product);
   }
   return false;
 #endif
 }
 
 bool UsbDeviceImpl::GetSerialNumber(base::string16* serial_number) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-#if defined(OS_LINUX)
+#if defined(USE_UDEV)
   if (serial_number_.empty()) {
     return false;
   }
   *serial_number = base::UTF8ToUTF16(serial_number_);
   return true;
 #else
   // This is a non-blocking call as libusb has the descriptor in memory.
   libusb_device_descriptor desc;
   const int rv = libusb_get_device_descriptor(platform_device_, &desc);
   if (rv != LIBUSB_SUCCESS) {
@@ skipping 17 matching lines @@
 
 void UsbDeviceImpl::OnDisconnect() {
   DCHECK(thread_checker_.CalledOnValidThread());
   HandlesVector handles;
   swap(handles, handles_);
   for (HandlesVector::iterator it = handles.begin(); it != handles.end(); ++it)
     (*it)->InternalClose();
 }
 
 }  // namespace device