AppShell: Create input method and handle key events

extensions/shell/browser/shell_desktop_controller_aura.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 "extensions/shell/browser/shell_desktop_controller_aura.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "extensions/browser/app_window/app_window.h"
 #include "extensions/browser/app_window/native_app_window.h"
+#include "extensions/shell/browser/input_method_event_handler.h"
 #include "extensions/shell/browser/shell_app_delegate.h"
 #include "extensions/shell/browser/shell_app_window_client.h"
 #include "extensions/shell/browser/shell_screen.h"
 #include "extensions/shell/common/switches.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/client/default_capture_client.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/cursor/cursor.h"
 #include "ui/base/cursor/image_cursors.h"
-#include "ui/base/ime/input_method_initializer.h"
+#include "ui/base/ime/input_method.h"
+#include "ui/base/ime/input_method_factory.h"
 #include "ui/base/user_activity/user_activity_detector.h"
 #include "ui/display/screen.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/wm/core/base_focus_rules.h"
 #include "ui/wm/core/compound_event_filter.h"
 #include "ui/wm/core/cursor_manager.h"
 #include "ui/wm/core/focus_controller.h"
 #include "ui/wm/core/native_cursor_manager.h"
 #include "ui/wm/core/native_cursor_manager_delegate.h"
@@ skipping 222 matching lines @@
 #endif
 
 void ShellDesktopControllerAura::OnHostCloseRequested(
     const aura::WindowTreeHost* host) {
   DCHECK_EQ(host_.get(), host);
   CloseAppWindows();
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 }
 
+ui::EventDispatchDetails ShellDesktopControllerAura::DispatchKeyEventPostIME(
+    ui::KeyEvent* key_event) {
+  // The input method has processed this event, so prevent the handler from
+  // dispatching it again.
+  input_method_event_handler_->SetPostIME(true);
+
+  // Send the event on to the host.
+  ui::EventDispatchDetails details =
+      host_->event_processor()->OnEventFromSource(key_event);
+
+  // Clear the handler's PostIME flag for the next event.
+  if (!details.dispatcher_destroyed)
+    input_method_event_handler_->SetPostIME(false);
+
+  return details;
+}
+
 void ShellDesktopControllerAura::InitWindowManager() {
   wm::FocusController* focus_controller =
       new wm::FocusController(new AppsFocusRules());
   aura::client::SetFocusClient(host_->window(), focus_controller);
   host_->window()->AddPreTargetHandler(focus_controller);
   aura::client::SetActivationClient(host_->window(), focus_controller);
   focus_client_.reset(focus_controller);
 
   capture_client_.reset(
       new aura::client::DefaultCaptureClient(host_->window()));
@@ skipping 27 matching lines @@
     CHECK_EQ(2, sscanf(size_str.c_str(), "%dx%d", &width, &height));
     size = gfx::Size(width, height);
   } else {
     size = GetPrimaryDisplaySize();
   }
   if (size.IsEmpty())
     size = gfx::Size(1920, 1080);
 
   screen_.reset(new ShellScreen(size));
   display::Screen::SetScreenInstance(screen_.get());
-  // TODO(mukai): Set up input method.
 
   host_.reset(screen_->CreateHostForPrimaryDisplay());
   aura::client::SetWindowParentingClient(host_->window(), this);
   root_window_event_filter_.reset(new wm::CompoundEventFilter);
   host_->window()->AddPreTargetHandler(root_window_event_filter_.get());
+
+  // Handle key events.
+  input_method_ = ui::CreateInputMethod(this, host_->GetAcceleratedWidget());
+  host_->SetSharedInputMethod(input_method_.get());

[Rahul Chaturvedi, 2016/12/15 22:42:46]

When we're destructing, and input_method_ will no longer be valid, do we need to
unset this?

[michaelpg, 2016/12/15 23:55:52]

Ugh, good point, this isn't quite safe. shuchen, am I abusing
SetSharedInputMethod?

We can achieve the same thing by triggering the host to create the input method
instead, then overriding the input method's delegate to point to us. Then the
host owns the input method. See next patch.

+  input_method_event_handler_.reset(
+      new InputMethodEventHandler(input_method_.get()));
+  host_->window()->AddPreTargetHandler(input_method_event_handler_.get());
+
   InitWindowManager();
 
   host_->AddObserver(this);
 
   // Ensure the X window gets mapped.
   host_->Show();
 }
 
 void ShellDesktopControllerAura::DestroyRootWindow() {
   host_->RemoveObserver(this);
   wm::FocusController* focus_controller =
       static_cast<wm::FocusController*>(focus_client_.get());
   if (focus_controller) {
     host_->window()->RemovePreTargetHandler(focus_controller);
     aura::client::SetActivationClient(host_->window(), NULL);
   }
+
+  host_->window()->RemovePreTargetHandler(input_method_event_handler_.get());
+  input_method_event_handler_.reset();
+
+  host_->window()->RemovePreTargetHandler(root_window_event_filter_.get());
   root_window_event_filter_.reset();
+
   capture_client_.reset();
   focus_client_.reset();
   cursor_manager_.reset();
 #if defined(OS_CHROMEOS)
   user_activity_notifier_.reset();
 #endif
   user_activity_detector_.reset();
   host_.reset();
   screen_.reset();
 }
 
 gfx::Size ShellDesktopControllerAura::GetPrimaryDisplaySize() {
 #if defined(OS_CHROMEOS)
   const ui::DisplayConfigurator::DisplayStateList& displays =
       display_configurator_->cached_displays();
   if (displays.empty())
     return gfx::Size();
   const ui::DisplayMode* mode = displays[0]->current_mode();
   return mode ? mode->size() : gfx::Size();
 #else
   return gfx::Size();
 #endif
 }
 
 }  // namespace extensions