tiny clean-up: Rename functions to make it clear that they don't depend on Views

views/ime/input_method_ibus.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 "views/ime/input_method_ibus.h"
 
 #include <ibus.h>
 #if defined(TOUCH_UI)
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #endif
 
 #include <algorithm>
 #include <cstring>
 #include <set>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/basictypes.h"
 #include "base/i18n/char_iterator.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/third_party/icu/icu_utf.h"
 #include "base/utf_string_conversions.h"
 #include "ui/base/keycodes/keyboard_codes.h"
+#include "ui/gfx/point.h"
+#include "ui/gfx/rect.h"
 #include "views/events/event.h"
 #include "views/widget/widget.h"
 
 #if defined(USE_AURA) || defined(TOUCH_UI)
 #include "ui/base/keycodes/keyboard_code_conversion_x.h"
 #elif defined(TOOLKIT_USES_GTK)
 #include "ui/base/keycodes/keyboard_code_conversion_gtk.h"
 #endif
 
 namespace {
 
 // A global flag to switch the InputMethod implementation to InputMethodIBus
 bool inputmethod_ibus_enabled = false;
 
-// Converts ibus key state flags to Views event flags.
-int ViewsFlagsFromIBusState(guint32 state) {
+// Converts ibus key state flags to event flags.
+int EventFlagsFromIBusState(guint32 state) {
   return (state & IBUS_LOCK_MASK ? ui::EF_CAPS_LOCK_DOWN : 0) |
          (state & IBUS_CONTROL_MASK ? ui::EF_CONTROL_DOWN : 0) |
          (state & IBUS_SHIFT_MASK ? ui::EF_SHIFT_DOWN : 0) |
          (state & IBUS_MOD1_MASK ? ui::EF_ALT_DOWN : 0) |
          (state & IBUS_BUTTON1_MASK ? ui::EF_LEFT_BUTTON_DOWN : 0) |
          (state & IBUS_BUTTON2_MASK ? ui::EF_MIDDLE_BUTTON_DOWN : 0) |
          (state & IBUS_BUTTON3_MASK ? ui::EF_RIGHT_BUTTON_DOWN : 0);
 }
 
-// Converts Views event flags to ibus key state flags.
-guint32 IBusStateFromViewsFlags(int flags) {
+// Converts event flags to ibus key state flags.
+guint32 IBusStateFromEventFlags(int flags) {
   return (flags & ui::EF_CAPS_LOCK_DOWN ? IBUS_LOCK_MASK : 0) |
          (flags & ui::EF_CONTROL_DOWN ? IBUS_CONTROL_MASK : 0) |
          (flags & ui::EF_SHIFT_DOWN ? IBUS_SHIFT_MASK : 0) |
          (flags & ui::EF_ALT_DOWN ? IBUS_MOD1_MASK : 0) |
          (flags & ui::EF_LEFT_BUTTON_DOWN ? IBUS_BUTTON1_MASK : 0) |
          (flags & ui::EF_MIDDLE_BUTTON_DOWN ? IBUS_BUTTON2_MASK : 0) |
          (flags & ui::EF_RIGHT_BUTTON_DOWN ? IBUS_BUTTON3_MASK : 0);
 }
 
 void IBusKeyEventFromViewsKeyEvent(const views::KeyEvent& key,
@@ skipping 24 matching lines @@
     GdkEventKey* gdk_key = reinterpret_cast<GdkEventKey*>(key.gdk_event());
     *ibus_keyval = gdk_key->keyval;
     *ibus_keycode = gdk_key->hardware_keycode;
   } else {
     *ibus_keyval = ui::GdkKeyCodeForWindowsKeyCode(
         key.key_code(), key.IsShiftDown() ^ key.IsCapsLockDown());
     *ibus_keycode = 0;
   }
 #endif
 
-  *ibus_state = IBusStateFromViewsFlags(key.flags());
+  *ibus_state = IBusStateFromEventFlags(key.flags());
   if (key.type() == ui::ET_KEY_RELEASED)
     *ibus_state |= IBUS_RELEASE_MASK;
 }
 
 void ExtractCompositionTextFromIBusPreedit(IBusText* text,
                                            guint cursor_position,
                                            ui::CompositionText* composition) {
   composition->Clear();
   composition->text = UTF8ToUTF16(text->text);
 
@@ skipping 585 matching lines @@
   // then it means the key event didn't generate any result text. So we need
   // to send corresponding character to the focused text input client.
 
   ui::TextInputClient* client = GetTextInputClient();
   char16 ch = key.GetCharacter();
   if (ch && client)
     client->InsertChar(ch, key.flags());
 }
 
 void InputMethodIBus::ProcessInputMethodResult(const KeyEvent& key,
-                                              bool filtered) {
+                                               bool handled) {
   ui::TextInputClient* client = GetTextInputClient();
   DCHECK(client);
 
   if (result_text_.length()) {
-    if (filtered && NeedInsertChar()) {
+    if (handled && NeedInsertChar()) {
       for (string16::const_iterator i = result_text_.begin();
            i != result_text_.end(); ++i) {
         client->InsertChar(*i, key.flags());
       }
     } else {
       client->InsertText(result_text_);
       composing_text_ = false;
     }
   }
 
@@ skipping 82 matching lines @@
   key_code = ui::KeyboardCodeFromXKeysym(keyval);
 #elif defined(TOOLKIT_USES_GTK)
   key_code = ui::WindowsKeyCodeForGdkKeyCode(keyval);
 #endif
 
   if (!key_code)
     return;
 
   KeyEvent key(state & IBUS_RELEASE_MASK ?
                ui::ET_KEY_RELEASED : ui::ET_KEY_PRESSED,
-               key_code, ViewsFlagsFromIBusState(state));
+               key_code, EventFlagsFromIBusState(state));
 
   // It is not clear when the input method will forward us a fake key event.
   // If there is a pending key event, then we may already received some input
   // method results, so we dispatch this fake key event directly rather than
   // calling ProcessKeyEventPostIME(), which will clear pending input method
   // results.
   if (key.type() == ui::ET_KEY_PRESSED)
     ProcessUnfilteredKeyPressEvent(key, keyval);
   else
     DispatchKeyEventPostIME(key);
@@ skipping 128 matching lines @@
   DCHECK_EQ(GetIBus(), bus);
   DCHECK(data);
   IBusInputContext* ic =
       ibus_bus_create_input_context_async_finish(bus, res, NULL);
   if (ic)
     data->StoreOrAbandonInputContext(ic);
   delete data;
 }
 
 }  // namespace views