ozone: evdev: Factor keyboard into KeyboardEvdev

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"
@@ skipping 30 matching lines @@
   int id;
 
   // Device path to open.
   base::FilePath path;
 
   // Callback for dispatching events. Call on UI thread only.
   EventDispatchCallback dispatch_callback;
 
   // State shared between devices. Must not be dereferenced on worker thread.
   EventModifiersEvdev* modifiers;
+  KeyboardEvdev* keyboard;
   CursorDelegateEvdev* cursor;
 };
 
 #if defined(USE_EVDEV_GESTURES)
 bool UseGesturesLibraryForDevice(const EventDeviceInfo& devinfo) {
   if (devinfo.HasAbsXY() && !devinfo.IsMappedToScreen())
     return true;  // touchpad
 
   if (devinfo.HasRelXY())
     return true;  // mouse
@@ skipping 23 matching lines @@
   }
 #endif
 
   // Touchscreen: use TouchEventConverterEvdev.
   scoped_ptr<EventConverterEvdev> converter;
   if (devinfo.HasAbsXY())
     return make_scoped_ptr<EventConverterEvdev>(new TouchEventConverterEvdev(
         fd, params.path, params.id, devinfo, params.dispatch_callback));
 
   // Everything else: use KeyEventConverterEvdev.
-  return make_scoped_ptr<EventConverterEvdev>(new KeyEventConverterEvdev(
-      fd, params.path, params.id, params.modifiers, params.dispatch_callback));
+  return make_scoped_ptr<EventConverterEvdev>(
+      new KeyEventConverterEvdev(fd, params.path, params.id, params.keyboard));
 }
 
 // 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 38 matching lines @@
   TRACE_EVENT1("ozone", "CloseInputDevice", "path", path.value());
   converter.reset();
 }
 
 }  // namespace
 
 EventFactoryEvdev::EventFactoryEvdev(CursorDelegateEvdev* cursor,
                                      DeviceManager* device_manager)
     : last_device_id_(0),
       device_manager_(device_manager),
-      cursor_(cursor),
       dispatch_callback_(
           base::Bind(base::IgnoreResult(&EventFactoryEvdev::DispatchUiEvent),
                      base::Unretained(this))),
+      keyboard_(&modifiers_, dispatch_callback_),
+      cursor_(cursor),
       weak_ptr_factory_(this) {
   DCHECK(device_manager_);
 }
 
 EventFactoryEvdev::~EventFactoryEvdev() { STLDeleteValues(&converters_); }
 
 void EventFactoryEvdev::DispatchUiEvent(Event* event) {
   DispatchEvent(event);
 }
 
@@ skipping 23 matching lines @@
   switch (event.action_type()) {
     case DeviceEvent::ADD:
     case DeviceEvent::CHANGE: {
       TRACE_EVENT1("ozone", "OnDeviceAdded", "path", event.path().value());
 
       scoped_ptr<OpenInputDeviceParams> params(new OpenInputDeviceParams);
       params->id = NextDeviceId();
       params->path = event.path();
       params->dispatch_callback = dispatch_callback_;
       params->modifiers = &modifiers_;
+      params->keyboard = &keyboard_;
       params->cursor = cursor_;
 
       OpenInputDeviceReplyCallback reply_callback =
           base::Bind(&EventFactoryEvdev::AttachInputDevice,
                      weak_ptr_factory_.GetWeakPtr());
 
       // Dispatch task to open from the worker pool, since open may block.
       base::WorkerPool::PostTask(FROM_HERE,
                                  base::Bind(&OpenInputDevice,
                                             base::Passed(&params),
@@ skipping 73 matching lines @@
   }
 
   observer->OnTouchscreenDevicesUpdated(touchscreens);
 }
 
 int EventFactoryEvdev::NextDeviceId() {
   return ++last_device_id_;
 }
 
 }  // namespace ui