[Spellcheck] Removing cruft.

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 "base/bind.h"
 #include "base/message_loop_proxy.h"
 #include "base/time.h"
 #include "chrome/common/render_messages.h"
@@ skipping 28 matching lines @@
   string16 text_;  // Text to be checked in this task.
   int offset_;   // The text offset from the beginning.
 
   // The interface to send the misspelled ranges to WebKit.
   WebKit::WebTextCheckingCompletion* completion_;
 
   DISALLOW_COPY_AND_ASSIGN(SpellcheckRequest);
 };
 
 SpellCheck::SpellCheck() : auto_spell_correct_turned_on_(false) {
+  platform_spelling_engine_.reset(CreateNativeSpellingEngine());
 }
 
 SpellCheck::~SpellCheck() {
 }
 
 bool SpellCheck::OnControlMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(SpellCheck, message)
     IPC_MESSAGE_HANDLER(SpellCheckMsg_Init, OnInit)
     IPC_MESSAGE_HANDLER(SpellCheckMsg_WordAdded, OnWordAdded)
@@ skipping 21 matching lines @@
   platform_spelling_engine_->OnWordAdded(word);
 }
 
 void SpellCheck::OnEnableAutoSpellCorrect(bool enable) {
   auto_spell_correct_turned_on_ = enable;
 }
 
 void SpellCheck::Init(base::PlatformFile file,
                       const std::vector<std::string>& custom_words,
                       const std::string& language) {
-  bool use_platform_spelling_engine =
-      file == base::kInvalidPlatformFileValue && !language.empty();
+  platform_spelling_engine_->Init(file, custom_words);
 
-  // Some tests under OSX still exercise hunspell. Only init native engine
-  // when no dictionary was specified.
-  // TODO(groby): Figure out if we can kill the hunspell dependency for OSX.
-  if (use_platform_spelling_engine) {
-    platform_spelling_engine_.reset(CreateNativeSpellingEngine());
-  } else {
-    HunspellEngine* engine = new HunspellEngine;
-    engine->Init(file, custom_words);
-    platform_spelling_engine_.reset(engine);
-  }
   character_attributes_.SetDefaultLanguage(language);
   text_iterator_.Reset();
   contraction_iterator_.Reset();
 }
 
 bool SpellCheck::SpellCheckWord(
     const char16* in_word,
     int in_word_len,
     int tag,
     int* misspelling_start,
@@ skipping 157 matching lines @@
   pending_request_param_.reset(new SpellcheckRequest(
       text, offset, 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() {
-  // TODO(groby): OSX creates a hunspell engine here, too. That seems
-  // wrong, but is (AFAICT) the existing flow. Fix that.
-  if (!platform_spelling_engine_.get())
-    platform_spelling_engine_.reset(new HunspellEngine);
-
+  DCHECK(platform_spelling_engine_.get());
   return platform_spelling_engine_->InitializeIfNeeded();
 }
 
 // When called, relays the request to check the spelling to the proper
 // backend, either hunspell or a platform-specific backend.
 bool SpellCheck::CheckSpelling(const string16& word_to_check, int tag) {
   DCHECK(platform_spelling_engine_.get());
   return platform_spelling_engine_->CheckSpelling(word_to_check, tag);
 }
 
@@ skipping 48 matching lines @@
   string16 word;
   int word_start;
   int word_length;
   while (contraction_iterator_.GetNextWord(&word, &word_start, &word_length)) {
     if (!CheckSpelling(word, tag))
       return false;
   }
   return true;
 }
 
-#if !defined(OS_MACOSX)
 void SpellCheck::CreateTextCheckingResults(
+    ResultFilter filter,
     int line_offset,
     const string16& line_text,
     const std::vector<SpellCheckResult>& spellcheck_results,
     WebVector<WebTextCheckingResult>* textcheck_results) {
   // Double-check misspelled words with our spellchecker and attach grammar
   // markers to them if our spellchecker tells they are correct words, i.e. they
   // are probably contextually-misspelled words.
   const char16* text = line_text.c_str();
   WebVector<WebTextCheckingResult> list(spellcheck_results.size());
   for (size_t i = 0; i < spellcheck_results.size(); ++i) {
     WebTextCheckingType type =
         static_cast<WebTextCheckingType>(spellcheck_results[i].type);
     int word_location = spellcheck_results[i].location;
     int word_length = spellcheck_results[i].length;
-    if (type == WebKit::WebTextCheckingTypeSpelling) {
+    if (type == WebKit::WebTextCheckingTypeSpelling &&
+        filter == USE_NATIVE_CHECKER) {
       int misspelling_start = 0;
       int misspelling_length = 0;
       if (SpellCheckWord(text + word_location, word_length, 0,
                          &misspelling_start, &misspelling_length, NULL)) {
         type = WebKit::WebTextCheckingTypeGrammar;
       }
     }
     list[i] = WebKit::WebTextCheckingResult(type,
                                             word_location + line_offset,
                                             word_length,
                                             spellcheck_results[i].replacement);
   }
   textcheck_results->swap(list);
 }
-#endif