diff --git a/java/res/values/keycodes.xml b/java/res/values/keycodes.xml
index 59cc075..4f8bfed 100644
--- a/java/res/values/keycodes.xml
+++ b/java/res/values/keycodes.xml
@@ -23,6 +23,7 @@
     <integer name="key_tab">9</integer>
     <integer name="key_return">10</integer>
     <integer name="key_space">32</integer>
+    <integer name="key_dummy">0</integer>
     <integer name="key_shift">-1</integer>
     <integer name="key_switch_alpha_symbol">-2</integer>
     <integer name="key_delete">-5</integer>
diff --git a/java/res/xml-sw600dp/kbd_key_styles.xml b/java/res/xml-sw600dp/kbd_key_styles.xml
index aba1a80..e0171b0 100644
--- a/java/res/xml-sw600dp/kbd_key_styles.xml
+++ b/java/res/xml-sw600dp/kbd_key_styles.xml
@@ -78,14 +78,14 @@
         latin:code="@integer/key_shortcut"
         latin:keyIcon="iconShortcutKey"
         latin:keyActionFlags="noKeyPreview|altCodeWhileTyping"
-        latin:altCode="@integer/key_space"
+        latin:altCode="@integer/key_dummy"
         latin:parentStyle="f2PopupStyle" />
     <key-style
         latin:styleName="settingsKeyStyle"
         latin:code="@integer/key_settings"
         latin:keyIcon="iconSettingsKey"
         latin:keyActionFlags="noKeyPreview|altCodeWhileTyping"
-        latin:altCode="@integer/key_space"
+        latin:altCode="@integer/key_dummy"
         latin:backgroundType="functional" />
     <key-style
         latin:styleName="tabKeyStyle"
diff --git a/java/res/xml-sw768dp/kbd_key_styles.xml b/java/res/xml-sw768dp/kbd_key_styles.xml
index e6ec53d..d926650 100644
--- a/java/res/xml-sw768dp/kbd_key_styles.xml
+++ b/java/res/xml-sw768dp/kbd_key_styles.xml
@@ -60,14 +60,14 @@
         latin:code="@integer/key_shortcut"
         latin:keyIcon="iconShortcutKey"
         latin:keyActionFlags="noKeyPreview|altCodeWhileTyping"
-        latin:altCode="@integer/key_space"
+        latin:altCode="@integer/key_dummy"
         latin:backgroundType="functional" />
     <key-style
         latin:styleName="settingsKeyStyle"
         latin:code="@integer/key_settings"
         latin:keyIcon="iconSettingsKey"
         latin:keyActionFlags="noKeyPreview|altCodeWhileTyping"
-        latin:altCode="@integer/key_space"
+        latin:altCode="@integer/key_dummy"
         latin:backgroundType="functional" />
     <key-style
         latin:styleName="tabKeyStyle"
