src/chrome/browser/ui/webui/translate_internals/translate_internals_handler.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/webui/translate_internals/translate_internals_handler.h"
   6
   7 #include <map>
   8 #include <vector>
   9
  10 #include "base/bind.h"
  11 #include "base/bind_helpers.h"
  12 #include "base/prefs/pref_service.h"
  13 #include "base/values.h"
  14 #include "chrome/browser/chrome_notification_types.h"
  15 #include "chrome/browser/profiles/profile.h"
  16 #include "chrome/browser/translate/translate_tab_helper.h"
  17 #include "chrome/common/pref_names.h"
  18 #include "components/translate/core/browser/translate_download_manager.h"
  19 #include "components/translate/core/browser/translate_error_details.h"
  20 #include "components/translate/core/browser/translate_event_details.h"
  21 #include "components/translate/core/browser/translate_prefs.h"
  22 #include "components/translate/core/common/language_detection_details.h"
  23 #include "components/translate/core/common/translate_pref_names.h"
  24 #include "content/public/browser/notification_details.h"
  25 #include "content/public/browser/notification_service.h"
  26 #include "content/public/browser/notification_source.h"
  27 #include "content/public/browser/notification_types.h"
  28 #include "content/public/browser/web_contents.h"
  29 #include "content/public/browser/web_ui.h"
  30
  31 TranslateInternalsHandler::TranslateInternalsHandler() {
  32   notification_registrar_.Add(this,
  33                               chrome::NOTIFICATION_TAB_LANGUAGE_DETERMINED,
  34                               content::NotificationService::AllSources());
  35
  36   error_subscription_ = TranslateManager::RegisterTranslateErrorCallback(
  37       base::Bind(&TranslateInternalsHandler::OnTranslateError,
  38                  base::Unretained(this)));
  39
  40   TranslateLanguageList* language_list =
  41       TranslateDownloadManager::GetInstance()->language_list();
  42   if (!language_list) {
  43     NOTREACHED();
  44     return;
  45   }
  46
  47   event_subscription_ = language_list->RegisterEventCallback(base::Bind(
  48       &TranslateInternalsHandler::OnTranslateEvent, base::Unretained(this)));
  49 }
  50
  51 TranslateInternalsHandler::~TranslateInternalsHandler() {
  52   // |event_subscription_| and |error_subscription_| are deleted automatically
  53   // and un-register the callbacks automatically.
  54 }
  55
  56 void TranslateInternalsHandler::RegisterMessages() {
  57   web_ui()->RegisterMessageCallback("removePrefItem", base::Bind(
  58       &TranslateInternalsHandler::OnRemovePrefItem, base::Unretained(this)));
  59   web_ui()->RegisterMessageCallback("requestInfo", base::Bind(
  60       &TranslateInternalsHandler::OnRequestInfo, base::Unretained(this)));
  61 }
  62
  63 void TranslateInternalsHandler::Observe(
  64     int type,
  65     const content::NotificationSource& source,
  66     const content::NotificationDetails& details) {
  67   DCHECK_EQ(chrome::NOTIFICATION_TAB_LANGUAGE_DETERMINED, type);
  68   const LanguageDetectionDetails* language_detection_details =
  69       content::Details<const LanguageDetectionDetails>(details).ptr();
  70   content::WebContents* web_contents =
  71       content::Source<content::WebContents>(source).ptr();
  72
  73   if (web_contents->GetBrowserContext()->IsOffTheRecord() ||
  74       !TranslateManager::IsTranslatableURL(language_detection_details->url)) {
  75     return;
  76   }
  77
  78   base::DictionaryValue dict;
  79   dict.Set(
  80       "time",
  81       new base::FundamentalValue(language_detection_details->time.ToJsTime()));
  82   dict.Set("url",
  83            new base::StringValue(language_detection_details->url.spec()));
  84   dict.Set("content_language",
  85            new base::StringValue(language_detection_details->content_language));
  86   dict.Set("cld_language",
  87            new base::StringValue(language_detection_details->cld_language));
  88   dict.Set(
  89       "is_cld_reliable",
  90       new base::FundamentalValue(language_detection_details->is_cld_reliable));
  91   dict.Set(
  92       "html_root_language",
  93       new base::StringValue(language_detection_details->html_root_language));
  94   dict.Set("adopted_language",
  95            new base::StringValue(language_detection_details->adopted_language));
  96   dict.Set("content",
  97            new base::StringValue(language_detection_details->contents));
  98   SendMessageToJs("languageDetectionInfoAdded", dict);
  99 }
 100
 101 void TranslateInternalsHandler::OnTranslateError(
 102     const TranslateErrorDetails& details) {
 103   base::DictionaryValue dict;
 104   dict.Set("time",
 105            new base::FundamentalValue(details.time.ToJsTime()));
 106   dict.Set("url",
 107            new base::StringValue(details.url.spec()));
 108   dict.Set("error",
 109            new base::FundamentalValue(details.error));
 110   SendMessageToJs("translateErrorDetailsAdded", dict);
 111 }
 112
 113 void TranslateInternalsHandler::OnTranslateEvent(
 114     const TranslateEventDetails& details) {
 115   base::DictionaryValue dict;
 116   dict.Set("time", new base::FundamentalValue(details.time.ToJsTime()));
 117   dict.Set("filename", new base::StringValue(details.filename));
 118   dict.Set("line", new base::FundamentalValue(details.line));
 119   dict.Set("message", new base::StringValue(details.message));
 120   SendMessageToJs("translateEventDetailsAdded", dict);
 121 }
 122
 123 void TranslateInternalsHandler::OnRemovePrefItem(const base::ListValue* args) {
 124   content::WebContents* web_contents = web_ui()->GetWebContents();
 125   Profile* profile =
 126       Profile::FromBrowserContext(web_contents->GetBrowserContext());
 127   PrefService* prefs = profile->GetOriginalProfile()->GetPrefs();
 128   scoped_ptr<TranslatePrefs> translate_prefs(
 129       TranslateTabHelper::CreateTranslatePrefs(prefs));
 130
 131   std::string pref_name;
 132   if (!args->GetString(0, &pref_name))
 133     return;
 134
 135   if (pref_name == "blocked_languages") {
 136     std::string language;
 137     if (!args->GetString(1, &language))
 138       return;
 139     translate_prefs->UnblockLanguage(language);
 140   } else if (pref_name == "language_blacklist") {
 141     std::string language;
 142     if (!args->GetString(1, &language))
 143       return;
 144     translate_prefs->RemoveLanguageFromLegacyBlacklist(language);
 145   } else if (pref_name == "site_blacklist") {
 146     std::string site;
 147     if (!args->GetString(1, &site))
 148       return;
 149     translate_prefs->RemoveSiteFromBlacklist(site);
 150   } else if (pref_name == "whitelists") {
 151     std::string from, to;
 152     if (!args->GetString(1, &from))
 153       return;
 154     if (!args->GetString(2, &to))
 155       return;
 156     translate_prefs->RemoveLanguagePairFromWhitelist(from, to);
 157   } else {
 158     return;
 159   }
 160
 161   SendPrefsToJs();
 162 }
 163
 164 void TranslateInternalsHandler::OnRequestInfo(const base::ListValue* /*args*/) {
 165   SendPrefsToJs();
 166   SendSupportedLanguagesToJs();
 167 }
 168
 169 void TranslateInternalsHandler::SendMessageToJs(const std::string& message,
 170                                                 const base::Value& value) {
 171   const char func[] = "cr.translateInternals.messageHandler";
 172   base::StringValue message_data(message);
 173   web_ui()->CallJavascriptFunction(func, message_data, value);
 174 }
 175
 176 void TranslateInternalsHandler::SendPrefsToJs() {
 177   content::WebContents* web_contents = web_ui()->GetWebContents();
 178   Profile* profile =
 179       Profile::FromBrowserContext(web_contents->GetBrowserContext());
 180   PrefService* prefs = profile->GetOriginalProfile()->GetPrefs();
 181
 182   base::DictionaryValue dict;
 183
 184   std::vector<std::string> keys;
 185   keys.push_back(prefs::kEnableTranslate);
 186
 187   keys.push_back(TranslatePrefs::kPrefTranslateBlockedLanguages);
 188   keys.push_back(TranslatePrefs::kPrefTranslateLanguageBlacklist);
 189   keys.push_back(TranslatePrefs::kPrefTranslateSiteBlacklist);
 190   keys.push_back(TranslatePrefs::kPrefTranslateWhitelists);
 191   keys.push_back(TranslatePrefs::kPrefTranslateDeniedCount);
 192   keys.push_back(TranslatePrefs::kPrefTranslateAcceptedCount);
 193
 194   for (std::vector<std::string>::const_iterator it = keys.begin();
 195        it != keys.end(); ++it) {
 196     const std::string& key = *it;
 197     const PrefService::Preference* pref = prefs->FindPreference(key.c_str());
 198     if (pref)
 199       dict.Set(key, pref->GetValue()->DeepCopy());
 200   }
 201
 202   SendMessageToJs("prefsUpdated", dict);
 203 }
 204
 205 void TranslateInternalsHandler::SendSupportedLanguagesToJs() {
 206   base::DictionaryValue dict;
 207
 208   std::vector<std::string> languages;
 209   TranslateDownloadManager::GetSupportedLanguages(&languages);
 210   base::Time last_updated =
 211       TranslateDownloadManager::GetSupportedLanguagesLastUpdated();
 212
 213   base::ListValue* languages_list = new base::ListValue();
 214   base::ListValue* alpha_languages_list = new base::ListValue();
 215   for (std::vector<std::string>::iterator it = languages.begin();
 216        it != languages.end(); ++it) {
 217     const std::string& lang = *it;
 218     languages_list->Append(new base::StringValue(lang));
 219     if (TranslateDownloadManager::IsAlphaLanguage(lang))
 220       alpha_languages_list->Append(new base::StringValue(lang));
 221   }
 222
 223   dict.Set("languages", languages_list);
 224   dict.Set("alpha_languages", alpha_languages_list);
 225   dict.Set("last_updated",
 226            new base::FundamentalValue(last_updated.ToJsTime()));
 227   SendMessageToJs("supportedLanguagesUpdated", dict);
 228 }