Move language detection to a component

components/translate/language_detection/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 "components/translate/language_detection/language_detection_util.h"
 
 #include "base/logging.h"
 #include "base/metrics/field_trial.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 "chrome/common/chrome_constants.h"
-#include "chrome/common/translate/translate_common_metrics.h"
-#include "chrome/common/translate/translate_util.h"
+#include "components/translate/common/translate_constants.h"
+#include "components/translate/common/translate_metrics.h"
+#include "components/translate/common/translate_util.h"
 
 #if !defined(CLD_VERSION) || 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 !defined(CLD_VERSION) || CLD_VERSION==2
 #include "third_party/cld_2/src/public/compact_lang_det.h"
 #endif
 
@@ skipping 19 matching lines @@
     if (language.find(kSimilarLanguageCodes[i].code) != 0)
       continue;
     return kSimilarLanguageCodes[i].group;
   }
   return 0;
 }
 
 // Well-known languages which often have wrong server configuration of
 // Content-Language: en.
 // TODO(toyoshim): Remove these static tables and caller functions to
-// chrome/common/translate, and implement them as std::set<>.
+// translate/common, and implement them as std::set<>.
 const char* kWellKnownCodesOnWrongConfiguration[] = {
   "es", "pt", "ja", "ru", "de", "zh-CN", "zh-TW", "ar", "id", "fr", "it", "th"
 };
 
 // Applies a series of language code modification in proper order.
 void ApplyLanguageCodeCorrection(std::string* code) {
   // Correct well-known format errors.
-  LanguageDetectionUtil::CorrectLanguageCodeTypo(code);
+  translate::CorrectLanguageCodeTypo(code);
 
-  if (!LanguageDetectionUtil::IsValidLanguageCode(*code)) {
+  if (!translate::IsValidLanguageCode(*code)) {
     *code = std::string();
     return;
   }
 
-  TranslateUtil::ToTranslateLanguageSynonym(code);
+  translate::ToTranslateLanguageSynonym(code);
 }
 
 int GetCLDMajorVersion() {
 #if !defined(CLD_VERSION)
   std::string group_name = base::FieldTrialList::FindFullName("CLD1VsCLD2");
   if (group_name == "CLD2")
     return 2;
   else
     return 1;
 #else
   return CLD_VERSION;
 #endif
 }
 
 // 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;
+  std::string language = translate::kUnknownLanguageCode;
   int text_bytes = 0;
   bool is_reliable = false;
 
   // Language or CLD2::Language
   int cld_language = 0;
   bool is_valid_language = false;
 
   switch (GetCLDMajorVersion()) {
 #if !defined(CLD_VERSION) || CLD_VERSION==1
     case 1: {
       int num_languages = 0;
       cld_language =
           DetectLanguageOfUnicodeText(NULL, text.c_str(), true, &is_reliable,
                                       &num_languages, NULL, &text_bytes);
       is_valid_language = cld_language != NUM_LANGUAGES &&
           cld_language != UNKNOWN_LANGUAGE &&
           cld_language != TG_UNKNOWN_LANGUAGE;
       break;
     }
 #endif
 #if !defined(CLD_VERSION) || CLD_VERSION==2
     case 2: {
       std::string utf8_text(UTF16ToUTF8(text));
       CLD2::Language language3[3];
       int percent3[3];
-      cld_language =
-          CLD2::DetectLanguageSummary(utf8_text.c_str(), utf8_text.size(), true,
-                                      language3, percent3,
-                                      &text_bytes, &is_reliable);
+      cld_language = CLD2::DetectLanguageSummary(
+          utf8_text.c_str(), (int)utf8_text.size(), true, language3, percent3,
+          &text_bytes, &is_reliable);
       is_valid_language = cld_language != CLD2::NUM_LANGUAGES &&
           cld_language != CLD2::UNKNOWN_LANGUAGE &&
           cld_language != CLD2::TG_UNKNOWN_LANGUAGE;
       break;
     }
 #endif
     default:
       NOTREACHED();
   }
 
@@ skipping 56 matching lines @@
     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 {
+namespace translate {
 
 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) {
   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());
+  translate::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);
+  translate::ToTranslateLanguageSynonym(&cld_language);
 
   // 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);
+    translate::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);
+    translate::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 |language| is empty, just use CLD result even though it might be
-  // chrome::kUnknownLanguageCode.
+  // translate::kUnknownLanguageCode.
   if (language.empty()) {
-    TranslateCommonMetrics::ReportLanguageVerification(
-        TranslateCommonMetrics::LANGUAGE_VERIFICATION_CLD_ONLY);
+    translate::ReportLanguageVerification(
+        translate::LANGUAGE_VERIFICATION_CLD_ONLY);
     return cld_language;
   }
 
