Add a CodeToNativeKeycode helper that converts UIEvent code to native code.

content/public/test/browser_test_utils.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 "content/public/test/browser_test_utils.h"
 
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/path_service.h"
 #include "base/process/kill.h"
@@ skipping 13 matching lines @@
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/browser/web_contents_view.h"
 #include "content/public/test/test_utils.h"
 #include "grit/webui_resources.h"
 #include "net/base/net_util.h"
 #include "net/cookies/cookie_store.h"
 #include "net/test/python_utils.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "testing/gtest/include/gtest/gtest.h"
+
+#if defined(OS_WIN)
+#define USB_KEYMAP(usb, xkb, win, mac, code) {usb, win, code}
+#elif defined(OS_LINUX)
+#define USB_KEYMAP(usb, xkb, win, mac, code) {usb, xkb, code}
+#elif defined(OS_MACOSX)
+#define USB_KEYMAP(usb, xkb, win, mac, code) {usb, mac, code}
+#else
+#define USB_KEYMAP(usb, xkb, win, mac, code) {usb, 0, code}
+#endif
+#include "ui/base/keycodes/usb_keycode_map.h"
+#undef USB_KEYMAP
+
 #include "ui/base/resource/resource_bundle.h"
 
 static const int kDefaultWsPort = 8880;
 
 namespace content {
 namespace {
 
 class DOMOperationObserver : public NotificationObserver,
                              public WebContentsObserver {
  public:
@@ skipping 70 matching lines @@
   if (!result->get()) {
     DLOG(ERROR) << reader.GetErrorMessage();
     return false;
   }
 
   return true;
 }
 
 void BuildSimpleWebKeyEvent(WebKit::WebInputEvent::Type type,
                             ui::KeyboardCode key,
+                            int nativeKeyCode,
                             bool control,
                             bool shift,
                             bool alt,
                             bool command,
                             NativeWebKeyboardEvent* event) {
-  event->nativeKeyCode = 0;
+  event->nativeKeyCode = nativeKeyCode;
   event->windowsKeyCode = key;
   event->setKeyIdentifierFromWindowsKeyCode();
   event->type = type;
   event->modifiers = 0;
   event->isSystemKey = false;
   event->timeStampSeconds = base::Time::Now().ToDoubleT();
   event->skip_in_browser = true;
 
   if (type == WebKit::WebInputEvent::Char ||
       type == WebKit::WebInputEvent::RawKeyDown) {
     event->text[0] = key;
     event->unmodifiedText[0] = key;
   }
 
   if (control)
     event->modifiers |= WebKit::WebInputEvent::ControlKey;
 
   if (shift)
     event->modifiers |= WebKit::WebInputEvent::ShiftKey;
 
   if (alt)
     event->modifiers |= WebKit::WebInputEvent::AltKey;
 
   if (command)
     event->modifiers |= WebKit::WebInputEvent::MetaKey;
 }
 
+void SimulateKeyPress(WebContents* web_contents,
+                      ui::KeyboardCode key,
+                      int nativeKeyCode,
+                      bool control,
+                      bool shift,
+                      bool alt,
+                      bool command) {
+  NativeWebKeyboardEvent event_down;
+  BuildSimpleWebKeyEvent(
+      WebKit::WebInputEvent::RawKeyDown,
+      key,
+      nativeKeyCode,
+      control,
+      shift,
+      alt,
+      command,
+      &event_down);
+  web_contents->GetRenderViewHost()->ForwardKeyboardEvent(event_down);
+
+  NativeWebKeyboardEvent char_event;
+  BuildSimpleWebKeyEvent(
+      WebKit::WebInputEvent::RawKeyDown,
+      key,
+      nativeKeyCode,
+      control,
+      shift,
+      alt,
+      command,
+      &char_event);
+  web_contents->GetRenderViewHost()->ForwardKeyboardEvent(char_event);
+
+  NativeWebKeyboardEvent event_up;
+  BuildSimpleWebKeyEvent(
+      WebKit::WebInputEvent::RawKeyDown,
+      key,
+      nativeKeyCode,
+      control,
+      shift,
+      alt,
+      command,
+      &event_up);
+  web_contents->GetRenderViewHost()->ForwardKeyboardEvent(event_up);
+}
+
 void GetCookiesCallback(std::string* cookies_out,
                         base::WaitableEvent* event,
                         const std::string& cookies) {
   *cookies_out = cookies;
   event->Signal();
 }
 
 void GetCookiesOnIOThread(const GURL& url,
                           net::URLRequestContextGetter* context_getter,
                           base::WaitableEvent* event,
@@ skipping 96 matching lines @@
   mouse_event.y = point.y();
   web_contents->GetRenderViewHost()->ForwardMouseEvent(mouse_event);
 }
 
 void SimulateKeyPress(WebContents* web_contents,
                       ui::KeyboardCode key,
                       bool control,
                       bool shift,
                       bool alt,
                       bool command) {
-  NativeWebKeyboardEvent event_down;
-  BuildSimpleWebKeyEvent(
-      WebKit::WebInputEvent::RawKeyDown, key, control, shift, alt, command,
-      &event_down);
-  web_contents->GetRenderViewHost()->ForwardKeyboardEvent(event_down);
+  SimulateKeyPress(web_contents, key, 0, control, shift, alt, command);
+}
 
-  NativeWebKeyboardEvent char_event;
-  BuildSimpleWebKeyEvent(
-      WebKit::WebInputEvent::Char, key, control, shift, alt, command,
-      &char_event);
-  web_contents->GetRenderViewHost()->ForwardKeyboardEvent(char_event);
-
-  NativeWebKeyboardEvent event_up;
-  BuildSimpleWebKeyEvent(
-      WebKit::WebInputEvent::KeyUp, key, control, shift, alt, command,
-      &event_up);
-  web_contents->GetRenderViewHost()->ForwardKeyboardEvent(event_up);
+void SimulateKeyPress(WebContents* web_contents,
+                      ui::KeyboardCode key,
+                      const char* code,
+                      bool control,
+                      bool shift,
+                      bool alt,
+                      bool command) {
+  int nativeKeyCode = CodeToNativeKeycode(code);
+  SimulateKeyPress(web_contents,
+                   key,
+                   nativeKeyCode,
+                   control,
+                   shift,
+                   alt,
+                   command);
 }
 
 namespace internal {
 
 ToRenderViewHost::ToRenderViewHost(WebContents* web_contents)
     : render_view_host_(web_contents->GetRenderViewHost()) {
 }
 
 ToRenderViewHost::ToRenderViewHost(RenderViewHost* render_view_host)
     : render_view_host_(render_view_host) {
@@ skipping 239 matching lines @@
   // The queue should not be empty, unless we were quit because of a timeout.
   if (message_queue_.empty())
     return false;
   if (message)
     *message = message_queue_.front();
   message_queue_.pop();
   return true;
 }
 
 }  // namespace content