Removed and replaced outdated mac-specific files and references.

chrome/renderer/spellchecker/spellcheck.cc

 // Copyright (c) 2012 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/renderer/spellchecker/spellcheck.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 180 matching lines @@
     bool auto_spell_correct) {
   languages_.clear();
   for (const auto& bdict_language : bdict_languages) {
     AddSpellcheckLanguage(
         IPC::PlatformFileForTransitToFile(bdict_language.file),
         bdict_language.language);
   }
 
   custom_dictionary_.Init(custom_words);
   auto_spell_correct_turned_on_ = auto_spell_correct;
-#if !defined(OS_MACOSX)
+#if !defined(USE_BROWSER_SPELLCHECKER)
   PostDelayedSpellCheckTask(pending_request_param_.release());
 #endif
 }
 
 void SpellCheck::OnCustomDictionaryChanged(
     const std::set<std::string>& words_added,
     const std::set<std::string>& words_removed) {
   custom_dictionary_.OnCustomDictionaryChanged(words_added, words_removed);
   if (words_added.empty())
     return;
@@ skipping 42 matching lines @@
     return true;
 
   return languages_.front()->SpellCheckWord(in_word, in_word_len, tag,
                                             misspelling_start, misspelling_len,
                                             optional_suggestions);
 }
 
 bool SpellCheck::SpellCheckParagraph(
     const base::string16& text,
     WebVector<WebTextCheckingResult>* results) {
-#if !defined(OS_MACOSX)
-  // Mac has its own spell checker, so this method will not be used.
+#if !defined(USE_BROWSER_SPELLCHECKER)
+  // Mac and Android have their own spell checkers,so this method won't be used
   DCHECK(results);
   std::vector<WebTextCheckingResult> textcheck_results;
   size_t length = text.length();
   size_t offset = 0;
 
   // Spellcheck::SpellCheckWord() automatically breaks text into words and
   // checks the spellings of the extracted words. This function sets the
   // position and length of the first misspelled word and returns false when
   // the text includes misspelled words. Therefore, we just repeat calling the
   // function until it returns true to check the whole text.
@@ skipping 18 matching lines @@
           misspelling_start + offset,
           misspelling_length,
           replacement));
     }
     offset += misspelling_start + misspelling_length;
   }
   results->assign(textcheck_results);
   return false;
 #else
   // This function is only invoked for spell checker functionality that runs
-  // on the render thread. OSX builds don't have that.
+  // on the render thread. OSX and Android builds don't have that.
   NOTREACHED();
   return true;
 #endif
 }
 
 base::string16 SpellCheck::GetAutoCorrectionWord(const base::string16& word,
                                                  int tag) {
   base::string16 autocorrect_word;
   if (!auto_spell_correct_turned_on_)
     return autocorrect_word;  // Return the empty string.
@@ skipping 38 matching lines @@
         break;
       }
     }
 
     // Restore the swapped characters.
     std::swap(misspelled_word[i], misspelled_word[i + 1]);
   }
   return autocorrect_word;
 }
 
-#if !defined(OS_MACOSX)  // OSX uses its own spell checker
+// OSX and Android use their own spell checkers
+#if !defined(USE_BROWSER_SPELLCHECKER)
 void SpellCheck::RequestTextChecking(
     const base::string16& text,
     blink::WebTextCheckingCompletion* completion) {
   // Clean up the previous request before starting a new request.
   if (pending_request_param_.get())
     pending_request_param_->completion()->didCancelCheckingText();
 
   pending_request_param_.reset(new SpellcheckRequest(
       text, completion));
   // We will check this text after we finish loading the hunspell dictionary.
   if (InitializeIfNeeded())
     return;
 
   PostDelayedSpellCheckTask(pending_request_param_.release());
 }
 #endif
 
 bool SpellCheck::InitializeIfNeeded() {
   return languages_.empty() ? true : languages_.front()->InitializeIfNeeded();
 }
 
-#if !defined(OS_MACOSX) // OSX doesn't have |pending_request_param_|
+// OSX and Android don't have |pending_request_param_|
+#if !defined(USE_BROWSER_SPELLCHECKER)
 void SpellCheck::PostDelayedSpellCheckTask(SpellcheckRequest* request) {
   if (!request)
     return;
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&SpellCheck::PerformSpellCheck, AsWeakPtr(),
                             base::Owned(request)));
 }
 #endif
 
-#if !defined(OS_MACOSX)  // Mac uses its platform engine instead.
+// Mac and Android use their platform engines instead.
+#if !defined(USE_BROWSER_SPELLCHECKER)
 void SpellCheck::PerformSpellCheck(SpellcheckRequest* param) {
   DCHECK(param);
 
   if (languages_.empty() || !languages_.front()->IsEnabled()) {
     param->completion()->didCancelCheckingText();
   } else {
     WebVector<blink::WebTextCheckingResult> results;
     SpellCheckParagraph(param->text(), &results);
     param->completion()->didFinishCheckingText(results);
   }
@@ skipping 49 matching lines @@
     }
 
     results.push_back(WebTextCheckingResult(
         static_cast<WebTextDecorationType>(decoration),
         line_offset + spellcheck_result.location, spellcheck_result.length,
         replacement, spellcheck_result.hash));
   }
 
   textcheck_results->assign(results);
 }