Drop support for Compact Language Detector v1.

components/translate/core/language_detection/language_detection_util.cc

 // Copyright 2014 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/translate/core/language_detection/language_detection_util.h"
 
 #include <stddef.h>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "components/translate/core/common/translate_constants.h"
 #include "components/translate/core/common/translate_metrics.h"
 #include "components/translate/core/common/translate_util.h"
-
-#if CLD_VERSION==1
-#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
-
-#if CLD_VERSION==2
 #include "third_party/cld_2/src/public/compact_lang_det.h"
 #include "third_party/cld_2/src/public/encodings.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 44 matching lines @@
                                   std::string& html_lang) {
   std::string language = translate::kUnknownLanguageCode;
   int num_bytes_evaluated = 0;
   bool is_reliable = false;
   const bool is_plain_text = true;
 
   // Language or CLD2::Language
   int cld_language = 0;
   bool is_valid_language = false;
 
-#if CLD_VERSION==1
-  int num_languages = 0;
-  cld_language = DetectLanguageOfUnicodeText(NULL, text.c_str(), is_plain_text,
-                                             &is_reliable, &num_languages, NULL,
-                                             &num_bytes_evaluated);
-  is_valid_language = cld_language != NUM_LANGUAGES &&
-                      cld_language != UNKNOWN_LANGUAGE &&
-                      cld_language != TG_UNKNOWN_LANGUAGE;
-#elif CLD_VERSION==2
   const std::string utf8_text(base::UTF16ToUTF8(text));
   const int num_utf8_bytes = static_cast<int>(utf8_text.size());
   const char* raw_utf8_bytes = utf8_text.c_str();
 
   CLD2::Language language3[3];
   int percent3[3];
   int flags = 0;   // No flags, see compact_lang_det.h for details.
   int text_bytes;  // Amount of non-tag/letters-only text (assumed 0).
   double normalized_score3[3];
 
@@ skipping 23 matching lines @@
                       cld_language != CLD2::UNKNOWN_LANGUAGE &&
                       cld_language != CLD2::TG_UNKNOWN_LANGUAGE;
 
   // Choose top language.
   cld_language = language3[0];
   UMA_HISTOGRAM_ENUMERATION("Translate.CLD2.LanguageDetected",
                             cld_language, CLD2::NUM_LANGUAGES);
   if (is_valid_language)
     UMA_HISTOGRAM_PERCENTAGE("Translate.CLD2.LanguageAccuracy", percent3[0]);
 
-
-#else
-# error "CLD_VERSION must be 1 or 2"
-#endif
-
   if (is_cld_reliable != NULL)
     *is_cld_reliable = is_reliable;
 
   // We don't trust the result if the CLD reports that the detection is not
   // reliable, or if the actual text used to detect the language was less than
   // 100 bytes (short texts can often lead to wrong results).
   // TODO(toyoshim): CLD provides |is_reliable| flag. But, it just says that
   // the determined language code is correct with 50% confidence. Chrome should
   // handle the real confidence value to judge.
   if (is_reliable && num_bytes_evaluated >= 100 && is_valid_language) {
     // We should not use LanguageCode_ISO_639_1 because it does not cover all
     // the languages CLD can detect. As a result, it'll return the invalid
     // language code for traditional 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.
-#if CLD_VERSION==1
-    language = LanguageCodeWithDialects(static_cast<Language>(cld_language));
-#elif CLD_VERSION==2
+    //
     // (1) CLD2's LanguageCode returns general Chinese 'zh' for
     // CLD2::CHINESE, but Translate server doesn't accept it. This is
     // converted to 'zh-CN' in the same way as CLD1's
     // LanguageCodeWithDialects.
     //
     // (2) CLD2's LanguageCode returns zh-Hant instead of zh-TW for
     // CLD2::CHINESE_T. This is technically more precise for the language
     // code of traditional Chinese, while Translate server hasn't accepted
     // zh-Hant yet.
     if (cld_language == CLD2::CHINESE)
       language = "zh-CN";
     else if (cld_language == CLD2::CHINESE_T)
       language = "zh-TW";
     else
       language = CLD2::LanguageCode(static_cast<CLD2::Language>(cld_language));
-#else
-# error "CLD_VERSION must be 1 or 2"
-#endif
   }
   VLOG(9) << "Detected lang_id: " << language << ", from Text:\n" << text
           << "\n*************************************\n";
   return language;
 }
 
 // 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) {
@@ skipping 195 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;
 }
 
 }  // namespace translate