Removes mouse listeners from UserInputMonitor.

media/base/user_input_monitor_linux.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 "media/base/user_input_monitor.h"
 
 #include <stddef.h>
 #include <sys/select.h>
 #include <unistd.h>
 #define XK_MISCELLANY
@@ skipping 24 matching lines @@
 namespace media {
 namespace {
 
 // This is the actual implementation of event monitoring. It's separated from
 // UserInputMonitorLinux since it needs to be deleted on the IO thread.
 class UserInputMonitorLinuxCore
     : public base::SupportsWeakPtr<UserInputMonitorLinuxCore>,
       public base::MessageLoop::DestructionObserver {
  public:
   enum EventType {
     MOUSE_EVENT,

[Wez, 2016/12/16 02:06:43]

nit: You can get rid of this now :)

[CJ, 2016/12/22 22:42:58]

Done.

     KEYBOARD_EVENT
   };
 
   explicit UserInputMonitorLinuxCore(
-      const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
-      const scoped_refptr<UserInputMonitor::MouseListenerList>&
-          mouse_listeners);
+      const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner);
   ~UserInputMonitorLinuxCore() override;
 
   // DestructionObserver overrides.
   void WillDestroyCurrentMessageLoop() override;
 
   size_t GetKeyPressCount() const;
   void StartMonitor(EventType type);
   void StopMonitor(EventType type);
 
  private:
   void OnXEvent();
 
-  // Processes key and mouse events.
+  // Processes key events.
   void ProcessXEvent(xEvent* event);
   static void ProcessReply(XPointer self, XRecordInterceptData* data);
 
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
-  scoped_refptr<base::ObserverListThreadSafe<
-      UserInputMonitor::MouseEventListener>> mouse_listeners_;
 
   //
   // The following members should only be accessed on the IO thread.
   //
   std::unique_ptr<base::FileDescriptorWatcher::Controller> watch_controller_;
   Display* x_control_display_;
   Display* x_record_display_;
   XRecordRange* x_record_range_[2];

[Wez, 2016/12/16 02:06:43]

nit: Don't need an arrange of XRecordRange, just a single one, now.

[CJ, 2016/12/22 22:42:58]

Done.

   XRecordContext x_record_context_;
   KeyboardEventCounter counter_;
 
   DISALLOW_COPY_AND_ASSIGN(UserInputMonitorLinuxCore);
 };
 
 class UserInputMonitorLinux : public UserInputMonitor {
  public:
   explicit UserInputMonitorLinux(
       const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner);
   ~UserInputMonitorLinux() override;
 
   // Public UserInputMonitor overrides.
   size_t GetKeyPressCount() const override;
 
  private:
   // Private UserInputMonitor overrides.
   void StartKeyboardMonitoring() override;
   void StopKeyboardMonitoring() override;
-  void StartMouseMonitoring() override;
-  void StopMouseMonitoring() override;
 
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
   UserInputMonitorLinuxCore* core_;
 
   DISALLOW_COPY_AND_ASSIGN(UserInputMonitorLinux);
 };
 
 UserInputMonitorLinuxCore::UserInputMonitorLinuxCore(
-    const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
-    const scoped_refptr<UserInputMonitor::MouseListenerList>& mouse_listeners)
+    const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
     : io_task_runner_(io_task_runner),
