Patch 5: Implemented android message filter and platform.

chrome/browser/spellchecker/spellcheck_platform_android.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/spellchecker/spellcheck_platform.h"
 
+//#include "base/android/jni_android.h"
+//#include "base/android/jni_array.h"
+//#include "base/android/jni_string.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/spellcheck_result.h"
+//#include "jni/SpellCheckerSessionBridge_jni.h"
+
+namespace {
+ //std::vector<int> offsets;
+ //std::vector<int> lengths;
+ //base::android::ScopedJavaGlobalRef<jobject> java_object_;
+ //base::Callback<void(const std::vector<SpellCheckResult>&)> callback_;
+}  // namespace
 
 namespace spellcheck_platform {
 
 void GetAvailableLanguages(std::vector<std::string>* spellcheck_languages) {
 }
 
 bool SpellCheckerAvailable() {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kEnableAndroidSpellChecker);
+    switches::kEnableAndroidSpellChecker);
 }
 
 bool SpellCheckerProvidesPanel() {
   return false;
 }
 
 bool SpellingPanelVisible() {
   return false;
 }
 
 void ShowSpellingPanel(bool show) {
 }
 
 void UpdateSpellingPanelWithMisspelledWord(const base::string16& word) {
 }
 
 bool PlatformSupportsLanguage(const std::string& current_language) {
   return true;
 }
 
 void SetLanguage(const std::string& lang_to_set) {
 }
 
 bool CheckSpelling(const base::string16& word_to_check, int tag) {
-  return true;
+    return true;
 }
 
 void FillSuggestionList(const base::string16& wrong_word,
                         std::vector<base::string16>* optional_suggestions) {
 }
 
 void AddWord(const base::string16& word) {
 }
 
 void RemoveWord(const base::string16& word) {
 }
 
 int GetDocumentTag() {
   return 1;
 }
 
 void IgnoreWord(const base::string16& word) {
 }
 
 void CloseDocumentWithTag(int tag) {
 }
 
 void RequestTextCheck(int document_tag,
                       const base::string16& text,
                       TextCheckCompleteCallback callback) {
-
+  //JNIEnv* env = base::android::AttachCurrentThread();
+  //callback_ = callback;
+  LOG(ERROR) << "DYLANKING RequestTextCheck on " << text;
+  //Java_SpellCheckerSessionBridge_checkSpelling(env, java_object_.obj(),
+      //base::android::ConvertUTF16ToJavaString(env, text).obj());
 }
 
+/*
+void InitializeJNIBridge() {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  java_object_.Reset(
+    Java_SpellCheckerSessionBridge_create(env));
+}
+
+//static
+bool RegisterSpellcheckPlatformAndroid(JNIEnv* env) {
+  return RegisterNativesImpl(env);
+}
+
+//static
+void GetSpellcheckInfo(JNIEnv* env, jobject jobj, jobjectArray suggestionsArray,
+                       jintArray offsetArray, jintArray lengthArray){
+
+  LOG(ERROR) << "DYLANKING In Native GetSpellcheckInfo";
+  std::vector<SpellCheckResult> check_results;
+  std::vector<base::string16> optional_suggestions;
+  base::android::AppendJavaStringArrayToStringVector(env, suggestionsArray, &optional_suggestions);
+
+  for(unsigned int i = 0; i < optional_suggestions.size(); i++){
+    LOG(ERROR) << "DYLANKING " << optional_suggestions[i];
+  }
+
+  base::android::JavaIntArrayToIntVector(env, offsetArray, &offsets);
+  base::android::JavaIntArrayToIntVector(env, lengthArray, &lengths);
+
+  for(unsigned int j = 0; j < offsets.size(); j++){
+    LOG(ERROR) << "DYLANKING offset: " << offsets[j] << " length: " << lengths[j];
+    check_results.push_back(SpellCheckResult(SpellCheckResult::SPELLING,offsets[j],lengths[j]));
+  }
+
+  callback_.Run(check_results);
+}
+*/
+
 }  // namespace spellcheck_platform