Add a new constructor to KeyEvent.

views/controls/textfield/native_textfield_win.cc

 // Copyright (c) 2011 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 "views/controls/textfield/native_textfield_win.h"
 
 #include <algorithm>
 
 #include "base/i18n/rtl.h"
 #include "base/string_util.h"
@@ skipping 470 matching lines @@
       CHILDID_SELF, PROPID_ACC_VALUE, value.c_str());
 
   ::NotifyWinEvent(EVENT_OBJECT_VALUECHANGE, m_hWnd, OBJID_CLIENT,
                    CHILDID_SELF);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeTextfieldWin, private:
 
 void NativeTextfieldWin::OnChar(TCHAR ch, UINT repeat_count, UINT flags) {
-  HandleKeystroke(GetCurrentMessage()->message, ch, repeat_count, flags);
+  HandleKeystroke();
 }
 
 void NativeTextfieldWin::OnContextMenu(HWND window, const POINT& point) {
   POINT p(point);
   if (point.x == -1 || point.y == -1) {
     GetCaretPos(&p);
     MapWindowPoints(HWND_DESKTOP, &p, 1);
   }
   BuildContextMenu();
   context_menu_->RunContextMenuAt(gfx::Point(p));
@@ skipping 178 matching lines @@
 
     case VK_PROCESSKEY:
       // This key event is consumed by an IME.
       // We ignore this event because an IME sends WM_IME_COMPOSITION messages
       // when it updates the CRichEditCtrl text.
       return;
   }
 
   // CRichEditCtrl changes its text on WM_KEYDOWN instead of WM_CHAR for many
   // different keys (backspace, ctrl-v, ...), so we call this in both cases.
-  HandleKeystroke(GetCurrentMessage()->message, key, repeat_count, flags);
+  HandleKeystroke();
 }
 
 void NativeTextfieldWin::OnLButtonDblClk(UINT keys, const CPoint& point) {
   // Save the double click info for later triple-click detection.
   tracking_double_click_ = true;
   double_click_point_ = point;
   double_click_time_ = GetCurrentMessage()->time;
 
   ScopedFreeze freeze(this, GetTextObjectModel());
   OnBeforePossibleChange();
@@ skipping 223 matching lines @@
   // useful, so we discard most.  Exceptions:
   //   * ctrl-alt-<xxx>, which is sometimes important, generates WM_CHAR instead
   //     of WM_SYSCHAR, so it doesn't need to be handled here.
   //   * alt-space gets translated by the default WM_SYSCHAR handler to a
   //     WM_SYSCOMMAND to open the application context menu, so we need to allow
   //     it through.
   if (ch == VK_SPACE)
     SetMsgHandled(false);
 }
 
-void NativeTextfieldWin::HandleKeystroke(UINT message,
-                                         TCHAR key,
-                                         UINT repeat_count,
-                                         UINT flags) {
+void NativeTextfieldWin::HandleKeystroke() {
+  const MSG* msg = GetCurrentMessage();
   ScopedFreeze freeze(this, GetTextObjectModel());
 
   Textfield::Controller* controller = textfield_->GetController();
   bool handled = false;
   if (controller) {
-    ui::EventType type;
-    switch (message) {
-      case WM_KEYDOWN:
-      case WM_SYSKEYDOWN:
-      case WM_CHAR:
-      case WM_SYSCHAR:
-        type = ui::ET_KEY_PRESSED;
-        break;
-      case WM_KEYUP:
-      case WM_SYSKEYUP:
-        type = ui::ET_KEY_RELEASED;
-        break;
-      default:
-        NOTREACHED() << "Unknown message:" << message;
-        // Passing through to avoid crash on release build.
-        type = ui::ET_KEY_PRESSED;
-    }
-    KeyEvent key_event(type,
-                       ui::KeyboardCodeForWindowsKeyCode(key),
-                       KeyEvent::GetKeyStateFlags(),
-                       repeat_count,
-                       flags,
-                       message);
-    handled = controller->HandleKeyEvent(textfield_, key_event);
+    KeyEvent event(*msg);
+    handled = controller->HandleKeyEvent(textfield_, event);
   }
 
   if (!handled) {
     OnBeforePossibleChange();
 
-    if (key == ui::VKEY_HOME || key == ui::VKEY_END) {
+    if (msg->wParam == ui::VKEY_HOME || msg->wParam == ui::VKEY_END) {
       // DefWindowProc() might reset the keyboard layout when it receives a
       // keydown event for VKEY_HOME or VKEY_END. When the window was created
       // with WS_EX_LAYOUTRTL and the current keyboard layout is not a RTL one,
       // if the input text is pure LTR text, the layout changes to the first RTL
       // keyboard layout in keyboard layout queue; if the input text is
       // bidirectional text, the layout changes to the keyboard layout of the
       // first RTL character in input text. When the window was created without
       // WS_EX_LAYOUTRTL and the current keyboard layout is not a LTR one, if
       // the input text is pure RTL text, the layout changes to English; if the
       // input text is bidirectional text, the layout changes to the keyboard
       // layout of the first LTR character in input text. Such keyboard layout
       // change behavior is surprising and inconsistent with keyboard behavior
       // elsewhere, so reset the layout in this case.
       HKL layout = GetKeyboardLayout(0);
-      DefWindowProc(message, key, MAKELPARAM(repeat_count, flags));
+      DefWindowProc(msg->message, msg->wParam, msg->lParam);
       ActivateKeyboardLayout(layout, KLF_REORDER);
     } else {
-      DefWindowProc(message, key, MAKELPARAM(repeat_count, flags));
+      DefWindowProc(msg->message, msg->wParam, msg->lParam);
     }
 
     // CRichEditCtrl automatically turns on IMF_AUTOKEYBOARD when the user
     // inputs an RTL character, making it difficult for the user to control
     // what language is set as they type. Force this off to make the edit's
     // behavior more stable.
     const int lang_options = SendMessage(EM_GETLANGOPTIONS, 0, 0);
     if (lang_options & IMF_AUTOKEYBOARD)
       SendMessage(EM_SETLANGOPTIONS, 0, lang_options & ~IMF_AUTOKEYBOARD);
 
@@ skipping 161 matching lines @@
 NativeTextfieldWrapper* NativeTextfieldWrapper::CreateWrapper(
     Textfield* field) {
   if (NativeTextfieldViews::IsTextfieldViewsEnabled()) {
     return new NativeTextfieldViews(field);
   } else {
     return new NativeTextfieldWin(field);
   }
 }
 
 }  // namespace views