Remove ENABLE_LANGUAGE_DETECTION

chrome/common/translate/language_detection_util.cc

 // Copyright 2013 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/common/translate/language_detection_util.h"
 
 #include "base/logging.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/translate/translate_common_metrics.h"
 #include "chrome/common/translate/translate_util.h"
-
-#if defined(ENABLE_LANGUAGE_DETECTION)
 #include "third_party/cld/encodings/compact_lang_det/compact_lang_det.h"
 #include "third_party/cld/encodings/compact_lang_det/win/cld_unicodetext.h"
-#endif
 
 namespace {
 
 // Similar language code list. Some languages are very similar and difficult
 // for CLD to distinguish.
 struct SimilarLanguageCode {
   const char* const code;
   int group;
 };
 
@@ skipping 28 matching lines @@
   LanguageDetectionUtil::CorrectLanguageCodeTypo(code);
 
   if (!LanguageDetectionUtil::IsValidLanguageCode(*code)) {
     *code = std::string();
     return;
   }
 
   TranslateUtil::ToTranslateLanguageSynonym(code);
 }
 
-#if defined(ENABLE_LANGUAGE_DETECTION)
 // Returns the ISO 639 language code of the specified |text|, or 'unknown' if it
 // failed.
 // |is_cld_reliable| will be set as true if CLD says the detection is reliable.
 std::string DetermineTextLanguage(const base::string16& text,
                                   bool* is_cld_reliable) {
   std::string language = chrome::kUnknownLanguageCode;
   int num_languages = 0;
   int text_bytes = 0;
   bool is_reliable = false;
   Language cld_language =
@@ skipping 15 matching lines @@
     // language code for tradtional Chinese among others.
     // |LanguageCodeWithDialect| will go through ISO 639-1, ISO-639-2 and
     // 'other' tables to do the 'right' thing. In addition, it'll return zh-CN
     // for Simplified Chinese.
     language = LanguageCodeWithDialects(cld_language);
   }
   VLOG(9) << "Detected lang_id: " << language << ", from Text:\n" << text
           << "\n*************************************\n";
   return language;
 }
-#endif  // defined(ENABLE_LANGUAGE_DETECTION)
 
 // Checks if CLD can complement a sub code when the page language doesn't know
 // the sub code.
 bool CanCLDComplementSubCode(
     const std::string& page_language, const std::string& cld_language) {
   // Translate server cannot treat general Chinese. If Content-Language and
   // CLD agree that the language is Chinese and Content-Language doesn't know
   // which dialect is used, CLD language has priority.
   // TODO(hajimehoshi): How about the other dialects like zh-MO?
   return page_language == "zh" && StartsWithASCII(cld_language, "zh-", false);
 }
 
 }  // namespace
 
 namespace LanguageDetectionUtil {
 
 std::string DeterminePageLanguage(const std::string& code,
                                   const std::string& html_lang,
                                   const base::string16& contents,
                                   std::string* cld_language_p,
                                   bool* is_cld_reliable_p) {
-#if defined(ENABLE_LANGUAGE_DETECTION)
   base::TimeTicks begin_time = base::TimeTicks::Now();
   bool is_cld_reliable;
   std::string cld_language = DetermineTextLanguage(contents, &is_cld_reliable);
   TranslateCommonMetrics::ReportLanguageDetectionTime(begin_time,
                                                       base::TimeTicks::Now());
 
   if (cld_language_p != NULL)
     *cld_language_p = cld_language;
   if (is_cld_reliable_p != NULL)
     *is_cld_reliable_p = is_cld_reliable;
   TranslateUtil::ToTranslateLanguageSynonym(&cld_language);
-#endif  // defined(ENABLE_LANGUAGE_DETECTION)
 
   // Check if html lang attribute is valid.
   std::string modified_html_lang;
   if (!html_lang.empty()) {
     modified_html_lang = html_lang;
     ApplyLanguageCodeCorrection(&modified_html_lang);
     TranslateCommonMetrics::ReportHtmlLang(html_lang, modified_html_lang);
     VLOG(9) << "html lang based language code: " << modified_html_lang;
   }
 
   // Check if Content-Language is valid.
   std::string modified_code;
   if (!code.empty()) {
     modified_code = code;
     ApplyLanguageCodeCorrection(&modified_code);
     TranslateCommonMetrics::ReportContentLanguage(code, modified_code);
   }
 
   // Adopt |modified_html_lang| if it is valid. Otherwise, adopt
   // |modified_code|.
   std::string language = modified_html_lang.empty() ? modified_code :
                                                       modified_html_lang;
 
-#if defined(ENABLE_LANGUAGE_DETECTION)
   // If |language| is empty, just use CLD result even though it might be
   // chrome::kUnknownLanguageCode.
   if (language.empty()) {
     TranslateCommonMetrics::ReportLanguageVerification(
         TranslateCommonMetrics::LANGUAGE_VERIFICATION_CLD_ONLY);
     return cld_language;
   }
 
   if (cld_language == chrome::kUnknownLanguageCode) {
     TranslateCommonMetrics::ReportLanguageVerification(
@@ skipping 13 matching lines @@
     return cld_language;
   } else {
     TranslateCommonMetrics::ReportLanguageVerification(
         TranslateCommonMetrics::LANGUAGE_VERIFICATION_CLD_DISAGREE);
     // Content-Language value might be wrong because CLD says that this page
     // is written in another language with confidence.
     // In this case, Chrome doesn't rely on any of the language codes, and
     // gives up suggesting a translation.
     return std::string(chrome::kUnknownLanguageCode);
   }
-#else  // defined(ENABLE_LANGUAGE_DETECTION)
-  TranslateCommonMetrics::ReportLanguageVerification(
-      TranslateCommonMetrics::LANGUAGE_VERIFICATION_CLD_DISABLED);
-#endif  // defined(ENABLE_LANGUAGE_DETECTION)
 
   return language;
 }
 
 void CorrectLanguageCodeTypo(std::string* code) {
   DCHECK(code);
 
   size_t coma_index = code->find(',');
   if (coma_index != std::string::npos) {
     // There are more than 1 language specified, just keep the first one.
@@ skipping 87 matching lines @@
   // distinguish from English, and the language is one of well-known languages
   // which often provide "en-*" meta information mistakenly.
   for (size_t i = 0; i < arraysize(kWellKnownCodesOnWrongConfiguration); ++i) {
     if (cld_language == kWellKnownCodesOnWrongConfiguration[i])
       return true;
   }
   return false;
 }
 
 std::string GetCLDVersion() {
-#if defined(ENABLE_LANGUAGE_DETECTION)
   return CompactLangDet::DetectLanguageVersion();
-#else
-  return ""
-#endif
 }
 
 }  // namespace LanguageDetectionUtil