-  if (cld_language == chrome::kUnknownLanguageCode) {
-    TranslateCommonMetrics::ReportLanguageVerification(
-        TranslateCommonMetrics::LANGUAGE_VERIFICATION_UNKNOWN);
+  if (cld_language == kUnknownLanguageCode) {
+    translate::ReportLanguageVerification(
+        translate::LANGUAGE_VERIFICATION_UNKNOWN);
     return language;
   } else if (CanCLDComplementSubCode(language, cld_language)) {
-    TranslateCommonMetrics::ReportLanguageVerification(
-        TranslateCommonMetrics::LANGUAGE_VERIFICATION_CLD_COMPLEMENT_SUB_CODE);
+    translate::ReportLanguageVerification(
+        translate::LANGUAGE_VERIFICATION_CLD_COMPLEMENT_SUB_CODE);
     return cld_language;
   } else if (IsSameOrSimilarLanguages(language, cld_language)) {
-    TranslateCommonMetrics::ReportLanguageVerification(
-        TranslateCommonMetrics::LANGUAGE_VERIFICATION_CLD_AGREE);
+    translate::ReportLanguageVerification(
+        translate::LANGUAGE_VERIFICATION_CLD_AGREE);
     return language;
   } else if (MaybeServerWrongConfiguration(language, cld_language)) {
-    TranslateCommonMetrics::ReportLanguageVerification(
-        TranslateCommonMetrics::LANGUAGE_VERIFICATION_TRUST_CLD);
+    translate::ReportLanguageVerification(
+        translate::LANGUAGE_VERIFICATION_TRUST_CLD);
     return cld_language;
   } else {
-    TranslateCommonMetrics::ReportLanguageVerification(
-        TranslateCommonMetrics::LANGUAGE_VERIFICATION_CLD_DISAGREE);
+    translate::ReportLanguageVerification(
+        translate::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);
+    return std::string(kUnknownLanguageCode);
   }
 
   return language;
 }
 
 void CorrectLanguageCodeTypo(std::string* code) {
   DCHECK(code);
 
   size_t coma_index = code->find(',');
   if (coma_index != std::string::npos) {
@@ skipping 66 matching lines @@
   base::SplitString(cld_language, '-', &chunks);
   if (chunks.size() == 0)
     return false;
   std::string cld_language_main_part = chunks[0];
 
   // Language code part of |page_language| is matched to one of |cld_language|.
   // Country code is ignored here.
   if (page_language_main_part == cld_language_main_part) {
     // Languages are matched strictly. Reports false to metrics, but returns
     // true.
-    TranslateCommonMetrics::ReportSimilarLanguageMatch(false);
+    translate::ReportSimilarLanguageMatch(false);
     return true;
   }
 
   // Check if |page_language| and |cld_language| are in the similar language
   // list and belong to the same language group.
   int page_code = GetSimilarLanguageGroupCode(page_language);
   bool match = page_code != 0 &&
                page_code == GetSimilarLanguageGroupCode(cld_language);
 
-  TranslateCommonMetrics::ReportSimilarLanguageMatch(match);
+  translate::ReportSimilarLanguageMatch(match);
   return match;
 }
 
 bool MaybeServerWrongConfiguration(const std::string& page_language,
                                    const std::string& cld_language) {
   // If |page_language| is not "en-*", respect it and just return false here.
   if (!StartsWithASCII(page_language, "en", false))
     return false;
 
   // A server provides a language meta information representing "en-*". But it
@@ skipping 17 matching lines @@
 #if !defined(CLD_VERSION) || CLD_VERSION==2
     case 2:
       return CLD2::DetectLanguageVersion();
 #endif
     default:
       NOTREACHED();
   }
   return "";
 }
 
-}  // namespace LanguageDetectionUtil
+}  // namespace translate