diff --git a/java/src/com/android/inputmethod/keyboard/PointerTracker.java b/java/src/com/android/inputmethod/keyboard/PointerTracker.java
index 62e674a..036372c 100644
--- a/java/src/com/android/inputmethod/keyboard/PointerTracker.java
+++ b/java/src/com/android/inputmethod/keyboard/PointerTracker.java
@@ -920,8 +920,12 @@
             final boolean isMajorEvent, final Key key) {
         final int gestureTime = (int)(eventTime - sGestureFirstDownTime);
         if (mIsDetectingGesture) {
+            final int beforeLength = mGestureStrokeWithPreviewPoints.getLength();
             final boolean onValidArea = mGestureStrokeWithPreviewPoints.addPointOnKeyboard(
                     x, y, gestureTime, isMajorEvent);
+            if (mGestureStrokeWithPreviewPoints.getLength() > beforeLength) {
+                mTimerProxy.startUpdateBatchInputTimer(this);
+            }
             // If the move event goes out from valid batch input area, cancel batch input.
             if (!onValidArea) {
                 cancelBatchInput();
@@ -943,7 +947,6 @@
         if (DEBUG_MOVE_EVENT) {
             printTouchEvent("onMoveEvent:", x, y, eventTime);
         }
-        mTimerProxy.cancelUpdateBatchInputTimer(this);
         if (mIsTrackingCanceled) {
             return;
         }
diff --git a/java/src/com/android/inputmethod/keyboard/internal/GestureStroke.java b/java/src/com/android/inputmethod/keyboard/internal/GestureStroke.java
index adf2236..ea03f1b 100644
--- a/java/src/com/android/inputmethod/keyboard/internal/GestureStroke.java
+++ b/java/src/com/android/inputmethod/keyboard/internal/GestureStroke.java
@@ -163,6 +163,10 @@
         }
     }
 
+    public int getLength() {
+        return mEventTimes.getLength();
+    }
+
     public void onDownEvent(final int x, final int y, final long downTime,
             final long gestureFirstDownTime, final long lastTypingTime) {
         reset();
@@ -202,7 +206,7 @@
         if (!hasDetectedFastMove()) {
             return false;
         }
-        final int size = mEventTimes.getLength();
+        final int size = getLength();
         if (size <= 0) {
             return false;
         }
@@ -229,7 +233,7 @@
     }
 
     public void duplicateLastPointWith(final int time) {
-        final int lastIndex = mEventTimes.getLength() - 1;
+        final int lastIndex = getLength() - 1;
         if (lastIndex >= 0) {
             final int x = mXCoordinates.get(lastIndex);
             final int y = mYCoordinates.get(lastIndex);
@@ -255,7 +259,7 @@
     }
 
     private void appendPoint(final int x, final int y, final int time) {
-        final int lastIndex = mEventTimes.getLength() - 1;
+        final int lastIndex = getLength() - 1;
         // The point that is created by {@link duplicateLastPointWith(int)} may have later event
         // time than the next {@link MotionEvent}. To maintain the monotonicity of the event time,
         // drop the successive point here.
@@ -281,7 +285,7 @@
     }
 
     private int detectFastMove(final int x, final int y, final int time) {
-        final int size = mEventTimes.getLength();
+        final int size = getLength();
         final int lastIndex = size - 1;
         final int lastX = mXCoordinates.get(lastIndex);
         final int lastY = mYCoordinates.get(lastIndex);
@@ -321,7 +325,7 @@
      */
     public boolean addPointOnKeyboard(final int x, final int y, final int time,
             final boolean isMajorEvent) {
-        final int size = mEventTimes.getLength();
+        final int size = getLength();
         if (size <= 0) {
             // Down event
             appendPoint(x, y, time);
@@ -348,7 +352,7 @@
         final int pixelsPerSec = pixels * MSEC_PER_SEC;
         // Equivalent to (pixels / msecs < mGestureRecognitionThreshold / MSEC_PER_SEC)
         if (pixelsPerSec < mGestureRecognitionSpeedThreshold * msecs) {
-            mIncrementalRecognitionSize = mEventTimes.getLength();
+            mIncrementalRecognitionSize = getLength();
         }
     }
 
@@ -358,7 +362,7 @@
     }
 
     public final void appendAllBatchPoints(final InputPointers out) {
-        appendBatchPoints(out, mEventTimes.getLength());
+        appendBatchPoints(out, getLength());
     }
 
     public final void appendIncrementalBatchPoints(final InputPointers out) {
diff --git a/java/src/com/android/inputmethod/latin/LatinIME.java b/java/src/com/android/inputmethod/latin/LatinIME.java
index 38f1377..f1f50fe 100644
--- a/java/src/com/android/inputmethod/latin/LatinIME.java
+++ b/java/src/com/android/inputmethod/latin/LatinIME.java
@@ -1131,7 +1131,7 @@
             commitChosenWord(typedWord, LastComposedWord.COMMIT_TYPE_USER_TYPED_WORD,
                     separatorString);
             if (ProductionFlag.IS_EXPERIMENTAL) {
-                ResearchLogger.getInstance().onWordFinished(typedWord);
+                ResearchLogger.getInstance().onWordFinished(typedWord, mWordComposer.isBatchMode());
             }
         }
     }
@@ -1163,7 +1163,7 @@
     }
 
     private void swapSwapperAndSpace() {
-        CharSequence lastTwo = mConnection.getTextBeforeCursor(2, 0);
+        final CharSequence lastTwo = mConnection.getTextBeforeCursor(2, 0);
         // It is guaranteed lastTwo.charAt(1) is a swapper - else this method is not called.
         if (lastTwo != null && lastTwo.length() == 2
                 && lastTwo.charAt(0) == Constants.CODE_SPACE) {
@@ -1171,7 +1171,7 @@
             final String text = lastTwo.charAt(1) + " ";
             mConnection.commitText(text, 1);
             if (ProductionFlag.IS_EXPERIMENTAL) {
-                ResearchLogger.latinIME_swapSwapperAndSpace(text);
+                ResearchLogger.latinIME_swapSwapperAndSpace(lastTwo, text);
             }
             mKeyboardSwitcher.updateShiftState();
         }
@@ -1191,7 +1191,8 @@
             final String textToInsert = ". ";
             mConnection.commitText(textToInsert, 1);
             if (ProductionFlag.IS_EXPERIMENTAL) {
-                ResearchLogger.latinIME_maybeDoubleSpacePeriod(textToInsert);
+                ResearchLogger.latinIME_maybeDoubleSpacePeriod(textToInsert,
+                        false /* isBatchMode */);
             }
             mKeyboardSwitcher.updateShiftState();
             return true;
@@ -1440,7 +1441,7 @@
         }
         mConnection.commitText(text, 1);
         if (ProductionFlag.IS_EXPERIMENTAL) {
-            ResearchLogger.latinIME_onTextInput(text);
+            ResearchLogger.latinIME_onTextInput(text, false /* isBatchMode */);
         }
         mConnection.endBatchEdit();
         // Space state must be updated before calling updateShiftState
@@ -1665,10 +1666,13 @@
             final int length = mWordComposer.size();
             if (length > 0) {
                 if (mWordComposer.isBatchMode()) {
-                    mWordComposer.reset();
                     if (ProductionFlag.IS_EXPERIMENTAL) {
-                        ResearchLogger.latinIME_handleBackspace_batch(mWordComposer.getTypedWord());
+                        final String word = mWordComposer.getTypedWord();
+                        ResearchLogger.latinIME_handleBackspace_batch(word);
+                        ResearchLogger.getInstance().uncommitCurrentLogUnit(
+                                word, false /* dumpCurrentLogUnit */);
                     }
+                    mWordComposer.reset();
                 } else {
                     mWordComposer.deleteLast();
                 }
@@ -2084,7 +2088,7 @@
             }
             if (ProductionFlag.IS_EXPERIMENTAL) {
                 ResearchLogger.latinIme_commitCurrentAutoCorrection(typedWord, autoCorrection,
-                        separatorString);
+                        separatorString, mWordComposer.isBatchMode());
             }
             mExpectingUpdateSelection = true;
             commitChosenWord(autoCorrection, LastComposedWord.COMMIT_TYPE_DECIDED_WORD,
@@ -2118,7 +2122,8 @@
             onCodeInput(primaryCode,
                     Constants.SUGGESTION_STRIP_COORDINATE, Constants.SUGGESTION_STRIP_COORDINATE);
             if (ProductionFlag.IS_EXPERIMENTAL) {
-                ResearchLogger.latinIME_punctuationSuggestion(index, suggestion);
+                ResearchLogger.latinIME_punctuationSuggestion(index, suggestion,
+                        false /* isBatchMode */);
             }
             return;
         }
