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;
+};
+}

[sky, 2014/08/11 22:42:56]

End with // namespace

[Sriram, 2014/08/11 23:49:56]

Done.

+
+namespace views {
+
+// Maintains low level registration for a window.
+class KeyboardInterceptRegistration {

[sky, 2014/08/11 22:42:56]

These classes should be in the anonymous namespace too. You should probably
move:
namespace views {
to 15.

[Sriram, 2014/08/11 23:49:57]

Done.

+ public:
+  KeyboardInterceptRegistration() : hook_handle_(NULL) {}
+
+  ~KeyboardInterceptRegistration() {
+    if (hook_handle_ != NULL)
+      Unhook();
+  }
+
+  // Register for low level hook.
+  bool Hook(HOOKPROC callback_function) {
+    // Make sure that hook is set from main thread as it has to be valid for

[sky, 2014/08/11 22:42:56]

It's confusing that some of these classes are totally inlined and some are a
hanful. In general the same rules for a header should apply here.

[Sriram, 2014/08/11 23:49:57]

Done.

+    // 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;
+  }
+
+  // Unhook registered hook.
+  bool 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 IsKeyboardEventQueueEmpty() { return keyboard_events_.empty(); }
+
+  // Insert keyboard event in the queue.
+  void QueueKeyboardEvent(const KeyboardEventInfo& info) {
+    keyboard_events_.push(info);
+  }
+
+  KeyboardEventInfo DequeueKeyboardEvent() {
+    KeyboardEventInfo info = keyboard_events_.front();
+    keyboard_events_.pop();
+    return info;
+  }
+
+ 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.
+  bool 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()
+      : 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() { UnregisterMessageFilter(); }
+
+  // Check if window handle is registered to intercept keyboard events.
+  bool IsRegistered(HWND handle);

[sky, 2014/08/11 22:42:56]

AFAICT this isn't used.

[Sriram, 2014/08/11 23:49:56]

Done.

+
+  // 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) {
+    return GetInstance()->HandleKeyboardHook(code, w_param, l_param);
+  }
+
+  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) {
+    return GetInstance()->HandleMessageFilterHook(code, w_param, l_param);
+  }
+
+  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_;
+};
+
+// static
+LowLevelHookHandler* LowLevelHookHandler::GetInstance() {
+  return Singleton<LowLevelHookHandler,
+                   DefaultSingletonTraits<LowLevelHookHandler> >::get();
+}
+
+bool LowLevelHookHandler::Register(HWND window_handle) {

[sky, 2014/08/11 22:42:56]

AFAICT you don't actually use the return value.

[Sriram, 2014/08/11 23:49:56]

Done.

+  if (registrations_.contains(window_handle))
+    return false;
+
+  if (!RegisterMessageFilter()) {

[sky, 2014/08/11 22:42:56]

nit: no {}

[Sriram, 2014/08/11 23:49:56]

Done.

[Sriram, 2014/08/11 23:49:56]

Done.

+    return FALSE;

[sky, 2014/08/11 22:42:56]

false

[Sriram, 2014/08/11 23:49:56]

Done.

+  }
+
+  scoped_ptr<KeyboardInterceptRegistration> registration(
+      new KeyboardInterceptRegistration());
+  if (registration->Hook(KeyboardHook)) {

[sky, 2014/08/11 22:42:56]

Why do we hook for each HWND? Shouldn't we only ever allow a single hook?

[Sriram, 2014/08/11 23:49:56]

Currently the scope of register/unregister is controlled outside of this calls
which could result in register being called before unregister is called. I
decided to keep it per HWND to avoid refcouting on registration.

On 2014/08/11 22:42:56, sky wrote:

+    if (registrations_.add(window_handle, registration.Pass()).second)
+      return true;
+  }
+  return false;
+}
+
+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::IsRegistered(HWND handle) {
+  return registrations_.contains(handle);
+}
+
+bool LowLevelHookHandler::RegisterMessageFilter() {
+  if (message_filter_hook_)
+    return TRUE;

[sky, 2014/08/11 22:42:55]

true (in fact go through all make sure you really need caps in any of these (eg
307/309 should be lower case too).

[Sriram, 2014/08/11 23:49:56]

Done.

+
+  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)
+    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) {

[sky, 2014/08/11 22:42:55]

Can you really end up with a situation where there is no one registered for
current_active_window?

[Sriram, 2014/08/11 23:49:56]

Yes, this is possible as you can get a callback after you have called unregister
(based on window API behavior). In this case we don't want to send message.

On 2014/08/11 22:42:55, sky wrote:

[sky, 2014/08/12 16:18:47]

Are you sure about that? Once you unhook you shouldn't see any more messages.

On 2014/08/11 23:49:56, Sriram wrote:

[Sriram, 2014/08/12 16:24:04]

See remarks for UnhookWindowsHookEx():
http://msdn.microsoft.com/en-us/library/windows/desktop/ms644993(v=vs.85).aspx

The hook procedure can be in the state of being called by another thread even
after UnhookWindowsHookEx returns. If the hook procedure is not being called
concurrently, the hook procedure is removed immediately before
UnhookWindowsHookEx returns.


On 2014/08/12 16:18:47, sky wrote:

+      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,

[sky, 2014/08/11 22:42:56]

I don't understand the need to post messages. Can't you process the keyboard
event immediately?

[Sriram, 2014/08/11 23:49:57]

Keyboard events needs to be posted so that char events are interested into
message loop when TranslateMessage() is called after delegates are called. Using
SendMessage() would bypass both which is not ideal and so need to inject one
keyboard event at a time and handling queuing.

On 2014/08/11 22:42:56, sky wrote:

[sky, 2014/08/12 16:18:47]

This seems wrong to me. I'm adding ananta to the review as he knows more about
the low level details like this.

On 2014/08/11 23:49:57, Sriram wrote:

+                    inject_keyboard_event_message_id_,
+                    static_cast<WPARAM>(0),
+                    static_cast<LPARAM>(0));
+      }
+      return 1;
+    }
+  }
+
+  return CallNextHookEx(NULL, code, w_param, l_param);
+}
+
+DesktopKeyboardCaptureWin::DesktopKeyboardCaptureWin(HWND window_handle)
+    : window_handle_(window_handle) {
+  LowLevelHookHandler::GetInstance()->Register(window_handle_);
+}
+
+DesktopKeyboardCaptureWin::~DesktopKeyboardCaptureWin() {
+  LowLevelHookHandler::GetInstance()->Deregister(window_handle_);
+}
+
+}  // namespace views