Merge "Fix double-close in EventConverterEvdevImpl"

ui/events/ozone/evdev/input_device_factory_evdev.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 "ui/events/ozone/evdev/input_device_factory_evdev.h"
 
 #include <fcntl.h>
 #include <linux/input.h>
 #include <stddef.h>
 
@@ skipping 64 matching lines @@
   if (property) {
     std::vector<bool> values(1, value);
     property->SetBoolValue(values);
   }
 }
 
 #endif
 
 std::unique_ptr<EventConverterEvdev> CreateConverter(
     const OpenInputDeviceParams& params,
-    int fd,
+    ScopedInputDevice fd,
     const EventDeviceInfo& devinfo) {
 #if defined(USE_EVDEV_GESTURES)
   // Touchpad or mouse: use gestures library.
   // EventReaderLibevdevCros -> GestureInterpreterLibevdevCros -> DispatchEvent
   if (devinfo.HasTouchpad() || devinfo.HasMouse()) {
     std::unique_ptr<GestureInterpreterLibevdevCros> gesture_interp =
         base::MakeUnique<GestureInterpreterLibevdevCros>(
             params.id, params.cursor, params.gesture_property_provider,
             params.dispatcher);
-    return base::MakeUnique<EventReaderLibevdevCros>(
-        fd, params.path, params.id, devinfo, std::move(gesture_interp));
+    return base::MakeUnique<EventReaderLibevdevCros>(std::move(fd), params.path,
+                                                     params.id, devinfo,
+                                                     std::move(gesture_interp));
   }
 #endif
 
   // Touchscreen: use TouchEventConverterEvdev.
   if (devinfo.HasTouchscreen()) {
     std::unique_ptr<TouchEventConverterEvdev> converter(
-        new TouchEventConverterEvdev(fd, params.path, params.id, devinfo,
-                                     params.dispatcher));
+        new TouchEventConverterEvdev(std::move(fd), params.path, params.id,
+                                     devinfo, params.dispatcher));
     converter->Initialize(devinfo);
     return std::move(converter);
   }
 
   // Graphics tablet
   if (devinfo.HasTablet())
     return base::WrapUnique<EventConverterEvdev>(new TabletEventConverterEvdev(
-        fd, params.path, params.id, params.cursor, devinfo, params.dispatcher));
+        std::move(fd), params.path, params.id, params.cursor, devinfo,
+        params.dispatcher));
 
   // Everything else: use EventConverterEvdevImpl.
-  return base::WrapUnique<EventConverterEvdevImpl>(new EventConverterEvdevImpl(
-      fd, params.path, params.id, devinfo, params.cursor, params.dispatcher));
+  return base::WrapUnique<EventConverterEvdevImpl>(
+      new EventConverterEvdevImpl(std::move(fd), params.path, params.id,
+                                  devinfo, params.cursor, params.dispatcher));
 }
 
 // Open an input device and construct an EventConverterEvdev.
 std::unique_ptr<EventConverterEvdev> OpenInputDevice(
     const OpenInputDeviceParams& params) {
   const base::FilePath& path = params.path;
   TRACE_EVENT1("evdev", "OpenInputDevice", "path", path.value());
 
-  int fd = open(path.value().c_str(), O_RDWR | O_NONBLOCK);
-  if (fd < 0) {
+  ScopedInputDevice fd(open(path.value().c_str(), O_RDWR | O_NONBLOCK));
+  if (fd.get() < 0) {
     PLOG(ERROR) << "Cannot open " << path.value();
     return nullptr;
   }
 
   // Use monotonic timestamps for events. The touch code in particular
   // expects event timestamps to correlate to the monotonic clock
   // (base::TimeTicks).
   unsigned int clk = CLOCK_MONOTONIC;
-  if (ioctl(fd, EVIOCSCLOCKID, &clk))
+  if (ioctl(fd.get(), EVIOCSCLOCKID, &clk))
     PLOG(ERROR) << "failed to set CLOCK_MONOTONIC";
 
   EventDeviceInfo devinfo;
-  if (!devinfo.Initialize(fd, path)) {
+  if (!devinfo.Initialize(fd.get(), path)) {
     LOG(ERROR) << "Failed to get device information for " << path.value();
-    close(fd);
     return nullptr;
   }
 
-  return CreateConverter(params, fd, devinfo);
+  return CreateConverter(params, std::move(fd), devinfo);
 }
 
 }  // namespace
 
 InputDeviceFactoryEvdev::InputDeviceFactoryEvdev(
     std::unique_ptr<DeviceEventDispatcherEvdev> dispatcher,
     CursorDelegateEvdev* cursor)
     : task_runner_(base::ThreadTaskRunnerHandle::Get()),
       cursor_(cursor),
 #if defined(USE_EVDEV_GESTURES)
@@ skipping 315 matching lines @@
   if (enabled == palm_suppression_enabled_)
     return;
   palm_suppression_enabled_ = enabled;
 
   for (const auto& it : converters_) {
     it.second->SetEnabled(IsDeviceEnabled(it.second.get()));
   }
 }
 
 }  // namespace ui