-      mouse_listeners_(mouse_listeners),
       x_control_display_(NULL),
       x_record_display_(NULL),
       x_record_context_(0) {
   x_record_range_[0] = NULL;
   x_record_range_[1] = NULL;
 }
 
 UserInputMonitorLinuxCore::~UserInputMonitorLinuxCore() {
   DCHECK(!x_control_display_);
   DCHECK(!x_record_display_);
@@ skipping 45 matching lines @@
 
   if (!x_record_range_[type])
     x_record_range_[type] = XRecordAllocRange();
 
   if (!x_record_range_[type]) {
     LOG(ERROR) << "XRecordAllocRange failed.";
     StopMonitor(type);
     return;
   }
 
   if (type == MOUSE_EVENT) {

[Wez, 2016/12/16 02:06:43]

This needs stripping out, as well - we now only want to listen for keyboard
input. :)

[CJ, 2016/12/22 22:42:57]

Done.

     x_record_range_[type]->device_events.first = MotionNotify;
     x_record_range_[type]->device_events.last = MotionNotify;
   } else {
     DCHECK_EQ(KEYBOARD_EVENT, type);
     x_record_range_[type]->device_events.first = KeyPress;
     x_record_range_[type]->device_events.last = KeyRelease;
   }
 
   if (x_record_context_) {
     XRecordDisableContext(x_control_display_, x_record_context_);
@@ skipping 81 matching lines @@
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   XEvent event;
   // Fetch pending events if any.
   while (XPending(x_record_display_)) {
     XNextEvent(x_record_display_, &event);
   }
 }
 
 void UserInputMonitorLinuxCore::ProcessXEvent(xEvent* event) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
-  if (event->u.u.type == MotionNotify) {
-    SkIPoint position(SkIPoint::Make(event->u.keyButtonPointer.rootX,
-                                     event->u.keyButtonPointer.rootY));
-    mouse_listeners_->Notify(
-        FROM_HERE, &UserInputMonitor::MouseEventListener::OnMouseMoved,
-        position);
-  } else {
+  if (event->u.u.type != MotionNotify) {

[Wez, 2016/12/16 02:06:43]

nit: Looks like you don't need this at all - just get rid of this if entirely -
you should no longer be registering for motion information.

[CJ, 2016/12/22 22:42:58]

Done.

     ui::EventType type;
     if (event->u.u.type == KeyPress) {
       type = ui::ET_KEY_PRESSED;
     } else if (event->u.u.type == KeyRelease) {
       type = ui::ET_KEY_RELEASED;
     } else {
       NOTREACHED();
       return;
     }
 
@@ skipping 14 matching lines @@
   XRecordFreeData(data);
 }
 
 //
 // Implementation of UserInputMonitorLinux.
 //
 
 UserInputMonitorLinux::UserInputMonitorLinux(
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
     : io_task_runner_(io_task_runner),
-      core_(new UserInputMonitorLinuxCore(io_task_runner, mouse_listeners())) {}
+      core_(new UserInputMonitorLinuxCore(io_task_runner)) {}
 
 UserInputMonitorLinux::~UserInputMonitorLinux() {
   if (!io_task_runner_->DeleteSoon(FROM_HERE, core_))
     delete core_;
 }
 
 size_t UserInputMonitorLinux::GetKeyPressCount() const {
   return core_->GetKeyPressCount();
 }
 
 void UserInputMonitorLinux::StartKeyboardMonitoring() {
   io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&UserInputMonitorLinuxCore::StartMonitor,
                  core_->AsWeakPtr(),
                  UserInputMonitorLinuxCore::KEYBOARD_EVENT));
 }
 
 void UserInputMonitorLinux::StopKeyboardMonitoring() {
   io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&UserInputMonitorLinuxCore::StopMonitor,
                  core_->AsWeakPtr(),
                  UserInputMonitorLinuxCore::KEYBOARD_EVENT));
 }
 
-void UserInputMonitorLinux::StartMouseMonitoring() {
-  io_task_runner_->PostTask(FROM_HERE,
-                            base::Bind(&UserInputMonitorLinuxCore::StartMonitor,
-                                       core_->AsWeakPtr(),
-                                       UserInputMonitorLinuxCore::MOUSE_EVENT));
-}
-
-void UserInputMonitorLinux::StopMouseMonitoring() {
-  io_task_runner_->PostTask(FROM_HERE,
-                            base::Bind(&UserInputMonitorLinuxCore::StopMonitor,
-                                       core_->AsWeakPtr(),
-                                       UserInputMonitorLinuxCore::MOUSE_EVENT));
-}
-
 }  // namespace
 
 std::unique_ptr<UserInputMonitor> UserInputMonitor::Create(
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
     const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner) {
   return base::WrapUnique(new UserInputMonitorLinux(io_task_runner));
 }
 
 }  // namespace media