mandoline: Fix character entry in html_viewer on Linux.

components/view_manager/display_manager.cc

 // Copyright 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 "components/view_manager/display_manager.h"
 
 #include "base/numerics/safe_conversions.h"
 #include "components/view_manager/display_manager_factory.h"
 #include "components/view_manager/gles2/gpu_state.h"
 #include "components/view_manager/native_viewport/onscreen_context_provider.h"
@@ skipping 260 matching lines @@
     case ui::ET_TOUCH_PRESSED:
       platform_window_->SetCapture();
       break;
     case ui::ET_MOUSE_RELEASED:
     case ui::ET_TOUCH_RELEASED:
       platform_window_->ReleaseCapture();
       break;
     default:
       break;
   }
+
+#if defined(USE_X11)
+  // We want to emulate the WM_CHAR generation behaviour of Windows.

[Shu Chen, 2015/07/17 01:54:08]

I don't recommend to emulate the WM_CHAR, because WM_KEYDOWN doesn't always
cause a WM_CHAR.

As input method is a platform dependent thing, why not instead implement 2
classes?
 - InputMethodMandolineX11
 - InputMethodMandolineWin

[Elliot Glaysher, 2015/07/17 17:52:35]

This is part of the patch which was a revert. That said, if there are more
detailed rules, we should be following them here, because we want things that
connect to the view_manager to not have to care about platform differences.

+  //
+  // On Linux, we've previously inserted characters by having
+  // InputMethodAuraLinux take all key down events and send a character event
+  // to the TextInputClient. This causes a mismatch in code that has to be
+  // shared between Windows and Linux, including blink code. Now that we're
+  // trying to have one way of doing things, we need to standardize on and
+  // emulate Windows character events.
+  //
+  // This is equivalent to what we're doing in the current Linux port, but
+  // done once instead of done multiple times in different places.
+  if (event->type() == ui::ET_KEY_PRESSED) {
+    ui::KeyEvent* key_press_event = static_cast<ui::KeyEvent*>(event);
+    ui::KeyEvent char_event(key_press_event->GetCharacter(),
+                            key_press_event->key_code(),
+                            key_press_event->flags());
+
+    DCHECK_EQ(key_press_event->GetCharacter(), char_event.GetCharacter());
+    DCHECK_EQ(key_press_event->key_code(), char_event.key_code());
+    DCHECK_EQ(key_press_event->flags(), char_event.flags());
+
+    char_event.SetExtendedKeyEventData(
+        make_scoped_ptr(new mojo::MojoExtendedKeyEventData(
+            key_press_event->GetLocatedWindowsKeyboardCode(),
+            key_press_event->GetText(),
+            key_press_event->GetUnmodifiedText())));
+    char_event.set_platform_keycode(key_press_event->platform_keycode());
+
+    delegate_->OnEvent(mojo::Event::From(char_event));
+  }
+#endif
 }
 
 void DefaultDisplayManager::OnCloseRequest() {
   platform_window_->Close();
 }
 
 void DefaultDisplayManager::OnClosed() {
   delegate_->OnDisplayClosed();
 }
 
 void DefaultDisplayManager::OnWindowStateChanged(
     ui::PlatformWindowState new_state) {
 }
 
 void DefaultDisplayManager::OnLostCapture() {
 }
 
 void DefaultDisplayManager::OnAcceleratedWidgetAvailable(
     gfx::AcceleratedWidget widget,
     float device_pixel_ratio) {
   context_provider_->SetAcceleratedWidget(widget);
   UpdateMetrics(metrics_.size_in_pixels.To<gfx::Size>(), device_pixel_ratio);
 }
 
 void DefaultDisplayManager::OnActivationChanged(bool active) {
 }
 
 }  // namespace view_manager