Translate: adopt html lang attribute if valid value is provided

chrome/renderer/translate/translate_helper.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/translate/translate_helper.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 77 matching lines @@
   // meta tag for "content-language".  This may or may not also
   // have a value derived from the actual Content-Language HTTP
   // header.  The two actually have different meanings (despite the
   // original intent of http-equiv to be an equivalent) with the former
   // being the language of the document and the latter being the
   // language of the intended audience (a distinction really only
   // relevant for things like langauge textbooks).  This distinction
   // shouldn't affect translation.
   WebDocument document = GetMainFrame()->document();
   std::string content_language = document.contentLanguage().utf8();
+  std::string html_lang =
+      document.documentElement().getAttribute("lang").utf8();
   std::string cld_language;
   bool is_cld_reliable;
   std::string language = DeterminePageLanguage(
-      content_language, contents, &cld_language, &is_cld_reliable);
+      content_language, html_lang, contents, &cld_language, &is_cld_reliable);
 
   if (language.empty())
     return;
 
   language_determined_time_ = base::TimeTicks::Now();
 
+  // TODO(toyoshim): Add |html_lang| to LanguageDetectionDetails.
   GURL url(document.url());
   LanguageDetectionDetails details;
   details.time = base::Time::Now();
   details.url = url;
   details.content_language = content_language;
   details.cld_language = cld_language;
   details.is_cld_reliable = is_cld_reliable;
   details.adopted_language = language;
 
   Send(new ChromeViewHostMsg_TranslateLanguageDetermined(
@@ skipping 194 matching lines @@
   // Roughly check if the language code follows [a-z][a-z](-[A-Z][A-Z]).
   size_t dash_index = code->find('-');
   if (!(dash_index == 2 && code->size() == 5) &&
       !(dash_index == std::string::npos && code->size() == 2)) {
     // Reset |language| to ignore the invalid code.
     *code = std::string();
   }
 }
 
 // static
+void TranslateHelper::ApplyLanguageCodeCorrection(std::string* code) {
+  // Correct well-known format errors.
+  CorrectLanguageCodeTypo(code);
+
+  // Convert language code synonym firstly because sometime synonym code is in
+  // invalid format, e.g. 'fil'. After validation, such a 3 characters language
+  // gets converted to an empty string.
+  ConvertLanguageCodeSynonym(code);
+  ResetInvalidLanguageCode(code);
+}
+
+// static
 std::string TranslateHelper::DeterminePageLanguage(const std::string& code,
+                                                   const std::string& html_lang,
                                                    const 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);
   TranslateHelperMetrics::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;
   ConvertLanguageCodeSynonym(&cld_language);
   VLOG(9) << "CLD determined language code: " << cld_language;
 #endif  // defined(ENABLE_LANGUAGE_DETECTION)
 
-  // Correct well-known format errors.
-  std::string language = code;
-  CorrectLanguageCodeTypo(&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);
+    TranslateHelperMetrics::ReportHtmlLang(html_lang, modified_html_lang);
+    VLOG(9) << "html lang based language code: " << modified_html_lang;
+  }
 
-  // Convert language code synonym firstly because sometime synonym code is in
-  // invalid format, e.g. 'fil'. After validation, such a 3 characters language
-  // gets converted to an empty string.
-  ConvertLanguageCodeSynonym(&language);
-  ResetInvalidLanguageCode(&language);
-  VLOG(9) << "Content-Language based language code: " << language;
+  // Check if Content-Language is valid.
+  std::string modified_code;
+  if (!code.empty()) {
+    modified_code = code;
+    ApplyLanguageCodeCorrection(&modified_code);
+    TranslateHelperMetrics::ReportContentLanguage(code, modified_code);
+    VLOG(9) << "Content-Language based language code: " << modified_code;
+  }
 
-  TranslateHelperMetrics::ReportContentLanguage(code, language);
+  // 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()) {
     TranslateHelperMetrics::ReportLanguageVerification(
         TranslateHelperMetrics::LANGUAGE_VERIFICATION_CLD_ONLY);
     return cld_language;
   }
 
@@ skipping 229 matching lines @@
   WebView* web_view = render_view()->GetWebView();
   if (!web_view) {
     // When the WebView is going away, the render view should have called
     // CancelPendingTranslation() which should have stopped any pending work, so
     // that case should not happen.
     NOTREACHED();
     return NULL;
   }
   return web_view->mainFrame();
 }