@@ -2157,7 +2162,8 @@
         commitChosenWord(suggestion, LastComposedWord.COMMIT_TYPE_MANUAL_PICK,
                 LastComposedWord.NOT_A_SEPARATOR);
         if (ProductionFlag.IS_EXPERIMENTAL) {
-            ResearchLogger.latinIME_pickSuggestionManually(replacedWord, index, suggestion);
+            ResearchLogger.latinIME_pickSuggestionManually(replacedWord, index, suggestion,
+                    mWordComposer.isBatchMode());
         }
         mConnection.endBatchEdit();
         // Don't allow cancellation of manual pick
@@ -2254,6 +2260,12 @@
                 mConnection.getWordBeforeCursorIfAtEndOfWord(mSettings.getCurrent());
         if (null != word) {
             restartSuggestionsOnWordBeforeCursor(word);
+            // TODO: Handle the case where the user manually moves the cursor and then backs up over
+            // a separator.  In that case, the current log unit should not be uncommitted.
+            if (ProductionFlag.IS_EXPERIMENTAL) {
+                ResearchLogger.getInstance().uncommitCurrentLogUnit(word.toString(),
+                        true /* dumpCurrentLogUnit */);
+            }
         }
     }
 
@@ -2297,7 +2309,8 @@
                     Constants.NOT_A_COORDINATE, Constants.NOT_A_COORDINATE);
         }
         if (ProductionFlag.IS_EXPERIMENTAL) {
-            ResearchLogger.latinIME_revertCommit(committedWord, originallyTypedWord);
+            ResearchLogger.latinIME_revertCommit(committedWord, originallyTypedWord,
+                    mWordComposer.isBatchMode());
         }
         // Don't restart suggestion yet. We'll restart if the user deletes the
         // separator.