diff --git a/java/src/com/android/inputmethod/keyboard/Keyboard.java b/java/src/com/android/inputmethod/keyboard/Keyboard.java
index e267aa6..814b523 100644
--- a/java/src/com/android/inputmethod/keyboard/Keyboard.java
+++ b/java/src/com/android/inputmethod/keyboard/Keyboard.java
@@ -151,6 +151,9 @@
     }
 
     public Key getKey(int code) {
+        if (code == CODE_DUMMY) {
+            return null;
+        }
         final Integer keyCode = code;
         if (mKeyCache.containsKey(keyCode)) {
             return mKeyCache.get(keyCode);
@@ -232,19 +235,6 @@
         return mProximityInfo.getNearestKeys(x, y);
     }
 
-    public static String themeName(int themeId) {
-        // This should be aligned with theme-*.xml resource files' themeId attribute.
-        switch (themeId) {
-        case 0: return "Basic";
-        case 1: return "BasicHighContrast";
-        case 5: return "IceCreamSandwich";
-        case 6: return "Stone";
-        case 7: return "StoneBold";
-        case 8: return "GingerBread";
-        default: return null;
-        }
-    }
-
     public static String printableCode(int code) {
         switch (code) {
         case CODE_SHIFT: return "shift";
diff --git a/java/src/com/android/inputmethod/keyboard/KeyboardId.java b/java/src/com/android/inputmethod/keyboard/KeyboardId.java
index 44c0c93..3b3ff07 100644
--- a/java/src/com/android/inputmethod/keyboard/KeyboardId.java
+++ b/java/src/com/android/inputmethod/keyboard/KeyboardId.java
@@ -51,11 +51,10 @@
     public static final int ELEMENT_PHONE_SHIFT = 8;
     public static final int ELEMENT_NUMBER = 9;
 
-    // TODO: These constants could be private.
-    public static final int F2KEY_MODE_NONE = 0;
-    public static final int F2KEY_MODE_SETTINGS = 1;
-    public static final int F2KEY_MODE_SHORTCUT_IME = 2;
-    public static final int F2KEY_MODE_SHORTCUT_IME_OR_SETTINGS = 3;
+    private static final int F2KEY_MODE_NONE = 0;
+    private static final int F2KEY_MODE_SETTINGS = 1;
+    private static final int F2KEY_MODE_SHORTCUT_IME = 2;
+    private static final int F2KEY_MODE_SHORTCUT_IME_OR_SETTINGS = 3;
 
     public final Locale mLocale;
     public final int mOrientation;
@@ -64,73 +63,82 @@
     // TODO: Remove this field.
     private final int mXmlId;
     public final int mElementState;
-    public final boolean mNavigateAction;
-    public final boolean mPasswordInput;
-    // TODO: Clean up these booleans and modes.
-    public final boolean mHasSettingsKey;
-    public final int mF2KeyMode;
+    private final int mInputType;
+    private final int mImeOptions;
+    private final boolean mSettingsKeyEnabled;
     public final boolean mClobberSettingsKey;
     public final boolean mShortcutKeyEnabled;
     public final boolean mHasShortcutKey;
-    public final int mImeAction;
-
-    // TODO: Remove this field.
-    private final EditorInfo mEditorInfo;
 
     private final int mHashCode;
 
-    // TODO: The hasSettings, f2KeyMode, and clobberSettingsKey arguments could be reduced.
     public KeyboardId(int xmlId, int elementState, Locale locale, int orientation, int width,
-            int mode, EditorInfo editorInfo, boolean hasSettingsKey, int f2KeyMode,
+            int mode, EditorInfo editorInfo, boolean settingsKeyEnabled,
             boolean clobberSettingsKey, boolean shortcutKeyEnabled, boolean hasShortcutKey) {
-        final int inputType = (editorInfo != null) ? editorInfo.inputType : 0;
-        final int imeOptions = (editorInfo != null) ? editorInfo.imeOptions : 0;
-        this.mElementState = elementState;
+        this(xmlId, elementState, locale, orientation, width, mode,
+                (editorInfo != null ? editorInfo.inputType : 0),
+                (editorInfo != null ? editorInfo.imeOptions : 0),
+                settingsKeyEnabled, clobberSettingsKey, shortcutKeyEnabled, hasShortcutKey);
+    }
+
+    private KeyboardId(int xmlId, int elementState, Locale locale, int orientation, int width,
+            int mode, int inputType, int imeOptions, boolean settingsKeyEnabled,
+            boolean clobberSettingsKey, boolean shortcutKeyEnabled, boolean hasShortcutKey) {
         this.mLocale = locale;
         this.mOrientation = orientation;
         this.mWidth = width;
         this.mMode = mode;
         this.mXmlId = xmlId;
-        // Note: Turn off checking navigation flag to show TAB key for now.
-        this.mNavigateAction = InputTypeCompatUtils.isWebInputType(inputType);
-//                || EditorInfoCompatUtils.hasFlagNavigateNext(imeOptions)
-//                || EditorInfoCompatUtils.hasFlagNavigatePrevious(imeOptions);
-        this.mPasswordInput = InputTypeCompatUtils.isPasswordInputType(inputType)
-                || InputTypeCompatUtils.isVisiblePasswordInputType(inputType);
-        this.mHasSettingsKey = hasSettingsKey;
-        this.mF2KeyMode = f2KeyMode;
+        this.mElementState = elementState;
+        this.mInputType = inputType;
+        this.mImeOptions = imeOptions;
+        this.mSettingsKeyEnabled = settingsKeyEnabled;
         this.mClobberSettingsKey = clobberSettingsKey;
         this.mShortcutKeyEnabled = shortcutKeyEnabled;
         this.mHasShortcutKey = hasShortcutKey;
-        // We are interested only in {@link EditorInfo#IME_MASK_ACTION} enum value and
-        // {@link EditorInfo#IME_FLAG_NO_ENTER_ACTION}.
-        this.mImeAction = imeOptions & (
-                EditorInfo.IME_MASK_ACTION | EditorInfo.IME_FLAG_NO_ENTER_ACTION);
 
-        this.mEditorInfo = editorInfo;
+        this.mHashCode = hashCode(this);
+    }
 
-        this.mHashCode = Arrays.hashCode(new Object[] {
-                locale,
-                orientation,
-                width,
-                mode,
-                xmlId,
-                elementState,
-                mNavigateAction,
-                mPasswordInput,
-                hasSettingsKey,
-                f2KeyMode,
-                clobberSettingsKey,
-                shortcutKeyEnabled,
-                hasShortcutKey,
-                mImeAction,
+    private static int hashCode(KeyboardId id) {
+        return Arrays.hashCode(new Object[] {
+                id.mOrientation,
+                id.mElementState,
+                id.mMode,
+                id.mWidth,
+                id.mXmlId,
+                id.navigateAction(),
+                id.passwordInput(),
+                id.mSettingsKeyEnabled,
+                id.mClobberSettingsKey,
+                id.mShortcutKeyEnabled,
+                id.mHasShortcutKey,
+                id.imeAction(),
+                id.mLocale
         });
     }
 
+    private boolean equals(KeyboardId other) {
+        if (other == this)
+            return true;
+        return other.mOrientation == this.mOrientation
+                && other.mElementState == this.mElementState
+                && other.mMode == this.mMode
+                && other.mWidth == this.mWidth
+                && other.mXmlId == this.mXmlId
+                && other.navigateAction() == this.navigateAction()
+                && other.passwordInput() == this.passwordInput()
+                && other.mSettingsKeyEnabled == this.mSettingsKeyEnabled
+                && other.mClobberSettingsKey == this.mClobberSettingsKey
+                && other.mShortcutKeyEnabled == this.mShortcutKeyEnabled
+                && other.mHasShortcutKey == this.mHasShortcutKey
+                && other.imeAction() == this.imeAction()
+                && other.mLocale.equals(this.mLocale);
+    }
+
     public KeyboardId cloneWithNewXml(int xmlId) {
-        return new KeyboardId(xmlId, mElementState, mLocale,
-                mOrientation, mWidth, mMode, mEditorInfo, false, F2KEY_MODE_NONE, false, false,
-                false);
+        return new KeyboardId(xmlId, mElementState, mLocale, mOrientation, mWidth, mMode,
+                mInputType, mImeOptions, false, false, false, false);
     }
 
     // Remove this method.
@@ -154,28 +162,50 @@
         return mElementState == ELEMENT_PHONE_SHIFT;
     }
 
+    public boolean navigateAction() {
+        // Note: Turn off checking navigation flag to show TAB key for now.
+        boolean navigateAction = InputTypeCompatUtils.isWebInputType(mInputType);
+//                || EditorInfoCompatUtils.hasFlagNavigateNext(mImeOptions)
+//                || EditorInfoCompatUtils.hasFlagNavigatePrevious(mImeOptions);
+        return navigateAction;
+    }
+
+    public boolean passwordInput() {
+        return InputTypeCompatUtils.isPasswordInputType(mInputType)
+                || InputTypeCompatUtils.isVisiblePasswordInputType(mInputType);
+    }
+
+    public int imeAction() {
+        // We are interested only in {@link EditorInfo#IME_MASK_ACTION} enum value and
+        // {@link EditorInfo#IME_FLAG_NO_ENTER_ACTION}.
+        return mImeOptions & (
+                EditorInfo.IME_MASK_ACTION | EditorInfo.IME_FLAG_NO_ENTER_ACTION);
+    }
+
+    public boolean hasSettingsKey() {
+        return mSettingsKeyEnabled && !mClobberSettingsKey;
+    }
+
+    public int f2KeyMode() {
+        if (mClobberSettingsKey) {
+            // Never shows the Settings key
+            return KeyboardId.F2KEY_MODE_SHORTCUT_IME;
+        }
+
+        if (mSettingsKeyEnabled) {
+            return KeyboardId.F2KEY_MODE_SETTINGS;
+        } else {
+            // It should be alright to fall back to the Settings key on 7-inch layouts
+            // even when the Settings key is not explicitly enabled.
+            return KeyboardId.F2KEY_MODE_SHORTCUT_IME_OR_SETTINGS;
+        }
+    }
+
     @Override
     public boolean equals(Object other) {
         return other instanceof KeyboardId && equals((KeyboardId) other);
     }
 
-    private boolean equals(KeyboardId other) {
-        return other.mLocale.equals(this.mLocale)
-            && other.mOrientation == this.mOrientation
-            && other.mWidth == this.mWidth
-            && other.mMode == this.mMode
-            && other.mXmlId == this.mXmlId
-            && other.mElementState == this.mElementState
-            && other.mNavigateAction == this.mNavigateAction
-            && other.mPasswordInput == this.mPasswordInput
-            && other.mHasSettingsKey == this.mHasSettingsKey
-            && other.mF2KeyMode == this.mF2KeyMode
-            && other.mClobberSettingsKey == this.mClobberSettingsKey
-            && other.mShortcutKeyEnabled == this.mShortcutKeyEnabled
-            && other.mHasShortcutKey == this.mHasShortcutKey
-            && other.mImeAction == this.mImeAction;
-    }
-
     @Override
     public int hashCode() {
         return mHashCode;
@@ -188,12 +218,12 @@
                 mLocale,
                 (mOrientation == 1 ? "port" : "land"), mWidth,
                 modeName(mMode),
-                EditorInfoCompatUtils.imeOptionsName(mImeAction),
-                f2KeyModeName(mF2KeyMode),
+                EditorInfoCompatUtils.imeOptionsName(imeAction()),
+                f2KeyModeName(f2KeyMode()),
                 (mClobberSettingsKey ? " clobberSettingsKey" : ""),
-                (mNavigateAction ? " navigateAction" : ""),
-                (mPasswordInput ? " passwordInput" : ""),
-                (mHasSettingsKey ? " hasSettingsKey" : ""),
+                (navigateAction() ? " navigateAction" : ""),
+                (passwordInput() ? " passwordInput" : ""),
+                (hasSettingsKey() ? " hasSettingsKey" : ""),
                 (mShortcutKeyEnabled ? " shortcutKeyEnabled" : ""),
                 (mHasShortcutKey ? " hasShortcutKey" : "")
         );
diff --git a/java/src/com/android/inputmethod/keyboard/KeyboardSet.java b/java/src/com/android/inputmethod/keyboard/KeyboardSet.java
index 9f182af..a28cfa8 100644
--- a/java/src/com/android/inputmethod/keyboard/KeyboardSet.java
+++ b/java/src/com/android/inputmethod/keyboard/KeyboardSet.java
@@ -69,11 +69,10 @@
                 new HashMap<Integer, Integer>();
 
         private final int mMode;
+        private final boolean mSettingsKeyEnabled;
         private final boolean mVoiceKeyEnabled;
-        private final boolean mNoSettingsKey;
-        private final boolean mHasSettingsKey;
-        private final int mF2KeyMode;
         private final boolean mVoiceKeyOnMain;
+        private final boolean mNoSettingsKey;
         private final Locale mLocale;
         private final Configuration mConf;
         private final DisplayMetrics mMetrics;
@@ -85,7 +84,7 @@
             final String packageName = context.getPackageName();
 
             mMode = Utils.getKeyboardMode(mEditorInfo);
-            final boolean settingsKeyEnabled = settingsValues.isSettingsKeyEnabled();
+            mSettingsKeyEnabled = settingsValues.isSettingsKeyEnabled();
             @SuppressWarnings("deprecation")
             final boolean noMicrophone = Utils.inPrivateImeOptions(
                     packageName, LatinIME.IME_OPTION_NO_MICROPHONE, editorInfo)
@@ -95,8 +94,6 @@
             mVoiceKeyOnMain = settingsValues.isVoiceKeyOnMain();
             mNoSettingsKey = Utils.inPrivateImeOptions(
                     packageName, LatinIME.IME_OPTION_NO_SETTINGS_KEY, editorInfo);
-            mHasSettingsKey = settingsKeyEnabled && !mNoSettingsKey;
-            mF2KeyMode = getF2KeyMode(settingsKeyEnabled, mNoSettingsKey);
             final boolean forceAscii = Utils.inPrivateImeOptions(
                     packageName, LatinIME.IME_OPTION_FORCE_ASCII, editorInfo);
             final boolean asciiCapable = subtypeSwitcher.currentSubtypeContainsExtraValueKey(
@@ -123,8 +120,8 @@
             final int xmlId = mElementKeyboards.get(elementState);
             final boolean hasShortcutKey = mVoiceKeyEnabled && (isSymbols != mVoiceKeyOnMain);
             return new KeyboardId(xmlId, elementState, mLocale, mConf.orientation,
-                    mMetrics.widthPixels, mMode, mEditorInfo, mHasSettingsKey, mF2KeyMode,
-                    mNoSettingsKey, mVoiceKeyEnabled, hasShortcutKey);
+                    mMetrics.widthPixels, mMode, mEditorInfo, mSettingsKeyEnabled, mNoSettingsKey,
+                    mVoiceKeyEnabled, hasShortcutKey);
         }
 
         private static int getElementState(int mode, boolean isSymbols, boolean isShift) {
@@ -142,22 +139,6 @@
             }
         }
 
-        // TODO: Move to KeyboardId.
-        private static int getF2KeyMode(boolean settingsKeyEnabled, boolean noSettingsKey) {
-            if (noSettingsKey) {
-                // Never shows the Settings key
-                return KeyboardId.F2KEY_MODE_SHORTCUT_IME;
-            }
-
-            if (settingsKeyEnabled) {
-                return KeyboardId.F2KEY_MODE_SETTINGS;
-            } else {
-                // It should be alright to fall back to the Settings key on 7-inch layouts
-                // even when the Settings key is not explicitly enabled.
-                return KeyboardId.F2KEY_MODE_SHORTCUT_IME_OR_SETTINGS;
-            }
-        }
-
         private void parseKeyboardSet(Resources res, int resId) throws XmlPullParserException,
                 IOException {
             final XmlResourceParser parser = res.getXml(resId);
diff --git a/java/src/com/android/inputmethod/keyboard/KeyboardSwitcher.java b/java/src/com/android/inputmethod/keyboard/KeyboardSwitcher.java
index 165e9ae..1f3006d 100644
--- a/java/src/com/android/inputmethod/keyboard/KeyboardSwitcher.java
+++ b/java/src/com/android/inputmethod/keyboard/KeyboardSwitcher.java
@@ -191,11 +191,11 @@
             if (DEBUG_CACHE) {
                 Log.d(TAG, "keyboard cache size=" + mKeyboardCache.size() + ": "
                         + ((ref == null) ? "LOAD" : "GCed") + " id=" + id
-                        + " theme=" + Keyboard.themeName(keyboard.mThemeId));
+                        + " theme=" + themeName(keyboard.mThemeId));
             }
         } else if (DEBUG_CACHE) {
             Log.d(TAG, "keyboard cache size=" + mKeyboardCache.size() + ": HIT  id=" + id
-                    + " theme=" + Keyboard.themeName(keyboard.mThemeId));
+                    + " theme=" + themeName(keyboard.mThemeId));
         }
 
         keyboard.onAutoCorrectionStateChanged(mIsAutoCorrectionActive);
