DevTools: Forward whitelisted unhandled shortcuts from inspected page into DevTools frontend

chrome/browser/devtools/devtools_window.cc

 // Copyright (c) 2012 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 "chrome/browser/devtools/devtools_window.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
@@ skipping 36 matching lines @@
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/devtools_client_host.h"
 #include "content/public/browser/devtools_manager.h"
 #include "content/public/browser/favicon_status.h"
 #include "content/public/browser/load_notification_details.h"
+#include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/browser/web_contents_view.h"
 #include "content/public/common/bindings_policy.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/page_transition_types.h"
 #include "content/public/common/renderer_preferences.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/test/test_utils.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/extension_set.h"
 #include "grit/generated_resources.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/base/l10n/l10n_util.h"
+#include "ui/events/keycodes/keyboard_codes.h"
 
 using base::DictionaryValue;
+using blink::WebInputEvent;
 using content::BrowserThread;
 using content::DevToolsAgentHost;
 
 
 // DevToolsConfirmInfoBarDelegate ---------------------------------------------
 
 class DevToolsConfirmInfoBarDelegate : public ConfirmInfoBarDelegate {
  public:
   // If |infobar_service| is NULL, runs |callback| with a single argument with
   // value "false".  Otherwise, creates a dev tools confirm infobar and delegate
@@ skipping 1134 matching lines @@
     return;
   }
   file_system_indexer_->SearchInPath(file_system_path,
                                      query,
                                      Bind(&DevToolsWindow::SearchCompleted,
                                           weak_factory_.GetWeakPtr(),
                                           request_id,
                                           file_system_path));
 }
 
+static inline int hashKeyCodeAndModifiers(int keyCode, int modifiers) {

[Tom Sepez, 2014/04/07 18:01:14]

nit: this isn't really a "hash" per-se, in that it encompasses all the
information needed to make the test later on without the possibility of
collision. Maybe combineKeyCodeAndModifiers()?

[apavlov, 2014/04/08 10:11:31]

Done.

+  return keyCode | (modifiers << 16);
+}
+
+void DevToolsWindow::SetWhitelistedShortcuts(const std::string& message) {

[Tom Sepez, 2014/04/07 18:01:14]

You'll probably want to check here that the keycode the devtools is asking to be
whitelisted is sane, just because we can.  In other words, it should have
modifiers or some such.  It might be bad if the devtools could steal every
keystroke, even for things like normal letters and numbers, no?

[apavlov, 2014/04/08 10:11:31]

Good point. For now, let's allow keys with modifiers and F-keys. Sounds good?

+  scoped_ptr<base::Value> parsed_message(base::JSONReader::Read(message));
+  base::ListValue* shortcut_list;
+  if (!parsed_message->GetAsList(&shortcut_list))
+      return;
+  base::ListValue::iterator it = shortcut_list->begin();
+  for (; it != shortcut_list->end(); ++it) {
+    base::DictionaryValue* dictionary;
+    if (!(*it)->GetAsDictionary(&dictionary))
+      continue;
+    int keyCode = 0;
+    dictionary->GetInteger("keyCode", &keyCode);
+    if (keyCode == 0)
+      continue;
+    int modifiers = 0;
+    dictionary->GetInteger("modifiers", &modifiers);
+    whitelisted_keys_.push_back(hashKeyCodeAndModifiers(keyCode, modifiers));
+  }
+}
+
 void DevToolsWindow::ZoomIn() {
   chrome_page_zoom::Zoom(web_contents(), content::PAGE_ZOOM_IN);
 }
 
 void DevToolsWindow::ZoomOut() {
   chrome_page_zoom::Zoom(web_contents(), content::PAGE_ZOOM_OUT);
 }
 
 void DevToolsWindow::ResetZoom() {
   chrome_page_zoom::Zoom(web_contents(), content::PAGE_ZOOM_RESET);
@@ skipping 291 matching lines @@
 }
 
 void DevToolsWindow::SetLoadCompletedCallback(const base::Closure& closure) {
   if (load_state_ == kLoadCompleted) {
     if (!closure.is_null())
       closure.Run();
     return;
   }
   load_completed_callback_ = closure;
 }
+
+static inline int windowsVirtualKeyCodeWithoutLocation(int keycode)

[Tom Sepez, 2014/04/07 18:01:14]

nit:  if you want to call this windows... I'd expect to see an #ifdef windows
around it. But clearly this benign in all cases, even on linux, and the name
means that only windows is (persumably dumb enough) to care about which ctrl key
we pressed (so as to enable insane different behaviours for each key as
desired). So the limited bloat probably outweighs the ugliness of the #ifdefs. 
I'd call it virtualKeyCodeWithoutLocation() though; this would be fine without
any ifdef's.

[apavlov, 2014/04/08 10:11:31]

Yeah, I just wanted to make it consistent with the Blink code (where I sto..
borrowed this function from.) But guess just having a comment referring to the
origin will be fine.

+{
+  switch (keycode) {
+    case ui::VKEY_LCONTROL:
+    case ui::VKEY_RCONTROL:
+        return ui::VKEY_CONTROL;
+    case ui::VKEY_LSHIFT:
+    case ui::VKEY_RSHIFT:
+        return ui::VKEY_SHIFT;
+    case ui::VKEY_LMENU:
+    case ui::VKEY_RMENU:
+        return ui::VKEY_MENU;
+    default:
+        return keycode;
+  }
+}
+
+bool DevToolsWindow::ForwardKeyboardEvent(
+    const content::NativeWebKeyboardEvent& event) {
+  std::string event_type;
+  switch (event.type) {
+    case WebInputEvent::KeyDown:
+    case WebInputEvent::RawKeyDown:
+      event_type = "keydown";
+      break;
+    case WebInputEvent::KeyUp:
+      event_type = "keyup";
+      break;
+    default:
+      return false;
+  }
+
+  int keyCode = windowsVirtualKeyCodeWithoutLocation(event.windowsKeyCode);
+  int hash = hashKeyCodeAndModifiers(keyCode, event.modifiers);
+  if (std::find(whitelisted_keys_.begin(), whitelisted_keys_.end(), hash) ==
+      whitelisted_keys_.end())
+    return false;
+
+  base::DictionaryValue event_data;
+  event_data.SetString("type", event_type);
+  event_data.SetString("keyIdentifier", event.keyIdentifier);
+  event_data.SetInteger("keyCode", keyCode);
+  event_data.SetInteger("modifiers", event.modifiers);
+  CallClientFunction(
+      "InspectorFrontendAPI.keyEventUnhandled", &event_data, NULL, NULL);
+  return true;
+}