ozone: evdev: Add property to identify internal or external devices

ui/events/ozone/evdev/event_factory_evdev.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 "ui/events/ozone/evdev/event_factory_evdev.h"
 
 #include <fcntl.h>
 #include <linux/input.h>
 
 #include "base/debug/trace_event.h"
 #include "base/stl_util.h"
 #include "base/task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/worker_pool.h"
 #include "ui/events/devices/device_data_manager.h"
+#include "ui/events/devices/device_util_linux.h"
+#include "ui/events/devices/input_device.h"
 #include "ui/events/ozone/device/device_event.h"
 #include "ui/events/ozone/device/device_manager.h"
 #include "ui/events/ozone/evdev/cursor_delegate_evdev.h"
 #include "ui/events/ozone/evdev/event_converter_evdev_impl.h"
 #include "ui/events/ozone/evdev/input_injector_evdev.h"
 #include "ui/events/ozone/evdev/tablet_event_converter_evdev.h"
 #include "ui/events/ozone/evdev/touch_event_converter_evdev.h"
 
 #if defined(USE_EVDEV_GESTURES)
 #include "ui/events/ozone/evdev/libgestures_glue/event_reader_libevdev_cros.h"
@@ skipping 41 matching lines @@
   if (devinfo.HasRelXY())
     return true;  // mouse
 
   return false;
 }
 #endif
 
 scoped_ptr<EventConverterEvdev> CreateConverter(
     const OpenInputDeviceParams& params,
     int fd,
+    InputDeviceType type,
     const EventDeviceInfo& devinfo) {
 #if defined(USE_EVDEV_GESTURES)
   // Touchpad or mouse: use gestures library.
   // EventReaderLibevdevCros -> GestureInterpreterLibevdevCros -> DispatchEvent
   if (UseGesturesLibraryForDevice(devinfo)) {
     scoped_ptr<GestureInterpreterLibevdevCros> gesture_interp =
         make_scoped_ptr(new GestureInterpreterLibevdevCros(
             params.id, params.modifiers, params.button_map, params.cursor,
             params.keyboard, params.gesture_property_provider,
             params.dispatch_callback));
     return make_scoped_ptr(new EventReaderLibevdevCros(
-          fd, params.path, params.id, gesture_interp.Pass()));
+        fd, params.path, params.id, type, gesture_interp.Pass()));
   }
 #endif
 
   // Touchscreen: use TouchEventConverterEvdev.
   if (devinfo.HasMTAbsXY()) {
     scoped_ptr<TouchEventConverterEvdev> converter(new TouchEventConverterEvdev(
-        fd, params.path, params.id, params.dispatch_callback));
+        fd, params.path, params.id, type, params.dispatch_callback));
     converter->Initialize(devinfo);
     return converter.Pass();
   }
 
   // Graphics tablet
   if (devinfo.HasAbsXY())
     return make_scoped_ptr<EventConverterEvdev>(new TabletEventConverterEvdev(
-        fd, params.path, params.id, params.modifiers, params.cursor, devinfo,
-        params.dispatch_callback));
+        fd, params.path, params.id, type, params.modifiers, params.cursor,
+        devinfo, params.dispatch_callback));
 
   // Everything else: use EventConverterEvdevImpl.
   return make_scoped_ptr<EventConverterEvdevImpl>(new EventConverterEvdevImpl(
-      fd, params.path, params.id, params.modifiers, params.button_map,
-      params.cursor, params.keyboard, params.dispatch_callback));
+      fd, params.path, params.id, type, params.modifiers,
+      params.button_map, params.cursor, params.keyboard,
+      params.dispatch_callback));
 }
 
 // Open an input device. Opening may put the calling thread to sleep, and
 // therefore should be run on a thread where latency is not critical. We
 // run it on a thread from the worker pool.
 //
 // This takes a TaskRunner and runs the reply on that thread, so that we
 // can hop threads if necessary (back to the UI thread).
 void OpenInputDevice(scoped_ptr<OpenInputDeviceParams> params,
                      scoped_refptr<base::TaskRunner> reply_runner,
@@ skipping 15 matching lines @@
   if (ioctl(fd, EVIOCSCLOCKID, &clk))
     PLOG(ERROR) << "failed to set CLOCK_MONOTONIC";
 
   EventDeviceInfo devinfo;
   if (!devinfo.Initialize(fd)) {
     LOG(ERROR) << "failed to get device information for " << path.value();
     close(fd);
     return;
   }
 
+  InputDeviceType type = GetInputDeviceTypeFromPath(path);
+
   scoped_ptr<EventConverterEvdev> converter =
-      CreateConverter(*params, fd, devinfo);
+      CreateConverter(*params, fd, type, devinfo);
 
   // Reply with the constructed converter.
   reply_runner->PostTask(FROM_HERE,
                          base::Bind(reply_callback, base::Passed(&converter)));
 }
 
 // Close an input device. Closing may put the calling thread to sleep, and
 // therefore should be run on a thread where latency is not critical. We
 // run it on the FILE thread.
 void CloseInputDevice(const base::FilePath& path,
@@ skipping 154 matching lines @@
     const EventConverterEvdev& converter) {
   // For now the only information propagated is related to touchscreens. Ignore
   // events for everything but touchscreens.
   if (!converter.HasTouchscreen())
     return;
 
   DeviceHotplugEventObserver* observer = DeviceDataManager::GetInstance();
   std::vector<TouchscreenDevice> touchscreens;
   for (auto it = converters_.begin(); it != converters_.end(); ++it) {
     if (it->second->HasTouchscreen()) {
-      InputDeviceType device_type = InputDeviceType::INPUT_DEVICE_EXTERNAL;
-      if (it->second->IsInternal())
-        device_type = InputDeviceType::INPUT_DEVICE_INTERNAL;
-
       touchscreens.push_back(
           TouchscreenDevice(it->second->id(),
-                            device_type,
+                            it->second->type(),
                             std::string(), /* Device name */
                             it->second->GetTouchscreenSize()));
     }
   }
 
   observer->OnTouchscreenDevicesUpdated(touchscreens);
 }
 
 int EventFactoryEvdev::NextDeviceId() {
   return ++last_device_id_;
@@ skipping 10 matching lines @@
   gesture_property_provider_->GetDeviceIdsByType(type, &ids);
 #endif
   // In the future we can add other device matching logics here.
 
   if (device_ids)
     device_ids->assign(ids.begin(), ids.end());
   return !ids.empty();
 }
 
 }  // namespace ui