@@ -463,4 +463,17 @@
             }
         }
     }
+
+    private static String themeName(int themeId) {
+        // This should be aligned with theme-*.xml resource files' themeId attribute.
+        switch (themeId) {
+        case 0: return "Basic";
+        case 1: return "BasicHighContrast";
+        case 5: return "IceCreamSandwich";
+        case 6: return "Stone";
+        case 7: return "StoneBold";
+        case 8: return "GingerBread";
+        default: return null;
+        }
+    }
 }
diff --git a/java/src/com/android/inputmethod/keyboard/LatinKeyboardView.java b/java/src/com/android/inputmethod/keyboard/LatinKeyboardView.java
index af5f808..e56f2ea 100644
--- a/java/src/com/android/inputmethod/keyboard/LatinKeyboardView.java
+++ b/java/src/com/android/inputmethod/keyboard/LatinKeyboardView.java
@@ -409,19 +409,16 @@
                 invokeReleaseKey(primaryCode);
                 return true;
             }
-        }
-        if (primaryCode == Keyboard.CODE_SETTINGS || primaryCode == Keyboard.CODE_SPACE) {
-            // Both long pressing settings key and space key invoke IME switcher dialog.
-            if (invokeCustomRequest(LatinIME.CODE_SHOW_INPUT_METHOD_PICKER)) {
-                tracker.onLongPressed();
-                invokeReleaseKey(primaryCode);
-                return true;
-            } else {
-                return openMoreKeysPanel(parentKey, tracker);
+            if (primaryCode == Keyboard.CODE_SPACE) {
+                // Long pressing the space key invokes IME switcher dialog.
+                if (invokeCustomRequest(LatinIME.CODE_SHOW_INPUT_METHOD_PICKER)) {
+                    tracker.onLongPressed();
+                    invokeReleaseKey(primaryCode);
+                    return true;
+                }
             }
-        } else {
-            return openMoreKeysPanel(parentKey, tracker);
         }
+        return openMoreKeysPanel(parentKey, tracker);
     }
 
     private boolean invokeCustomRequest(int code) {
diff --git a/java/src/com/android/inputmethod/keyboard/internal/KeyboardBuilder.java b/java/src/com/android/inputmethod/keyboard/internal/KeyboardBuilder.java
index a88a163..7382cfa 100644
--- a/java/src/com/android/inputmethod/keyboard/internal/KeyboardBuilder.java
+++ b/java/src/com/android/inputmethod/keyboard/internal/KeyboardBuilder.java
@@ -613,13 +613,13 @@
             final boolean modeMatched = matchTypedValue(a,
                     R.styleable.Keyboard_Case_mode, id.mMode, KeyboardId.modeName(id.mMode));
             final boolean navigateActionMatched = matchBoolean(a,
-                    R.styleable.Keyboard_Case_navigateAction, id.mNavigateAction);
+                    R.styleable.Keyboard_Case_navigateAction, id.navigateAction());
             final boolean passwordInputMatched = matchBoolean(a,
-                    R.styleable.Keyboard_Case_passwordInput, id.mPasswordInput);
+                    R.styleable.Keyboard_Case_passwordInput, id.passwordInput());
             final boolean hasSettingsKeyMatched = matchBoolean(a,
-                    R.styleable.Keyboard_Case_hasSettingsKey, id.mHasSettingsKey);
+                    R.styleable.Keyboard_Case_hasSettingsKey, id.hasSettingsKey());
             final boolean f2KeyModeMatched = matchInteger(a,
-                    R.styleable.Keyboard_Case_f2KeyMode, id.mF2KeyMode);
+                    R.styleable.Keyboard_Case_f2KeyMode, id.f2KeyMode());
             final boolean clobberSettingsKeyMatched = matchBoolean(a,
                     R.styleable.Keyboard_Case_clobberSettingsKey, id.mClobberSettingsKey);
             final boolean shortcutKeyEnabledMatched = matchBoolean(a,
@@ -631,7 +631,7 @@
             // {@link android.view.inputmethod.EditorInfo#IME_FLAG_NO_ENTER_ACTION}. So matching
             // this attribute with id.mImeOptions as integer value is enough for our purpose.
             final boolean imeActionMatched = matchInteger(a,
-                    R.styleable.Keyboard_Case_imeAction, id.mImeAction);
+                    R.styleable.Keyboard_Case_imeAction, id.imeAction());
             final boolean localeCodeMatched = matchString(a,
                     R.styleable.Keyboard_Case_localeCode, id.mLocale.toString());
             final boolean languageCodeMatched = matchString(a,
diff --git a/java/src/com/android/inputmethod/latin/LatinIME.java b/java/src/com/android/inputmethod/latin/LatinIME.java
index eb2f797..98fea1b 100644
--- a/java/src/com/android/inputmethod/latin/LatinIME.java
+++ b/java/src/com/android/inputmethod/latin/LatinIME.java
@@ -1586,7 +1586,6 @@
             mHandler.postUpdateSuggestions();
         }
 
