Fix double-close in EventConverterEvdevImpl

ui/events/ozone/evdev/touch_event_converter_evdev_unittest.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/touch_event_converter_evdev.h"
 
 #include <errno.h>
 #include <linux/input.h>
 #include <stddef.h>
 #include <unistd.h>
@@ skipping 62 matching lines @@
     MouseMoveEventParams mouse_move;
     MouseButtonEventParams mouse_button;
     TouchEventParams touch;
   };
 };
 
 }  // namespace
 
 class MockTouchEventConverterEvdev : public TouchEventConverterEvdev {
  public:
-  MockTouchEventConverterEvdev(int fd,
+  MockTouchEventConverterEvdev(ScopedInputDevice fd,
                                base::FilePath path,
                                const EventDeviceInfo& devinfo,
                                DeviceEventDispatcherEvdev* dispatcher);
   ~MockTouchEventConverterEvdev() override;
 
   void ConfigureReadMock(struct input_event* queue,
                          long read_this_many,
                          long queue_index);
 
   // Actually dispatch the event reader code.
@@ skipping 57 matching lines @@
   void DispatchTouchpadDevicesUpdated(
       const std::vector<InputDevice>& devices) override {}
   void DispatchDeviceListsComplete() override {}
   void DispatchStylusStateChanged(StylusState stylus_state) override {}
 
  private:
   base::Callback<void(const GenericEventParams& params)> callback_;
 };
 
 MockTouchEventConverterEvdev::MockTouchEventConverterEvdev(
-    int fd,
+    ScopedInputDevice fd,
     base::FilePath path,
     const EventDeviceInfo& devinfo,
     DeviceEventDispatcherEvdev* dispatcher)
-    : TouchEventConverterEvdev(fd,
-                               path,
-                               1,
-                               devinfo,
-                               dispatcher) {
+    : TouchEventConverterEvdev(std::move(fd), path, 1, devinfo, dispatcher) {
   int fds[2];
 
   if (pipe(fds))
     PLOG(FATAL) << "failed pipe";
 
   EXPECT_TRUE(base::SetNonBlocking(fds[0]) || base::SetNonBlocking(fds[1]))
     << "failed to set non-blocking: " << strerror(errno);
 
   read_pipe_ = fds[0];
   write_pipe_ = fds[1];
@@ skipping 24 matching lines @@
 class TouchEventConverterEvdevTest : public testing::Test {
  public:
   TouchEventConverterEvdevTest() {}
 
   // Overridden from testing::Test:
   void SetUp() override {
     // Set up pipe to satisfy message pump (unused).
     int evdev_io[2];
     if (pipe(evdev_io))
       PLOG(FATAL) << "failed pipe";
-    events_in_ = evdev_io[0];
-    events_out_ = evdev_io[1];
+    ScopedInputDevice events_in(evdev_io[0]);
+    events_out_.reset(evdev_io[1]);
 
     // Device creation happens on a worker thread since it may involve blocking
     // operations. Simulate that by creating it before creating a UI message
     // loop.
     EventDeviceInfo devinfo;
     dispatcher_.reset(new ui::MockDeviceEventDispatcherEvdev(
         base::Bind(&TouchEventConverterEvdevTest::DispatchCallback,
                    base::Unretained(this))));
     device_.reset(new ui::MockTouchEventConverterEvdev(
-        events_in_, base::FilePath(kTestDevicePath), devinfo,
+        std::move(events_in), base::FilePath(kTestDevicePath), devinfo,
         dispatcher_.get()));
     loop_ = new base::MessageLoopForUI;
 
     ui::DeviceDataManager::CreateInstance();
   }
 
   void TearDown() override {
     device_.reset();
     delete loop_;
   }
@@ skipping 21 matching lines @@
   }
   void ClearDispatchedEvents() { dispatched_events_.clear(); }
 
   void DestroyDevice() { device_.reset(); }
 
  private:
   base::MessageLoop* loop_;
   std::unique_ptr<ui::MockTouchEventConverterEvdev> device_;
   std::unique_ptr<ui::MockDeviceEventDispatcherEvdev> dispatcher_;
 
-  int events_out_;
-  int events_in_;
+  ScopedInputDevice events_out_;
 
   void DispatchCallback(const GenericEventParams& params) {
     dispatched_events_.push_back(params);
   }
   std::vector<GenericEventParams> dispatched_events_;
 
   DISALLOW_COPY_AND_ASSIGN(TouchEventConverterEvdevTest);
 };
 
 TEST_F(TouchEventConverterEvdevTest, NoEvents) {
@@ skipping 821 matching lines @@
   event = dispatched_touch_event(3);
   EXPECT_EQ(ET_TOUCH_RELEASED, event.type);
   EXPECT_EQ(8930, event.location.x());
   EXPECT_EQ(980, event.location.y());
   EXPECT_EQ(EventPointerType::POINTER_TYPE_PEN,
             event.pointer_details.pointer_type);
   EXPECT_EQ(0.f / 1024, event.pointer_details.force);
 }
 
 }  // namespace ui