Ozone support for device special cases in keyboard event rewriting.

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 <errno.h>
 #include <fcntl.h>
 #include <linux/input.h>
 #include <unistd.h>
 
 #include <vector>
@@ skipping 35 matching lines @@
   EXPECT_TRUE(CapabilitiesToDeviceInfo(kLinkTouchscreen, &devinfo));
   device->Initialize(devinfo);
 }
 
 }  // namespace
 
 class MockTouchEventConverterEvdev : public TouchEventConverterEvdev {
  public:
   MockTouchEventConverterEvdev(int 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.
   void ReadNow() {
     OnFileCanReadWithoutBlocking(read_pipe_);
@@ skipping 38 matching lines @@
   void DispatchTouchpadDevicesUpdated(
       const std::vector<InputDevice>& devices) override {}
 
  private:
   base::Callback<void(const TouchEventParams& params)> callback_;
 };
 
 MockTouchEventConverterEvdev::MockTouchEventConverterEvdev(
     int fd,
     base::FilePath path,
+    const EventDeviceInfo& devinfo,
     DeviceEventDispatcherEvdev* dispatcher)
-    : TouchEventConverterEvdev(fd, path, 1, INPUT_DEVICE_UNKNOWN, dispatcher) {
+    : TouchEventConverterEvdev(fd,
+                               path,
+                               1,
+                               INPUT_DEVICE_UNKNOWN,
+                               devinfo,
+                               dispatcher) {
   int fds[2];
 
   if (pipe(fds))
     PLOG(FATAL) << "failed pipe";
 
   EXPECT_FALSE(SetNonBlocking(fds[0]) || SetNonBlocking(fds[1]))
     << "failed to set non-blocking: " << strerror(errno);
 
   read_pipe_ = fds[0];
   write_pipe_ = fds[1];
@@ skipping 24 matching lines @@
     // 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];
 
     // 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_ = new ui::MockTouchEventConverterEvdev(
-        events_in_, base::FilePath(kTestDevicePath), dispatcher_.get());
+        events_in_, base::FilePath(kTestDevicePath), devinfo,
+        dispatcher_.get());
     loop_ = new base::MessageLoopForUI;
 
     ui::DeviceDataManager::CreateInstance();
   }
 
   void TearDown() override {
     delete device_;
     delete loop_;
   }
 
   ui::MockTouchEventConverterEvdev* device() { return device_; }
 
   unsigned size() { return dispatched_events_.size(); }
   const ui::TouchEventParams& dispatched_event(unsigned index) {
     DCHECK_GT(dispatched_events_.size(), index);
     return dispatched_events_[index];
   }
 
-  void ClearDispatchedEvents() {
-    dispatched_events_.clear();
-  }
+  void ClearDispatchedEvents() { dispatched_events_.clear(); }
 
  private:
   base::MessageLoop* loop_;
   ui::MockTouchEventConverterEvdev* device_;
   scoped_ptr<ui::MockDeviceEventDispatcherEvdev> dispatcher_;
 
   int events_out_;
   int events_in_;
 
   void DispatchCallback(const ui::TouchEventParams& params) {
@@ skipping 526 matching lines @@
   ASSERT_EQ(0u, size());
 
   EventTypeTouchNoiseFilter* filter =
       static_cast<EventTypeTouchNoiseFilter*>(first_filter());
   EXPECT_EQ(1u, filter->num_events(ET_TOUCH_PRESSED));
   EXPECT_EQ(2u, filter->num_events(ET_TOUCH_MOVED));
   EXPECT_EQ(1u, filter->num_events(ET_TOUCH_RELEASED));
 }
 
 }  // namespace ui