| // Copyright 2014 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/browser/translate/chrome_translate_client.h" |
| |
| #include <vector> |
| |
| #include "base/logging.h" |
| #include "base/prefs/pref_service.h" |
| #include "base/strings/string_split.h" |
| #include "chrome/browser/chrome_notification_types.h" |
| #include "chrome/browser/infobars/infobar_service.h" |
| #include "chrome/browser/profiles/profile.h" |
| #include "chrome/browser/translate/translate_accept_languages_factory.h" |
| #include "chrome/browser/translate/translate_service.h" |
| #include "chrome/browser/ui/browser.h" |
| #include "chrome/browser/ui/browser_finder.h" |
| #include "chrome/browser/ui/browser_tabstrip.h" |
| #include "chrome/browser/ui/browser_window.h" |
| #include "chrome/browser/ui/tabs/tab_strip_model.h" |
| #include "chrome/browser/ui/translate/translate_bubble_factory.h" |
| #include "chrome/common/pref_names.h" |
| #include "components/infobars/core/infobar.h" |
| #include "components/translate/content/common/translate_messages.h" |
| #include "components/translate/core/browser/language_state.h" |
| #include "components/translate/core/browser/page_translated_details.h" |
| #include "components/translate/core/browser/translate_accept_languages.h" |
| #include "components/translate/core/browser/translate_download_manager.h" |
| #include "components/translate/core/browser/translate_infobar_delegate.h" |
| #include "components/translate/core/browser/translate_manager.h" |
| #include "components/translate/core/browser/translate_prefs.h" |
| #include "components/translate/core/common/language_detection_details.h" |
| #include "content/public/browser/navigation_details.h" |
| #include "content/public/browser/navigation_entry.h" |
| #include "content/public/browser/notification_service.h" |
| #include "content/public/browser/render_view_host.h" |
| #include "content/public/browser/web_contents.h" |
| #include "grit/theme_resources.h" |
| #include "net/http/http_status_code.h" |
| #include "url/gurl.h" |
| |
| #if defined(CLD2_DYNAMIC_MODE) |
| #include "base/files/file.h" |
| #include "base/path_service.h" |
| #include "chrome/common/chrome_constants.h" |
| #include "chrome/common/chrome_paths.h" |
| #include "content/public/browser/browser_thread.h" |
| #include "content/public/browser/render_process_host.h" |
| #endif |
| |
| #if defined(CLD2_IS_COMPONENT) |
| #include "chrome/browser/component_updater/cld_component_installer.h" |
| #endif |
| |
| namespace { |
| |
| // The maximum number of attempts we'll do to see if the page has finshed |
| // loading before giving up the translation |
| const int kMaxTranslateLoadCheckAttempts = 20; |
| |
| } // namespace |
| |
| DEFINE_WEB_CONTENTS_USER_DATA_KEY(ChromeTranslateClient); |
| |
| #if defined(CLD2_DYNAMIC_MODE) |
| // Statics defined in the .h file: |
| base::File* ChromeTranslateClient::s_cached_file_ = NULL; |
| uint64 ChromeTranslateClient::s_cached_data_offset_ = 0; |
| uint64 ChromeTranslateClient::s_cached_data_length_ = 0; |
| base::LazyInstance<base::Lock> ChromeTranslateClient::s_file_lock_ = |
| LAZY_INSTANCE_INITIALIZER; |
| #endif |
| |
| ChromeTranslateClient::ChromeTranslateClient(content::WebContents* web_contents) |
| : content::WebContentsObserver(web_contents), |
| max_reload_check_attempts_(kMaxTranslateLoadCheckAttempts), |
| translate_driver_(&web_contents->GetController()), |
| translate_manager_(new TranslateManager(this, prefs::kAcceptLanguages)), |
| weak_pointer_factory_(this) { |
| } |
| |
| ChromeTranslateClient::~ChromeTranslateClient() { |
| } |
| |
| LanguageState& ChromeTranslateClient::GetLanguageState() { |
| return translate_manager_->GetLanguageState(); |
| } |
| |
| // static |
| scoped_ptr<TranslatePrefs> ChromeTranslateClient::CreateTranslatePrefs( |
| PrefService* prefs) { |
| #if defined(OS_CHROMEOS) |
| const char* preferred_languages_prefs = prefs::kLanguagePreferredLanguages; |
| #else |
| const char* preferred_languages_prefs = NULL; |
| #endif |
| return scoped_ptr<TranslatePrefs>(new TranslatePrefs( |
| prefs, prefs::kAcceptLanguages, preferred_languages_prefs)); |
| } |
| |
| // static |
| TranslateAcceptLanguages* ChromeTranslateClient::GetTranslateAcceptLanguages( |
| content::BrowserContext* browser_context) { |
| return TranslateAcceptLanguagesFactory::GetForBrowserContext(browser_context); |
| } |
| |
| // static |
| TranslateManager* ChromeTranslateClient::GetManagerFromWebContents( |
| content::WebContents* web_contents) { |
| ChromeTranslateClient* chrome_translate_client = |
| FromWebContents(web_contents); |
| if (!chrome_translate_client) |
| return NULL; |
| return chrome_translate_client->GetTranslateManager(); |
| } |
| |
| // static |
| void ChromeTranslateClient::GetTranslateLanguages( |
| content::WebContents* web_contents, |
| std::string* source, |
| std::string* target) { |
| DCHECK(source != NULL); |
| DCHECK(target != NULL); |
| |
| ChromeTranslateClient* chrome_translate_client = |
| FromWebContents(web_contents); |
| if (!chrome_translate_client) |
| return; |
| |
| *source = TranslateDownloadManager::GetLanguageCode( |
| chrome_translate_client->GetLanguageState().original_language()); |
| |
| Profile* profile = |
| Profile::FromBrowserContext(web_contents->GetBrowserContext()); |
| Profile* original_profile = profile->GetOriginalProfile(); |
| PrefService* prefs = original_profile->GetPrefs(); |
| scoped_ptr<TranslatePrefs> translate_prefs = CreateTranslatePrefs(prefs); |
| if (!web_contents->GetBrowserContext()->IsOffTheRecord()) { |
| std::string auto_translate_language = |
| TranslateManager::GetAutoTargetLanguage(*source, translate_prefs.get()); |
| if (!auto_translate_language.empty()) { |
| *target = auto_translate_language; |
| return; |
| } |
| } |
| |
| std::string accept_languages_str = prefs->GetString(prefs::kAcceptLanguages); |
| std::vector<std::string> accept_languages_list; |
| base::SplitString(accept_languages_str, ',', &accept_languages_list); |
| *target = TranslateManager::GetTargetLanguage(accept_languages_list); |
| } |
| |
| TranslateManager* ChromeTranslateClient::GetTranslateManager() { |
| return translate_manager_.get(); |
| } |
| |
| content::WebContents* ChromeTranslateClient::GetWebContents() { |
| return web_contents(); |
| } |
| |
| void ChromeTranslateClient::ShowTranslateUI(translate::TranslateStep step, |
| const std::string source_language, |
| const std::string target_language, |
| TranslateErrors::Type error_type, |
| bool triggered_from_menu) { |
| DCHECK(web_contents()); |
| if (error_type != TranslateErrors::NONE) |
| step = translate::TRANSLATE_STEP_TRANSLATE_ERROR; |
| |
| if (TranslateService::IsTranslateBubbleEnabled()) { |
| // Bubble UI. |
| if (step == translate::TRANSLATE_STEP_BEFORE_TRANSLATE) { |
| // TODO(droger): Move this logic out of UI code. |
| GetLanguageState().SetTranslateEnabled(true); |
| if (!GetLanguageState().HasLanguageChanged()) |
| return; |
| } |
| ShowBubble(step, error_type); |
| return; |
| } |
| |
| // Infobar UI. |
| TranslateInfoBarDelegate::Create( |
| step != translate::TRANSLATE_STEP_BEFORE_TRANSLATE, |
| translate_manager_->GetWeakPtr(), |
| InfoBarService::FromWebContents(web_contents()), |
| web_contents()->GetBrowserContext()->IsOffTheRecord(), |
| step, |
| source_language, |
| target_language, |
| error_type, |
| triggered_from_menu); |
| } |
| |
| TranslateDriver* ChromeTranslateClient::GetTranslateDriver() { |
| return &translate_driver_; |
| } |
| |
| PrefService* ChromeTranslateClient::GetPrefs() { |
| DCHECK(web_contents()); |
| Profile* profile = |
| Profile::FromBrowserContext(web_contents()->GetBrowserContext()); |
| return profile->GetOriginalProfile()->GetPrefs(); |
| } |
| |
| scoped_ptr<TranslatePrefs> ChromeTranslateClient::GetTranslatePrefs() { |
| DCHECK(web_contents()); |
| Profile* profile = |
| Profile::FromBrowserContext(web_contents()->GetBrowserContext()); |
| return CreateTranslatePrefs(profile->GetPrefs()); |
| } |
| |
| TranslateAcceptLanguages* ChromeTranslateClient::GetTranslateAcceptLanguages() { |
| DCHECK(web_contents()); |
| return GetTranslateAcceptLanguages(web_contents()->GetBrowserContext()); |
| } |
| |
| int ChromeTranslateClient::GetInfobarIconID() const { |
| return IDR_INFOBAR_TRANSLATE; |
| } |
| |
| // ChromeTranslateClient::CreateInfoBar() is implemented in platform-specific |
| // files, except the TOOLKIT_VIEWS implementation, which has been removed. |
| #if defined(TOOLKIT_VIEWS) |
| scoped_ptr<infobars::InfoBar> ChromeTranslateClient::CreateInfoBar( |
| scoped_ptr<TranslateInfoBarDelegate> delegate) const { |
| return scoped_ptr<infobars::InfoBar>(); |
| } |
| #endif |
| |
| bool ChromeTranslateClient::IsTranslatableURL(const GURL& url) { |
| return TranslateService::IsTranslatableURL(url); |
| } |
| |
| void ChromeTranslateClient::ShowReportLanguageDetectionErrorUI( |
| const GURL& report_url) { |
| #if defined(OS_ANDROID) |
| // Android does not support reporting language detection errors. |
| NOTREACHED(); |
| #else |
| // We'll open the URL in a new tab so that the user can tell us more. |
| Browser* browser = chrome::FindBrowserWithWebContents(web_contents()); |
| if (!browser) { |
| NOTREACHED(); |
| return; |
| } |
| |
| chrome::AddSelectedTabWithURL( |
| browser, report_url, content::PAGE_TRANSITION_AUTO_BOOKMARK); |
| #endif // defined(OS_ANDROID) |
| } |
| |
| bool ChromeTranslateClient::OnMessageReceived(const IPC::Message& message) { |
| bool handled = true; |
| IPC_BEGIN_MESSAGE_MAP(ChromeTranslateClient, message) |
| IPC_MESSAGE_HANDLER(ChromeViewHostMsg_TranslateLanguageDetermined, |
| OnLanguageDetermined) |
| IPC_MESSAGE_HANDLER(ChromeViewHostMsg_PageTranslated, OnPageTranslated) |
| #if defined(CLD2_DYNAMIC_MODE) |
| IPC_MESSAGE_HANDLER(ChromeViewHostMsg_NeedCLDData, OnCLDDataRequested) |
| #endif |
| IPC_MESSAGE_UNHANDLED(handled = false) |
| IPC_END_MESSAGE_MAP() |
| |
| return handled; |
| } |
| |
| void ChromeTranslateClient::NavigationEntryCommitted( |
| const content::LoadCommittedDetails& load_details) { |
| // Check whether this is a reload: When doing a page reload, the |
| // TranslateLanguageDetermined IPC is not sent so the translation needs to be |
| // explicitly initiated. |
| |
| content::NavigationEntry* entry = |
| web_contents()->GetController().GetActiveEntry(); |
| if (!entry) { |
| NOTREACHED(); |
| return; |
| } |
| |
| // If the navigation happened while offline don't show the translate |
| // bar since there will be nothing to translate. |
| if (load_details.http_status_code == 0 || |
| load_details.http_status_code == net::HTTP_INTERNAL_SERVER_ERROR) { |
| return; |
| } |
| |
| if (!load_details.is_main_frame && |
| GetLanguageState().translation_declined()) { |
| // Some sites (such as Google map) may trigger sub-frame navigations |
| // when the user interacts with the page. We don't want to show a new |
| // infobar if the user already dismissed one in that case. |
| return; |
| } |
| |
| // If not a reload, return. |
| if (entry->GetTransitionType() != content::PAGE_TRANSITION_RELOAD && |
| load_details.type != content::NAVIGATION_TYPE_SAME_PAGE) { |
| return; |
| } |
| |
| if (!GetLanguageState().page_needs_translation()) |
| return; |
| |
| // Note that we delay it as the ordering of the processing of this callback |
| // by WebContentsObservers is undefined and might result in the current |
| // infobars being removed. Since the translation initiation process might add |
| // an infobar, it must be done after that. |
| base::MessageLoop::current()->PostTask( |
| FROM_HERE, |
| base::Bind(&ChromeTranslateClient::InitiateTranslation, |
| weak_pointer_factory_.GetWeakPtr(), |
| GetLanguageState().original_language(), |
| 0)); |
| } |
| |
| void ChromeTranslateClient::DidNavigateAnyFrame( |
| const content::LoadCommittedDetails& details, |
| const content::FrameNavigateParams& params) { |
| // Let the LanguageState clear its state. |
| const bool reload = |
| details.entry->GetTransitionType() == content::PAGE_TRANSITION_RELOAD || |
| details.type == content::NAVIGATION_TYPE_SAME_PAGE; |
| GetLanguageState().DidNavigate( |
| details.is_in_page, details.is_main_frame, reload); |
| } |
| |
| void ChromeTranslateClient::WebContentsDestroyed() { |
| // Translation process can be interrupted. |
| // Destroying the TranslateManager now guarantees that it never has to deal |
| // with NULL WebContents. |
| translate_manager_.reset(); |
| } |
| |
| #if defined(CLD2_DYNAMIC_MODE) |
| void ChromeTranslateClient::OnCLDDataRequested() { |
| // Quickly try to read s_cached_file_. If valid, the file handle is |
| // cached and can be used immediately. Else, queue the caching task to the |
| // blocking pool. |
| base::File* handle = NULL; |
| uint64 data_offset = 0; |
| uint64 data_length = 0; |
| { |
| base::AutoLock lock(s_file_lock_.Get()); |
| handle = s_cached_file_; |
| data_offset = s_cached_data_offset_; |
| data_length = s_cached_data_length_; |
| } |
| |
| if (handle && handle->IsValid()) { |
| // Cached data available. Respond to the request. |
| SendCLDDataAvailable(handle, data_offset, data_length); |
| return; |
| } |
| |
| // Else, we don't have the data file yet. Queue a caching attempt. |
| // The caching attempt happens in the blocking pool because it may involve |
| // arbitrary filesystem access. |
| // After the caching attempt is made, we call MaybeSendCLDDataAvailable |
| // to pass the file handle to the renderer. This only results in an IPC |
| // message if the caching attempt was successful. |
| content::BrowserThread::PostBlockingPoolTaskAndReply( |
| FROM_HERE, |
| base::Bind(&ChromeTranslateClient::HandleCLDDataRequest), |
| base::Bind(&ChromeTranslateClient::MaybeSendCLDDataAvailable, |
| weak_pointer_factory_.GetWeakPtr())); |
| } |
| |
| void ChromeTranslateClient::MaybeSendCLDDataAvailable() { |
| base::File* handle = NULL; |
| uint64 data_offset = 0; |
| uint64 data_length = 0; |
| { |
| base::AutoLock lock(s_file_lock_.Get()); |
| handle = s_cached_file_; |
| data_offset = s_cached_data_offset_; |
| data_length = s_cached_data_length_; |
| } |
| |
| if (handle && handle->IsValid()) |
| SendCLDDataAvailable(handle, data_offset, data_length); |
| } |
| |
| void ChromeTranslateClient::SendCLDDataAvailable(const base::File* handle, |
| const uint64 data_offset, |
| const uint64 data_length) { |
| // Data available, respond to the request. |
| IPC::PlatformFileForTransit ipc_platform_file = IPC::GetFileHandleForProcess( |
| handle->GetPlatformFile(), |
| GetWebContents()->GetRenderViewHost()->GetProcess()->GetHandle(), |
| false); |
| // In general, sending a response from within the code path that is processing |
| // a request is discouraged because there is potential for deadlock (if the |
| // methods are sent synchronously) or loops (if the response can trigger a |
| // new request). Neither of these concerns is relevant in this code, so |
| // sending the response from within the code path of the request handler is |
| // safe. |
| Send(new ChromeViewMsg_CLDDataAvailable( |
| GetWebContents()->GetRenderViewHost()->GetRoutingID(), |
| ipc_platform_file, |
| data_offset, |
| data_length)); |
| } |
| |
| void ChromeTranslateClient::HandleCLDDataRequest() { |
| // Because this function involves arbitrary file system access, it must run |
| // on the blocking pool. |
| DCHECK(!content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)); |
| DCHECK(!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); |
| |
| { |
| base::AutoLock lock(s_file_lock_.Get()); |
| if (s_cached_file_) |
| return; // Already done, duplicate request |
| } |
| |
| #if defined(CLD2_IS_COMPONENT) |
| base::FilePath path = component_updater::GetLatestCldDataFile(); |
| if (path.empty()) |
| return; |
| #else // CLD2 data is at a well-known file path |
| base::FilePath path; |
| if (!PathService::Get(chrome::DIR_USER_DATA, &path)) { |
| LOG(WARNING) << "Unable to locate user data directory"; |
| return; // Chrome isn't properly installed. |
| } |
| path = path.Append(chrome::kCLDDataFilename); |
| #endif |
| |
| // If the file exists, we can send an IPC-safe construct back to the |
| // renderer process immediately; otherwise, nothing to do here. |
| if (!base::PathExists(path)) |
| return; |
| |
| // Attempt to open the file for reading. |
| scoped_ptr<base::File> file( |
| new base::File(path, base::File::FLAG_OPEN | base::File::FLAG_READ)); |
| if (!file->IsValid()) { |
| LOG(WARNING) << "CLD data file exists but cannot be opened"; |
| return; |
| } |
| |
| base::File::Info file_info; |
| if (!file->GetInfo(&file_info)) { |
| LOG(WARNING) << "CLD data file exists but cannot be inspected"; |
| return; |
| } |
| |
| // For now, our offset and length are simply 0 and the length of the file, |
| // respectively. If we later decide to include the CLD2 data file inside of |
| // a larger binary context, these params can be twiddled appropriately. |
| const uint64 data_offset = 0; |
| const uint64 data_length = file_info.size; |
| |
| { |
| base::AutoLock lock(s_file_lock_.Get()); |
| if (s_cached_file_) { |
| // Idempotence: Racing another request on the blocking pool, abort. |
| } else { |
| // Else, this request has taken care of it all. Cache all info. |
| s_cached_file_ = file.release(); |
| s_cached_data_offset_ = data_offset; |
| s_cached_data_length_ = data_length; |
| } |
| } |
| } |
| |
| #endif // defined(CLD2_DYNAMIC_MODE) |
| |
| void ChromeTranslateClient::InitiateTranslation(const std::string& page_lang, |
| int attempt) { |
| if (GetLanguageState().translation_pending()) |
| return; |
| |
| // During a reload we need web content to be available before the |
| // translate script is executed. Otherwise we will run the translate script on |
| // an empty DOM which will fail. Therefore we wait a bit to see if the page |
| // has finished. |
| if (web_contents()->IsLoading() && attempt < max_reload_check_attempts_) { |
| int backoff = attempt * kMaxTranslateLoadCheckAttempts; |
| base::MessageLoop::current()->PostDelayedTask( |
| FROM_HERE, |
| base::Bind(&ChromeTranslateClient::InitiateTranslation, |
| weak_pointer_factory_.GetWeakPtr(), |
| page_lang, |
| ++attempt), |
| base::TimeDelta::FromMilliseconds(backoff)); |
| return; |
| } |
| |
| translate_manager_->InitiateTranslation( |
| TranslateDownloadManager::GetLanguageCode(page_lang)); |
| } |
| |
| void ChromeTranslateClient::OnLanguageDetermined( |
| const LanguageDetectionDetails& details, |
| bool page_needs_translation) { |
| GetLanguageState().LanguageDetermined(details.adopted_language, |
| page_needs_translation); |
| |
| if (web_contents()) |
| translate_manager_->InitiateTranslation(details.adopted_language); |
| |
| content::NotificationService::current()->Notify( |
| chrome::NOTIFICATION_TAB_LANGUAGE_DETERMINED, |
| content::Source<content::WebContents>(web_contents()), |
| content::Details<const LanguageDetectionDetails>(&details)); |
| } |
| |
| void ChromeTranslateClient::OnPageTranslated(int32 page_id, |
| const std::string& original_lang, |
| const std::string& translated_lang, |
| TranslateErrors::Type error_type) { |
| DCHECK(web_contents()); |
| translate_manager_->PageTranslated( |
| original_lang, translated_lang, error_type); |
| |
| PageTranslatedDetails details; |
| details.source_language = original_lang; |
| details.target_language = translated_lang; |
| details.error_type = error_type; |
| content::NotificationService::current()->Notify( |
| chrome::NOTIFICATION_PAGE_TRANSLATED, |
| content::Source<content::WebContents>(web_contents()), |
| content::Details<PageTranslatedDetails>(&details)); |
| } |
| |
| void ChromeTranslateClient::ShowBubble(translate::TranslateStep step, |
| TranslateErrors::Type error_type) { |
| // The bubble is implemented only on the desktop platforms. |
| #if !defined(OS_ANDROID) && !defined(OS_IOS) |
| Browser* browser = chrome::FindBrowserWithWebContents(web_contents()); |
| |
| // |browser| might be NULL when testing. In this case, Show(...) should be |
| // called because the implementation for testing is used. |
| if (!browser) { |
| TranslateBubbleFactory::Show(NULL, web_contents(), step, error_type); |
| return; |
| } |
| |
| if (web_contents() != browser->tab_strip_model()->GetActiveWebContents()) |
| return; |
| |
| // This ShowBubble function is also used for upating the existing bubble. |
| // However, with the bubble shown, any browser windows are NOT activated |
| // because the bubble takes the focus from the other widgets including the |
| // browser windows. So it is checked that |browser| is the last activated |
| // browser, not is now activated. |
| if (browser != |
| chrome::FindLastActiveWithHostDesktopType(browser->host_desktop_type())) { |
| return; |
| } |
| |
| // During auto-translating, the bubble should not be shown. |
| if (step == translate::TRANSLATE_STEP_TRANSLATING || |
| step == translate::TRANSLATE_STEP_AFTER_TRANSLATE) { |
| if (GetLanguageState().InTranslateNavigation()) |
| return; |
| } |
| |
| TranslateBubbleFactory::Show( |
| browser->window(), web_contents(), step, error_type); |
| #else |
| NOTREACHED(); |
| #endif |
| } |