-        boolean pickedDefault = false;
         // Handle separator
         final InputConnection ic = getCurrentInputConnection();
         if (ic != null) {
@@ -1603,27 +1602,12 @@
             final boolean shouldAutoCorrect = mSettingsValues.mAutoCorrectEnabled
                     && !mInputTypeNoAutoCorrect;
             if (shouldAutoCorrect && primaryCode != Keyboard.CODE_SINGLE_QUOTE) {
-                pickedDefault = pickDefaultSuggestion(primaryCode);
+                commitCurrentAutoCorrection(primaryCode, ic);
             } else {
                 commitTyped(ic);
             }
         }
 
-        if (pickedDefault) {
-            final CharSequence autoCorrection = mWordComposer.getAutoCorrectionOrNull();
-            final String typedWord = mWordComposer.getTypedWord();
-            if (TextUtils.isEmpty(typedWord)) {
-                throw new RuntimeException("We have non-committed chars but the typed word "
-                        + "is empty? Impossible! I must commit suicide.");
-            }
-            if (!typedWord.equals(autoCorrection)) {
-                // This will make the correction flash for a short while as a visual clue
-                // to the user that auto-correction happened.
-                InputConnectionCompatUtils.commitCorrection(
-                        ic, mLastSelectionEnd - typedWord.length(), typedWord, autoCorrection);
-            }
-        }
-
         final boolean swapMagicSpace;
         if (Keyboard.CODE_ENTER == primaryCode && (SPACE_STATE_MAGIC == spaceState
                 || SPACE_STATE_SWAP_PUNCTUATION == spaceState)) {
@@ -1875,7 +1859,8 @@
         setSuggestionStripShown(isSuggestionsStripVisible());
     }
 
