media/base/user_input_monitor_win.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "media/base/user_input_monitor.h"
   6
   7 #include "base/bind.h"
   8 #include "base/location.h"
   9 #include "base/logging.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/single_thread_task_runner.h"
  12 #include "base/strings/stringprintf.h"
  13 #include "base/synchronization/lock.h"
  14 #include "base/win/message_window.h"
  15 #include "media/base/keyboard_event_counter.h"
  16 #include "third_party/skia/include/core/SkPoint.h"
  17 #include "ui/events/keycodes/keyboard_code_conversion_win.h"
  18
  19 namespace media {
  20 namespace {
  21
  22 // From the HID Usage Tables specification.
  23 const USHORT kGenericDesktopPage = 1;
  24 const USHORT kMouseUsage = 2;
  25 const USHORT kKeyboardUsage = 6;
  26
  27 // This is the actual implementation of event monitoring. It's separated from
  28 // UserInputMonitorWin since it needs to be deleted on the UI thread.
  29 class UserInputMonitorWinCore
  30     : public base::SupportsWeakPtr<UserInputMonitorWinCore>,
  31       public base::MessageLoop::DestructionObserver {
  32  public:
  33   enum EventBitMask {
  34     MOUSE_EVENT_MASK = 1,
  35     KEYBOARD_EVENT_MASK = 2,
  36   };
  37
  38   explicit UserInputMonitorWinCore(
  39       scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
  40       const scoped_refptr<UserInputMonitor::MouseListenerList>&
  41           mouse_listeners);
  42   ~UserInputMonitorWinCore();
  43
  44   // DestructionObserver overrides.
  45   virtual void WillDestroyCurrentMessageLoop() OVERRIDE;
  46
  47   size_t GetKeyPressCount() const;
  48   void StartMonitor(EventBitMask type);
  49   void StopMonitor(EventBitMask type);
  50
  51  private:
  52   // Handles WM_INPUT messages.
  53   LRESULT OnInput(HRAWINPUT input_handle);
  54   // Handles messages received by |window_|.
  55   bool HandleMessage(UINT message,
  56                      WPARAM wparam,
  57                      LPARAM lparam,
  58                      LRESULT* result);
  59   RAWINPUTDEVICE* GetRawInputDevices(EventBitMask event, DWORD flags);
  60
  61   // Task runner on which |window_| is created.
  62   scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
  63   scoped_refptr<ObserverListThreadSafe<UserInputMonitor::MouseEventListener> >
  64       mouse_listeners_;
  65
  66   // These members are only accessed on the UI thread.
  67   scoped_ptr<base::win::MessageWindow> window_;
  68   uint8 events_monitored_;
  69   KeyboardEventCounter counter_;
  70
  71   DISALLOW_COPY_AND_ASSIGN(UserInputMonitorWinCore);
  72 };
  73
  74 class UserInputMonitorWin : public UserInputMonitor {
  75  public:
  76   explicit UserInputMonitorWin(
  77       const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner);
  78   virtual ~UserInputMonitorWin();
  79
  80   // Public UserInputMonitor overrides.
  81   virtual size_t GetKeyPressCount() const OVERRIDE;
  82
  83  private:
  84   // Private UserInputMonitor overrides.
  85   virtual void StartKeyboardMonitoring() OVERRIDE;
  86   virtual void StopKeyboardMonitoring() OVERRIDE;
  87   virtual void StartMouseMonitoring() OVERRIDE;
  88   virtual void StopMouseMonitoring() OVERRIDE;
  89
  90   scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
  91   UserInputMonitorWinCore* core_;
  92
  93   DISALLOW_COPY_AND_ASSIGN(UserInputMonitorWin);
  94 };
  95
  96 UserInputMonitorWinCore::UserInputMonitorWinCore(
  97     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
  98     const scoped_refptr<UserInputMonitor::MouseListenerList>& mouse_listeners)
  99     : ui_task_runner_(ui_task_runner),
 100       mouse_listeners_(mouse_listeners),
 101       events_monitored_(0) {}
 102
 103 UserInputMonitorWinCore::~UserInputMonitorWinCore() {
 104   DCHECK(!window_);
 105   DCHECK(!events_monitored_);
 106 }
 107
 108 void UserInputMonitorWinCore::WillDestroyCurrentMessageLoop() {
 109   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 110   StopMonitor(MOUSE_EVENT_MASK);
 111   StopMonitor(KEYBOARD_EVENT_MASK);
 112 }
 113
 114 size_t UserInputMonitorWinCore::GetKeyPressCount() const {
 115   return counter_.GetKeyPressCount();
 116 }
 117
 118 void UserInputMonitorWinCore::StartMonitor(EventBitMask type) {
 119   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 120
 121   if (events_monitored_ & type)
 122     return;
 123
 124   if (type == KEYBOARD_EVENT_MASK)
 125     counter_.Reset();
 126
 127   if (!window_) {
 128     window_.reset(new base::win::MessageWindow());
 129     if (!window_->Create(base::Bind(&UserInputMonitorWinCore::HandleMessage,
 130                                     base::Unretained(this)))) {
 131       LOG_GETLASTERROR(ERROR) << "Failed to create the raw input window";
 132       window_.reset();
 133       return;
 134     }
 135   }
 136
 137   // Register to receive raw mouse and/or keyboard input.
 138   scoped_ptr<RAWINPUTDEVICE> device(GetRawInputDevices(type, RIDEV_INPUTSINK));
 139   if (!RegisterRawInputDevices(device.get(), 1, sizeof(*device))) {
 140     LOG_GETLASTERROR(ERROR)
 141         << "RegisterRawInputDevices() failed for RIDEV_INPUTSINK";
 142     window_.reset();
 143     return;
 144   }
 145
 146   // Start observing message loop destruction if we start monitoring the first
 147   // event.
 148   if (!events_monitored_)
 149     base::MessageLoop::current()->AddDestructionObserver(this);
 150
 151   events_monitored_ |= type;
 152 }
 153
 154 void UserInputMonitorWinCore::StopMonitor(EventBitMask type) {
 155   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 156
 157   if (!(events_monitored_ & type))
 158     return;
 159
 160   // Stop receiving raw input.
 161   DCHECK(window_);
 162   scoped_ptr<RAWINPUTDEVICE> device(GetRawInputDevices(type, RIDEV_REMOVE));
 163
 164   if (!RegisterRawInputDevices(device.get(), 1, sizeof(*device))) {
 165     LOG_GETLASTERROR(INFO)
 166         << "RegisterRawInputDevices() failed for RIDEV_REMOVE";
 167   }
 168
 169   events_monitored_ &= ~type;
 170   if (events_monitored_ == 0) {
 171     window_.reset();
 172
 173     // Stop observing message loop destruction if no event is being monitored.
 174     base::MessageLoop::current()->RemoveDestructionObserver(this);
 175   }
 176 }
 177
 178 LRESULT UserInputMonitorWinCore::OnInput(HRAWINPUT input_handle) {
 179   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 180
 181   // Get the size of the input record.
 182   UINT size = 0;
 183   UINT result = GetRawInputData(
 184       input_handle, RID_INPUT, NULL, &size, sizeof(RAWINPUTHEADER));
 185   if (result == -1) {
 186     LOG_GETLASTERROR(ERROR) << "GetRawInputData() failed";
 187     return 0;
 188   }
 189   DCHECK_EQ(0u, result);
 190
 191   // Retrieve the input record itself.
 192   scoped_ptr<uint8[]> buffer(new uint8[size]);
 193   RAWINPUT* input = reinterpret_cast<RAWINPUT*>(buffer.get());
 194   result = GetRawInputData(
 195       input_handle, RID_INPUT, buffer.get(), &size, sizeof(RAWINPUTHEADER));
 196   if (result == -1) {
 197     LOG_GETLASTERROR(ERROR) << "GetRawInputData() failed";
 198     return 0;
 199   }
 200   DCHECK_EQ(size, result);
 201
 202   // Notify the observer about events generated locally.
 203   if (input->header.dwType == RIM_TYPEMOUSE && input->header.hDevice != NULL) {
 204     POINT position;
 205     if (!GetCursorPos(&position)) {
 206       position.x = 0;
 207       position.y = 0;
 208     }
 209     mouse_listeners_->Notify(
 210         &UserInputMonitor::MouseEventListener::OnMouseMoved,
 211         SkIPoint::Make(position.x, position.y));
 212   } else if (input->header.dwType == RIM_TYPEKEYBOARD &&
 213              input->header.hDevice != NULL) {
 214     ui::EventType event = (input->data.keyboard.Flags & RI_KEY_BREAK)
 215                               ? ui::ET_KEY_RELEASED
 216                               : ui::ET_KEY_PRESSED;
 217     ui::KeyboardCode key_code =
 218         ui::KeyboardCodeForWindowsKeyCode(input->data.keyboard.VKey);
 219     counter_.OnKeyboardEvent(event, key_code);
 220   }
 221
 222   return DefRawInputProc(&input, 1, sizeof(RAWINPUTHEADER));
 223 }
 224
 225 bool UserInputMonitorWinCore::HandleMessage(UINT message,
 226                                             WPARAM wparam,
 227                                             LPARAM lparam,
 228                                             LRESULT* result) {
 229   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 230
 231   switch (message) {
 232     case WM_INPUT:
 233       *result = OnInput(reinterpret_cast<HRAWINPUT>(lparam));
 234       return true;
 235
 236     default:
 237       return false;
 238   }
 239 }
 240
 241 RAWINPUTDEVICE* UserInputMonitorWinCore::GetRawInputDevices(EventBitMask event,
 242                                                             DWORD flags) {
 243   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 244
 245   scoped_ptr<RAWINPUTDEVICE> device(new RAWINPUTDEVICE());
 246   if (event == MOUSE_EVENT_MASK) {
 247     device->dwFlags = flags;
 248     device->usUsagePage = kGenericDesktopPage;
 249     device->usUsage = kMouseUsage;
 250     device->hwndTarget = window_->hwnd();
 251   } else {
 252     DCHECK_EQ(KEYBOARD_EVENT_MASK, event);
 253     device->dwFlags = flags;
 254     device->usUsagePage = kGenericDesktopPage;
 255     device->usUsage = kKeyboardUsage;
 256     device->hwndTarget = window_->hwnd();
 257   }
 258   return device.release();
 259 }
 260
 261 //
 262 // Implementation of UserInputMonitorWin.
 263 //
 264
 265 UserInputMonitorWin::UserInputMonitorWin(
 266     const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner)
 267     : ui_task_runner_(ui_task_runner),
 268       core_(new UserInputMonitorWinCore(ui_task_runner, mouse_listeners())) {}
 269
 270 UserInputMonitorWin::~UserInputMonitorWin() {
 271   if (!ui_task_runner_->DeleteSoon(FROM_HERE, core_))
 272     delete core_;
 273 }
 274
 275 size_t UserInputMonitorWin::GetKeyPressCount() const {
 276   return core_->GetKeyPressCount();
 277 }
 278
 279 void UserInputMonitorWin::StartKeyboardMonitoring() {
 280   ui_task_runner_->PostTask(
 281       FROM_HERE,
 282       base::Bind(&UserInputMonitorWinCore::StartMonitor,
 283                  core_->AsWeakPtr(),
 284                  UserInputMonitorWinCore::KEYBOARD_EVENT_MASK));
 285 }
 286
 287 void UserInputMonitorWin::StopKeyboardMonitoring() {
 288   ui_task_runner_->PostTask(
 289       FROM_HERE,
 290       base::Bind(&UserInputMonitorWinCore::StopMonitor,
 291                  core_->AsWeakPtr(),
 292                  UserInputMonitorWinCore::KEYBOARD_EVENT_MASK));
 293 }
 294
 295 void UserInputMonitorWin::StartMouseMonitoring() {
 296   ui_task_runner_->PostTask(
 297       FROM_HERE,
 298       base::Bind(&UserInputMonitorWinCore::StartMonitor,
 299                  core_->AsWeakPtr(),
 300                  UserInputMonitorWinCore::MOUSE_EVENT_MASK));
 301 }
 302
 303 void UserInputMonitorWin::StopMouseMonitoring() {
 304   ui_task_runner_->PostTask(
 305       FROM_HERE,
 306       base::Bind(&UserInputMonitorWinCore::StopMonitor,
 307                  core_->AsWeakPtr(),
 308                  UserInputMonitorWinCore::MOUSE_EVENT_MASK));
 309 }
 310
 311 }  // namespace
 312
 313 scoped_ptr<UserInputMonitor> UserInputMonitor::Create(
 314     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
 315     const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner) {
 316   return scoped_ptr<UserInputMonitor>(new UserInputMonitorWin(ui_task_runner));
 317 }
 318
 319 }  // namespace media