IME (input method editor) support for Aura, part 3 of 3: Use ui::InputMethod in ash.

ui/aura/root_window.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 "ui/aura/root_window.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 178 matching lines @@
 }
 
 bool RootWindow::DispatchKeyEvent(KeyEvent* event) {
   if (focused_window_) {
     KeyEvent translated_event(*event);
     return ProcessKeyEvent(focused_window_, &translated_event);
   }
   return false;
 }
 
+bool RootWindow::DispatchTranslatedKeyEvent(TranslatedKeyEvent* event) {
+  if (focused_window_) {
+    TranslatedKeyEvent translated_event(*event);
+    return ProcessTranslatedKeyEvent(focused_window_, &translated_event);
+  }
+  return false;
+}
+
 bool RootWindow::DispatchTouchEvent(TouchEvent* event) {
   event->UpdateForTransform(layer()->transform());
   bool handled = false;
   Window* target =
       touch_event_handler_ ? touch_event_handler_ : capture_window_;
   if (!target)
     target = GetEventHandlerForPoint(event->location());
   if (target) {
     TouchEvent translated_event(*event, this, target);
     ui::TouchStatus status = ProcessTouchEvent(target, &translated_event);
@@ skipping 205 matching lines @@
     return false;
 
   EventFilters filters;
   GetEventFiltersToNotify(target, &filters);
   for (EventFilters::const_reverse_iterator it = filters.rbegin();
        it != filters.rend(); ++it) {
     if ((*it)->PreHandleKeyEvent(target, event))
       return true;
   }
 
+  // Usually, an EventFilter bound to an IME (input method) will consume the
+  // |event|. If such EventFilter is not available, the event is dispatched to
+  // the |target|.
   return target->delegate()->OnKeyEvent(event);
 }
 
+bool RootWindow::ProcessTranslatedKeyEvent(Window* target,
+                                           TranslatedKeyEvent* event) {
+  if (!target->IsVisible())
+    return false;
+
+  EventFilters filters;
+  GetEventFiltersToNotify(target, &filters);
+  for (EventFilters::const_reverse_iterator it = filters.rbegin();
+       it != filters.rend(); ++it) {
+    if ((*it)->PreHandleTranslatedKeyEvent(target, event))
+      return true;
+  }
+
+  // If the |filters|, such as a filter for handling global shortcut keys, do
+  // not consume the |event|, dispatch it to the |target| as a normal KeyEvent.
+  // Note that the target->delegate() interface is IME agnostic.
+  return target->delegate()->OnKeyEvent(event);
+}
+
 ui::TouchStatus RootWindow::ProcessTouchEvent(Window* target,
                                               TouchEvent* event) {
   if (!target->IsVisible())
     return ui::TOUCH_STATUS_UNKNOWN;
 
   EventFilters filters;
   GetEventFiltersToNotify(target, &filters);
   for (EventFilters::const_reverse_iterator it = filters.rbegin();
        it != filters.rend(); ++it) {
     ui::TouchStatus status = (*it)->PreHandleTouchEvent(target, event);
@@ skipping 58 matching lines @@
 
 void RootWindow::OnLayerAnimationAborted(
     const ui::LayerAnimationSequence* animation) {
 }
 
 void RootWindow::SetFocusedWindow(Window* focused_window) {
   if (focused_window == focused_window_)
     return;
   if (focused_window && !focused_window->CanFocus())
     return;
-  // The NULL-check of |focused)window| is essential here before asking the
+  // The NULL-check of |focused_window| is essential here before asking the
   // activation client, since it is valid to clear the focus by calling
   // SetFocusedWindow() to NULL.
   if (focused_window && ActivationClient::GetActivationClient() &&
       !ActivationClient::GetActivationClient()->CanFocusWindow(
           focused_window)) {
     return;
   }
 
   if (focused_window_ && focused_window_->delegate())
     focused_window_->delegate()->OnBlur();
@@ skipping 35 matching lines @@
       base::StringToInt(parts[1], &parsed_height) && parsed_height > 0) {
     bounds.set_size(gfx::Size(parsed_width, parsed_height));
   } else if (use_fullscreen_host_window_) {
     bounds = gfx::Rect(RootWindowHost::GetNativeScreenSize());
   }
 
   return bounds;
 }
 
 }  // namespace aura