-    private boolean pickDefaultSuggestion(int separatorCode) {
+    private void commitCurrentAutoCorrection(final int separatorCodePoint,
+            final InputConnection ic) {
         // Complete any pending suggestions query first
         if (mHandler.hasPendingUpdateSuggestions()) {
             mHandler.cancelUpdateSuggestions();
@@ -1884,7 +1869,11 @@
         final CharSequence autoCorrection = mWordComposer.getAutoCorrectionOrNull();
         if (autoCorrection != null) {
             final String typedWord = mWordComposer.getTypedWord();
-            Utils.Stats.onAutoCorrection(typedWord, autoCorrection.toString(), separatorCode);
+            if (TextUtils.isEmpty(typedWord)) {
+                throw new RuntimeException("We have an auto-correction but the typed word "
+                        + "is empty? Impossible! I must commit suicide.");
+            }
+            Utils.Stats.onAutoCorrection(typedWord, autoCorrection.toString(), separatorCodePoint);
             mExpectingUpdateSelection = true;
             commitBestWord(autoCorrection);
             if (!autoCorrection.equals(typedWord)) {
@@ -1893,9 +1882,13 @@
             // Add the word to the user unigram dictionary if it's not a known word
             addToUserUnigramAndBigramDictionaries(autoCorrection,
                     UserUnigramDictionary.FREQUENCY_FOR_TYPED);
-            return true;
+            if (!typedWord.equals(autoCorrection) && null != ic) {
+                // This will make the correction flash for a short while as a visual clue
+                // to the user that auto-correction happened.
+                InputConnectionCompatUtils.commitCorrection(ic,
+                        mLastSelectionEnd - typedWord.length(), typedWord, autoCorrection);
+            }
         }
-        return false;
     }
 
     @Override
diff --git a/native/src/defines.h b/native/src/defines.h
index b59f623..ea643bf 100644
--- a/native/src/defines.h
+++ b/native/src/defines.h
@@ -198,7 +198,7 @@
 #define NEUTRAL_SCORE_SQUARED_RADIUS 8.0f
 #define HALF_SCORE_SQUARED_RADIUS 32.0f
 
-// This should be greater than or equal to MAX_WORD_LENGTH defined in BinaryDictionary.java
+// This must be greater than or equal to MAX_WORD_LENGTH defined in BinaryDictionary.java
 // This is only used for the size of array. Not to be used in c functions.
 #define MAX_WORD_LENGTH_INTERNAL 48
 
diff --git a/native/src/dictionary.cpp b/native/src/dictionary.cpp
index a49769b..55358ec 100644
--- a/native/src/dictionary.cpp
+++ b/native/src/dictionary.cpp
@@ -38,6 +38,8 @@
             LOGI("IN NATIVE SUGGEST Version: %d", (mDict[0] & 0xFF));
         }
     }
+    mCorrection = new Correction(typedLetterMultiplier, fullWordMultiplier);
+    mWordsPriorityQueue = new WordsPriorityQueue(maxWords, maxWordLength);
     mUnigramDictionary = new UnigramDictionary(mDict, typedLetterMultiplier, fullWordMultiplier,
             maxWordLength, maxWords, maxAlternatives, IS_LATEST_DICT_VERSION);
     mBigramDictionary = new BigramDictionary(mDict, maxWordLength, maxAlternatives,
@@ -45,6 +47,8 @@
 }
 
 Dictionary::~Dictionary() {
+    delete mCorrection;
+    delete mWordsPriorityQueue;
     delete mUnigramDictionary;
     delete mBigramDictionary;
 }
diff --git a/native/src/dictionary.h b/native/src/dictionary.h
index f891e74..2a6e4e0 100644
--- a/native/src/dictionary.h
+++ b/native/src/dictionary.h
@@ -19,9 +19,11 @@
 
 #include "bigram_dictionary.h"
 #include "char_utils.h"
+#include "correction.h"
 #include "defines.h"
 #include "proximity_info.h"
 #include "unigram_dictionary.h"
+#include "words_priority_queue.h"
 
 namespace latinime {
 
@@ -29,9 +31,11 @@
 public:
     Dictionary(void *dict, int dictSize, int mmapFd, int dictBufAdjust, int typedLetterMultipler,
             int fullWordMultiplier, int maxWordLength, int maxWords, int maxAlternatives);
+
     int getSuggestions(ProximityInfo *proximityInfo, int *xcoordinates, int *ycoordinates,
             int *codes, int codesSize, int flags, unsigned short *outWords, int *frequencies) {
-        return mUnigramDictionary->getSuggestions(proximityInfo, xcoordinates, ycoordinates, codes,
+        return mUnigramDictionary->getSuggestions(proximityInfo, mWordsPriorityQueue,
+                mCorrection, xcoordinates, ycoordinates, codes,
                 codesSize, flags, outWords, frequencies);
     }
 
@@ -77,6 +81,8 @@
     const bool IS_LATEST_DICT_VERSION;
     UnigramDictionary *mUnigramDictionary;
     BigramDictionary *mBigramDictionary;
+    WordsPriorityQueue *mWordsPriorityQueue;
+    Correction *mCorrection;
 };
 
 // public static utility methods
diff --git a/native/src/unigram_dictionary.cpp b/native/src/unigram_dictionary.cpp
index e17e7d0..a2c1f72 100644
--- a/native/src/unigram_dictionary.cpp
+++ b/native/src/unigram_dictionary.cpp
@@ -48,21 +48,23 @@
     if (DEBUG_DICT) {
         LOGI("UnigramDictionary - constructor");
     }
-    mCorrection = new Correction(typedLetterMultiplier, fullWordMultiplier);
-    mWordsPriorityQueue = new WordsPriorityQueue(maxWords, maxWordLength);
 }
 
 UnigramDictionary::~UnigramDictionary() {
-    delete mCorrection;
-    delete mWordsPriorityQueue;
 }
 
-static inline unsigned int getCodesBufferSize(const int* codes, const int codesSize,
+static inline unsigned int getCodesBufferSize(const int *codes, const int codesSize,
         const int MAX_PROXIMITY_CHARS) {
     return sizeof(*codes) * MAX_PROXIMITY_CHARS * codesSize;
 }
 
-bool UnigramDictionary::isDigraph(const int* codes, const int i, const int codesSize) const {
+// TODO: This needs to take an const unsigned short* and not tinker with its contents
+static inline void addWord(
+        unsigned short *word, int length, int frequency, WordsPriorityQueue *queue) {
+    queue->push(frequency, word, length);
+}
+
+bool UnigramDictionary::isDigraph(const int *codes, const int i, const int codesSize) const {
 
     // There can't be a digraph if we don't have at least 2 characters to examine
     if (i + 2 > codesSize) return false;
@@ -88,9 +90,10 @@
 // codesSrc is the current point in the user-input, original, content-unmodified buffer.
 // codesRemain is the remaining size in codesSrc.
 void UnigramDictionary::getWordWithDigraphSuggestionsRec(ProximityInfo *proximityInfo,
-        const int *xcoordinates, const int* ycoordinates, const int *codesBuffer,
-        const int codesBufferSize, const int flags, const int* codesSrc, const int codesRemain,
-        const int currentDepth, int* codesDest) {
+        const int *xcoordinates, const int *ycoordinates, const int *codesBuffer,
+        const int codesBufferSize, const int flags, const int *codesSrc,
+        const int codesRemain, const int currentDepth, int *codesDest, Correction *correction,
+        WordsPriorityQueue *queue) {
 
     if (currentDepth < MAX_UMLAUT_SEARCH_DEPTH) {
         for (int i = 0; i < codesRemain; ++i) {
@@ -107,7 +110,7 @@
                 getWordWithDigraphSuggestionsRec(proximityInfo, xcoordinates, ycoordinates,
                         codesBuffer, codesBufferSize, flags,
                         codesSrc + (i + 1) * MAX_PROXIMITY_CHARS, codesRemain - i - 1,
-                        currentDepth + 1, codesDest + i * MAX_PROXIMITY_CHARS);
+                        currentDepth + 1, codesDest + i * MAX_PROXIMITY_CHARS, correction, queue);
 
                 // Copy the second char of the digraph in place, then continue processing on
                 // the remaining part of the word.
@@ -115,8 +118,9 @@
                 memcpy(codesDest + i * MAX_PROXIMITY_CHARS, codesSrc + i * MAX_PROXIMITY_CHARS,
                         BYTES_IN_ONE_CHAR);
                 getWordWithDigraphSuggestionsRec(proximityInfo, xcoordinates, ycoordinates,
-                        codesBuffer, codesBufferSize, flags, codesSrc + i * MAX_PROXIMITY_CHARS,
-                        codesRemain - i, currentDepth + 1, codesDest + i * MAX_PROXIMITY_CHARS);
+                        codesBuffer, codesBufferSize, flags,
+                        codesSrc + i * MAX_PROXIMITY_CHARS, codesRemain - i, currentDepth + 1,
+                        codesDest + i * MAX_PROXIMITY_CHARS, correction, queue);
                 return;
             }
         }
@@ -132,25 +136,28 @@
         memcpy(codesDest, codesSrc, remainingBytes);
 
     getWordSuggestions(proximityInfo, xcoordinates, ycoordinates, codesBuffer,
-            (codesDest - codesBuffer) / MAX_PROXIMITY_CHARS + codesRemain, flags);
+            (codesDest - codesBuffer) / MAX_PROXIMITY_CHARS + codesRemain, flags, correction,
+            queue);
 }
 
-int UnigramDictionary::getSuggestions(ProximityInfo *proximityInfo, const int *xcoordinates,
-        const int *ycoordinates, const int *codes, const int codesSize, const int flags,
-        unsigned short *outWords, int *frequencies) {
+int UnigramDictionary::getSuggestions(ProximityInfo *proximityInfo, WordsPriorityQueue *queue,
+        Correction *correction, const int *xcoordinates, const int *ycoordinates, const int *codes,
+        const int codesSize, const int flags, unsigned short *outWords, int *frequencies) {
 
+    WordsPriorityQueue* masterQueue = queue;
+    Correction* masterCorrection = correction;
     if (REQUIRES_GERMAN_UMLAUT_PROCESSING & flags)
     { // Incrementally tune the word and try all possibilities
         int codesBuffer[getCodesBufferSize(codes, codesSize, MAX_PROXIMITY_CHARS)];
         getWordWithDigraphSuggestionsRec(proximityInfo, xcoordinates, ycoordinates, codesBuffer,
-                codesSize, flags, codes, codesSize, 0, codesBuffer);
+                codesSize, flags, codes, codesSize, 0, codesBuffer, masterCorrection, masterQueue);
     } else { // Normal processing
-        getWordSuggestions(proximityInfo, xcoordinates, ycoordinates, codes, codesSize, flags);
+        getWordSuggestions(proximityInfo, xcoordinates, ycoordinates, codes, codesSize, flags,
+                masterCorrection, masterQueue);
     }
 
     PROF_START(20);
-    const int suggestedWordsCount =
-            mWordsPriorityQueue->outputSuggestions(frequencies, outWords);
+    const int suggestedWordsCount = masterQueue->outputSuggestions(frequencies, outWords);
 
     if (DEBUG_DICT) {
         LOGI("Returning %d words", suggestedWordsCount);
@@ -170,23 +177,22 @@
 }
 
 void UnigramDictionary::getWordSuggestions(ProximityInfo *proximityInfo,
-        const int *xcoordinates, const int *ycoordinates, const int *codes, const int codesSize,
-        const int flags) {
+        const int *xcoordinates, const int *ycoordinates, const int *codes,
+        const int inputLength, const int flags, Correction *correction, WordsPriorityQueue *queue) {
 
     PROF_OPEN;
     PROF_START(0);
-    initSuggestions(
-            proximityInfo, xcoordinates, ycoordinates, codes, codesSize);
-    if (DEBUG_DICT) assert(codesSize == mInputLength);
+    initSuggestions(proximityInfo, xcoordinates, ycoordinates, codes, inputLength, queue);
+    if (DEBUG_DICT) assert(codesSize == inputLength);
 
-    const int maxDepth = min(mInputLength * MAX_DEPTH_MULTIPLIER, MAX_WORD_LENGTH);
-    mCorrection->initCorrection(mProximityInfo, mInputLength, maxDepth);
+    const int maxDepth = min(inputLength * MAX_DEPTH_MULTIPLIER, MAX_WORD_LENGTH);
+    correction->initCorrection(proximityInfo, inputLength, maxDepth);
     PROF_END(0);
 
     const bool useFullEditDistance = USE_FULL_EDIT_DISTANCE & flags;
     // TODO: remove
     PROF_START(1);
-    getSuggestionCandidates(useFullEditDistance);
+    getSuggestionCandidates(useFullEditDistance, inputLength, correction, queue);
     PROF_END(1);
 
     PROF_START(2);
@@ -204,12 +210,13 @@
     PROF_START(5);
     // Suggestions with missing space
     if (SUGGEST_WORDS_WITH_MISSING_SPACE_CHARACTER
-            && mInputLength >= MIN_USER_TYPED_LENGTH_FOR_MISSING_SPACE_SUGGESTION) {
-        for (int i = 1; i < codesSize; ++i) {
+            && inputLength >= MIN_USER_TYPED_LENGTH_FOR_MISSING_SPACE_SUGGESTION) {
+        for (int i = 1; i < inputLength; ++i) {
             if (DEBUG_DICT) {
                 LOGI("--- Suggest missing space characters %d", i);
             }
-            getMissingSpaceWords(mInputLength, i, mCorrection, useFullEditDistance);
+            getMissingSpaceWords(
+                    inputLength, i, proximityInfo, correction, useFullEditDistance, queue);
         }
     }
     PROF_END(5);
@@ -217,7 +224,7 @@
     PROF_START(6);
     if (SUGGEST_WORDS_WITH_SPACE_PROXIMITY && proximityInfo) {
         // The first and last "mistyped spaces" are taken care of by excessive character handling
-        for (int i = 1; i < codesSize - 1; ++i) {
+        for (int i = 1; i < inputLength - 1; ++i) {
             if (DEBUG_DICT) {
                 LOGI("--- Suggest words with proximity space %d", i);
             }
@@ -228,7 +235,8 @@
                         i, x, y, proximityInfo->hasSpaceProximity(x, y));
             }
             if (proximityInfo->hasSpaceProximity(x, y)) {
-                getMistypedSpaceWords(mInputLength, i, mCorrection, useFullEditDistance);
+                getMistypedSpaceWords(
+                        inputLength, i, proximityInfo, correction, useFullEditDistance, queue);
             }
         }
     }
@@ -236,93 +244,83 @@
 }
 
 void UnigramDictionary::initSuggestions(ProximityInfo *proximityInfo, const int *xCoordinates,
-        const int *yCoordinates, const int *codes, const int codesSize) {
+        const int *yCoordinates, const int *codes, const int codesSize,
+        WordsPriorityQueue *queue) {
     if (DEBUG_DICT) {
         LOGI("initSuggest");
     }
-    mInputLength = codesSize;
     proximityInfo->setInputParams(codes, codesSize, xCoordinates, yCoordinates);
-    mProximityInfo = proximityInfo;
-    mWordsPriorityQueue->clear();
-}
-
-// TODO: This needs to take an const unsigned short* and not tinker with its contents
-void UnigramDictionary::addWord(unsigned short *word, int length, int frequency) {
-    mWordsPriorityQueue->push(frequency, word, length);
+    queue->clear();
 }
 
 static const char QUOTE = '\'';
 static const char SPACE = ' ';
 
-void UnigramDictionary::getSuggestionCandidates(const bool useFullEditDistance) {
+void UnigramDictionary::getSuggestionCandidates(const bool useFullEditDistance,
+        const int inputLength, Correction *correction, WordsPriorityQueue *queue) {
     // TODO: Remove setCorrectionParams
-    mCorrection->setCorrectionParams(0, 0, 0,
+    correction->setCorrectionParams(0, 0, 0,
             -1 /* spaceProximityPos */, -1 /* missingSpacePos */, useFullEditDistance);
     int rootPosition = ROOT_POS;
     // Get the number of children of root, then increment the position
     int childCount = Dictionary::getCount(DICT_ROOT, &rootPosition);
     int outputIndex = 0;
 
-    mCorrection->initCorrectionState(rootPosition, childCount, (mInputLength <= 0));
+    correction->initCorrectionState(rootPosition, childCount, (inputLength <= 0));
 
     // Depth first search
     while (outputIndex >= 0) {
-        if (mCorrection->initProcessState(outputIndex)) {
-            int siblingPos = mCorrection->getTreeSiblingPos(outputIndex);
+        if (correction->initProcessState(outputIndex)) {
+            int siblingPos = correction->getTreeSiblingPos(outputIndex);
             int firstChildPos;
 
             const bool needsToTraverseChildrenNodes = processCurrentNode(siblingPos,
-                    mCorrection, &childCount, &firstChildPos, &siblingPos);
+                    correction, &childCount, &firstChildPos, &siblingPos, queue);
             // Update next sibling pos
-            mCorrection->setTreeSiblingPos(outputIndex, siblingPos);
+            correction->setTreeSiblingPos(outputIndex, siblingPos);
 
             if (needsToTraverseChildrenNodes) {
                 // Goes to child node
-                outputIndex = mCorrection->goDownTree(outputIndex, childCount, firstChildPos);
+                outputIndex = correction->goDownTree(outputIndex, childCount, firstChildPos);
             }
         } else {
             // Goes to parent sibling node
-            outputIndex = mCorrection->getTreeParentIndex(outputIndex);
+            outputIndex = correction->getTreeParentIndex(outputIndex);
         }
     }
 }
 
 void UnigramDictionary::getMissingSpaceWords(
-        const int inputLength, const int missingSpacePos, Correction *correction,
-        const bool useFullEditDistance) {
+        const int inputLength, const int missingSpacePos, ProximityInfo *proximityInfo,
+        Correction *correction, const bool useFullEditDistance, WordsPriorityQueue *queue) {
     correction->setCorrectionParams(-1 /* skipPos */, -1 /* excessivePos */,
             -1 /* transposedPos */, -1 /* spaceProximityPos */, missingSpacePos,
             useFullEditDistance);
-    getSplitTwoWordsSuggestion(inputLength, correction);
+    getSplitTwoWordsSuggestion(inputLength, proximityInfo, correction, queue);
 }
 
 void UnigramDictionary::getMistypedSpaceWords(
-        const int inputLength, const int spaceProximityPos, Correction *correction,
-        const bool useFullEditDistance) {
+        const int inputLength, const int spaceProximityPos, ProximityInfo *proximityInfo,
+        Correction *correction, const bool useFullEditDistance, WordsPriorityQueue *queue) {
     correction->setCorrectionParams(-1 /* skipPos */, -1 /* excessivePos */,
             -1 /* transposedPos */, spaceProximityPos, -1 /* missingSpacePos */,
             useFullEditDistance);
-    getSplitTwoWordsSuggestion(inputLength, correction);
+    getSplitTwoWordsSuggestion(inputLength, proximityInfo, correction, queue);
 }
 
-inline bool UnigramDictionary::needsToSkipCurrentNode(const unsigned short c,
-        const int inputIndex, const int skipPos, const int depth) {
-    const unsigned short userTypedChar = mProximityInfo->getPrimaryCharAt(inputIndex);
-    // Skip the ' or other letter and continue deeper
-    return (c == QUOTE && userTypedChar != QUOTE) || skipPos == depth;
-}
-
-inline void UnigramDictionary::onTerminal(const int freq, Correction *correction) {
+inline void UnigramDictionary::onTerminal(
+        const int freq, Correction *correction, WordsPriorityQueue *queue) {
     int wordLength;
     unsigned short* wordPointer;
     const int finalFreq = correction->getFinalFreq(freq, &wordPointer, &wordLength);
     if (finalFreq >= 0) {
-        addWord(wordPointer, wordLength, finalFreq);
+        addWord(wordPointer, wordLength, finalFreq, queue);
     }
 }
 
 void UnigramDictionary::getSplitTwoWordsSuggestion(
-        const int inputLength, Correction* correction) {
+        const int inputLength, ProximityInfo *proximityInfo, Correction *correction,
+        WordsPriorityQueue *queue) {
     const int spaceProximityPos = correction->getSpaceProximityPos();
     const int missingSpacePos = correction->getMissingSpacePos();
     if (DEBUG_DICT) {
@@ -347,7 +345,8 @@
     const int newWordLength = firstWordLength + secondWordLength + 1;
     // Allocating variable length array on stack
     unsigned short word[newWordLength];
-    const int firstFreq = getMostFrequentWordLike(firstWordStartPos, firstWordLength, mWord);
+    const int firstFreq = getMostFrequentWordLike(
+            firstWordStartPos, firstWordLength, proximityInfo, mWord);
     if (DEBUG_DICT) {
         LOGI("First freq: %d", firstFreq);
     }
@@ -357,7 +356,8 @@
         word[i] = mWord[i];
     }
 
-    const int secondFreq = getMostFrequentWordLike(secondWordStartPos, secondWordLength, mWord);
+    const int secondFreq = getMostFrequentWordLike(
+            secondWordStartPos, secondWordLength, proximityInfo, mWord);
     if (DEBUG_DICT) {
         LOGI("Second  freq:  %d", secondFreq);
     }
@@ -368,22 +368,22 @@
         word[i] = mWord[i - firstWordLength - 1];
     }
 
-    const int pairFreq = mCorrection->getFreqForSplitTwoWords(firstFreq, secondFreq, word);
+    const int pairFreq = correction->getFreqForSplitTwoWords(firstFreq, secondFreq, word);
     if (DEBUG_DICT) {
         LOGI("Split two words:  %d, %d, %d, %d", firstFreq, secondFreq, pairFreq, inputLength);
     }
-    addWord(word, newWordLength, pairFreq);
+    addWord(word, newWordLength, pairFreq, queue);
     return;
 }
 
 // Wrapper for getMostFrequentWordLikeInner, which matches it to the previous
 // interface.
 inline int UnigramDictionary::getMostFrequentWordLike(const int startInputIndex,
-        const int inputLength, unsigned short *word) {
+        const int inputLength, ProximityInfo *proximityInfo, unsigned short *word) {
     uint16_t inWord[inputLength];
 
     for (int i = 0; i < inputLength; ++i) {
-        inWord[i] = (uint16_t)mProximityInfo->getPrimaryCharAt(startInputIndex + i);
+        inWord[i] = (uint16_t)proximityInfo->getPrimaryCharAt(startInputIndex + i);
     }
     return getMostFrequentWordLikeInner(inWord, inputLength, word);
 }
@@ -534,7 +534,7 @@
 // given level, as output into newCount when traversing this level's parent.
 inline bool UnigramDictionary::processCurrentNode(const int initialPos,
         Correction *correction, int *newCount,
-        int *newChildrenPosition, int *nextSiblingPosition) {
+        int *newChildrenPosition, int *nextSiblingPosition, WordsPriorityQueue *queue) {
     if (DEBUG_DICT) {
         correction->checkState();
     }
@@ -613,7 +613,7 @@
             // The frequency should be here, because we come here only if this is actually
             // a terminal node, and we are on its last char.
             const int freq = BinaryFormat::readFrequencyWithoutMovingPointer(DICT_ROOT, pos);
-            onTerminal(freq, mCorrection);
+            onTerminal(freq, correction, queue);
         }
 
         // If there are more chars in this node, then this virtual node has children.
diff --git a/native/src/unigram_dictionary.h b/native/src/unigram_dictionary.h
index 506ed62..0b01265 100644
--- a/native/src/unigram_dictionary.h
+++ b/native/src/unigram_dictionary.h
@@ -66,7 +66,8 @@
             const bool isLatestDictVersion);
     bool isValidWord(const uint16_t* const inWord, const int length) const;
     int getBigramPosition(int pos, unsigned short *word, int offset, int length) const;
-    int getSuggestions(ProximityInfo *proximityInfo, const int *xcoordinates,
+    int getSuggestions(ProximityInfo *proximityInfo, WordsPriorityQueue *queue,
+            Correction *correction, const int *xcoordinates,
             const int *ycoordinates, const int *codes, const int codesSize, const int flags,
             unsigned short *outWords, int *frequencies);
     virtual ~UnigramDictionary();
@@ -74,32 +75,38 @@
 private:
 
     void getWordSuggestions(ProximityInfo *proximityInfo, const int *xcoordinates,
-            const int *ycoordinates, const int *codes, const int codesSize, const int flags);
-    bool isDigraph(const int* codes, const int i, const int codesSize) const;
+            const int *ycoordinates, const int *codes, const int inputLength,
+            const int flags, Correction *correction, WordsPriorityQueue *queue);
+    bool isDigraph(const int *codes, const int i, const int codesSize) const;
     void getWordWithDigraphSuggestionsRec(ProximityInfo *proximityInfo,
         const int *xcoordinates, const int* ycoordinates, const int *codesBuffer,
-        const int codesBufferSize, const int flags, const int* codesSrc, const int codesRemain,
-        const int currentDepth, int* codesDest);
+        const int codesBufferSize, const int flags, const int* codesSrc,
+        const int codesRemain, const int currentDepth, int* codesDest, Correction *correction,
+        WordsPriorityQueue* queue);
     void initSuggestions(ProximityInfo *proximityInfo, const int *xcoordinates,
-            const int *ycoordinates, const int *codes, const int codesSize);
-    void getSuggestionCandidates(const bool useFullEditDistance);
-    void addWord(unsigned short *word, int length, int frequency);
-    void getSplitTwoWordsSuggestion(const int inputLength, Correction *correction);
+            const int *ycoordinates, const int *codes, const int codesSize,
+            WordsPriorityQueue *queue);
+    void getSuggestionCandidates(
+            const bool useFullEditDistance, const int inputLength, Correction *correction,
+            WordsPriorityQueue* queue);
+    void getSplitTwoWordsSuggestion(const int inputLength, ProximityInfo *proximityInfo,
+            Correction *correction, WordsPriorityQueue *queue);
     void getMissingSpaceWords(const int inputLength, const int missingSpacePos,
-            Correction *correction, const bool useFullEditDistance);
+            ProximityInfo *proximityInfo, Correction *correction,
+            const bool useFullEditDistance, WordsPriorityQueue *queue);
     void getMistypedSpaceWords(const int inputLength, const int spaceProximityPos,
-            Correction *correction, const bool useFullEditDistance);
-    void onTerminal(const int freq, Correction *correction);
+            ProximityInfo *proximityInfo, Correction *correction,
+            const bool useFullEditDistance, WordsPriorityQueue *queue);
+    void onTerminal(const int freq, Correction *correction, WordsPriorityQueue *queue);
     bool needsToSkipCurrentNode(const unsigned short c,
             const int inputIndex, const int skipPos, const int depth);
     // Process a node by considering proximity, missing and excessive character