diff --git a/java/src/com/android/inputmethod/latin/RichInputConnection.java b/java/src/com/android/inputmethod/latin/RichInputConnection.java
index 0d3ebac..f7268fc 100644
--- a/java/src/com/android/inputmethod/latin/RichInputConnection.java
+++ b/java/src/com/android/inputmethod/latin/RichInputConnection.java
@@ -648,19 +648,20 @@
         // Here we test whether we indeed have a period and a space before us. This should not
         // be needed, but it's there just in case something went wrong.
         final CharSequence textBeforeCursor = getTextBeforeCursor(2, 0);
-        if (!". ".equals(textBeforeCursor)) {
+        final String periodSpace = ". ";
+        if (!periodSpace.equals(textBeforeCursor)) {
             // Theoretically we should not be coming here if there isn't ". " before the
             // cursor, but the application may be changing the text while we are typing, so
             // anything goes. We should not crash.
             Log.d(TAG, "Tried to revert double-space combo but we didn't find "
-                    + "\". \" just before the cursor.");
+                    + "\"" + periodSpace + "\" just before the cursor.");
             return false;
         }
         deleteSurroundingText(2, 0);
         final String doubleSpace = "  ";
         commitText(doubleSpace, 1);
         if (ProductionFlag.IS_EXPERIMENTAL) {
-            ResearchLogger.richInputConnection_revertDoubleSpacePeriod(doubleSpace);
+            ResearchLogger.richInputConnection_revertDoubleSpacePeriod();
         }
         return true;
     }
@@ -685,7 +686,7 @@
         final String text = " " + textBeforeCursor.subSequence(0, 1);
         commitText(text, 1);
         if (ProductionFlag.IS_EXPERIMENTAL) {
-            ResearchLogger.richInputConnection_revertSwapPunctuation(text);
+            ResearchLogger.richInputConnection_revertSwapPunctuation();
         }
         return true;
     }
diff --git a/java/src/com/android/inputmethod/research/FixedLogBuffer.java b/java/src/com/android/inputmethod/research/FixedLogBuffer.java
index f3302d8..9613c2d 100644
--- a/java/src/com/android/inputmethod/research/FixedLogBuffer.java
+++ b/java/src/com/android/inputmethod/research/FixedLogBuffer.java
@@ -72,6 +72,15 @@
         mNumActualWords++; // Must be a word, or we wouldn't be here.
     }
 
