Patch 2: Added a preprocessor flag for platform spellcheck.

chrome/renderer/spellchecker/spellcheck_provider.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_provider.h"
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/spellcheck_marker.h"
@@ skipping 54 matching lines @@
 
   // Try to satisfy check from cache.
   if (SatisfyRequestFromCache(text, completion))
     return;
 
   // Send this text to a browser. A browser checks the user profile and send
   // this text to the Spelling service only if a user enables this feature.
   last_request_.clear();
   last_results_.assign(blink::WebVector<blink::WebTextCheckingResult>());
 
-#if defined(OS_MACOSX)
+#if defined(USE_PLATFORM_SPELLCHECKER)
   // Text check (unified request for grammar and spell check) is only
   // available for browser process, so we ask the system spellchecker
   // over IPC or return an empty result if the checker is not
   // available.
   Send(new SpellCheckHostMsg_RequestTextCheck(
       routing_id(),
       text_check_completions_.Add(completion),
       text,
       markers));
 #else
   Send(new SpellCheckHostMsg_CallSpellingService(
       routing_id(),
       text_check_completions_.Add(completion),
       base::string16(text),
       markers));
-#endif  // !OS_MACOSX
+#endif  // !USE_PLATFORM_SPELLCHECKER
 }
 
 bool SpellCheckProvider::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(SpellCheckProvider, message)
-#if !defined(OS_MACOSX)
+#if !defined(USE_PLATFORM_SPELLCHECKER)
     IPC_MESSAGE_HANDLER(SpellCheckMsg_RespondSpellingService,
                         OnRespondSpellingService)
-#endif
-#if defined(OS_MACOSX)
+#else
     IPC_MESSAGE_HANDLER(SpellCheckMsg_AdvanceToNextMisspelling,
                         OnAdvanceToNextMisspelling)
     IPC_MESSAGE_HANDLER(SpellCheckMsg_RespondTextCheck, OnRespondTextCheck)
     IPC_MESSAGE_HANDLER(SpellCheckMsg_ToggleSpellPanel, OnToggleSpellPanel)
-#endif
+#endif // USE_PLATFORM_SPELLCHECKER
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void SpellCheckProvider::FocusedNodeChanged(const blink::WebNode& unused) {
-#if defined(OS_MACOSX)
+#if defined(USE_PLATFORM_SPELLCHECKER)
   WebFrame* frame = render_view()->GetWebView()->focusedFrame();
   WebElement element = frame->document().isNull() ? WebElement() :
       frame->document().focusedElement();
   bool enabled = !element.isNull() && render_view()->IsEditableNode(element);
 
   bool checked = enabled && render_view()->GetWebView() &&
       frame->isContinuousSpellCheckingEnabled();
 
   Send(new SpellCheckHostMsg_ToggleSpellCheck(routing_id(), enabled, checked));
-#endif  // OS_MACOSX
+#endif  // USE_PLATFORM_SPELLCHECKER
 }
 
 void SpellCheckProvider::spellCheck(
     const WebString& text,
     int& offset,
     int& length,
     WebVector<WebString>* optional_suggestions) {
   base::string16 word(text);
   std::vector<base::string16> suggestions;
   spellcheck_->SpellCheckWord(
@@ skipping 45 matching lines @@
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kEnableSpellingAutoCorrect)) {
     UMA_HISTOGRAM_COUNTS("SpellCheck.api.autocorrect", word.length());
     return spellcheck_->GetAutoCorrectionWord(word, routing_id());
   }
   return base::string16();
 }
 
 void SpellCheckProvider::showSpellingUI(bool show) {
-#if defined(OS_MACOSX)
+#if defined(USE_PLATFORM_SPELLCHECKER)
   UMA_HISTOGRAM_BOOLEAN("SpellCheck.api.showUI", show);
   Send(new SpellCheckHostMsg_ShowSpellingPanel(routing_id(), show));
 #endif
 }
 
 bool SpellCheckProvider::isShowingSpellingUI() {
   return spelling_panel_visible_;
 }
 
 void SpellCheckProvider::updateSpellingUIWithMisspelledWord(
     const WebString& word) {
-#if defined(OS_MACOSX)
+#if defined(USE_PLATFORM_SPELLCHECKER)
   Send(new SpellCheckHostMsg_UpdateSpellingPanelWithMisspelledWord(routing_id(),
                                                                    word));
 #endif
 }
 
-#if !defined(OS_MACOSX)
+#if !defined(USE_PLATFORM_SPELLCHECKER)
 void SpellCheckProvider::OnRespondSpellingService(
     int identifier,
     bool succeeded,
     const base::string16& line,
     const std::vector<SpellCheckResult>& results) {
   WebTextCheckingCompletion* completion =
       text_check_completions_.Lookup(identifier);
   if (!completion)
     return;
   text_check_completions_.Remove(identifier);
@@ skipping 11 matching lines @@
                                          0,
                                          line,
                                          results,
                                          &textcheck_results);
   completion->didFinishCheckingText(textcheck_results);
 
   // Cache the request and the converted results.
   last_request_ = line;
   last_results_.swap(textcheck_results);
 }
-#endif
+#endif // !USE_PLATFORM_SPELLCHECKER
 
 bool SpellCheckProvider::HasWordCharacters(
     const base::string16& text,
     int index) const {
   const base::char16* data = text.data();
   int length = text.length();
   while (index < length) {
     uint32 code = 0;
     U16_NEXT(data, index, length, code);
     UErrorCode error = U_ZERO_ERROR;
     if (uscript_getScript(code, &error) != USCRIPT_COMMON)
       return true;
   }
   return false;
 }
 
-#if defined(OS_MACOSX)
+#if defined(USE_PLATFORM_SPELLCHECKER)
 void SpellCheckProvider::OnAdvanceToNextMisspelling() {
   if (!render_view()->GetWebView())
     return;
   render_view()->GetWebView()->focusedFrame()->executeCommand(
       WebString::fromUTF8("AdvanceToNextMisspelling"));
 }
 
 void SpellCheckProvider::OnRespondTextCheck(
     int identifier,
     const std::vector<SpellCheckResult>& results) {
@@ skipping 19 matching lines @@
 
 void SpellCheckProvider::OnToggleSpellPanel(bool is_currently_visible) {
   if (!render_view()->GetWebView())
     return;
   // We need to tell the webView whether the spelling panel is visible or not so
   // that it won't need to make ipc calls later.
   spelling_panel_visible_ = is_currently_visible;
   render_view()->GetWebView()->focusedFrame()->executeCommand(
       WebString::fromUTF8("ToggleSpellPanel"));
 }
-#endif
+#endif // USE_PLATFORM_SPELLCHECKER
 
 void SpellCheckProvider::EnableSpellcheck(bool enable) {
   if (!render_view()->GetWebView())
     return;
 
   WebFrame* frame = render_view()->GetWebView()->focusedFrame();
   frame->enableContinuousSpellChecking(enable);
   if (!enable)
     frame->removeSpellingMarkers();
 }
@@ skipping 44 matching lines @@
         results[i].length = last_results_[i].length;
         results[i].replacement = last_results_[i].replacement;
       }
       completion->didFinishCheckingText(results);
       return true;
     }
   }
 
   return false;
 }