Convert spellcheck to a buildflag header.

components/spellcheck/renderer/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 "components/spellcheck/renderer/spellcheck.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "components/spellcheck/common/spellcheck_common.h"
 #include "components/spellcheck/common/spellcheck_features.h"
 #include "components/spellcheck/common/spellcheck_messages.h"
 #include "components/spellcheck/common/spellcheck_result.h"
 #include "components/spellcheck/common/spellcheck_switches.h"
 #include "components/spellcheck/renderer/spellcheck_language.h"
 #include "components/spellcheck/renderer/spellcheck_provider.h"
+#include "components/spellcheck/spellcheck_build_features.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/render_view.h"
 #include "content/public/renderer/render_view_visitor.h"
 #include "ipc/ipc_platform_file.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebTextCheckingCompletion.h"
 #include "third_party/WebKit/public/web/WebTextCheckingResult.h"
 #include "third_party/WebKit/public/web/WebTextDecorationType.h"
 #include "third_party/WebKit/public/web/WebView.h"
@@ skipping 185 matching lines @@
     const std::vector<SpellCheckBDictLanguage>& bdict_languages,
     const std::set<std::string>& custom_words) {
   languages_.clear();
   for (const auto& bdict_language : bdict_languages) {
     AddSpellcheckLanguage(
         IPC::PlatformFileForTransitToFile(bdict_language.file),
         bdict_language.language);
   }
 
   custom_dictionary_.Init(custom_words);
-#if !defined(USE_BROWSER_SPELLCHECKER)
+#if !BUILDFLAG(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 119 matching lines @@
     }
   }
 
   NOTREACHED();
   return true;
 }
 
 bool SpellCheck::SpellCheckParagraph(
     const base::string16& text,
     WebVector<WebTextCheckingResult>* results) {
-#if !defined(USE_BROWSER_SPELLCHECKER)
+#if !BUILDFLAG(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 position_in_text = 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
@@ skipping 27 matching lines @@
   return false;
 #else
   // This function is only invoked for spell checker functionality that runs
   // on the render thread. OSX and Android builds don't have that.
   NOTREACHED();
   return true;
 #endif
 }
 
 // OSX and Android use their own spell checkers
-#if !defined(USE_BROWSER_SPELLCHECKER)
+#if !BUILDFLAG(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() {
   if (languages_.empty())
     return true;
 
   bool initialize_if_needed = false;
   for (SpellcheckLanguage* language : languages_)
     initialize_if_needed |= language->InitializeIfNeeded();
 
   return initialize_if_needed;
 }
 
 // OSX and Android don't have |pending_request_param_|
-#if !defined(USE_BROWSER_SPELLCHECKER)
+#if !BUILDFLAG(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
 
 // Mac and Android use their platform engines instead.
-#if !defined(USE_BROWSER_SPELLCHECKER)
+#if !BUILDFLAG(USE_BROWSER_SPELLCHECKER)
 void SpellCheck::PerformSpellCheck(SpellcheckRequest* param) {
   DCHECK(param);
 
   if (languages_.empty() ||
       std::find_if(languages_.begin(), languages_.end(),
                    [](SpellcheckLanguage* language) {
                      return !language->IsEnabled();
                    }) != languages_.end()) {
     param->completion()->didCancelCheckingText();
   } else {
@@ skipping 61 matching lines @@
 
   textcheck_results->assign(results);
 }
 
 bool SpellCheck::IsSpellcheckEnabled() {
 #if defined(OS_ANDROID)
   if (!spellcheck::IsAndroidSpellCheckFeatureEnabled()) return false;
 #endif
   return spellcheck_enabled_;
 }