+    @Override
+    public LogUnit unshiftIn() {
+        final LogUnit logUnit = super.unshiftIn();
+        if (logUnit != null && logUnit.hasWord()) {
+            mNumActualWords--;
+        }
+        return logUnit;
+    }
+
     private void shiftOutThroughFirstWord() {
         final LinkedList<LogUnit> logUnits = getLogUnits();
         while (!logUnits.isEmpty()) {
diff --git a/java/src/com/android/inputmethod/research/LogBuffer.java b/java/src/com/android/inputmethod/research/LogBuffer.java
index 14e8d08..9d095f8 100644
--- a/java/src/com/android/inputmethod/research/LogBuffer.java
+++ b/java/src/com/android/inputmethod/research/LogBuffer.java
@@ -46,6 +46,20 @@
         mLogUnits.add(logUnit);
     }
 
+    public LogUnit unshiftIn() {
+        if (mLogUnits.isEmpty()) {
+            return null;
+        }
+        return mLogUnits.removeLast();
+    }
+
+    public LogUnit peekLastLogUnit() {
+        if (mLogUnits.isEmpty()) {
+            return null;
+        }
+        return mLogUnits.peekLast();
+    }
+
     public boolean isEmpty() {
         return mLogUnits.isEmpty();
     }
diff --git a/java/src/com/android/inputmethod/research/LogUnit.java b/java/src/com/android/inputmethod/research/LogUnit.java
index bcb144f..ef2c4ea 100644
--- a/java/src/com/android/inputmethod/research/LogUnit.java
+++ b/java/src/com/android/inputmethod/research/LogUnit.java
@@ -240,6 +240,7 @@
     public LogUnit splitByTime(final long maxTime) {
         // Assume that mTimeList is in sorted order.
         final int length = mTimeList.size();
+        // TODO: find time by binary search, e.g. using Collections#binarySearch()
         for (int index = 0; index < length; index++) {
             if (mTimeList.get(index) > maxTime) {
                 final List<LogStatement> laterLogStatements =
@@ -267,4 +268,13 @@
         }
         return new LogUnit();
     }
+
+    public void append(final LogUnit logUnit) {
+        mLogStatementList.addAll(logUnit.mLogStatementList);
+        mValuesList.addAll(logUnit.mValuesList);
+        mTimeList.addAll(logUnit.mTimeList);
+        mWord = null;
+        mMayContainDigit = mMayContainDigit || logUnit.mMayContainDigit;
+        mIsPartOfMegaword = false;
+    }
 }
diff --git a/java/src/com/android/inputmethod/research/MainLogBuffer.java b/java/src/com/android/inputmethod/research/MainLogBuffer.java
index bec21d7..898a042 100644
--- a/java/src/com/android/inputmethod/research/MainLogBuffer.java
+++ b/java/src/com/android/inputmethod/research/MainLogBuffer.java
@@ -119,6 +119,7 @@
         // complete buffer contents in detail.
         final LinkedList<LogUnit> logUnits = getLogUnits();
         final int length = logUnits.size();
+        int wordsFound = 0;
         for (int i = 0; i < length; i++) {
             final LogUnit logUnit = logUnits.get(i);
             final String word = logUnit.getWord();
@@ -135,9 +136,18 @@
                                 + ", isValid: " + (dictionary.isValidWord(word)));
                     }
                     return false;
+                } else {
+                    wordsFound++;
                 }
             }
         }
+        if (wordsFound < N_GRAM_SIZE) {
+            // Not enough words.  Not unsafe, but reject anyway.
+            if (DEBUG) {
+                Log.d(TAG, "not enough words");
+            }
+            return false;
+        }
         // All checks have passed; this buffer's content can be safely uploaded.
         return true;
     }
diff --git a/java/src/com/android/inputmethod/research/ResearchLog.java b/java/src/com/android/inputmethod/research/ResearchLog.java
index a6b1b88..a2356e6 100644
--- a/java/src/com/android/inputmethod/research/ResearchLog.java
+++ b/java/src/com/android/inputmethod/research/ResearchLog.java
@@ -193,6 +193,9 @@
             });
         } catch (RejectedExecutionException e) {
             // TODO: Add code to record loss of data, and report.
+            if (DEBUG) {
+                Log.d(TAG, "ResearchLog.publish() rejecting scheduled execution");
+            }
         }
     }
 
diff --git a/java/src/com/android/inputmethod/research/ResearchLogger.java b/java/src/com/android/inputmethod/research/ResearchLogger.java
index b1484e6..b61db27 100644
--- a/java/src/com/android/inputmethod/research/ResearchLogger.java
+++ b/java/src/com/android/inputmethod/research/ResearchLogger.java
@@ -85,7 +85,7 @@
     private static final String TAG = ResearchLogger.class.getSimpleName();
     private static final boolean DEBUG = false && ProductionFlag.IS_EXPERIMENTAL_DEBUG;
     // Whether all n-grams should be logged.  true will disclose private info.
-    private static final boolean LOG_EVERYTHING = false
+    private static final boolean IS_LOGGING_EVERYTHING = false
             && ProductionFlag.IS_EXPERIMENTAL_DEBUG;
     // Whether the TextView contents are logged at the end of the session.  true will disclose
     // private info.
@@ -105,7 +105,7 @@
     private static final boolean IS_SHOWING_INDICATOR = true;
     // Change the default indicator to something very visible.  Currently two red vertical bars on
     // either side of they keyboard.
-    private static final boolean IS_SHOWING_INDICATOR_CLEARLY = false || LOG_EVERYTHING;
+    private static final boolean IS_SHOWING_INDICATOR_CLEARLY = false || IS_LOGGING_EVERYTHING;
     public static final int FEEDBACK_WORD_BUFFER_SIZE = 5;
 
     // constants related to specific log points
@@ -390,11 +390,12 @@
         if (DEBUG) {
             Log.d(TAG, "stop called");
         }
