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 75 matching lines @@
 void TranslateHelper::PageCaptured(const string16& contents) {
   // Get the document language as set by WebKit from the http-equiv
   // 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();
+  WebFrame* main_frame = GetMainFrame();
+  if (!main_frame)
+    return;
+  WebDocument document = main_frame->document();
   std::string content_language = document.contentLanguage().utf8();
+  WebElement html_element = document.documentElement();
+  std::string html_lang;
+  // |html_element| can be null element, e.g. in
+  // BrowserTest.WindowOpenClose.
+  if (!html_element.isNull())
+    html_lang = html_element.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);
 #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);
+  // Check if Content-Language is valid.
+  std::string modified_code;
+  if (!code.empty()) {
+    modified_code = code;
+    ApplyLanguageCodeCorrection(&modified_code);
+    TranslateHelperMetrics::ReportContentLanguage(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 65 matching lines @@
     IPC_MESSAGE_HANDLER(ChromeViewMsg_RevertTranslation, OnRevertTranslation)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void TranslateHelper::OnTranslatePage(int page_id,
                                       const std::string& translate_script,
                                       const std::string& source_lang,
                                       const std::string& target_lang) {
-  if (render_view()->GetPageId() != page_id)
+  WebFrame* main_frame = GetMainFrame();
+  if (!main_frame || render_view()->GetPageId() != page_id)
     return;  // We navigated away, nothing to do.
 
   if (translation_pending_ && page_id == page_id_ &&
       target_lang_ == target_lang) {
     // A similar translation is already under way, nothing to do.
     return;
   }
 
   // Any pending translation is now irrelevant.
   CancelPendingTranslation();
 
   // Set our states.
   translation_pending_ = true;
   page_id_ = page_id;
   // If the source language is undetermined, we'll let the translate element
   // detect it.
   source_lang_ = (source_lang != chrome::kUnknownLanguageCode) ?
                   source_lang : kAutoDetectionLanguage;
   target_lang_ = target_lang;
 
   TranslateHelperMetrics::ReportUserActionDuration(language_determined_time_,
                                                    base::TimeTicks::Now());
 
-  GURL url(GetMainFrame()->document().url());
+  GURL url(main_frame->document().url());
   TranslateHelperMetrics::ReportPageScheme(url.scheme());
 
   if (!IsTranslateLibAvailable()) {
     // Evaluate the script to add the translation related method to the global
     // context of the page.
     ExecuteScript(translate_script);
     DCHECK(IsTranslateLibAvailable());
   }
 
   TranslatePageImpl(0);
@@ skipping 112 matching lines @@
     TranslateErrors::Type error) {
   translation_pending_ = false;
   // Notify the browser there was an error.
   render_view()->Send(new ChromeViewHostMsg_PageTranslated(
       render_view()->GetRoutingID(), page_id_, source_lang_,
       target_lang_, error));
 }
 
 WebFrame* TranslateHelper::GetMainFrame() {
   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();
+
+  // When the tab is going to be closed, the web_view can be NULL.
+  if (!web_view)
     return NULL;
-  }
+
   return web_view->mainFrame();
 }