ozone: evdev: Sync caps lock LED state to evdev

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 "base/stl_util.h"
@@ skipping 124 matching lines @@
 // 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,
                      const OpenInputDeviceReplyCallback& reply_callback) {
   const base::FilePath& path = params->path;
   scoped_ptr<EventConverterEvdev> converter;
 
   TRACE_EVENT1("ozone", "OpenInputDevice", "path", path.value());
 
-  int fd = open(path.value().c_str(), O_RDONLY | O_NONBLOCK);
+  int fd = open(path.value().c_str(), O_RDWR | O_NONBLOCK);
   if (fd < 0) {
     PLOG(ERROR) << "Cannot open '" << path.value();
     reply_runner->PostTask(
         FROM_HERE, base::Bind(reply_callback, base::Passed(&converter)));
     return;
   }
 
   // Use monotonic timestamps for events. The touch code in particular
   // expects event timestamps to correlate to the monotonic clock
   // (base::TimeTicks).
@@ skipping 37 matching lines @@
       cursor_(cursor),
 #if defined(USE_EVDEV_GESTURES)
       gesture_property_provider_(new GesturePropertyProvider),
 #endif
       dispatcher_(dispatcher.Pass()),
       pending_device_changes_(0),
       touchscreen_list_dirty_(false),
       keyboard_list_dirty_(false),
       mouse_list_dirty_(false),
       touchpad_list_dirty_(false),
+      caps_lock_led_enabled_(false),
       weak_ptr_factory_(this) {
 }
 
 InputDeviceFactoryEvdev::~InputDeviceFactoryEvdev() {
   STLDeleteValues(&converters_);
 }
 
 void InputDeviceFactoryEvdev::AddInputDevice(int id,
                                              const base::FilePath& path) {
   scoped_ptr<OpenInputDeviceParams> params(new OpenInputDeviceParams);
@@ skipping 36 matching lines @@
     if (converters_[path])
       DetachInputDevice(path);
 
     // Add initialized device to map.
     converters_[path] = converter.release();
     converters_[path]->Start();
     UpdateDirtyFlags(converters_[path]);
 
     // Sync settings to new device.
     ApplyInputDeviceSettings();
+    ApplyCapsLockLed();
   }
 
   if (--pending_device_changes_ == 0)
     NotifyDevicesUpdated();
 }
 
 void InputDeviceFactoryEvdev::DetachInputDevice(const base::FilePath& path) {
   TRACE_EVENT1("ozone", "DetachInputDevice", "path", path.value());
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
@@ skipping 52 matching lines @@
 void InputDeviceFactoryEvdev::EnableInternalKeyboard() {
   for (const auto& it : converters_) {
     EventConverterEvdev* converter = it.second;
     if (converter->type() == InputDeviceType::INPUT_DEVICE_INTERNAL &&
         converter->HasKeyboard()) {
       converter->AllowAllKeys();
     }
   }
 }
 
+void InputDeviceFactoryEvdev::SetCapsLockLed(bool enabled) {
+  caps_lock_led_enabled_ = enabled;
+  ApplyCapsLockLed();
+}
+
 void InputDeviceFactoryEvdev::UpdateInputDeviceSettings(
     const InputDeviceSettingsEvdev& settings) {
   input_device_settings_ = settings;
   ApplyInputDeviceSettings();
 }
 
 void InputDeviceFactoryEvdev::GetTouchDeviceStatus(
     const GetTouchDeviceStatusReply& reply) {
   scoped_ptr<std::string> status(new std::string);
 #if defined(USE_EVDEV_GESTURES)
@@ skipping 37 matching lines @@
 
   SetIntPropertyForOneType(DT_MOUSE, "Pointer Sensitivity",
                            input_device_settings_.mouse_sensitivity);
   SetIntPropertyForOneType(DT_MOUSE, "Scroll Sensitivity",
                            input_device_settings_.mouse_sensitivity);
 
   SetBoolPropertyForOneType(DT_TOUCHPAD, "Tap Paused",
                             input_device_settings_.tap_to_click_paused);
 }
 
+void InputDeviceFactoryEvdev::ApplyCapsLockLed() {
+  for (const auto& it : converters_) {
+    EventConverterEvdev* converter = it.second;
+    converter->SetCapsLockLed(caps_lock_led_enabled_);
+  }
+}
+
 void InputDeviceFactoryEvdev::UpdateDirtyFlags(
     const EventConverterEvdev* converter) {
   if (converter->HasTouchscreen())
     touchscreen_list_dirty_ = true;
 
   if (converter->HasKeyboard())
     keyboard_list_dirty_ = true;
 
   if (converter->HasMouse())
     mouse_list_dirty_ = true;
@@ skipping 86 matching lines @@
   std::vector<int> ids;
   gesture_property_provider_->GetDeviceIdsByType(type, &ids);
   for (size_t i = 0; i < ids.size(); ++i) {
     SetGestureBoolProperty(gesture_property_provider_.get(), ids[i], name,
                            value);
   }
 #endif
 }
 
 }  // namespace ui