Refactoring for the InputMethod & InputMethodDelegate interfaces.

ui/base/ime/input_method_win.cc

 // Copyright (c) 2012 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/base/ime/input_method_win.h"
 
 #include "base/auto_reset.h"
 #include "base/basictypes.h"
 #include "base/profiler/scoped_tracker.h"
 #include "ui/base/ime/text_input_client.h"
@@ skipping 15 matching lines @@
 }  // namespace
 
 InputMethodWin::InputMethodWin(internal::InputMethodDelegate* delegate,
                                HWND toplevel_window_handle)
     : toplevel_window_handle_(toplevel_window_handle),
       pending_requested_direction_(base::i18n::UNKNOWN_DIRECTION),
       accept_carriage_return_(false),
       enabled_(false),
       is_candidate_popup_open_(false),
       composing_window_handle_(NULL),
-      suppress_next_char_(false),
-      destroyed_ptr_(nullptr) {
+      suppress_next_char_(false) {
   SetDelegate(delegate);
 }
 
-InputMethodWin::~InputMethodWin() {
-  if (destroyed_ptr_)
-    *destroyed_ptr_ = true;
-}
-
 void InputMethodWin::OnFocus() {
   InputMethodBase::OnFocus();
   if (GetTextInputClient())
     UpdateIMEState();
 }
 
 void InputMethodWin::OnBlur() {
   ConfirmCompositionText();
   // Gets the focused text input client before calling parent's OnBlur() because
   // it will cause GetTextInputClient() returns NULL.
@@ skipping 41 matching lines @@
       break;
     default:
       NOTREACHED() << "Unknown IME message:" << event.message;
       break;
   }
   if (result)
     *result = original_result;
   return !!handled;
 }
 
-bool InputMethodWin::DispatchKeyEvent(const ui::KeyEvent& event) {
-  if (!event.HasNativeEvent())
-    return DispatchFabricatedKeyEvent(event);
+void InputMethodWin::DispatchKeyEvent(ui::KeyEvent* event) {
+  if (!event->HasNativeEvent()) {
+    DispatchFabricatedKeyEvent(event);
+    return;
+  }
 
-  const base::NativeEvent& native_key_event = event.native_event();
+  const base::NativeEvent& native_key_event = event->native_event();
   if (native_key_event.message == WM_CHAR) {
     BOOL handled;
     OnChar(native_key_event.hwnd, native_key_event.message,
            native_key_event.wParam, native_key_event.lParam, &handled);
-    return !!handled;  // Don't send WM_CHAR for post event processing.
+    if (handled)
+      event->StopPropagation();
+    return;
   }
   // Handles ctrl-shift key to change text direction and layout alignment.
   if (ui::IMM32Manager::IsRTLKeyboardLayoutInstalled() &&
       !IsTextInputTypeNone()) {
     // TODO: shouldn't need to generate a KeyEvent here.
     const ui::KeyEvent key(native_key_event);
     ui::KeyboardCode code = key.key_code();
     if (key.type() == ui::ET_KEY_PRESSED) {
       if (code == ui::VKEY_SHIFT) {
         base::i18n::TextDirection dir;
         if (ui::IMM32Manager::IsCtrlShiftPressed(&dir))
           pending_requested_direction_ = dir;
       } else if (code != ui::VKEY_CONTROL) {
         pending_requested_direction_ = base::i18n::UNKNOWN_DIRECTION;
       }
     } else if (key.type() == ui::ET_KEY_RELEASED &&
                (code == ui::VKEY_SHIFT || code == ui::VKEY_CONTROL) &&
                pending_requested_direction_ != base::i18n::UNKNOWN_DIRECTION) {
       GetTextInputClient()->ChangeTextDirectionAndLayoutAlignment(
           pending_requested_direction_);
       pending_requested_direction_ = base::i18n::UNKNOWN_DIRECTION;
     }
   }
 
-  bool destroyed = false;
-  base::AutoReset<bool*> auto_reset(&destroyed_ptr_, &destroyed);
-  bool handled = DispatchKeyEventPostIME(event);
-  if (destroyed)
-    return true;
-  suppress_next_char_ = handled;
-  return handled;
+  ui::EventDispatchDetails details = DispatchKeyEventPostIME(event);
+  if (!details.dispatcher_destroyed)
+    suppress_next_char_ = event->stopped_propagation();
 }
 
 void InputMethodWin::OnTextInputTypeChanged(const TextInputClient* client) {
   if (!IsTextInputClientFocused(client) || !IsWindowFocused(client))
     return;
   imm32_manager_.CancelIME(toplevel_window_handle_);
   UpdateIMEState();
 }
 
 void InputMethodWin::OnCaretBoundsChanged(const TextInputClient* client) {
@@ skipping 426 matching lines @@
     return false;
   // When Aura is enabled, |attached_window_handle| should always be a top-level
   // window. So we can safely assume that |attached_window_handle| is ready for
   // receiving keyboard input as long as it is an active window. This works well
   // even when the |attached_window_handle| becomes active but has not received
   // WM_FOCUS yet.
   return toplevel_window_handle_ &&
       GetActiveWindow() == toplevel_window_handle_;
 }
 
-bool InputMethodWin::DispatchFabricatedKeyEvent(const ui::KeyEvent& event) {
-  if (event.is_char()) {
+void InputMethodWin::DispatchFabricatedKeyEvent(ui::KeyEvent* event) {
+  if (event->is_char()) {
     if (suppress_next_char_) {
       suppress_next_char_ = false;
-      return true;
+      return;
     }
     if (GetTextInputClient()) {
       GetTextInputClient()->InsertChar(
-          static_cast<base::char16>(event.key_code()),
+          static_cast<base::char16>(event->key_code()),
           ui::GetModifiersFromKeyState());
-      return true;
+      return;
     }
   }
-  return DispatchKeyEventPostIME(event);
+  ignore_result(DispatchKeyEventPostIME(event));
 }
 
 void InputMethodWin::ConfirmCompositionText() {
   if (composing_window_handle_)
     imm32_manager_.CleanupComposition(composing_window_handle_);
 
   if (!IsTextInputTypeNone()) {
     // Though above line should confirm the client's composition text by sending
     // a result text to us, in case the input method and the client are in
     // inconsistent states, we check the client's composition state again.
@@ skipping 19 matching lines @@
       enabled_ = true;
       break;
   }
 
   imm32_manager_.SetTextInputMode(window_handle, text_input_mode);
   tsf_inputscope::SetInputScopeForTsfUnawareWindow(
       window_handle, text_input_type, text_input_mode);
 }
 
 }  // namespace ui