diff --git a/java/src/com/android/inputmethod/latin/LastComposedWord.java b/java/src/com/android/inputmethod/latin/LastComposedWord.java
new file mode 100644
index 0000000..dcecdb3
--- /dev/null
+++ b/java/src/com/android/inputmethod/latin/LastComposedWord.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.android.inputmethod.latin;
+
+/**
+ * This class encapsulates data about a word previously composed, but that has been
+ * committed already. This is used for resuming suggestion, and cancel auto-correction.
+ */
+public class LastComposedWord {
+    // COMMIT_TYPE_USER_TYPED_WORD is used when the word committed is the exact typed word, with
+    // no hinting from the IME. It happens when some external event happens (rotating the device,
+    // for example) or when auto-correction is off by settings or editor attributes.
+    public static final int COMMIT_TYPE_USER_TYPED_WORD = 0;
+    // COMMIT_TYPE_MANUAL_PICK is used when the user pressed a field in the suggestion strip.
+    public static final int COMMIT_TYPE_MANUAL_PICK = 1;
+    // COMMIT_TYPE_DECIDED_WORD is used when the IME commits the word it decided was best
+    // for the current user input. It may be different from what the user typed (true auto-correct)
+    // or it may be exactly what the user typed if it's in the dictionary or the IME does not have
+    // enough confidence in any suggestion to auto-correct (auto-correct to typed word).
+    public static final int COMMIT_TYPE_DECIDED_WORD = 2;
+    // COMMIT_TYPE_CANCEL_AUTO_CORRECT is used upon committing back the old word upon cancelling
+    // an auto-correction.
+    public static final int COMMIT_TYPE_CANCEL_AUTO_CORRECT = 3;
+
+    public final int mType;
+
+    public LastComposedWord(final int type) {
+        mType = type;
+    }
+}
diff --git a/java/src/com/android/inputmethod/latin/LatinIME.java b/java/src/com/android/inputmethod/latin/LatinIME.java
index f2fa788..51e3998 100644
--- a/java/src/com/android/inputmethod/latin/LatinIME.java
+++ b/java/src/com/android/inputmethod/latin/LatinIME.java
@@ -1096,7 +1096,7 @@
     public void commitTyped(final InputConnection ic) {
         if (!mWordComposer.isComposingWord()) return;
         final CharSequence typedWord = mWordComposer.getTypedWord();
-        mWordComposer.onCommitWord(WordComposer.COMMIT_TYPE_USER_TYPED_WORD);
+        mWordComposer.onCommitWord(LastComposedWord.COMMIT_TYPE_USER_TYPED_WORD);
         if (typedWord.length() > 0) {
             if (ic != null) {
                 ic.commitText(typedWord, 1);
@@ -1847,7 +1847,7 @@
             }
             Utils.Stats.onAutoCorrection(typedWord, autoCorrection.toString(), separatorCodePoint);
             mExpectingUpdateSelection = true;
-            commitChosenWord(autoCorrection, WordComposer.COMMIT_TYPE_DECIDED_WORD);
+            commitChosenWord(autoCorrection, LastComposedWord.COMMIT_TYPE_DECIDED_WORD);
             // Add the word to the user unigram dictionary if it's not a known word
             addToUserUnigramAndBigramDictionaries(autoCorrection,
                     UserUnigramDictionary.FREQUENCY_FOR_TYPED);
@@ -1917,7 +1917,7 @@
         LatinImeLogger.logOnManualSuggestion(mWordComposer.getTypedWord().toString(),
                 suggestion.toString(), index, suggestions.mWords);
         mExpectingUpdateSelection = true;
-        commitChosenWord(suggestion, WordComposer.COMMIT_TYPE_MANUAL_PICK);
+        commitChosenWord(suggestion, LastComposedWord.COMMIT_TYPE_MANUAL_PICK);
         // Add the word to the auto dictionary if it's not a known word
         if (index == 0) {
             addToUserUnigramAndBigramDictionaries(suggestion,
@@ -2176,7 +2176,7 @@
         // Re-insert the separator
         ic.commitText(separator, 1);
         mWordComposer.deleteAutoCorrection();
-        mWordComposer.onCommitWord(WordComposer.COMMIT_TYPE_CANCEL_AUTO_CORRECT);
+        mWordComposer.onCommitWord(LastComposedWord.COMMIT_TYPE_CANCEL_AUTO_CORRECT);
         Utils.Stats.onSeparator(separator.charAt(0), WordComposer.NOT_A_COORDINATE,
                 WordComposer.NOT_A_COORDINATE);
         mHandler.cancelUpdateBigramPredictions();
diff --git a/java/src/com/android/inputmethod/latin/WordComposer.java b/java/src/com/android/inputmethod/latin/WordComposer.java
index e95dcfd..02968c9 100644
--- a/java/src/com/android/inputmethod/latin/WordComposer.java
+++ b/java/src/com/android/inputmethod/latin/WordComposer.java
@@ -33,23 +33,6 @@
     public static final int NOT_A_CODE = KeyDetector.NOT_A_CODE;
     public static final int NOT_A_COORDINATE = -1;
 
-    // TODO: Straighten out commit behavior so that the flags here are more understandable,
-    // and possibly adjust their names.
-    // COMMIT_TYPE_USER_TYPED_WORD is used when the word committed is the exact typed word, with
-    // no hinting from the IME. It happens when some external event happens (rotating the device,
-    // for example) or when auto-correction is off by settings or editor attributes.
-    public static final int COMMIT_TYPE_USER_TYPED_WORD = 0;
-    // COMMIT_TYPE_MANUAL_PICK is used when the user pressed a field in the suggestion strip.
-    public static final int COMMIT_TYPE_MANUAL_PICK = 1;
-    // COMMIT_TYPE_DECIDED_WORD is used when the IME commits the word it decided was best
-    // for the current user input. It may be different from what the user typed (true auto-correct)
-    // or it may be exactly what the user typed if it's in the dictionary or the IME does not have
-    // enough confidence in any suggestion to auto-correct (auto-correct to typed word).
-    public static final int COMMIT_TYPE_DECIDED_WORD = 2;
-    // COMMIT_TYPE_CANCEL_AUTO_CORRECT is used upon committing back the old word upon cancelling
-    // an auto-correction.
-    public static final int COMMIT_TYPE_CANCEL_AUTO_CORRECT = 3;
-
     // Storage for all the info about the current input.
     private static class CharacterStore {
         /**
@@ -346,8 +329,8 @@
         return mCurrentWord.mAutoCorrection;
     }
 
-    // `type' should be one of the COMMIT_TYPE_* constants above.
-    public void onCommitWord(final int type) {
+    // `type' should be one of the LastComposedWord.COMMIT_TYPE_* constants above.
+    public LastComposedWord onCommitWord(final int type) {
         mCommittedWordSavedForSuggestionResuming = mCurrentWord;
         // Note: currently, we come here whenever we commit a word. If it's any *other* kind than
         // DECIDED_WORD, we should reset mAutoCorrection so that we don't attempt to cancel later.
@@ -359,12 +342,13 @@
         // #didAutoCorrectToAnotherWord with #equals(). It would be marginally cleaner to do it
         // here, but it would be slower (since we would #equals() for each commit, instead of
         // only on cancel), and ultimately we want to figure it out even earlier anyway.
-        if (type != COMMIT_TYPE_DECIDED_WORD) {
+        if (type != LastComposedWord.COMMIT_TYPE_DECIDED_WORD) {
             // Only ever revert an auto-correct.
             mCommittedWordSavedForSuggestionResuming.mAutoCorrection = null;
         }
         // TODO: improve performance by swapping buffers instead of creating a new object.
         mCurrentWord = new CharacterStore();
+        return new LastComposedWord(type);
     }
 
     public boolean hasWordKeptForSuggestionResuming() {