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 69 matching lines @@
   result->reset(reader.ReadToValue(json));
   if (!result->get()) {
     DLOG(ERROR) << reader.GetErrorMessage();
     return false;
   }
 
   return true;
 }
 
 void BuildSimpleWebKeyEvent(WebKit::WebInputEvent::Type type,
-                            ui::KeyboardCode key,
+                            ui::KeyboardCode keyCode,
+                            int nativeKeyCode,
                             bool control,
                             bool shift,
                             bool alt,
                             bool command,
                             NativeWebKeyboardEvent* event) {
-  event->nativeKeyCode = 0;
-  event->windowsKeyCode = key;
+  event->nativeKeyCode = nativeKeyCode;
+  event->windowsKeyCode = keyCode;
   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;
+    event->text[0] = keyCode;
+    event->unmodifiedText[0] = keyCode;
   }
 
   if (control)
     event->modifiers |= WebKit::WebInputEvent::ControlKey;
 
   if (shift)
     event->modifiers |= WebKit::WebInputEvent::ShiftKey;
 
   if (alt)
     event->modifiers |= WebKit::WebInputEvent::AltKey;
@@ skipping 106 matching lines @@
                         WebKit::WebInputEvent::Type type,
                         const gfx::Point& point) {
   WebKit::WebMouseEvent mouse_event;
   mouse_event.type = type;
   mouse_event.x = point.x();
   mouse_event.y = point.y();
   web_contents->GetRenderViewHost()->ForwardMouseEvent(mouse_event);
 }
 
 void SimulateKeyPress(WebContents* web_contents,
-                      ui::KeyboardCode key,
+                      ui::KeyboardCode keyCode,
                       bool control,
                       bool shift,
                       bool alt,
                       bool command) {
+  SimulateKeyPressWithCode(web_contents,

[Sergey Ulanov, 2013/09/05 16:18:16]

nit: there is no need to put each argument to a separate line like this. IMO it
makes this code less readable, and in this case it's also inconsistent with the
rest of the code in this file.

[weitao, 2013/09/05 16:46:33]

Done.

+                           keyCode,
+                           NULL,
+                           control,
+                           shift,
+                           alt,
+                           command);
+}
+
+void SimulateKeyPressWithCode(WebContents* web_contents,
+                              ui::KeyboardCode keyCode,
+                              const char* code,
+                              bool control,
+                              bool shift,
+                              bool alt,
+                              bool command) {
+  int nativeKeyCode = CodeToNativeKeycode(code);
+
   NativeWebKeyboardEvent event_down;
   BuildSimpleWebKeyEvent(
-      WebKit::WebInputEvent::RawKeyDown, key, control, shift, alt, command,
+      WebKit::WebInputEvent::RawKeyDown,
+      keyCode,
+      nativeKeyCode,
+      control,
+      shift,
+      alt,
+      command,
       &event_down);
   web_contents->GetRenderViewHost()->ForwardKeyboardEvent(event_down);
 
   NativeWebKeyboardEvent char_event;
   BuildSimpleWebKeyEvent(
-      WebKit::WebInputEvent::Char, key, control, shift, alt, command,
+      WebKit::WebInputEvent::Char,
+      keyCode,
+      nativeKeyCode,
+      control,
+      shift,
+      alt,
+      command,
       &char_event);
   web_contents->GetRenderViewHost()->ForwardKeyboardEvent(char_event);
 
   NativeWebKeyboardEvent event_up;
   BuildSimpleWebKeyEvent(
-      WebKit::WebInputEvent::KeyUp, key, control, shift, alt, command,
+      WebKit::WebInputEvent::KeyUp,
+      keyCode,
+      nativeKeyCode,
+      control,
+      shift,
+      alt,
+      command,
       &event_up);
   web_contents->GetRenderViewHost()->ForwardKeyboardEvent(event_up);
 }
 
 namespace internal {
 
 ToRenderViewHost::ToRenderViewHost(WebContents* web_contents)
     : render_view_host_(web_contents->GetRenderViewHost()) {
 }
 
@@ skipping 241 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