Add spellcheck and word suggestion to the prediction service

third_party/android_prediction/CHROMIUM.diff

Index: third_party/android_prediction/CHROMIUM.diff
diff --git a/third_party/android_prediction/CHROMIUM.diff b/third_party/android_prediction/CHROMIUM.diff
new file mode 100644
index 0000000000000000000000000000000000000000..18aa21203c205bfae0155aa3ebe2e685c8d5e646
--- /dev/null
+++ b/third_party/android_prediction/CHROMIUM.diff
@@ -0,0 +1,240 @@
+Only in third_party/android_prediction/: BUILD.gn
+Only in third_party/android_prediction/: CHROMIUM.diff
+diff -r third_party/android_prediction/defines.h /usr/local/google/home/riajiang/Downloads/android_prediction/defines.h

[viettrungluu, 2015/08/06 00:09:40]

Your diff is probably backwards from the usual direction, I think. (This is so
common that patch would tell you that, and has the -R flag for that.)

Unified diffs are also typically easier to read.

[riajiang, 2015/08/06 17:19:43]

Done.

+20,21d19
+< #include "base/macros.h"
+< 
+44,45c42,43
+< // template <typename T, int N>
+< // char (&ArraySizeHelper(T (&array)[N]))[N];
+---
+> template <typename T, int N>
+> char (&ArraySizeHelper(T (&array)[N]))[N];
+353,359c351,357
+< /*
+< */
+Only in third_party/android_prediction/: LICENSE
+Only in third_party/android_prediction/: README.chromium
+diff -r third_party/android_prediction/suggest/core/dictionary/dictionary.cpp /usr/local/google/home/riajiang/Downloads/android_prediction/suggest/core/dictionary/dictionary.cpp
+30a31
+> #include "third_party/android_prediction/utils/log_utils.h"
+37c38
+< Dictionary::Dictionary(DictionaryStructureWithBufferPolicy::StructurePolicyPtr
+---
+> Dictionary::Dictionary(JNIEnv *env, DictionaryStructureWithBufferPolicy::StructurePolicyPtr
+41a43
+>     logDictionaryInfo(env);
+189a192,219
+> }
+> 
+> void Dictionary::logDictionaryInfo(JNIEnv *const env) const {
+>     int dictionaryIdCodePointBuffer[HEADER_ATTRIBUTE_BUFFER_SIZE];
+>     int versionStringCodePointBuffer[HEADER_ATTRIBUTE_BUFFER_SIZE];
+>     int dateStringCodePointBuffer[HEADER_ATTRIBUTE_BUFFER_SIZE];
+>     const DictionaryHeaderStructurePolicy *const headerPolicy =
+>             getDictionaryStructurePolicy()->getHeaderStructurePolicy();
+>     headerPolicy->readHeaderValueOrQuestionMark("dictionary", dictionaryIdCodePointBuffer,
+>             HEADER_ATTRIBUTE_BUFFER_SIZE);
+>     headerPolicy->readHeaderValueOrQuestionMark("version", versionStringCodePointBuffer,
+>             HEADER_ATTRIBUTE_BUFFER_SIZE);
+>     headerPolicy->readHeaderValueOrQuestionMark("date", dateStringCodePointBuffer,
+>             HEADER_ATTRIBUTE_BUFFER_SIZE);
+> 
+>     char dictionaryIdCharBuffer[HEADER_ATTRIBUTE_BUFFER_SIZE];
+>     char versionStringCharBuffer[HEADER_ATTRIBUTE_BUFFER_SIZE];
+>     char dateStringCharBuffer[HEADER_ATTRIBUTE_BUFFER_SIZE];
+>     intArrayToCharArray(dictionaryIdCodePointBuffer, HEADER_ATTRIBUTE_BUFFER_SIZE,
+>             dictionaryIdCharBuffer, HEADER_ATTRIBUTE_BUFFER_SIZE);
+>     intArrayToCharArray(versionStringCodePointBuffer, HEADER_ATTRIBUTE_BUFFER_SIZE,
+>             versionStringCharBuffer, HEADER_ATTRIBUTE_BUFFER_SIZE);
+>     intArrayToCharArray(dateStringCodePointBuffer, HEADER_ATTRIBUTE_BUFFER_SIZE,
+>             dateStringCharBuffer, HEADER_ATTRIBUTE_BUFFER_SIZE);
+> 
+>     LogUtils::logToJava(env,
+>             "Dictionary info: dictionary = %s ; version = %s ; date = %s",
+>             dictionaryIdCharBuffer, versionStringCharBuffer, dateStringCharBuffer);
+diff -r third_party/android_prediction/suggest/core/dictionary/dictionary.h /usr/local/google/home/riajiang/Downloads/android_prediction/suggest/core/dictionary/dictionary.h
+22a23
+> #include "jni.h"
+61c62
+<     Dictionary(DictionaryStructureWithBufferPolicy::StructurePolicyPtr
+---
+>     Dictionary(JNIEnv *env, DictionaryStructureWithBufferPolicy::StructurePolicyPtr
+137a139,140
+> 
+>     void logDictionaryInfo(JNIEnv *const env) const;
+Only in /usr/local/google/home/riajiang/Downloads/android_prediction/suggest/core/dictionary/property: word_property.cpp
+diff -r third_party/android_prediction/suggest/core/dictionary/property/word_property.h /usr/local/google/home/riajiang/Downloads/android_prediction/suggest/core/dictionary/property/word_property.h
+22a23
+> #include "jni.h"
+38a40,43
+> 
+>     void outputProperties(JNIEnv *const env, jintArray outCodePoints, jbooleanArray outFlags,
+>             jintArray outProbabilityInfo, jobject outBigramTargets, jobject outBigramProbabilities,
+>             jobject outShortcutTargets, jobject outShortcutProbabilities) const;
+diff -r third_party/android_prediction/suggest/core/layout/proximity_info.cpp /usr/local/google/home/riajiang/Downloads/android_prediction/suggest/core/layout/proximity_info.cpp
+25a26
+> #include "jni.h"
+33,34c34,35
+< static AK_FORCE_INLINE void safeGetOrFillZeroIntArrayRegion(const int *jArray,
+<         int len, int *buffer) {
+---
+> static AK_FORCE_INLINE void safeGetOrFillZeroIntArrayRegion(JNIEnv *env, jintArray jArray,
+>         jsize len, jint *buffer) {
+36,38c37
+<         for (int i = 0; i < len; i++) {
+<             buffer[i] = jArray[i];
+<         }
+---
+>         env->GetIntArrayRegion(jArray, 0, len, buffer);
+44,45c43,44
+< static AK_FORCE_INLINE void safeGetOrFillZeroFloatArrayRegion(const float *jArray,
+<         int len, float *buffer) {
+---
+> static AK_FORCE_INLINE void safeGetOrFillZeroFloatArrayRegion(JNIEnv *env, jfloatArray jArray,
+>         jsize len, jfloat *buffer) {
+47,49c46
+<         for (int i = 0; i < len; i++) {
+<             buffer[i] = jArray[i];
+<         }
+---
+>         env->GetFloatArrayRegion(jArray, 0, len, buffer);
+55c52
+< ProximityInfo::ProximityInfo(const std::string localeJStr,
+---
+> ProximityInfo::ProximityInfo(JNIEnv *env, const jstring localeJStr,
+58,61c55,58
+<         int *proximityChars, int proximitySize, const int keyCount, const int *keyXCoordinates,
+<         const int *keyYCoordinates, const int *keyWidths, const int *keyHeights,
+<         const int *keyCharCodes, const float *sweetSpotCenterXs,
+<         const float *sweetSpotCenterYs, const float *sweetSpotRadii)
+---
+>         const jintArray proximityChars, const int keyCount, const jintArray keyXCoordinates,
+>         const jintArray keyYCoordinates, const jintArray keyWidths, const jintArray keyHeights,
+>         const jintArray keyCharCodes, const jfloatArray sweetSpotCenterXs,
+>         const jfloatArray sweetSpotCenterYs, const jfloatArray sweetSpotRadii)
+79c76
+<     int proximityCharsLength = proximitySize;
+---
+>     const jsize proximityCharsLength = env->GetArrayLength(proximityChars);
+88c85
+<     const int localeCStrUtf8Length = localeJStr.length();
+---
+>     const jsize localeCStrUtf8Length = env->GetStringUTFLength(localeJStr);
+94,97c91,92
+<     for (int i = 0; i < localeCStrUtf8Length; i++) {
+<         mLocaleStr[i] = localeJStr[i];
+<     }
+<     safeGetOrFillZeroIntArrayRegion(proximityChars, proximityCharsLength,
+---
+>     env->GetStringUTFRegion(localeJStr, 0, env->GetStringLength(localeJStr), mLocaleStr);
+>     safeGetOrFillZeroIntArrayRegion(env, proximityChars, proximityCharsLength,
+99,106c94,101
+<     safeGetOrFillZeroIntArrayRegion(keyXCoordinates, KEY_COUNT, mKeyXCoordinates);
+<     safeGetOrFillZeroIntArrayRegion(keyYCoordinates, KEY_COUNT, mKeyYCoordinates);
+<     safeGetOrFillZeroIntArrayRegion(keyWidths, KEY_COUNT, mKeyWidths);
+<     safeGetOrFillZeroIntArrayRegion(keyHeights, KEY_COUNT, mKeyHeights);
+<     safeGetOrFillZeroIntArrayRegion(keyCharCodes, KEY_COUNT, mKeyCodePoints);
+<     safeGetOrFillZeroFloatArrayRegion(sweetSpotCenterXs, KEY_COUNT, mSweetSpotCenterXs);
+<     safeGetOrFillZeroFloatArrayRegion(sweetSpotCenterYs, KEY_COUNT, mSweetSpotCenterYs);
+<     safeGetOrFillZeroFloatArrayRegion(sweetSpotRadii, KEY_COUNT, mSweetSpotRadii);
+---
+>     safeGetOrFillZeroIntArrayRegion(env, keyXCoordinates, KEY_COUNT, mKeyXCoordinates);
+>     safeGetOrFillZeroIntArrayRegion(env, keyYCoordinates, KEY_COUNT, mKeyYCoordinates);
+>     safeGetOrFillZeroIntArrayRegion(env, keyWidths, KEY_COUNT, mKeyWidths);
+>     safeGetOrFillZeroIntArrayRegion(env, keyHeights, KEY_COUNT, mKeyHeights);
+>     safeGetOrFillZeroIntArrayRegion(env, keyCharCodes, KEY_COUNT, mKeyCodePoints);
+>     safeGetOrFillZeroFloatArrayRegion(env, sweetSpotCenterXs, KEY_COUNT, mSweetSpotCenterXs);
+>     safeGetOrFillZeroFloatArrayRegion(env, sweetSpotCenterYs, KEY_COUNT, mSweetSpotCenterYs);
+>     safeGetOrFillZeroFloatArrayRegion(env, sweetSpotRadii, KEY_COUNT, mSweetSpotRadii);
+diff -r third_party/android_prediction/suggest/core/layout/proximity_info.h /usr/local/google/home/riajiang/Downloads/android_prediction/suggest/core/layout/proximity_info.h
+20d19
+< #include <string>
+23a23
+> #include "jni.h"
+30c30
+<     ProximityInfo(const std::string localeJStr,
+---
+>     ProximityInfo(JNIEnv *env, const jstring localeJStr,
+33,36c33,36
+<             int *proximityChars, int proximitySize, const int keyCount, const int *keyXCoordinates,
+<             const int *keyYCoordinates, const int *keyWidths, const int *keyHeights,
+<             const int *keyCharCodes, const float *sweetSpotCenterXs,
+<             const float *sweetSpotCenterYs, const float *sweetSpotRadii);
+---
+>             const jintArray proximityChars, const int keyCount, const jintArray keyXCoordinates,
+>             const jintArray keyYCoordinates, const jintArray keyWidths, const jintArray keyHeights,
+>             const jintArray keyCharCodes, const jfloatArray sweetSpotCenterXs,
+>             const jfloatArray sweetSpotCenterYs, const jfloatArray sweetSpotRadii);
+diff -r third_party/android_prediction/suggest/core/result/suggestion_results.cpp /usr/local/google/home/riajiang/Downloads/android_prediction/suggest/core/result/suggestion_results.cpp
+18a19,20
+> #include "third_party/android_prediction/utils/jni_data_utils.h"
+> 
+19a22,48
+> 
+> void SuggestionResults::outputSuggestions(JNIEnv *env, jintArray outSuggestionCount,
+>         jintArray outputCodePointsArray, jintArray outScoresArray, jintArray outSpaceIndicesArray,
+>         jintArray outTypesArray, jintArray outAutoCommitFirstWordConfidenceArray,
+>         jfloatArray outLanguageWeight) {
+>     int outputIndex = 0;
+>     while (!mSuggestedWords.empty()) {
+>         const SuggestedWord &suggestedWord = mSuggestedWords.top();
+>         suggestedWord.getCodePointCount();
+>         const int start = outputIndex * MAX_WORD_LENGTH;
+>         JniDataUtils::outputCodePoints(env, outputCodePointsArray, start,
+>                 MAX_WORD_LENGTH /* maxLength */, suggestedWord.getCodePoint(),
+>                 suggestedWord.getCodePointCount(), true /* needsNullTermination */);
+>         JniDataUtils::putIntToArray(env, outScoresArray, outputIndex, suggestedWord.getScore());
+>         JniDataUtils::putIntToArray(env, outSpaceIndicesArray, outputIndex,
+>                 suggestedWord.getIndexToPartialCommit());
+>         JniDataUtils::putIntToArray(env, outTypesArray, outputIndex, suggestedWord.getType());
+>         if (mSuggestedWords.size() == 1) {
+>             JniDataUtils::putIntToArray(env, outAutoCommitFirstWordConfidenceArray, 0 /* index */,
+>                     suggestedWord.getAutoCommitFirstWordConfidence());
+>         }
+>         ++outputIndex;
+>         mSuggestedWords.pop();
+>     }
+>     JniDataUtils::putIntToArray(env, outSuggestionCount, 0 /* index */, outputIndex);
+>     JniDataUtils::putFloatToArray(env, outLanguageWeight, 0 /* index */, mLanguageWeight);
+> }
+diff -r third_party/android_prediction/suggest/core/result/suggestion_results.h /usr/local/google/home/riajiang/Downloads/android_prediction/suggest/core/result/suggestion_results.h
+23a24
+> #include "jni.h"
+31,32c32,33
+<             : mSuggestedWords(), mMaxSuggestionCount(maxSuggestionCount), 
+<               mLanguageWeight(NOT_A_LANGUAGE_WEIGHT) {}
+---
+>             : mMaxSuggestionCount(maxSuggestionCount), mLanguageWeight(NOT_A_LANGUAGE_WEIGHT),
+>               mSuggestedWords() {}
+33a35,38
+>     // Returns suggestion count.
+>     void outputSuggestions(JNIEnv *env, jintArray outSuggestionCount, jintArray outCodePointsArray,
+>             jintArray outScoresArray, jintArray outSpaceIndicesArray, jintArray outTypesArray,
+>             jintArray outAutoCommitFirstWordConfidenceArray, jfloatArray outLanguageWeight);
+49,51d53
+<     std::priority_queue<
+<         SuggestedWord, std::vector<SuggestedWord>, SuggestedWord::Comparator> mSuggestedWords;
+< 
+56a59,60
+>     std::priority_queue<
+>             SuggestedWord, std::vector<SuggestedWord>, SuggestedWord::Comparator> mSuggestedWords;
+diff -r third_party/android_prediction/suggest/core/session/dic_traverse_session.h /usr/local/google/home/riajiang/Downloads/android_prediction/suggest/core/session/dic_traverse_session.h
+22a23
+> #include "jni.h"
+39c40
+<     static AK_FORCE_INLINE void *getSessionInstance(std::string localeStr, long dictSize
+---
+>     static AK_FORCE_INLINE void *getSessionInstance(JNIEnv *env, jstring localeStr, jlong dictSize
+43c44
+<         return new DicTraverseSession(localeStr,
+---
+>         return new DicTraverseSession(env, localeStr,
+51c52
+<     AK_FORCE_INLINE DicTraverseSession(std::string localeStr, bool usesLargeCache)
+---
+>     AK_FORCE_INLINE DicTraverseSession(JNIEnv *env, jstring localeStr, bool usesLargeCache)
+Only in /usr/local/google/home/riajiang/Downloads/android_prediction/utils: jni_data_utils.cpp
+Only in /usr/local/google/home/riajiang/Downloads/android_prediction/utils: jni_data_utils.h
+Only in /usr/local/google/home/riajiang/Downloads/android_prediction/utils: log_utils.cpp
+Only in /usr/local/google/home/riajiang/Downloads/android_prediction/utils: log_utils.h