+        // Commit mCurrentLogUnit before closing.
         commitCurrentLogUnit();
 
         if (mMainLogBuffer != null) {
             publishLogBuffer(mMainLogBuffer, mMainResearchLog,
-                    LOG_EVERYTHING /* isIncludingPrivateData */);
+                    IS_LOGGING_EVERYTHING /* isIncludingPrivateData */);
             mMainResearchLog.close(null /* callback */);
             mMainLogBuffer = null;
         }
@@ -676,11 +677,17 @@
     /**
      * Buffer a research log event, flagging it as privacy-sensitive.
      */
-    private synchronized void enqueueEvent(LogStatement logStatement, Object... values) {
+    private synchronized void enqueueEvent(final LogStatement logStatement,
+            final Object... values) {
+        enqueueEvent(mCurrentLogUnit, logStatement, values);
+    }
+
+    private synchronized void enqueueEvent(final LogUnit logUnit, final LogStatement logStatement,
+            final Object... values) {
         assert values.length == logStatement.mKeys.length;
-        if (isAllowedToLog()) {
+        if (isAllowedToLog() && logUnit != null) {
             final long time = SystemClock.uptimeMillis();
-            mCurrentLogUnit.addLogStatement(logStatement, time, values);
+            logUnit.addLogStatement(logStatement, time, values);
         }
     }
 
@@ -695,12 +702,13 @@
         }
         if (!mCurrentLogUnit.isEmpty()) {
             if (mMainLogBuffer != null) {
-                mMainLogBuffer.shiftIn(mCurrentLogUnit);
-                if ((mMainLogBuffer.isSafeToLog() || LOG_EVERYTHING) && mMainResearchLog != null) {
+                if ((mMainLogBuffer.isSafeToLog() || IS_LOGGING_EVERYTHING)
+                        && mMainResearchLog != null) {
                     publishLogBuffer(mMainLogBuffer, mMainResearchLog,
                             true /* isIncludingPrivateData */);
                     mMainLogBuffer.resetWordCounter();
                 }
+                mMainLogBuffer.shiftIn(mCurrentLogUnit);
             }
             if (mFeedbackLogBuffer != null) {
                 mFeedbackLogBuffer.shiftIn(mCurrentLogUnit);
@@ -709,6 +717,50 @@
         }
     }
 
+    public void uncommitCurrentLogUnit(final String expectedWord,
+            final boolean dumpCurrentLogUnit) {
+        // The user has deleted this word and returned to the previous.  Check that the word in the
+        // logUnit matches the expected word.  If so, restore the last log unit committed to be the
+        // current logUnit.  I.e., pull out the last LogUnit from all the LogBuffers, and make
+        // restore it to mCurrentLogUnit so the new edits are captured with the word.  Optionally
+        // dump the contents of mCurrentLogUnit (useful if they contain deletions of the next word
+        // that should not be reported to protect user privacy)
+        //
+        // Note that we don't use mLastLogUnit here, because it only goes one word back and is only
+        // needed for reverts, which only happen one back.
+        if (mMainLogBuffer == null) {
+            return;
+        }
+        final LogUnit oldLogUnit = mMainLogBuffer.peekLastLogUnit();
+
+        // Check that expected word matches.
+        if (oldLogUnit != null) {
+            final String oldLogUnitWord = oldLogUnit.getWord();
+            if (!oldLogUnitWord.equals(expectedWord)) {
+                return;
+            }
+        }
+
+        // Uncommit, merging if necessary.
+        mMainLogBuffer.unshiftIn();
+        if (oldLogUnit != null && !dumpCurrentLogUnit) {
+            oldLogUnit.append(mCurrentLogUnit);
+            mSavedDownEventTime = Long.MAX_VALUE;
+        }
+        if (oldLogUnit == null) {
+            mCurrentLogUnit = new LogUnit();
+        } else {
+            mCurrentLogUnit = oldLogUnit;
+        }
+        if (mFeedbackLogBuffer != null) {
+            mFeedbackLogBuffer.unshiftIn();
+        }
+        if (DEBUG) {
+            Log.d(TAG, "uncommitCurrentLogUnit back to " + (mCurrentLogUnit.hasWord()
+                    ? ": '" + mCurrentLogUnit.getWord() + "'" : ""));
+        }
+    }
+
     private static final LogStatement LOGSTATEMENT_LOG_SEGMENT_OPENING =
             new LogStatement("logSegmentStart", false, false, "isIncludingPrivateData");
     private static final LogStatement LOGSTATEMENT_LOG_SEGMENT_CLOSING =
@@ -751,24 +803,26 @@
      * After this operation completes, mCurrentLogUnit will hold any logStatements that happened
      * after maxTime.
      */
-    private static final LogStatement LOGSTATEMENT_COMMIT_RECORD_SPLIT_WORDS =
-            new LogStatement("recordSplitWords", true, false);
-    /* package for test */ void commitCurrentLogUnitAsWord(final String word, final long maxTime) {
+    /* package for test */ void commitCurrentLogUnitAsWord(final String word, final long maxTime,
+            final boolean isBatchMode) {
+        if (word == null) {
+            return;
+        }
         final Dictionary dictionary = getDictionary();
-        if (word != null && word.length() > 0 && hasLetters(word)) {
+        if (word.length() > 0 && hasLetters(word)) {
             mCurrentLogUnit.setWord(word);
             final boolean isDictionaryWord = dictionary != null
                     && dictionary.isValidWord(word);
             mStatistics.recordWordEntered(isDictionaryWord);
         }
         final LogUnit newLogUnit = mCurrentLogUnit.splitByTime(maxTime);
-        enqueueCommitText(word);
+        enqueueCommitText(word, isBatchMode);
         commitCurrentLogUnit();
         mCurrentLogUnit = newLogUnit;
     }
 
-    public void onWordFinished(final String word) {
-        commitCurrentLogUnitAsWord(word, mSavedDownEventTime);
+    public void onWordFinished(final String word, final boolean isBatchMode) {
+        commitCurrentLogUnitAsWord(word, mSavedDownEventTime, isBatchMode);
         mSavedDownEventTime = Long.MAX_VALUE;
     }
 
@@ -863,7 +917,7 @@
                         Integer.toHexString(editorInfo.inputType),
                         Integer.toHexString(editorInfo.imeOptions), editorInfo.fieldId,
                         Build.DISPLAY, Build.MODEL, prefs, versionCode, versionName,
-                        OUTPUT_FORMAT_VERSION, LOG_EVERYTHING,
+                        OUTPUT_FORMAT_VERSION, IS_LOGGING_EVERYTHING,
                         ProductionFlag.IS_EXPERIMENTAL_DEBUG);
             } catch (NameNotFoundException e) {
                 e.printStackTrace();
@@ -1060,9 +1114,9 @@
      *
      * SystemResponse: Raw text is added to the TextView.
      */
-    public static void latinIME_onTextInput(final String text) {
+    public static void latinIME_onTextInput(final String text, final boolean isBatchMode) {
         final ResearchLogger researchLogger = getInstance();
-        researchLogger.commitCurrentLogUnitAsWord(text, Long.MAX_VALUE);
+        researchLogger.commitCurrentLogUnitAsWord(text, Long.MAX_VALUE, isBatchMode);
     }
 
     /**
@@ -1074,14 +1128,14 @@
             new LogStatement("LatinIMEPickSuggestionManually", true, false, "replacedWord", "index",
                     "suggestion", "x", "y");
     public static void latinIME_pickSuggestionManually(final String replacedWord,
-            final int index, final String suggestion) {
+            final int index, final String suggestion, final boolean isBatchMode) {
         final String scrubbedWord = scrubDigitsFromString(suggestion);
         final ResearchLogger researchLogger = getInstance();
         researchLogger.enqueueEvent(LOGSTATEMENT_LATINIME_PICKSUGGESTIONMANUALLY,
                 scrubDigitsFromString(replacedWord), index,
                 suggestion == null ? null : scrubbedWord, Constants.SUGGESTION_STRIP_COORDINATE,
                 Constants.SUGGESTION_STRIP_COORDINATE);
-        researchLogger.commitCurrentLogUnitAsWord(scrubbedWord, Long.MAX_VALUE);
+        researchLogger.commitCurrentLogUnitAsWord(scrubbedWord, Long.MAX_VALUE, isBatchMode);
         researchLogger.mStatistics.recordManualSuggestion();
     }
 
@@ -1093,11 +1147,12 @@
     private static final LogStatement LOGSTATEMENT_LATINIME_PUNCTUATIONSUGGESTION =
             new LogStatement("LatinIMEPunctuationSuggestion", false, false, "index", "suggestion",
                     "x", "y");
-    public static void latinIME_punctuationSuggestion(final int index, final String suggestion) {
+    public static void latinIME_punctuationSuggestion(final int index, final String suggestion,
+            final boolean isBatchMode) {
         final ResearchLogger researchLogger = getInstance();
         researchLogger.enqueueEvent(LOGSTATEMENT_LATINIME_PUNCTUATIONSUGGESTION, index, suggestion,
                 Constants.SUGGESTION_STRIP_COORDINATE, Constants.SUGGESTION_STRIP_COORDINATE);
-        researchLogger.commitCurrentLogUnitAsWord(suggestion, Long.MAX_VALUE);
+        researchLogger.commitCurrentLogUnitAsWord(suggestion, Long.MAX_VALUE, isBatchMode);
     }
 
     /**
@@ -1125,11 +1180,16 @@
      * if a soft space is inserted after a word.
      */
     private static final LogStatement LOGSTATEMENT_LATINIME_SWAPSWAPPERANDSPACE =
-            new LogStatement("LatinIMESwapSwapperAndSpace", false, false);
-    public static void latinIME_swapSwapperAndSpace(final String text) {
+            new LogStatement("LatinIMESwapSwapperAndSpace", false, false, "originalCharacters",
+                    "charactersAfterSwap");
+    public static void latinIME_swapSwapperAndSpace(final CharSequence originalCharacters,
+            final String charactersAfterSwap) {
         final ResearchLogger researchLogger = getInstance();
-        researchLogger.commitCurrentLogUnitAsWord(text, Long.MAX_VALUE);
-        researchLogger.enqueueEvent(LOGSTATEMENT_LATINIME_SWAPSWAPPERANDSPACE);
+        final LogUnit logUnit = researchLogger.mMainLogBuffer.peekLastLogUnit();
+        if (logUnit != null) {
+            researchLogger.enqueueEvent(logUnit, LOGSTATEMENT_LATINIME_SWAPSWAPPERANDSPACE,
+                    originalCharacters, charactersAfterSwap);
+        }
     }
 
     /**
@@ -1137,9 +1197,10 @@
      *
      * SystemResponse: Two spaces have been replaced by period space.
      */
-    public static void latinIME_maybeDoubleSpacePeriod(final String text) {
+    public static void latinIME_maybeDoubleSpacePeriod(final String text,
+            final boolean isBatchMode) {
         final ResearchLogger researchLogger = getInstance();
-        researchLogger.commitCurrentLogUnitAsWord(text, Long.MAX_VALUE);
+        researchLogger.commitCurrentLogUnitAsWord(text, Long.MAX_VALUE, isBatchMode);
     }
 
     /**
@@ -1191,12 +1252,18 @@
             new LogStatement("LatinIMERevertCommit", true, false, "committedWord",
                     "originallyTypedWord");
     public static void latinIME_revertCommit(final String committedWord,
-            final String originallyTypedWord) {
+            final String originallyTypedWord, final boolean isBatchMode) {
         final ResearchLogger researchLogger = getInstance();
-        researchLogger.enqueueEvent(LOGSTATEMENT_LATINIME_REVERTCOMMIT, committedWord,
-                originallyTypedWord);
+        final LogUnit logUnit = researchLogger.mMainLogBuffer.peekLastLogUnit();
+        if (originallyTypedWord.length() > 0 && hasLetters(originallyTypedWord)) {
+            if (logUnit != null) {
+                logUnit.setWord(originallyTypedWord);
+            }
+        }
+        researchLogger.enqueueEvent(logUnit != null ? logUnit : researchLogger.mCurrentLogUnit,
+                LOGSTATEMENT_LATINIME_REVERTCOMMIT, committedWord, originallyTypedWord);
         researchLogger.mStatistics.recordRevertCommit();
-        researchLogger.commitCurrentLogUnitAsWord(originallyTypedWord, Long.MAX_VALUE);
+        researchLogger.commitCurrentLogUnitAsWord(originallyTypedWord, Long.MAX_VALUE, isBatchMode);
     }
 
     /**
@@ -1295,9 +1362,10 @@
      *
      * SystemResponse: The IME has reverted ". ", which had previously replaced two typed spaces.
      */
-    public static void richInputConnection_revertDoubleSpacePeriod(final String doubleSpace) {
-        final ResearchLogger researchLogger = getInstance();
-        researchLogger.commitCurrentLogUnitAsWord(doubleSpace, Long.MAX_VALUE);
+    private static final LogStatement LOGSTATEMENT_RICHINPUTCONNECTION_REVERTDOUBLESPACEPERIOD =
+            new LogStatement("RichInputConnectionRevertDoubleSpacePeriod", false, false);
+    public static void richInputConnection_revertDoubleSpacePeriod() {
+        getInstance().enqueueEvent(LOGSTATEMENT_RICHINPUTCONNECTION_REVERTDOUBLESPACEPERIOD);
     }
 
     /**
@@ -1305,9 +1373,10 @@
      *
      * SystemResponse: The IME has reverted a punctuation swap.
      */
-    public static void richInputConnection_revertSwapPunctuation(final String text) {
-        final ResearchLogger researchLogger = getInstance();
-        researchLogger.commitCurrentLogUnitAsWord(text, Long.MAX_VALUE);
+    private static final LogStatement LOGSTATEMENT_RICHINPUTCONNECTION_REVERTSWAPPUNCTUATION =
+            new LogStatement("RichInputConnectionRevertSwapPunctuation", false, false);
+    public static void richInputConnection_revertSwapPunctuation() {
+        getInstance().enqueueEvent(LOGSTATEMENT_RICHINPUTCONNECTION_REVERTSWAPPUNCTUATION);
     }
 
     /**
@@ -1317,16 +1386,17 @@
      * text input to another word that the user more likely desired to type.
      */
     private static final LogStatement LOGSTATEMENT_LATINIME_COMMITCURRENTAUTOCORRECTION =
-            new LogStatement("LatinIMECommitCurrentAutoCorrection", true, false, "typedWord",
+            new LogStatement("LatinIMECommitCurrentAutoCorrection", true, true, "typedWord",
                     "autoCorrection", "separatorString");
     public static void latinIme_commitCurrentAutoCorrection(final String typedWord,
-            final String autoCorrection, final String separatorString) {
+            final String autoCorrection, final String separatorString, final boolean isBatchMode) {
         final String scrubbedTypedWord = scrubDigitsFromString(typedWord);
         final String scrubbedAutoCorrection = scrubDigitsFromString(autoCorrection);
         final ResearchLogger researchLogger = getInstance();
         researchLogger.enqueueEvent(LOGSTATEMENT_LATINIME_COMMITCURRENTAUTOCORRECTION,
                 scrubbedTypedWord, scrubbedAutoCorrection, separatorString);
-        researchLogger.commitCurrentLogUnitAsWord(scrubbedAutoCorrection, Long.MAX_VALUE);
+        researchLogger.commitCurrentLogUnitAsWord(scrubbedAutoCorrection, Long.MAX_VALUE,
+                isBatchMode);
     }
 
     private boolean isExpectingCommitText = false;
@@ -1340,13 +1410,13 @@
     // add invocations.
     private static final LogStatement LOGSTATEMENT_LATINIME_COMMIT_PARTIAL_TEXT =
             new LogStatement("LatinIMECommitPartialText", true, false, "newCursorPosition");
-    public static void latinIME_commitPartialText(final CharSequence committedWord,
-            final long lastTimestampOfWordData) {
+    public static void latinIME_commitPartialText(final String committedWord,
+            final long lastTimestampOfWordData, final boolean isBatchMode) {
         final ResearchLogger researchLogger = getInstance();
-        final String scrubbedWord = scrubDigitsFromString(committedWord.toString());
+        final String scrubbedWord = scrubDigitsFromString(committedWord);
         researchLogger.enqueueEvent(LOGSTATEMENT_LATINIME_COMMIT_PARTIAL_TEXT);
-        researchLogger.commitCurrentLogUnitAsWord(scrubbedWord, lastTimestampOfWordData);
-        researchLogger.mStatistics.recordSplitWords();
+        researchLogger.commitCurrentLogUnitAsWord(scrubbedWord, lastTimestampOfWordData,
+                isBatchMode);
     }
 
     /**
@@ -1357,14 +1427,14 @@
      */
     private static final LogStatement LOGSTATEMENT_RICHINPUTCONNECTIONCOMMITTEXT =
             new LogStatement("RichInputConnectionCommitText", true, false, "newCursorPosition");
-    public static void richInputConnection_commitText(final CharSequence committedWord,
-            final int newCursorPosition) {
+    public static void richInputConnection_commitText(final String committedWord,
+            final int newCursorPosition, final boolean isBatchMode) {
         final ResearchLogger researchLogger = getInstance();
-        final String scrubbedWord = scrubDigitsFromString(committedWord.toString());
+        final String scrubbedWord = scrubDigitsFromString(committedWord);
         if (!researchLogger.isExpectingCommitText) {
             researchLogger.enqueueEvent(LOGSTATEMENT_RICHINPUTCONNECTIONCOMMITTEXT,
                     newCursorPosition);
-            researchLogger.commitCurrentLogUnitAsWord(scrubbedWord, Long.MAX_VALUE);
+            researchLogger.commitCurrentLogUnitAsWord(scrubbedWord, Long.MAX_VALUE, isBatchMode);
         }
         researchLogger.isExpectingCommitText = false;
     }
@@ -1373,9 +1443,9 @@
      * Shared event for logging committed text.
      */
     private static final LogStatement LOGSTATEMENT_COMMITTEXT =
-            new LogStatement("CommitText", true, false, "committedText");
-    private void enqueueCommitText(final CharSequence word) {
-        enqueueEvent(LOGSTATEMENT_COMMITTEXT, word);
+            new LogStatement("CommitText", true, false, "committedText", "isBatchMode");
+    private void enqueueCommitText(final String word, final boolean isBatchMode) {
+        enqueueEvent(LOGSTATEMENT_COMMITTEXT, word, isBatchMode);
     }
 
     /**