evdev: Move EventConverterOzone ownership from EventFactoryOzone to subclass

ui/events/ozone/evdev/key_event_converter_unittest.cc

 // Copyright 2013 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 <linux/input.h>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
+#include "base/message_loop/message_loop.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/event.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/events/ozone/evdev/key_event_converter.h"
 
 namespace ui {
 
-const int kInvalidFileDescriptor = -1;
 const char kTestDevicePath[] = "/dev/input/test-device";
 
 class MockKeyEventConverterEvdev : public KeyEventConverterEvdev {
  public:
-  MockKeyEventConverterEvdev(EventModifiersEvdev* modifiers)
-      : KeyEventConverterEvdev(kInvalidFileDescriptor,
-                               base::FilePath(kTestDevicePath),
-                               modifiers) {}
+  MockKeyEventConverterEvdev(int fd, EventModifiersEvdev* modifiers)
+      : KeyEventConverterEvdev(fd, base::FilePath(kTestDevicePath), modifiers) {
+  }
   virtual ~MockKeyEventConverterEvdev() {};
 
   unsigned size() { return dispatched_events_.size(); }
-  KeyEvent* event(unsigned index) { return dispatched_events_[index]; }
+  KeyEvent* event(unsigned index) {
+    CHECK_GT(dispatched_events_.size(), index);
+    return dispatched_events_[index];
+  }
 
   virtual void DispatchEvent(scoped_ptr<Event> event) OVERRIDE;
 
  private:
   ScopedVector<KeyEvent> dispatched_events_;
 
   DISALLOW_COPY_AND_ASSIGN(MockKeyEventConverterEvdev);
 };
 
 void MockKeyEventConverterEvdev::DispatchEvent(scoped_ptr<Event> event) {
   dispatched_events_.push_back(static_cast<KeyEvent*>(event.release()));
 }
 
 }  // namespace ui
 
 // Test fixture.
 class KeyEventConverterEvdevTest : public testing::Test {
  public:
   KeyEventConverterEvdevTest() {}
 
   // Overridden from testing::Test:
   virtual 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];
+
     modifiers_ = new ui::EventModifiersEvdev();
-    device_ = new ui::MockKeyEventConverterEvdev(modifiers_);
+    device_ = new ui::MockKeyEventConverterEvdev(events_in_, modifiers_);
   }
   virtual void TearDown() OVERRIDE {
     delete device_;
     delete modifiers_;
+    close(events_in_);
+    close(events_out_);
   }
 
   ui::MockKeyEventConverterEvdev* device() { return device_; }
   ui::EventModifiersEvdev* modifiers() { return modifiers_; }
 
  private:
+  base::MessageLoopForUI ui_loop_;
+
   ui::EventModifiersEvdev* modifiers_;
   ui::MockKeyEventConverterEvdev* device_;
+
+  int events_out_;
+  int events_in_;
+
   DISALLOW_COPY_AND_ASSIGN(KeyEventConverterEvdevTest);
 };
 
 TEST_F(KeyEventConverterEvdevTest, KeyPress) {
   ui::MockKeyEventConverterEvdev* dev = device();
 
   struct input_event mock_kernel_queue[] = {
       {{0, 0}, EV_MSC, MSC_SCAN, 0x7002a},
       {{0, 0}, EV_KEY, KEY_BACKSPACE, 1},
       {{0, 0}, EV_SYN, SYN_REPORT, 0},
@@ skipping 241 matching lines @@
   event = dev->event(4);
   EXPECT_EQ(ui::ET_KEY_PRESSED, event->type());
   EXPECT_EQ(ui::VKEY_CAPITAL, event->key_code());
   EXPECT_EQ(0, event->flags());
 
   event = dev->event(5);
   EXPECT_EQ(ui::ET_KEY_RELEASED, event->type());
   EXPECT_EQ(ui::VKEY_CAPITAL, event->key_code());
   EXPECT_EQ(0, event->flags());
 }