Refactoring the ownership of ui::InputMethod.

ui/keyboard/keyboard_util.cc

 // Copyright (c) 2013 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/keyboard/keyboard_util.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string16.h"
 #include "grit/keyboard_resources.h"
 #include "grit/keyboard_resources_map.h"
 #include "ui/aura/client/aura_constants.h"

[James Cook, 2015/06/01 22:21:00]

Can this be removed?

[Shu Chen, 2015/06/02 04:11:17]

Yes, it can be remvoed.

 #include "ui/aura/window_tree_host.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/base/ime/text_input_client.h"
 #include "ui/events/event_processor.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/dom/dom_code.h"
 #include "ui/events/keycodes/dom/dom_key.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
 #include "ui/events/keycodes/keyboard_code_conversion.h"
 #include "ui/keyboard/keyboard_controller.h"
 #include "ui/keyboard/keyboard_controller_proxy.h"
 #include "ui/keyboard/keyboard_switches.h"
 #include "url/gurl.h"
 
 namespace {
 
 const char kKeyDown[] ="keydown";
 const char kKeyUp[] = "keyup";
 
 void SendProcessKeyEvent(ui::EventType type,
                          aura::WindowTreeHost* host) {
   ui::KeyEvent event(type, ui::VKEY_PROCESSKEY, ui::DomCode::NONE, ui::EF_NONE,
                      ui::DomKey::PROCESS, 0, ui::EventTimeForNow());
-  event.SetTranslated(true);
   ui::EventDispatchDetails details =
       host->event_processor()->OnEventFromSource(&event);
   CHECK(!details.dispatcher_destroyed);
 }
 
 base::LazyInstance<base::Time> g_keyboard_load_time_start =
     LAZY_INSTANCE_INITIALIZER;
 
 bool g_accessibility_keyboard_enabled = false;
 
@@ skipping 225 matching lines @@
   ui::EventType event_type = ui::ET_UNKNOWN;
   if (type == kKeyDown)
     event_type = ui::ET_KEY_PRESSED;
   else if (type == kKeyUp)
     event_type = ui::ET_KEY_RELEASED;
   if (event_type == ui::ET_UNKNOWN)
     return false;
 
   ui::KeyboardCode code = static_cast<ui::KeyboardCode>(key_code);
 
+  ui::InputMethod* input_method = host->GetInputMethod();
   if (code == ui::VKEY_UNKNOWN) {
     // Handling of special printable characters (e.g. accented characters) for
     // which there is no key code.
     if (event_type == ui::ET_KEY_RELEASED) {
-      ui::InputMethod* input_method = host->window()->GetProperty(
-          aura::client::kRootWindowInputMethodKey);
       if (!input_method)
         return false;
 
       ui::TextInputClient* tic = input_method->GetTextInputClient();
 
       SendProcessKeyEvent(ui::ET_KEY_PRESSED, host);
       tic->InsertChar(static_cast<uint16>(key_value), ui::EF_NONE);
       SendProcessKeyEvent(ui::ET_KEY_RELEASED, host);
     }
   } else {
@@ skipping 16 matching lines @@
     if (!key_name.empty())
       dom_code = ui::KeycodeConverter::CodeStringToDomCode(key_name.c_str());
     if (dom_code == ui::DomCode::NONE)
       dom_code = ui::UsLayoutKeyboardCodeToDomCode(code);
     CHECK(dom_code != ui::DomCode::NONE);
     ui::KeyEvent event(
         event_type,
         code,
         dom_code,
         modifiers);
-    ui::EventDispatchDetails details =
-        host->event_processor()->OnEventFromSource(&event);
-    CHECK(!details.dispatcher_destroyed);
+    if (input_method) {
+      input_method->DispatchKeyEvent(event);
+    } else {
+      ui::EventDispatchDetails details =
+          host->event_processor()->OnEventFromSource(&event);
+      CHECK(!details.dispatcher_destroyed);
+    }
   }
   return true;
 }
 
 void MarkKeyboardLoadStarted() {
   if (!g_keyboard_load_time_start.Get().ToInternalValue())
     g_keyboard_load_time_start.Get() = base::Time::Now();
 }
 
 void MarkKeyboardLoadFinished() {
@@ skipping 100 matching lines @@
 }
 
 void LogKeyboardControlEvent(KeyboardControlEvent event) {
   UMA_HISTOGRAM_ENUMERATION(
       "VirtualKeyboard.KeyboardControlEvent",
       event,
       keyboard::KEYBOARD_CONTROL_MAX);
 }
 
 }  // namespace keyboard