API proposal for chrome.app.window to intercept all keys.

ui/views/widget/desktop_aura/desktop_keyboard_capture_win.cc

+// Copyright (c) 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/views/widget/desktop_aura/desktop_keyboard_capture_win.h"
+
+#include <map>
+
+#include "base/containers/scoped_ptr_hash_map.h"
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/memory/singleton.h"
+#include "base/message_loop/message_loop.h"
+#include "base/message_loop/message_pump_win.h"
+
+namespace {
+// Some helper routines used to construct keyboard event.
+
+// Return true of WPARAM corresponds to a UP keyboard event.
+bool IsKeyUp(WPARAM w_param) {
+  return (w_param == WM_KEYUP) || (w_param == WM_SYSKEYUP);
+}
+
+// Check if the given bit is set.
+bool IsBitSet(ULONG value, ULONG mask) {
+  return ((value & mask) != 0);
+}
+
+// Return the location independent keycode corresponding to given keycode (e.g.
+// return shift when left/right shift is pressed). This is needed as low level
+// hooks get location information which is not returned as part of normal window
+// keyboard events.
+DWORD RemoveLocationOnKeycode(DWORD vk_code) {
+  // Virtual keycode from low level hook include location while window messages
+  // does not. So convert them to be without location.
+  switch (vk_code) {
+    case VK_LSHIFT:
+    case VK_RSHIFT:
+      return VK_SHIFT;
+    case VK_LCONTROL:
+    case VK_RCONTROL:
+      return VK_CONTROL;
+    case VK_LMENU:
+    case VK_RMENU:
+      return VK_MENU;
+  }
+  return vk_code;
+}
+
+// Construct LPARAM corresponding to the given low level hook callback
+// structure.
+LPARAM GetLParamFromHookStruct(WPARAM w_param, KBDLLHOOKSTRUCT* hook_struct) {
+  ULONG key_state = 0;
+  // There is no way to get repeat count so always set it to 1.
+  key_state = 1;
+
+  // Scan code.
+  key_state |= (hook_struct->scanCode & 0xFF) << 16;
+
+  // Extended key when the event is received as part window event and so skip
+  // it.
+
+  // Context code.
+  key_state |= IsBitSet(hook_struct->flags, LLKHF_ALTDOWN) << 29;
+
+  // Previous key state - set to 1 for KEYUP events.
+  key_state |= IsKeyUp(w_param) << 30;
+
+  // Transition state.
+  key_state |= IsBitSet(hook_struct->flags, LLKHF_UP) << 31;
+
+  return static_cast<LPARAM>(key_state);
+}
+
+// List of key state that we want to save.
+int keys_to_save[] = {VK_SHIFT, VK_CONTROL, VK_MENU};
+
+// Make sure that we are not going to run out of bits saving the state.
+C_ASSERT((arraysize(keys_to_save) * 2) <= (sizeof(WPARAM) * 8));
+
+// Save keyboard state to WPARAM so it can be restored later before the keyboard
+// message is processed in the main thread. This is necessary for
+// GetKeyboardState() to work as keyboard state will be different by the time
+// main thread processes the message.
+WPARAM SaveKeyboardState() {
+  WPARAM value = 0;
+
+  for (int index = 0; index < arraysize(keys_to_save); index++) {
+    value <<= 2;
+    SHORT key_state = GetAsyncKeyState(keys_to_save[index]);
+    value |= ((IsBitSet(key_state, 0x8000) ? 0x2 : 0) |
+              (IsBitSet(key_state, 0x1) ? 0x1 : 0));
+  }
+  return value;
+}
+
+// Restore keyboard state based on saved values.
+bool RestoreKeyboardState(WPARAM w_param) {
+  const int kKeyboardStateLength = 256;
+  BYTE keyboard_state[kKeyboardStateLength];
+  if (!GetKeyboardState(keyboard_state)) {
+    DVLOG(ERROR) << "Error getting keyboard state";
+    return false;
+  }
+
+  // restore in the reverse order of what was saved so we have the right bit for
+  // each key that was saved.
+  for (int index = arraysize(keys_to_save) - 1; index >= 0; index--) {
+    int key = keys_to_save[index];
+    keyboard_state[key] =
+        (IsBitSet(w_param, 0x2) ? 0x80 : 0) | (IsBitSet(w_param, 0x1) ? 1 : 0);
+    w_param >>= 2;
+  }
+
+  if (!SetKeyboardState(keyboard_state)) {
+    DVLOG(ERROR) << "Error setting keyboard state";
+    return false;
+  }
+
+  return true;
+}
+
+// Data corresponding to keyboard event.
+struct KeyboardEventInfo {
+  UINT message_id;
+  WPARAM event_w_param;
+  LPARAM event_l_param;
+  WPARAM keyboard_state_to_restore;
+};
+
+// Maintains low level registration for a window.
+class KeyboardInterceptRegistration {
+ public:
+  KeyboardInterceptRegistration();
+
+  ~KeyboardInterceptRegistration();
+
+  // Register for low level hook.
+  bool Hook(HOOKPROC callback_function);
+
+  // Unhook registered hook.
+  bool Unhook();
+
+  // Are there any keyboard events queued.
+  bool IsKeyboardEventQueueEmpty();
+
+  // Insert keyboard event in the queue.
+  void QueueKeyboardEvent(const KeyboardEventInfo& info);
+
+  KeyboardEventInfo DequeueKeyboardEvent();
+
+ private:
+  std::queue<KeyboardEventInfo> keyboard_events_;
+
+  // Hook returned when it was installed.
+  HHOOK hook_handle_;
+
+  DISALLOW_COPY_AND_ASSIGN(KeyboardInterceptRegistration);
+};
+
+// Implements low level hook and manages registration for all the windows.
+class LowLevelHookHandler {
+ public:
+  // Request all keyboard events to be routed to the given window.
+  void Register(HWND window_handle);
+
+  // Release the request for all keyboard events.
+  void Deregister(HWND window_handle);
+
+  // Get singleton instance.
+  static LowLevelHookHandler* GetInstance();
+
+ private:
+  // Private constructor/destructor so it is accessible only
+  // DefaultSingletonTraits.
+  friend struct DefaultSingletonTraits<LowLevelHookHandler>;
+  LowLevelHookHandler();
+
+  ~LowLevelHookHandler();
+
+  // Low level keyboard hook processing related functions.
+  // Hook callback called from the OS.
+  static LRESULT CALLBACK
+      KeyboardHook(int code, WPARAM w_param, LPARAM l_param);
+
+  // Low level keyboard hook handler.
+  LRESULT HandleKeyboardHook(int code, WPARAM w_param, LPARAM l_param);
+
+  // Message filter to set keyboard state based on private message.
+  static LRESULT CALLBACK
+      MessageFilterHook(int code, WPARAM w_param, LPARAM l_param);
+
+  // Message filter handler.
+  LRESULT HandleMessageFilterHook(int code, WPARAM w_param, LPARAM l_param);
+
+  bool RegisterMessageFilter();
+  void UnregisterMessageFilter();
+
+  // Hook handle for window message to set keyboard state based on private
+  // message.
+  HHOOK message_filter_hook_;
+
+  // Private window message to set keyboard state for the thread.
+  UINT restore_keyboard_state_message_id_;
+
+  // Private message to inject keyboard event after current injected message is
+  // processed.
+  UINT inject_keyboard_event_message_id_;
+
+  // There is no lock protecting this list as the low level hook callbacks are
+  // executed on same thread that registered the hook and there is only one
+  // thread
+  // that execute all view code in browser.
+  base::ScopedPtrHashMap<HWND, KeyboardInterceptRegistration> registrations_;
+};
+
+KeyboardInterceptRegistration::KeyboardInterceptRegistration()
+    : hook_handle_(NULL) {
+}
+
+KeyboardInterceptRegistration::~KeyboardInterceptRegistration() {
+  if (hook_handle_ != NULL)
+    Unhook();
+}
+
+bool KeyboardInterceptRegistration::Hook(HOOKPROC callback_function) {
+  // Make sure that hook is set from main thread as it has to be valid for
+  // the lifetime of the registration.
+  DCHECK(base::MessageLoopForUI::IsCurrent());
+  DCHECK(hook_handle_ == NULL) << "Keyboard hook already registered";
+  hook_handle_ = SetWindowsHookEx(WH_KEYBOARD_LL, callback_function, NULL, 0);
+  if (hook_handle_ == NULL) {
+    DVLOG(ERROR) << "Error calling SetWindowsHookEx() - GLE = "
+                 << GetLastError();
+    return false;
+  }
+  return true;
+}
+
+bool KeyboardInterceptRegistration::Unhook() {
+  DCHECK(hook_handle_ != NULL) << "Unhook called without registring hooks";
+  BOOL result = UnhookWindowsHookEx(hook_handle_);
+  if (!result) {
+    DVLOG(ERROR) << "Error calling UnhookWindowsHookEx() - GLE = "
+                 << GetLastError();
+    return false;
+  }
+  hook_handle_ = NULL;
+  return true;
+}
+
+bool KeyboardInterceptRegistration::IsKeyboardEventQueueEmpty() {
+  return keyboard_events_.empty();
+}
+
+void KeyboardInterceptRegistration::QueueKeyboardEvent(
+    const KeyboardEventInfo& info) {
+  keyboard_events_.push(info);
+}
+
+KeyboardEventInfo KeyboardInterceptRegistration::DequeueKeyboardEvent() {
+  KeyboardEventInfo info = keyboard_events_.front();
+  keyboard_events_.pop();
+  return info;
+}
+
+LowLevelHookHandler::LowLevelHookHandler()
+    : message_filter_hook_(NULL),
+      restore_keyboard_state_message_id_(0),
+      inject_keyboard_event_message_id_(0) {
+  restore_keyboard_state_message_id_ =
+      RegisterWindowMessage(L"chrome:restore_keyboard_state");
+  inject_keyboard_event_message_id_ =
+      RegisterWindowMessage(L"chrome:inject_keyboard_event");
+}
+
+LowLevelHookHandler::~LowLevelHookHandler() {
+  UnregisterMessageFilter();
+}
+
+// static
+LRESULT CALLBACK
+LowLevelHookHandler::KeyboardHook(int code, WPARAM w_param, LPARAM l_param) {
+  return GetInstance()->HandleKeyboardHook(code, w_param, l_param);
+}
+
+// static
+LRESULT CALLBACK LowLevelHookHandler::MessageFilterHook(int code,
+                                                        WPARAM w_param,
+                                                        LPARAM l_param) {
+  return GetInstance()->HandleMessageFilterHook(code, w_param, l_param);
+}
+
+// static
+LowLevelHookHandler* LowLevelHookHandler::GetInstance() {
+  return Singleton<LowLevelHookHandler,
+                   DefaultSingletonTraits<LowLevelHookHandler> >::get();
+}
+
+void LowLevelHookHandler::Register(HWND window_handle) {
+  if (registrations_.contains(window_handle))
+    return;
+
+  if (!RegisterMessageFilter())
+    return;
+
+  scoped_ptr<KeyboardInterceptRegistration> registration(
+      new KeyboardInterceptRegistration());
+  if (registration->Hook(KeyboardHook)) {

[ananta, 2014/08/12 17:51:49]

We can record the window handle but register once if that is doable

[Sriram, 2014/08/12 19:02:49]

Done.

+    registrations_.add(window_handle, registration.Pass());
+  }
+}
+
+void LowLevelHookHandler::Deregister(HWND window_handle) {
+  registrations_.erase(window_handle);
+  if (registrations_.empty())
+    UnregisterMessageFilter();
+
+  DVLOG(1) << "Keyboard hook unregistered for handle = " << window_handle;
+}
+
+bool LowLevelHookHandler::RegisterMessageFilter() {
+  if (message_filter_hook_)
+    return true;
+
+  message_filter_hook_ = SetWindowsHookEx(
+      WH_MSGFILTER, MessageFilterHook, NULL, GetCurrentThreadId());
+  if (message_filter_hook_ == NULL) {
+    DVLOG(ERROR) << "Error calling SetWindowsHookEx() to set message hook, "
+                 << "gle = " << GetLastError();
+    return false;
+  }
+  return true;
+}
+
+void LowLevelHookHandler::UnregisterMessageFilter() {
+  if (message_filter_hook_ != NULL) {
+    UnhookWindowsHookEx(message_filter_hook_);
+    message_filter_hook_ = NULL;
+  }
+}
+
+LRESULT
+LowLevelHookHandler::HandleMessageFilterHook(int code,
+                                             WPARAM w_param,
+                                             LPARAM l_param) {
+  // Ignore if not called from main message loop.
+  if (code != base::MessagePumpForUI::kMessageFilterCode)

[ananta, 2014/08/12 17:51:49]

Shouldn't we be calling CallNextHookEx here?

[Sriram, 2014/08/12 19:02:49]

Done.

+    return false;
+
+  MSG* msg = reinterpret_cast<MSG*>(l_param);
+  if (msg->message == restore_keyboard_state_message_id_) {
+    RestoreKeyboardState(msg->wParam);
+    return true;
+  } else if (msg->message == inject_keyboard_event_message_id_) {
+    KeyboardInterceptRegistration* registration = registrations_.get(msg->hwnd);
+    if (registration) {
+      // Post keyboard state and key event to main thread for processing.
+      KeyboardEventInfo event_info = registration->DequeueKeyboardEvent();
+      PostMessage(msg->hwnd,
+                  restore_keyboard_state_message_id_,
+                  event_info.keyboard_state_to_restore,
+                  static_cast<LPARAM>(0));
+
+      PostMessage(msg->hwnd,
+                  event_info.message_id,
+                  event_info.event_w_param,
+                  event_info.event_l_param);
+
+      if (!registration->IsKeyboardEventQueueEmpty()) {
+        // Post another inject keyboard event if there are more key events to
+        // process after the current injected event is processed.
+        PostMessage(msg->hwnd,
+                    inject_keyboard_event_message_id_,
+                    static_cast<WPARAM>(0),
+                    static_cast<LPARAM>(0));
+      }
+
+      return true;
+    }
+  }
+
+  return false;
+}
+
+LRESULT
+LowLevelHookHandler::HandleKeyboardHook(int code,
+                                        WPARAM w_param,
+                                        LPARAM l_param) {
+  HWND current_active_window = GetActiveWindow();
+
+  if (code >= 0) {
+    KeyboardInterceptRegistration* registration =
+        registrations_.get(current_active_window);
+    if (registration) {
+      // Save keyboard state to queue and post message to handle keyboard event
+      // if the queue is not empty. It is done this way as keyboard state should
+      // be preserved until char event corresponding to the keyboard event is
+      // handled (so correct alt/shift/control key state is set). Also
+      // SendMessage() cannot be used as it would bypass both message loop
+      // delegates and TransalateMessage() calls (which will inserts char
+      // events).
+      PKBDLLHOOKSTRUCT hook_struct =
+          reinterpret_cast<PKBDLLHOOKSTRUCT>(l_param);
+
+      KeyboardEventInfo event_info = {0};
+      event_info.message_id = w_param;
+      event_info.event_w_param = RemoveLocationOnKeycode(hook_struct->vkCode);
+      event_info.event_l_param = GetLParamFromHookStruct(w_param, hook_struct);
+      event_info.keyboard_state_to_restore = SaveKeyboardState();
+
+      bool should_queue_inject_event =
+          registration->IsKeyboardEventQueueEmpty();
+
+      registration->QueueKeyboardEvent(event_info);
+      if (should_queue_inject_event) {
+        PostMessage(current_active_window,
+                    inject_keyboard_event_message_id_,
+                    static_cast<WPARAM>(0),
+                    static_cast<LPARAM>(0));
+      }
+      return 1;
+    }
+  }
+
+  return CallNextHookEx(NULL, code, w_param, l_param);
+}
+
+}  // namespace
+
+namespace views {
+
+DesktopKeyboardCaptureWin::DesktopKeyboardCaptureWin(HWND window_handle)
+    : window_handle_(window_handle) {
+  LowLevelHookHandler::GetInstance()->Register(window_handle_);

[ananta, 2014/08/12 17:51:49]

Registering on a per window basis seems like overkill. In any case low level
keyboard hooks are expensive due to
the context switches involved from the thread for which the input was intended
to the keyboard hook thread.

We should do this once for the main thread. 

[Sriram, 2014/08/12 19:02:49]

Changed to register low level hook per thread but left the keyboard hook
handling to be per window.

On 2014/08/12 17:51:49, ananta wrote:

+}
+
+DesktopKeyboardCaptureWin::~DesktopKeyboardCaptureWin() {
+  LowLevelHookHandler::GetInstance()->Deregister(window_handle_);
+}
+
+}  // namespace views