Refactoring the ownership of ui::InputMethod.

ui/aura/window_tree_host.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/aura/window_tree_host.h"
 
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_targeter.h"
 #include "ui/aura/window_tree_host_observer.h"
+#include "ui/base/ime/input_method.h"
+#include "ui/base/ime/input_method_factory.h"
 #include "ui/base/view_prop.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/point3_f.h"
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/screen.h"
 
 namespace aura {
 
 const char kWindowTreeHostForAcceleratedWidget[] =
     "__AURA_WINDOW_TREE_HOST_ACCELERATED_WIDGET__";
 
 float GetDeviceScaleFactorFromDisplay(Window* window) {
   gfx::Display display = gfx::Screen::GetScreenFor(window)->
       GetDisplayNearestWindow(window);
   DCHECK(display.is_valid());
   return display.device_scale_factor();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowTreeHost, public:
 
 WindowTreeHost::~WindowTreeHost() {
   DCHECK(!compositor_) << "compositor must be destroyed before root window";
+  if (owned_input_method_) {
+    delete input_method_;
+    input_method_ = nullptr;
+  }
 }
 
 #if defined(OS_ANDROID)
 // static
 WindowTreeHost* WindowTreeHost::Create(const gfx::Rect& bounds) {
   // This is only hit for tests and ash, right now these aren't an issue so
   // adding the CHECK.
   // TODO(sky): decide if we want a factory.
   CHECK(false);
   return NULL;
@@ skipping 116 matching lines @@
   gfx::Point root_location(host_location);
   ConvertPointFromHost(&root_location);
   MoveCursorToInternal(root_location, host_location);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowTreeHost, protected:
 
 WindowTreeHost::WindowTreeHost()
     : window_(new Window(NULL)),
-      last_cursor_(ui::kCursorNull) {
+      last_cursor_(ui::kCursorNull),
+      input_method_(NULL),

[James Su, 2015/06/03 06:41:16]

nullptr?

[Shu Chen, 2015/06/03 07:29:57]

Done.

+      owned_input_method_(false) {
+}
+
+ui::InputMethod* WindowTreeHost::GetInputMethod() {
+  if (!input_method_) {
+    input_method_ =
+        ui::CreateInputMethod(this, GetAcceleratedWidget()).release();
+    // Makes sure the input method is focused by default when created.
+    input_method_->OnFocus();
+    owned_input_method_ = true;
+  }
+  return input_method_;
+};
+
+void WindowTreeHost::SetInputMethod(ui::InputMethod* input_method) {
+  DCHECK(!input_method_);
+  input_method_ = input_method;
+  owned_input_method_ = false;
 }
 
 void WindowTreeHost::DestroyCompositor() {
   compositor_.reset();
 }
 
 void WindowTreeHost::DestroyDispatcher() {
   delete window_;
   window_ = NULL;
   dispatcher_.reset();
@@ skipping 61 matching lines @@
 void WindowTreeHost::OnHostActivated() {
   Env::GetInstance()->NotifyHostActivated(this);
 }
 
 void WindowTreeHost::OnHostLostWindowCapture() {
   Window* capture_window = client::GetCaptureWindow(window());
   if (capture_window && capture_window->GetRootWindow() == window())
     capture_window->ReleaseCapture();
 }
 
+bool WindowTreeHost::DispatchKeyEventPostIME(const ui::KeyEvent& event) {
+  ui::KeyEvent copied_event(event);
+  ui::EventDispatchDetails details =
+      event_processor()->OnEventFromSource(&copied_event);
+  DCHECK(!details.dispatcher_destroyed);
+  return copied_event.handled();
+}
+
+ui::EventProcessor* WindowTreeHost::GetEventProcessor() {
+  return event_processor();
+}
+
+ui::EventDispatchDetails WindowTreeHost::DeliverEventToProcessor(
+    ui::Event* event) {
+  if (event->IsKeyEvent()) {
+    if (GetInputMethod()->DispatchKeyEvent(
+            *static_cast<ui::KeyEvent*>(event))) {
+      event->StopPropagation();
+      return ui::EventDispatchDetails();
+    }
+  }
+  return ui::EventSource::DeliverEventToProcessor(event);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // WindowTreeHost, private:
 
 void WindowTreeHost::MoveCursorToInternal(const gfx::Point& root_location,
                                           const gfx::Point& host_location) {
   last_cursor_request_position_in_host_ = host_location;
   MoveCursorToNative(host_location);
   client::CursorClient* cursor_client = client::GetCursorClient(window());
   if (cursor_client) {
     const gfx::Display& display =
         gfx::Screen::GetScreenFor(window())->GetDisplayNearestWindow(window());
     cursor_client->SetDisplay(display);
   }
   dispatcher()->OnCursorMovedToRootLocation(root_location);
 }
 
 }  // namespace aura