diff --git a/java/res/values/strings.xml b/java/res/values/strings.xml
index f4d072d..f618473 100644
--- a/java/res/values/strings.xml
+++ b/java/res/values/strings.xml
@@ -484,8 +484,6 @@
     <string name="prefs_read_external_dictionary">Read external dictionary file</string>
     <!-- Title of the settings for using only personalization dictionary -->
     <string name="prefs_use_only_personalization_dictionary" translatable="false">Use only personalization dictionary</string>
-    <!-- Title of the settings for boosting personalization dictionary -->
-    <string name="prefs_boost_personalization_dictionary" translatable="false">Boost personalization dictionary</string>
     <!-- Message to show when there are no files to install as an external dictionary [CHAR LIMIT=100] -->
     <string name="read_external_dictionary_no_files_message">No dictionary files in the Downloads folder</string>
     <!-- Title of the dialog that selects a file to install as an external dictionary [CHAR LIMIT=50] -->
diff --git a/java/res/xml/prefs_for_debug.xml b/java/res/xml/prefs_for_debug.xml
index 124c443..8d9508e 100644
--- a/java/res/xml/prefs_for_debug.xml
+++ b/java/res/xml/prefs_for_debug.xml
@@ -58,12 +58,6 @@
         android:persistent="true"
         android:title="@string/prefs_use_only_personalization_dictionary" />
 
-    <CheckBoxPreference
-        android:defaultValue="false"
-        android:key="boost_personalization_dictionary_for_debug"
-        android:persistent="true"
-        android:title="@string/prefs_boost_personalization_dictionary" />
-
     <PreferenceScreen
         android:key="read_external_dictionary"
         android:title="@string/prefs_read_external_dictionary" />
diff --git a/java/src/com/android/inputmethod/keyboard/PointerTracker.java b/java/src/com/android/inputmethod/keyboard/PointerTracker.java
index 3fee6c6..d4e3e29 100644
--- a/java/src/com/android/inputmethod/keyboard/PointerTracker.java
+++ b/java/src/com/android/inputmethod/keyboard/PointerTracker.java
@@ -203,6 +203,7 @@
     // true if dragging finger is allowed.
     private boolean mIsAllowedDraggingFinger;
 
+    private final GestureStrokeRecognitionPoints mGestureStrokeRecognitionPoints;
     private final GestureStrokeDrawingPoints mGestureStrokeDrawingPoints;
 
     // TODO: Add PointerTrackerFactory singleton and move some class static methods into it.
@@ -286,8 +287,9 @@
 
     private PointerTracker(final int id) {
         mPointerId = id;
-        mGestureStrokeDrawingPoints = new GestureStrokeDrawingPoints(
-                id, sGestureStrokeRecognitionParams, sGestureStrokeDrawingParams);
+        mGestureStrokeRecognitionPoints = new GestureStrokeRecognitionPoints(
+                id, sGestureStrokeRecognitionParams);
+        mGestureStrokeDrawingPoints = new GestureStrokeDrawingPoints(sGestureStrokeDrawingParams);
     }
 
     // Returns true if keyboard has been changed by this callback.
@@ -408,7 +410,7 @@
         mKeyboardLayoutHasBeenChanged = true;
         final int keyWidth = mKeyboard.mMostCommonKeyWidth;
         final int keyHeight = mKeyboard.mMostCommonKeyHeight;