-    bool processCurrentNode(const int initialPos,
-            Correction *correction, int *newCount,
-            int *newChildPosition, int *nextSiblingPosition);
+    bool processCurrentNode(const int initialPos, Correction *correction, int *newCount,
+            int *newChildPosition, int *nextSiblingPosition, WordsPriorityQueue *queue);
     int getMostFrequentWordLike(const int startInputIndex, const int inputLength,
-            unsigned short *word);
+            ProximityInfo *proximityInfo, unsigned short *word);
     int getMostFrequentWordLikeInner(const uint16_t* const inWord, const int length,
-            short unsigned int* outWord);
+            short unsigned int *outWord);
 
     const uint8_t* const DICT_ROOT;
     const int MAX_WORD_LENGTH;
@@ -122,13 +129,8 @@
     };
     static const struct digraph_t { int first; int second; } GERMAN_UMLAUT_DIGRAPHS[];
 
-    WordsPriorityQueue *mWordsPriorityQueue;
-    ProximityInfo *mProximityInfo;
-    Correction *mCorrection;
-    int mInputLength;
-    // MAX_WORD_LENGTH_INTERNAL must be bigger than MAX_WORD_LENGTH
-    unsigned short mWord[MAX_WORD_LENGTH_INTERNAL];
-
+    // Still bundled members
+    unsigned short mWord[MAX_WORD_LENGTH_INTERNAL];// TODO: remove
     int mStackChildCount[MAX_WORD_LENGTH_INTERNAL];// TODO: remove
     int mStackInputIndex[MAX_WORD_LENGTH_INTERNAL];// TODO: remove
     int mStackSiblingPos[MAX_WORD_LENGTH_INTERNAL];// TODO: remove
diff --git a/tests/src/com/android/inputmethod/latin/SuggestTestsBase.java b/tests/src/com/android/inputmethod/latin/SuggestTestsBase.java
index 7029dde..7b4c6a9 100644
--- a/tests/src/com/android/inputmethod/latin/SuggestTestsBase.java
+++ b/tests/src/com/android/inputmethod/latin/SuggestTestsBase.java
@@ -21,7 +21,6 @@
 import android.test.AndroidTestCase;
 import android.text.TextUtils;
 import android.util.DisplayMetrics;
-import android.view.inputmethod.EditorInfo;
 
 import com.android.inputmethod.keyboard.KeyboardId;
 
@@ -52,7 +51,7 @@
         }
         return new KeyboardId(com.android.inputmethod.latin.R.xml.kbd_qwerty,
                 KeyboardId.ELEMENT_ALPHABET, locale, orientation, width, KeyboardId.MODE_TEXT,
-                new EditorInfo(), false, KeyboardId.F2KEY_MODE_NONE, false, false, false);
+                null, false, false, false, false);
     }
 
     protected InputStream openTestRawResource(int resIdInTest) {