Added the 'Translation Logs' tab to chrome://translate-internals/

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 74 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 language = DeterminePageLanguage(content_language, contents);
+  std::string cld_language;
+  bool is_cld_reliable;
+  std::string language = DeterminePageLanguage(
+      content_language, contents, &cld_language, &is_cld_reliable);
+
   if (language.empty())
     return;
 
+  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(
-      routing_id(), language, IsPageTranslatable(&document)));
+      routing_id(), details, IsPageTranslatable(&document)));
 }
 
 void TranslateHelper::CancelPendingTranslation() {
   weak_method_factory_.InvalidateWeakPtrs();
   translation_pending_ = false;
   page_id_ = -1;
   source_lang_.clear();
   target_lang_.clear();
 }
 
 #if defined(ENABLE_LANGUAGE_DETECTION)
 // static
-std::string TranslateHelper::DetermineTextLanguage(const string16& text) {
+std::string TranslateHelper::DetermineTextLanguage(const 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 =
       DetectLanguageOfUnicodeText(NULL, text.c_str(), true, &is_reliable,
                                   &num_languages, NULL, &text_bytes);
+  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 && text_bytes >= 100 && cld_language != NUM_LANGUAGES &&
       cld_language != UNKNOWN_LANGUAGE && cld_language != TG_UNKNOWN_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
@@ skipping 158 matching lines @@
   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
 std::string TranslateHelper::DeterminePageLanguage(const std::string& code,
-                                                   const string16& contents) {
+                                                   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();
-  std::string cld_language = DetermineTextLanguage(contents);
+  bool is_cld_reliable;
+  std::string cld_language = DetermineTextLanguage(contents, &is_cld_reliable);
+
+  if (cld_language_p != NULL)
+    *cld_language_p = cld_language;
+  if (is_cld_reliable_p != NULL)
+    *is_cld_reliable_p = is_cld_reliable;
+
   UMA_HISTOGRAM_MEDIUM_TIMES("Renderer4.LanguageDetection",
                              base::TimeTicks::Now() - begin_time);
   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);
 
@@ skipping 219 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();
 }