-        mGestureStrokeDrawingPoints.setKeyboardGeometry(keyWidth, mKeyboard.mOccupiedHeight);
+        mGestureStrokeRecognitionPoints.setKeyboardGeometry(keyWidth, mKeyboard.mOccupiedHeight);
         final Key newKey = mKeyDetector.detectHitKey(mKeyX, mKeyY);
         if (newKey != mCurrentKey) {
             if (sDrawingProxy != null) {
@@ -581,7 +583,7 @@
      * @return true if the batch input has started successfully.
      */
     private boolean mayStartBatchInput() {
-        if (!mGestureStrokeDrawingPoints.isStartOfAGesture()) {
+        if (!mGestureStrokeRecognitionPoints.isStartOfAGesture()) {
             return false;
         }
         if (DEBUG_LISTENER) {
@@ -609,13 +611,13 @@
 
     public void updateBatchInputByTimer(final long syntheticMoveEventTime) {
         final int gestureTime = (int)(syntheticMoveEventTime - sGestureFirstDownTime);
-        mGestureStrokeDrawingPoints.duplicateLastPointWith(gestureTime);
+        mGestureStrokeRecognitionPoints.duplicateLastPointWith(gestureTime);
         updateBatchInput(syntheticMoveEventTime);
     }
 
     private void updateBatchInput(final long moveEventTime) {
         synchronized (sAggregatedPointers) {
-            final GestureStrokeRecognitionPoints stroke = mGestureStrokeDrawingPoints;
+            final GestureStrokeRecognitionPoints stroke = mGestureStrokeRecognitionPoints;
             stroke.appendIncrementalBatchPoints(sAggregatedPointers);
             final int size = sAggregatedPointers.getPointerSize();
             if (size > sLastRecognitionPointSize
@@ -642,7 +644,7 @@
     private boolean mayEndBatchInput(final long upEventTime) {
         boolean hasEndBatchInputSuccessfully = false;
         synchronized (sAggregatedPointers) {
-            mGestureStrokeDrawingPoints.appendAllBatchPoints(sAggregatedPointers);
+            mGestureStrokeRecognitionPoints.appendAllBatchPoints(sAggregatedPointers);
             if (getActivePointerTrackerCount() == 1) {
                 hasEndBatchInputSuccessfully = true;
                 sTypingTimeRecorder.onEndBatchInput(upEventTime);
@@ -754,8 +756,12 @@
             if (getActivePointerTrackerCount() == 1) {
                 sGestureFirstDownTime = eventTime;
             }
-            mGestureStrokeDrawingPoints.onDownEvent(x, y, eventTime, sGestureFirstDownTime,
-                    sTypingTimeRecorder.getLastLetterTypingTime());
+            final int elapsedTimeSinceFirstDown = (int)(eventTime - sGestureFirstDownTime);
+            final int elapsedTimeSinceLastTyping = (int)(
+                    eventTime - sTypingTimeRecorder.getLastLetterTypingTime());
+            mGestureStrokeRecognitionPoints.onDownEvent(x, y, elapsedTimeSinceFirstDown,
+                    elapsedTimeSinceLastTyping);
+            mGestureStrokeDrawingPoints.onDownEvent(x, y, elapsedTimeSinceFirstDown);
         }
     }
 
@@ -814,11 +820,11 @@
         if (!mIsDetectingGesture) {
             return;
         }
-        final int beforeLength = mGestureStrokeDrawingPoints.getLength();
-        final int gestureTime = (int)(eventTime - sGestureFirstDownTime);
-        final boolean onValidArea = mGestureStrokeDrawingPoints.addPointOnKeyboard(
-                x, y, gestureTime, isMajorEvent);
-        if (mGestureStrokeDrawingPoints.getLength() > beforeLength) {
+        final int beforeLength = mGestureStrokeRecognitionPoints.getLength();
+        final int elapsedTimeSinceFirstDown = (int)(eventTime - sGestureFirstDownTime);
+        final boolean onValidArea = mGestureStrokeRecognitionPoints.addPointOnKeyboard(
+                x, y, elapsedTimeSinceFirstDown, isMajorEvent);
+        if (mGestureStrokeRecognitionPoints.getLength() > beforeLength) {
             sTimerProxy.startUpdateBatchInputTimer(this);
         }
         // If the move event goes out from valid batch input area, cancel batch input.
@@ -826,6 +832,7 @@
             cancelBatchInput();
             return;
         }
+        mGestureStrokeDrawingPoints.onMoveEvent(x, y, elapsedTimeSinceFirstDown);
         // If the MoreKeysPanel is showing then do not attempt to enter gesture mode. However,
         // the gestured touch points are still being recorded in case the panel is dismissed.
         if (isShowingMoreKeysPanel()) {
diff --git a/java/src/com/android/inputmethod/keyboard/internal/GestureStrokeDrawingPoints.java b/java/src/com/android/inputmethod/keyboard/internal/GestureStrokeDrawingPoints.java
index 0c09cbc..7618682 100644
--- a/java/src/com/android/inputmethod/keyboard/internal/GestureStrokeDrawingPoints.java
+++ b/java/src/com/android/inputmethod/keyboard/internal/GestureStrokeDrawingPoints.java
@@ -20,11 +20,8 @@
 
 /**
  * This class holds drawing points to represent a gesture stroke on the screen.
- * TODO: Currently this class extends {@link GestureStrokeRecognitionPoints} that holds recognition
- * points of a gesture stroke. This class should be independent from
- * {@link GestureStrokeRecognitionPoints}.
  */
-public final class GestureStrokeDrawingPoints extends GestureStrokeRecognitionPoints {
+public final class GestureStrokeDrawingPoints {
     public static final int PREVIEW_CAPACITY = 256;
 
     private final ResizableIntArray mPreviewEventTimes = new ResizableIntArray(PREVIEW_CAPACITY);
@@ -42,16 +39,11 @@
     private int mLastY;
     private double mDistanceFromLastSample;
 
-    public GestureStrokeDrawingPoints(final int pointerId,
-            final GestureStrokeRecognitionParams recognitionParams,
-            final GestureStrokeDrawingParams drawingParams) {
-        super(pointerId, recognitionParams);
+    public GestureStrokeDrawingPoints(final GestureStrokeDrawingParams drawingParams) {
         mDrawingParams = drawingParams;
     }
 
-    @Override
-    protected void reset() {
-        super.reset();
+    private void reset() {
         mStrokeId++;
         mLastPreviewSize = 0;
         mLastInterpolatedPreviewIndex = 0;
@@ -64,6 +56,11 @@
         return mStrokeId;
     }
 
+    public void onDownEvent(final int x, final int y, final int elapsedTimeSinceFirstDown) {
+        reset();
+        onMoveEvent(x, y, elapsedTimeSinceFirstDown);
+    }
+
     private boolean needsSampling(final int x, final int y) {
         mDistanceFromLastSample += Math.hypot(x - mLastX, y - mLastY);
         mLastX = x;
@@ -76,16 +73,12 @@
         return false;
     }
 
-    @Override
-    public boolean addPointOnKeyboard(final int x, final int y, final int time,
-            final boolean isMajorEvent) {
+    public void onMoveEvent(final int x, final int y, final int elapsedTimeSinceFirstDown) {
         if (needsSampling(x, y)) {
-            mPreviewEventTimes.add(time);
+            mPreviewEventTimes.add(elapsedTimeSinceFirstDown);
             mPreviewXCoordinates.add(x);
             mPreviewYCoordinates.add(y);
         }
-        return super.addPointOnKeyboard(x, y, time, isMajorEvent);
-
     }
 
     /**
diff --git a/java/src/com/android/inputmethod/keyboard/internal/GestureStrokeRecognitionPoints.java b/java/src/com/android/inputmethod/keyboard/internal/GestureStrokeRecognitionPoints.java
index 343c898..5d4f5e8 100644
--- a/java/src/com/android/inputmethod/keyboard/internal/GestureStrokeRecognitionPoints.java
+++ b/java/src/com/android/inputmethod/keyboard/internal/GestureStrokeRecognitionPoints.java
@@ -103,19 +103,17 @@
         return mEventTimes.getLength();
     }
 
-    public void onDownEvent(final int x, final int y, final long downTime,
-            final long gestureFirstDownTime, final long lastTypingTime) {
+    public void onDownEvent(final int x, final int y, final int elapsedTimeSinceFirstDown,
+            final int elapsedTimeSinceLastTyping) {
         reset();
-        final long elapsedTimeAfterTyping = downTime - lastTypingTime;
-        if (elapsedTimeAfterTyping < mRecognitionParams.mStaticTimeThresholdAfterFastTyping) {
+        if (elapsedTimeSinceLastTyping < mRecognitionParams.mStaticTimeThresholdAfterFastTyping) {
             mAfterFastTyping = true;
         }
         if (DEBUG) {
             Log.d(TAG, String.format("[%d] onDownEvent: dT=%3d%s", mPointerId,
-                    elapsedTimeAfterTyping, mAfterFastTyping ? " afterFastTyping" : ""));
+                    elapsedTimeSinceLastTyping, mAfterFastTyping ? " afterFastTyping" : ""));
         }
-        final int elapsedTimeFromFirstDown = (int)(downTime - gestureFirstDownTime);
-        addPointOnKeyboard(x, y, elapsedTimeFromFirstDown, true /* isMajorEvent */);
+        addPointOnKeyboard(x, y, elapsedTimeSinceFirstDown, true /* isMajorEvent */);
     }
 
     private int getGestureDynamicDistanceThreshold(final int deltaTime) {
@@ -184,7 +182,7 @@
         }
     }
 
-    protected void reset() {
+    private void reset() {
         mIncrementalRecognitionSize = 0;
         mLastIncrementalBatchSize = 0;
         mEventTimes.setLength(0);
diff --git a/java/src/com/android/inputmethod/latin/LatinIME.java b/java/src/com/android/inputmethod/latin/LatinIME.java
index 54c6543..68ed238 100644
--- a/java/src/com/android/inputmethod/latin/LatinIME.java
+++ b/java/src/com/android/inputmethod/latin/LatinIME.java
@@ -79,7 +79,6 @@
 import com.android.inputmethod.latin.settings.SettingsValues;
 import com.android.inputmethod.latin.suggestions.SuggestionStripView;
 import com.android.inputmethod.latin.utils.ApplicationUtils;
-import com.android.inputmethod.latin.utils.AutoCorrectionUtils;
 import com.android.inputmethod.latin.utils.CapsModeUtils;
 import com.android.inputmethod.latin.utils.CompletionInfoUtils;
 import com.android.inputmethod.latin.utils.IntentUtils;
@@ -128,8 +127,6 @@
     private final SubtypeSwitcher mSubtypeSwitcher;
     private final SubtypeState mSubtypeState = new SubtypeState();
 
-    private UserBinaryDictionary mUserDictionary;
-
     // Object for reacting to adding/removing a dictionary pack.
     private BroadcastReceiver mDictionaryPackInstallReceiver =
             new DictionaryPackInstallBroadcastReceiver(this);
@@ -518,6 +515,7 @@
         final SettingsValues currentSettingsValues = mSettings.getCurrent();
         if (!mHandler.hasPendingReopenDictionaries() && mInputLogic.mSuggest != null) {
             // May need to reset dictionaries depending on the user settings.
+            // TODO: Quit setting dictionaries from LatinIME.
             mInputLogic.mSuggest.setAdditionalDictionaries(mInputLogic.mSuggest /* oldSuggest */,
                    currentSettingsValues);
         }
@@ -555,9 +553,9 @@
             subtypeLocale = switcherSubtypeLocale;
         }
 
-        final Suggest newSuggest = new Suggest(this /* Context */, subtypeLocale,
-                this /* SuggestInitializationListener */);
         final SettingsValues settingsValues = mSettings.getCurrent();
+        final Suggest newSuggest = new Suggest(this /* Context */, subtypeLocale, settingsValues,
+                this /* SuggestInitializationListener */);
         if (settingsValues.mCorrectionEnabled) {
             newSuggest.setAutoCorrectionThreshold(settingsValues.mAutoCorrectionThreshold);
         }
@@ -565,11 +563,8 @@
         if (ProductionFlag.USES_DEVELOPMENT_ONLY_DIAGNOSTICS) {
             ResearchLogger.getInstance().initSuggest(newSuggest);
         }
-
-        mUserDictionary = new UserBinaryDictionary(this, subtypeLocale);
-        newSuggest.setUserDictionary(mUserDictionary);
-        newSuggest.setAdditionalDictionaries(mInputLogic.mSuggest /* oldSuggest */,
-                mSettings.getCurrent());
+        // TODO: Quit setting dictionaries from LatinIME.
+        newSuggest.setAdditionalDictionaries(mInputLogic.mSuggest /* oldSuggest */, settingsValues);
         final Suggest oldSuggest = mInputLogic.mSuggest;
         mInputLogic.mSuggest = newSuggest;
         if (oldSuggest != null) oldSuggest.close();
@@ -1208,7 +1203,7 @@
         } else {
             wordToEdit = word;
         }
-        mUserDictionary.addWordToUserDictionary(wordToEdit);
+        mInputLogic.mSuggest.addWordToUserDictionary(wordToEdit);
     }
 
     public void displaySettingsDialog() {
@@ -1739,13 +1734,13 @@
                         || SuggestedWordInfo.KIND_OOV_CORRECTION == suggestionInfo.mKind)
                         && suggest != null
                         // If the suggestion is not in the dictionary, the hint should be shown.
-                        && !AutoCorrectionUtils.isValidWord(suggest, suggestion, true);
+                        && !suggest.isValidWord(suggestion, true);
 
         if (currentSettings.mIsInternal) {
             LatinImeLoggerUtils.onSeparator((char)Constants.CODE_SPACE,
                     Constants.NOT_A_COORDINATE, Constants.NOT_A_COORDINATE);
         }
-        if (showingAddToDictionaryHint && mUserDictionary.mEnabled) {
+        if (showingAddToDictionaryHint && suggest.isUserDictionaryEnabled()) {
             mSuggestionStripView.showAddToDictionaryHint(
                     suggestion, currentSettings.mHintToSaveText);
         } else {
diff --git a/java/src/com/android/inputmethod/latin/Suggest.java b/java/src/com/android/inputmethod/latin/Suggest.java
index 32ab1f3..1684122 100644
--- a/java/src/com/android/inputmethod/latin/Suggest.java
+++ b/java/src/com/android/inputmethod/latin/Suggest.java
@@ -17,7 +17,6 @@
 package com.android.inputmethod.latin;
 
 import android.content.Context;
-import android.preference.PreferenceManager;
 import android.text.TextUtils;
 import android.util.Log;
 
@@ -27,7 +26,6 @@
 import com.android.inputmethod.latin.personalization.PersonalizationDictionary;
 import com.android.inputmethod.latin.personalization.PersonalizationHelper;
 import com.android.inputmethod.latin.personalization.UserHistoryDictionary;
-import com.android.inputmethod.latin.settings.Settings;
 import com.android.inputmethod.latin.settings.SettingsValues;
 import com.android.inputmethod.latin.utils.AutoCorrectionUtils;
 import com.android.inputmethod.latin.utils.BoundedTreeSet;
@@ -39,11 +37,13 @@
 import java.util.HashSet;
 import java.util.Locale;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.TimeUnit;
 
 /**
  * This class loads a dictionary and provides a list of suggestions for a given sequence of
  * characters. This includes corrections and completions.
  */
+// TODO: Separate dictionary operations from suggestions handling logic.
 public final class Suggest {
     public static final String TAG = Suggest.class.getSimpleName();
 
@@ -74,6 +74,7 @@
     private HashSet<String> mOnlyDictionarySetForDebug = null;
     private Dictionary mMainDictionary;
     private ContactsBinaryDictionary mContactsDictionary;
+    private UserBinaryDictionary mUserDictionary;
     private UserHistoryDictionary mUserHistoryDictionary;
     private PersonalizationDictionary mPersonalizationDictionary;
     @UsedForTesting
@@ -86,18 +87,17 @@
 
     private final Context mContext;
 
-    public Suggest(final Context context, final Locale locale,
+    public Suggest(final Context context, final Locale locale, final SettingsValues settingsValues,
             final SuggestInitializationListener listener) {
         initAsynchronously(context, locale, listener);
         mLocale = locale;
         mContext = context;
-        // TODO: Use SettingsValues instead of Settings.
         // initialize a debug flag for the personalization
-        if (Settings.readUseOnlyPersonalizationDictionaryForDebug(
-                PreferenceManager.getDefaultSharedPreferences(context))) {
+        if (settingsValues.mUseOnlyPersonalizationDictionaryForDebug) {
             mOnlyDictionarySetForDebug = new HashSet<String>();
             mOnlyDictionarySetForDebug.add(Dictionary.TYPE_PERSONALIZATION);
         }
+        setUserDictionary(new UserBinaryDictionary(context, locale));
     }
 
     @UsedForTesting
@@ -171,27 +171,13 @@
         return mMainDictionary;
     }
 
-    public ContactsBinaryDictionary getContactsDictionary() {
-        return mContactsDictionary;
-    }
-
-    public UserHistoryDictionary getUserHistoryDictionary() {
-        return mUserHistoryDictionary;
-    }
-
-    public PersonalizationDictionary getPersonalizationDictionary() {
-        return mPersonalizationDictionary;
-    }
-
-    public ConcurrentHashMap<String, Dictionary> getUnigramDictionaries() {
-        return mDictionaries;
-    }
-
     /**
      * Sets an optional user dictionary resource to be loaded. The user dictionary is consulted
      * before the main dictionary, if set. This refers to the system-managed user dictionary.
      */
+    @UsedForTesting
     public void setUserDictionary(final UserBinaryDictionary userDictionary) {
+        mUserDictionary = userDictionary;
         addOrReplaceDictionaryInternal(Dictionary.TYPE_USER, userDictionary);
     }
 
@@ -200,17 +186,18 @@
      * the contacts dictionary by passing null to this method. In this case no contacts dictionary
      * won't be used.
      */
+    @UsedForTesting
     public void setContactsDictionary(final ContactsBinaryDictionary contactsDictionary) {
         mContactsDictionary = contactsDictionary;
         addOrReplaceDictionaryInternal(Dictionary.TYPE_CONTACTS, contactsDictionary);
     }
 
-    public void setUserHistoryDictionary(final UserHistoryDictionary userHistoryDictionary) {
+    private void setUserHistoryDictionary(final UserHistoryDictionary userHistoryDictionary) {
         mUserHistoryDictionary = userHistoryDictionary;
         addOrReplaceDictionaryInternal(Dictionary.TYPE_USER_HISTORY, userHistoryDictionary);
     }
 
-    public void setPersonalizationDictionary(
+    private void setPersonalizationDictionary(
             final PersonalizationDictionary personalizationDictionary) {
         mPersonalizationDictionary = personalizationDictionary;
         addOrReplaceDictionaryInternal(Dictionary.TYPE_PERSONALIZATION, personalizationDictionary);
@@ -225,7 +212,7 @@
     public void setAdditionalDictionaries(final Suggest oldSuggest,
             final SettingsValues settingsValues) {
         // Contacts dictionary
-        resetContactsDictionary(null != oldSuggest ? oldSuggest.getContactsDictionary() : null,
+        resetContactsDictionary(null != oldSuggest ? oldSuggest.mContactsDictionary : null,
                 settingsValues);
         // User history dictionary & Personalization dictionary
         resetPersonalizedDictionaries(oldSuggest, settingsValues);
@@ -245,9 +232,9 @@
         final boolean shouldSetDictionaries = settingsValues.mUsePersonalizedDicts;
 
         final UserHistoryDictionary oldUserHistoryDictionary = (null == oldSuggest) ? null :
-                oldSuggest.getUserHistoryDictionary();
+                oldSuggest.mUserHistoryDictionary;
         final PersonalizationDictionary oldPersonalizationDictionary = (null == oldSuggest) ? null :
-                oldSuggest.getPersonalizationDictionary();
+                oldSuggest.mPersonalizationDictionary;
         final UserHistoryDictionary userHistoryDictionaryToUse;
         final PersonalizationDictionary personalizationDictionaryToUse;
         if (!shouldSetDictionaries) {
@@ -311,6 +298,43 @@
         setContactsDictionary(dictionaryToUse);
     }
 
+    public boolean isUserDictionaryEnabled() {
+        if (mUserDictionary == null) {
+            return false;
+        }
+        return mUserDictionary.mEnabled;
+    }
+
+    public void addWordToUserDictionary(String word) {
+        if (mUserDictionary == null) {
+            return;
+        }
+        mUserDictionary.addWordToUserDictionary(word);
+    }
+
+    public String addToUserHistory(final WordComposer wordComposer, final String previousWord,
+            final String suggestion) {
+        if (mUserHistoryDictionary == null) {
+            return null;
+        }
+        final String secondWord;
+        if (wordComposer.wasAutoCapitalized() && !wordComposer.isMostlyCaps()) {
+            secondWord = suggestion.toLowerCase(mLocale);
+        } else {
+            secondWord = suggestion;
+        }
+        // We demote unrecognized words (frequency < 0, below) by specifying them as "invalid".
+        // We don't add words with 0-frequency (assuming they would be profanity etc.).
+        final int maxFreq = getMaxFrequency(suggestion);
+        if (maxFreq == 0) {
+            return null;
+        }
+        final boolean isValid = maxFreq > 0;
+        final int timeStamp = (int)TimeUnit.MILLISECONDS.toSeconds((System.currentTimeMillis()));
+        mUserHistoryDictionary.addToDictionary(previousWord, secondWord, isValid, timeStamp);
+        return previousWord;
+    }
+
     public void cancelAddingUserHistory(final String previousWord, final String committedWord) {
         if (mUserHistoryDictionary != null) {
             mUserHistoryDictionary.cancelAddingUserHistory(previousWord, committedWord);
@@ -389,8 +413,8 @@
         // or if it's a 2+ characters non-word (i.e. it's not in the dictionary).
         final boolean allowsToBeAutoCorrected = (null != whitelistedWord
                 && !whitelistedWord.equals(consideredWord))
-                || (consideredWord.length() > 1 && !AutoCorrectionUtils.isValidWord(this,
-                        consideredWord, wordComposer.isFirstCharCapitalized()));
+                || (consideredWord.length() > 1
+                        && !isValidWord(consideredWord, wordComposer.isFirstCharCapitalized()));
 
         final boolean hasAutoCorrection;
         // TODO: using isCorrectionEnabled here is not very good. It's probably useless, because
@@ -594,6 +618,45 @@
                 wordInfo.mAutoCommitFirstWordConfidence);
     }
 
+    public boolean isValidWord(final String word, final boolean ignoreCase) {
+        if (TextUtils.isEmpty(word)) {
+            return false;
+        }
+        final String lowerCasedWord = word.toLowerCase(mLocale);
+        for (final String key : mDictionaries.keySet()) {
+            final Dictionary dictionary = mDictionaries.get(key);
+            // It's unclear how realistically 'dictionary' can be null, but the monkey is somehow
+            // managing to get null in here. Presumably the language is changing to a language with
+            // no main dictionary and the monkey manages to type a whole word before the thread
+            // that reads the dictionary is started or something?
+            // Ideally the passed map would come out of a {@link java.util.concurrent.Future} and
+            // would be immutable once it's finished initializing, but concretely a null test is
+            // probably good enough for the time being.
+            if (null == dictionary) continue;
+            if (dictionary.isValidWord(word)
+                    || (ignoreCase && dictionary.isValidWord(lowerCasedWord))) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private int getMaxFrequency(final String word) {
+        if (TextUtils.isEmpty(word)) {
+            return Dictionary.NOT_A_PROBABILITY;
+        }
+        int maxFreq = -1;
+        for (final String key : mDictionaries.keySet()) {
+            final Dictionary dictionary = mDictionaries.get(key);
+            if (null == dictionary) continue;
+            final int tempFreq = dictionary.getFrequency(word);
+            if (tempFreq >= maxFreq) {
+                maxFreq = tempFreq;
+            }
+        }
+        return maxFreq;
+    }
+
     public void close() {
         final HashSet<Dictionary> dictionaries = CollectionUtils.newHashSet();
         dictionaries.addAll(mDictionaries.values());
diff --git a/java/src/com/android/inputmethod/latin/inputlogic/InputLogic.java b/java/src/com/android/inputmethod/latin/inputlogic/InputLogic.java
index fe5b69f..61d4bab 100644
--- a/java/src/com/android/inputmethod/latin/inputlogic/InputLogic.java
+++ b/java/src/com/android/inputmethod/latin/inputlogic/InputLogic.java
@@ -44,12 +44,10 @@
 import com.android.inputmethod.latin.SuggestedWords.SuggestedWordInfo;
 import com.android.inputmethod.latin.WordComposer;
 import com.android.inputmethod.latin.define.ProductionFlag;
-import com.android.inputmethod.latin.personalization.UserHistoryDictionary;
 import com.android.inputmethod.latin.settings.Settings;
 import com.android.inputmethod.latin.settings.SettingsValues;
 import com.android.inputmethod.latin.suggestions.SuggestionStripView;
 import com.android.inputmethod.latin.utils.AsyncResultHolder;
-import com.android.inputmethod.latin.utils.AutoCorrectionUtils;
 import com.android.inputmethod.latin.utils.CollectionUtils;
 import com.android.inputmethod.latin.utils.InputTypeUtils;
 import com.android.inputmethod.latin.utils.LatinImeLoggerUtils;
@@ -60,7 +58,6 @@
 
 import java.util.ArrayList;
 import java.util.TreeSet;
-import java.util.concurrent.TimeUnit;
 
 /**
  * This class manages the input logic.
@@ -983,24 +980,8 @@
         final Suggest suggest = mSuggest;
         if (suggest == null) return null;
 
-        final UserHistoryDictionary userHistoryDictionary = suggest.getUserHistoryDictionary();
-        if (userHistoryDictionary == null) return null;
-
         final String prevWord = mConnection.getNthPreviousWord(settingsValues, 2);
-        final String secondWord;
-        if (mWordComposer.wasAutoCapitalized() && !mWordComposer.isMostlyCaps()) {
-            secondWord = suggestion.toLowerCase(settingsValues.mLocale);
-        } else {
-            secondWord = suggestion;
-        }
-        // We demote unrecognized words (frequency < 0, below) by specifying them as "invalid".
-        // We don't add words with 0-frequency (assuming they would be profanity etc.).
-        final int maxFreq = AutoCorrectionUtils.getMaxFrequency(
-                suggest.getUnigramDictionaries(), suggestion);
-        if (maxFreq == 0) return null;
-        userHistoryDictionary.addToDictionary(prevWord, secondWord, maxFreq > 0,
-                (int)TimeUnit.MILLISECONDS.toSeconds((System.currentTimeMillis())));
-        return prevWord;
+        return suggest.addToUserHistory(mWordComposer, prevWord, suggestion);
     }
 
     public void performUpdateSuggestionStripSync(final SettingsValues settingsValues,
diff --git a/java/src/com/android/inputmethod/latin/settings/DebugSettings.java b/java/src/com/android/inputmethod/latin/settings/DebugSettings.java
index d060485..29bbed8 100644
--- a/java/src/com/android/inputmethod/latin/settings/DebugSettings.java
+++ b/java/src/com/android/inputmethod/latin/settings/DebugSettings.java
@@ -39,8 +39,6 @@
     public static final String PREF_STATISTICS_LOGGING = "enable_logging";
     public static final String PREF_USE_ONLY_PERSONALIZATION_DICTIONARY_FOR_DEBUG =
             "use_only_personalization_dictionary_for_debug";
-    public static final String PREF_BOOST_PERSONALIZATION_DICTIONARY_FOR_DEBUG =
-            "boost_personalization_dictionary_for_debug";
     private static final String PREF_READ_EXTERNAL_DICTIONARY = "read_external_dictionary";
     private static final boolean SHOW_STATISTICS_LOGGING = false;
 
diff --git a/java/src/com/android/inputmethod/latin/settings/Settings.java b/java/src/com/android/inputmethod/latin/settings/Settings.java
index 64f53b5..75c7258 100644
--- a/java/src/com/android/inputmethod/latin/settings/Settings.java
+++ b/java/src/com/android/inputmethod/latin/settings/Settings.java
@@ -358,18 +358,6 @@
         return prefs.getBoolean(Settings.PREF_KEY_IS_INTERNAL, false);
     }
 
-    public static boolean readUseOnlyPersonalizationDictionaryForDebug(
-            final SharedPreferences prefs) {
-        return prefs.getBoolean(
-                DebugSettings.PREF_USE_ONLY_PERSONALIZATION_DICTIONARY_FOR_DEBUG, false);
-    }
-
-    public static boolean readBoostPersonalizationDictionaryForDebug(
-            final SharedPreferences prefs) {
-        return prefs.getBoolean(
-                DebugSettings.PREF_BOOST_PERSONALIZATION_DICTIONARY_FOR_DEBUG, false);
-    }
-
     public void writeLastUsedPersonalizationToken(byte[] token) {
         if (token == null) {
             mPrefs.edit().remove(PREF_LAST_USED_PERSONALIZATION_TOKEN).apply();
diff --git a/java/src/com/android/inputmethod/latin/settings/SettingsValues.java b/java/src/com/android/inputmethod/latin/settings/SettingsValues.java
index 64c0c8e..a07a0ce 100644
--- a/java/src/com/android/inputmethod/latin/settings/SettingsValues.java
+++ b/java/src/com/android/inputmethod/latin/settings/SettingsValues.java
@@ -99,7 +99,6 @@
     public final float mAutoCorrectionThreshold;
     public final boolean mCorrectionEnabled;
     public final int mSuggestionVisibility;
-    public final boolean mBoostPersonalizationDictionaryForDebug;
     public final boolean mUseOnlyPersonalizationDictionaryForDebug;
     public final int mDisplayOrientation;
     private final AsyncResultHolder<AppWorkaroundsUtils> mAppWorkarounds;
@@ -181,10 +180,8 @@
         AdditionalFeaturesSettingUtils.readAdditionalFeaturesPreferencesIntoArray(
                 prefs, mAdditionalFeaturesSettingValues);
         mIsInternal = Settings.isInternal(prefs);
-        mBoostPersonalizationDictionaryForDebug =
-                Settings.readBoostPersonalizationDictionaryForDebug(prefs);
-        mUseOnlyPersonalizationDictionaryForDebug =
-                Settings.readUseOnlyPersonalizationDictionaryForDebug(prefs);
+        mUseOnlyPersonalizationDictionaryForDebug = prefs.getBoolean(
+                DebugSettings.PREF_USE_ONLY_PERSONALIZATION_DICTIONARY_FOR_DEBUG, false);
         mDisplayOrientation = res.getConfiguration().orientation;
         mAppWorkarounds = new AsyncResultHolder<AppWorkaroundsUtils>();
         final PackageInfo packageInfo = TargetPackageInfoGetterTask.getCachedPackageInfo(
@@ -241,7 +238,6 @@
         mCorrectionEnabled = mAutoCorrectEnabled && !mInputAttributes.mInputTypeNoAutoCorrect;
         mSuggestionVisibility = 0;
         mIsInternal = false;
-        mBoostPersonalizationDictionaryForDebug = false;
         mUseOnlyPersonalizationDictionaryForDebug = false;
         mDisplayOrientation = Configuration.ORIENTATION_PORTRAIT;
         mAppWorkarounds = new AsyncResultHolder<AppWorkaroundsUtils>();
diff --git a/java/src/com/android/inputmethod/latin/utils/AutoCorrectionUtils.java b/java/src/com/android/inputmethod/latin/utils/AutoCorrectionUtils.java
index 066c5fd..37c173f 100644
--- a/java/src/com/android/inputmethod/latin/utils/AutoCorrectionUtils.java
+++ b/java/src/com/android/inputmethod/latin/utils/AutoCorrectionUtils.java
@@ -17,16 +17,11 @@
 package com.android.inputmethod.latin.utils;
 
 import com.android.inputmethod.latin.BinaryDictionary;
-import com.android.inputmethod.latin.Dictionary;
 import com.android.inputmethod.latin.LatinImeLogger;
-import com.android.inputmethod.latin.Suggest;
 import com.android.inputmethod.latin.SuggestedWords.SuggestedWordInfo;
 
-import android.text.TextUtils;
 import android.util.Log;
 
-import java.util.concurrent.ConcurrentHashMap;
-
 public final class AutoCorrectionUtils {
     private static final boolean DBG = LatinImeLogger.sDBG;
     private static final String TAG = AutoCorrectionUtils.class.getSimpleName();
@@ -36,48 +31,6 @@
         // Purely static class: can't instantiate.
     }
 
-    public static boolean isValidWord(final Suggest suggest, final String word,
-            final boolean ignoreCase) {
-        if (TextUtils.isEmpty(word)) {
-            return false;
-        }
-        final ConcurrentHashMap<String, Dictionary> dictionaries = suggest.getUnigramDictionaries();
-        final String lowerCasedWord = word.toLowerCase(suggest.mLocale);
-        for (final String key : dictionaries.keySet()) {
-            final Dictionary dictionary = dictionaries.get(key);
-            // It's unclear how realistically 'dictionary' can be null, but the monkey is somehow
-            // managing to get null in here. Presumably the language is changing to a language with
-            // no main dictionary and the monkey manages to type a whole word before the thread
-            // that reads the dictionary is started or something?
-            // Ideally the passed map would come out of a {@link java.util.concurrent.Future} and
-            // would be immutable once it's finished initializing, but concretely a null test is
-            // probably good enough for the time being.
-            if (null == dictionary) continue;
-            if (dictionary.isValidWord(word)
-                    || (ignoreCase && dictionary.isValidWord(lowerCasedWord))) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    public static int getMaxFrequency(final ConcurrentHashMap<String, Dictionary> dictionaries,
-            final String word) {
-        if (TextUtils.isEmpty(word)) {
-            return Dictionary.NOT_A_PROBABILITY;
-        }
-        int maxFreq = -1;
-        for (final String key : dictionaries.keySet()) {
-            final Dictionary dictionary = dictionaries.get(key);
-            if (null == dictionary) continue;
-            final int tempFreq = dictionary.getFrequency(word);
-            if (tempFreq >= maxFreq) {
-                maxFreq = tempFreq;
-            }
-        }
-        return maxFreq;
-    }
-
     public static boolean suggestionExceedsAutoCorrectionThreshold(
             final SuggestedWordInfo suggestion, final String consideredWord,
             final float autoCorrectionThreshold) {