chrome_translate_client.cc revision 116680a4aac90f2aa7413d9095a592090648e557 
1// Copyright 2014 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/translate/chrome_translate_client.h"
6
7#include <vector>
8
9#include "base/logging.h"
10#include "base/prefs/pref_service.h"
11#include "base/strings/string_split.h"
12#include "chrome/browser/chrome_notification_types.h"
13#include "chrome/browser/infobars/infobar_service.h"
14#include "chrome/browser/profiles/profile.h"
15#include "chrome/browser/translate/translate_accept_languages_factory.h"
16#include "chrome/browser/translate/translate_service.h"
17#include "chrome/browser/ui/browser.h"
18#include "chrome/browser/ui/browser_finder.h"
19#include "chrome/browser/ui/browser_tabstrip.h"
20#include "chrome/browser/ui/browser_window.h"
21#include "chrome/browser/ui/tabs/tab_strip_model.h"
22#include "chrome/browser/ui/translate/translate_bubble_factory.h"
23#include "chrome/common/pref_names.h"
24#include "components/infobars/core/infobar.h"
25#include "components/translate/content/common/translate_messages.h"
26#include "components/translate/core/browser/language_state.h"
27#include "components/translate/core/browser/page_translated_details.h"
28#include "components/translate/core/browser/translate_accept_languages.h"
29#include "components/translate/core/browser/translate_download_manager.h"
30#include "components/translate/core/browser/translate_infobar_delegate.h"
31#include "components/translate/core/browser/translate_manager.h"
32#include "components/translate/core/browser/translate_prefs.h"
33#include "components/translate/core/common/language_detection_details.h"
34#include "content/public/browser/navigation_details.h"
35#include "content/public/browser/navigation_entry.h"
36#include "content/public/browser/notification_service.h"
37#include "content/public/browser/render_view_host.h"
38#include "content/public/browser/web_contents.h"
39#include "grit/theme_resources.h"
40#include "net/http/http_status_code.h"
41#include "url/gurl.h"
42
43#if defined(CLD_DATA_FROM_STANDALONE)
44#include "base/path_service.h"
45#include "chrome/common/chrome_paths.h"
46#include "components/translate/content/browser/data_file_browser_cld_data_provider.h"
47#endif
48
49namespace {
50
51// The maximum number of attempts we'll do to see if the page has finshed
52// loading before giving up the translation
53const int kMaxTranslateLoadCheckAttempts = 20;
54
55#if defined(CLD_DATA_FROM_STANDALONE)
56// This build uses a standalone CLD2 data file.
57// TODO(andrewhayden): Make the data file path into a gyp/gn define
58// If you change this, also update standalone_cld_data_harness.cc
59// accordingly!
60const base::FilePath::CharType kCldDataFileName[] =
61    FILE_PATH_LITERAL("cld2_data.bin");
62
63bool g_cld_file_path_initialized_ = false;
64
65void InitCldFilePath() {
66  VLOG(1) << "Initializing CLD file path for the first time.";
67  base::FilePath path;
68  if (!PathService::Get(chrome::DIR_USER_DATA, &path)) {
69    LOG(WARNING) << "Unable to locate user data directory";
70    return;  // Chrome isn't properly installed
71  }
72  g_cld_file_path_initialized_ = true;
73  path = path.Append(kCldDataFileName);
74  VLOG(1) << "Setting CLD data file path: " << path.value();
75  translate::DataFileBrowserCldDataProvider::SetCldDataFilePath(path);
76}
77#endif
78
79}  // namespace
80
81DEFINE_WEB_CONTENTS_USER_DATA_KEY(ChromeTranslateClient);
82
83ChromeTranslateClient::ChromeTranslateClient(content::WebContents* web_contents)
84    : content::WebContentsObserver(web_contents),
85      max_reload_check_attempts_(kMaxTranslateLoadCheckAttempts),
86      translate_driver_(&web_contents->GetController()),
87      translate_manager_(new TranslateManager(this, prefs::kAcceptLanguages)),
88      cld_data_provider_(translate::CreateBrowserCldDataProviderFor(
89          web_contents)),
90      weak_pointer_factory_(this) {
91#if defined(CLD_DATA_FROM_STANDALONE)
92  if (!g_cld_file_path_initialized_)
93    InitCldFilePath();
94#endif
95}
96
97ChromeTranslateClient::~ChromeTranslateClient() {
98}
99
100LanguageState& ChromeTranslateClient::GetLanguageState() {
101  return translate_manager_->GetLanguageState();
102}
103
104// static
105scoped_ptr<TranslatePrefs> ChromeTranslateClient::CreateTranslatePrefs(
106    PrefService* prefs) {
107#if defined(OS_CHROMEOS)
108  const char* preferred_languages_prefs = prefs::kLanguagePreferredLanguages;
109#else
110  const char* preferred_languages_prefs = NULL;
111#endif
112  return scoped_ptr<TranslatePrefs>(new TranslatePrefs(
113      prefs, prefs::kAcceptLanguages, preferred_languages_prefs));
114}
115
116// static
117TranslateAcceptLanguages* ChromeTranslateClient::GetTranslateAcceptLanguages(
118    content::BrowserContext* browser_context) {
119  return TranslateAcceptLanguagesFactory::GetForBrowserContext(browser_context);
120}
121
122// static
123TranslateManager* ChromeTranslateClient::GetManagerFromWebContents(
124    content::WebContents* web_contents) {
125  ChromeTranslateClient* chrome_translate_client =
126      FromWebContents(web_contents);
127  if (!chrome_translate_client)
128    return NULL;
129  return chrome_translate_client->GetTranslateManager();
130}
131
132// static
133void ChromeTranslateClient::GetTranslateLanguages(
134    content::WebContents* web_contents,
135    std::string* source,
136    std::string* target) {
137  DCHECK(source != NULL);
138  DCHECK(target != NULL);
139
140  ChromeTranslateClient* chrome_translate_client =
141      FromWebContents(web_contents);
142  if (!chrome_translate_client)
143    return;
144
145  *source = TranslateDownloadManager::GetLanguageCode(
146      chrome_translate_client->GetLanguageState().original_language());
147
148  Profile* profile =
149      Profile::FromBrowserContext(web_contents->GetBrowserContext());
150  Profile* original_profile = profile->GetOriginalProfile();
151  PrefService* prefs = original_profile->GetPrefs();
152  scoped_ptr<TranslatePrefs> translate_prefs = CreateTranslatePrefs(prefs);
153  if (!web_contents->GetBrowserContext()->IsOffTheRecord()) {
154    std::string auto_translate_language =
155        TranslateManager::GetAutoTargetLanguage(*source, translate_prefs.get());
156    if (!auto_translate_language.empty()) {
157      *target = auto_translate_language;
158      return;
159    }
160  }
161
162  std::string accept_languages_str = prefs->GetString(prefs::kAcceptLanguages);
163  std::vector<std::string> accept_languages_list;
164  base::SplitString(accept_languages_str, ',', &accept_languages_list);
165  *target = TranslateManager::GetTargetLanguage(accept_languages_list);
166}
167
168TranslateManager* ChromeTranslateClient::GetTranslateManager() {
169  return translate_manager_.get();
170}
171
172content::WebContents* ChromeTranslateClient::GetWebContents() {
173  return web_contents();
174}
175
176void ChromeTranslateClient::ShowTranslateUI(translate::TranslateStep step,
177                                            const std::string source_language,
178                                            const std::string target_language,
179                                            TranslateErrors::Type error_type,
180                                            bool triggered_from_menu) {
181  DCHECK(web_contents());
182  if (error_type != TranslateErrors::NONE)
183    step = translate::TRANSLATE_STEP_TRANSLATE_ERROR;
184
185  if (TranslateService::IsTranslateBubbleEnabled()) {
186    // Bubble UI.
187    if (step == translate::TRANSLATE_STEP_BEFORE_TRANSLATE) {
188      // TODO(droger): Move this logic out of UI code.
189      GetLanguageState().SetTranslateEnabled(true);
190      if (!GetLanguageState().HasLanguageChanged())
191        return;
192
193      if (!triggered_from_menu) {
194        if (web_contents()->GetBrowserContext()->IsOffTheRecord())
195          return;
196        if (GetTranslatePrefs()->IsTooOftenDenied())
197          return;
198      }
199    }
200    ShowBubble(step, error_type);
201    return;
202  }
203
204  // Infobar UI.
205  TranslateInfoBarDelegate::Create(
206      step != translate::TRANSLATE_STEP_BEFORE_TRANSLATE,
207      translate_manager_->GetWeakPtr(),
208      InfoBarService::FromWebContents(web_contents()),
209      web_contents()->GetBrowserContext()->IsOffTheRecord(),
210      step,
211      source_language,
212      target_language,
213      error_type,
214      triggered_from_menu);
215}
216
217TranslateDriver* ChromeTranslateClient::GetTranslateDriver() {
218  return &translate_driver_;
219}
220
221PrefService* ChromeTranslateClient::GetPrefs() {
222  DCHECK(web_contents());
223  Profile* profile =
224      Profile::FromBrowserContext(web_contents()->GetBrowserContext());
225  return profile->GetOriginalProfile()->GetPrefs();
226}
227
228scoped_ptr<TranslatePrefs> ChromeTranslateClient::GetTranslatePrefs() {
229  DCHECK(web_contents());
230  Profile* profile =
231      Profile::FromBrowserContext(web_contents()->GetBrowserContext());
232  return CreateTranslatePrefs(profile->GetPrefs());
233}
234
235TranslateAcceptLanguages* ChromeTranslateClient::GetTranslateAcceptLanguages() {
236  DCHECK(web_contents());
237  return GetTranslateAcceptLanguages(web_contents()->GetBrowserContext());
238}
239
240int ChromeTranslateClient::GetInfobarIconID() const {
241  return IDR_INFOBAR_TRANSLATE;
242}
243
244// ChromeTranslateClient::CreateInfoBar() is implemented in platform-specific
245// files, except the TOOLKIT_VIEWS implementation, which has been removed. Note
246// for Mac, Cocoa is still providing the infobar in a toolkit-views build.
247#if defined(TOOLKIT_VIEWS) && !defined(OS_MACOSX)
248scoped_ptr<infobars::InfoBar> ChromeTranslateClient::CreateInfoBar(
249    scoped_ptr<TranslateInfoBarDelegate> delegate) const {
250  return scoped_ptr<infobars::InfoBar>();
251}
252#endif
253
254bool ChromeTranslateClient::IsTranslatableURL(const GURL& url) {
255  return TranslateService::IsTranslatableURL(url);
256}
257
258void ChromeTranslateClient::ShowReportLanguageDetectionErrorUI(
259    const GURL& report_url) {
260#if defined(OS_ANDROID)
261  // Android does not support reporting language detection errors.
262  NOTREACHED();
263#else
264  // We'll open the URL in a new tab so that the user can tell us more.
265  Browser* browser = chrome::FindBrowserWithWebContents(web_contents());
266  if (!browser) {
267    NOTREACHED();
268    return;
269  }
270
271  chrome::AddSelectedTabWithURL(
272      browser, report_url, content::PAGE_TRANSITION_AUTO_BOOKMARK);
273#endif  // defined(OS_ANDROID)
274}
275
276bool ChromeTranslateClient::OnMessageReceived(const IPC::Message& message) {
277  bool handled = true;
278  IPC_BEGIN_MESSAGE_MAP(ChromeTranslateClient, message)
279  IPC_MESSAGE_HANDLER(ChromeViewHostMsg_TranslateAssignedSequenceNumber,
280                      OnTranslateAssignedSequenceNumber)
281  IPC_MESSAGE_HANDLER(ChromeViewHostMsg_TranslateLanguageDetermined,
282                      OnLanguageDetermined)
283  IPC_MESSAGE_HANDLER(ChromeViewHostMsg_PageTranslated, OnPageTranslated)
284  IPC_MESSAGE_UNHANDLED(handled = false)
285  IPC_END_MESSAGE_MAP()
286
287  if (!handled) {
288    handled = cld_data_provider_->OnMessageReceived(message);
289  }
290  return handled;
291}
292
293void ChromeTranslateClient::NavigationEntryCommitted(
294    const content::LoadCommittedDetails& load_details) {
295  // Check whether this is a reload: When doing a page reload, the
296  // TranslateLanguageDetermined IPC is not sent so the translation needs to be
297  // explicitly initiated.
298
299  content::NavigationEntry* entry =
300      web_contents()->GetController().GetActiveEntry();
301  if (!entry) {
302    NOTREACHED();
303    return;
304  }
305
306  // If the navigation happened while offline don't show the translate
307  // bar since there will be nothing to translate.
308  if (load_details.http_status_code == 0 ||
309      load_details.http_status_code == net::HTTP_INTERNAL_SERVER_ERROR) {
310    return;
311  }
312
313  if (!load_details.is_main_frame &&
314      GetLanguageState().translation_declined()) {
315    // Some sites (such as Google map) may trigger sub-frame navigations
316    // when the user interacts with the page.  We don't want to show a new
317    // infobar if the user already dismissed one in that case.
318    return;
319  }
320
321  // If not a reload, return.
322  if (entry->GetTransitionType() != content::PAGE_TRANSITION_RELOAD &&
323      load_details.type != content::NAVIGATION_TYPE_SAME_PAGE) {
324    return;
325  }
326
327  if (!GetLanguageState().page_needs_translation())
328    return;
329
330  // Note that we delay it as the ordering of the processing of this callback
331  // by WebContentsObservers is undefined and might result in the current
332  // infobars being removed. Since the translation initiation process might add
333  // an infobar, it must be done after that.
334  base::MessageLoop::current()->PostTask(
335      FROM_HERE,
336      base::Bind(&ChromeTranslateClient::InitiateTranslation,
337                 weak_pointer_factory_.GetWeakPtr(),
338                 GetLanguageState().original_language(),
339                 0));
340}
341
342void ChromeTranslateClient::DidNavigateAnyFrame(
343    const content::LoadCommittedDetails& details,
344    const content::FrameNavigateParams& params) {
345  // Let the LanguageState clear its state.
346  const bool reload =
347      details.entry->GetTransitionType() == content::PAGE_TRANSITION_RELOAD ||
348      details.type == content::NAVIGATION_TYPE_SAME_PAGE;
349  GetLanguageState().DidNavigate(
350      details.is_in_page, details.is_main_frame, reload);
351}
352
353void ChromeTranslateClient::WebContentsDestroyed() {
354  // Translation process can be interrupted.
355  // Destroying the TranslateManager now guarantees that it never has to deal
356  // with NULL WebContents.
357  translate_manager_.reset();
358}
359
360void ChromeTranslateClient::InitiateTranslation(const std::string& page_lang,
361                                                int attempt) {
362  if (GetLanguageState().translation_pending())
363    return;
364
365  // During a reload we need web content to be available before the
366  // translate script is executed. Otherwise we will run the translate script on
367  // an empty DOM which will fail. Therefore we wait a bit to see if the page
368  // has finished.
369  if (web_contents()->IsLoading() && attempt < max_reload_check_attempts_) {
370    int backoff = attempt * kMaxTranslateLoadCheckAttempts;
371    base::MessageLoop::current()->PostDelayedTask(
372        FROM_HERE,
373        base::Bind(&ChromeTranslateClient::InitiateTranslation,
374                   weak_pointer_factory_.GetWeakPtr(),
375                   page_lang,
376                   attempt + 1),
377        base::TimeDelta::FromMilliseconds(backoff));
378    return;
379  }
380
381  translate_manager_->InitiateTranslation(
382      TranslateDownloadManager::GetLanguageCode(page_lang));
383}
384
385void ChromeTranslateClient::OnTranslateAssignedSequenceNumber(int page_seq_no) {
386  translate_manager_->set_current_seq_no(page_seq_no);
387}
388
389void ChromeTranslateClient::OnLanguageDetermined(
390    const LanguageDetectionDetails& details,
391    bool page_needs_translation) {
392  GetLanguageState().LanguageDetermined(details.adopted_language,
393                                        page_needs_translation);
394
395  if (web_contents())
396    translate_manager_->InitiateTranslation(details.adopted_language);
397
398  content::NotificationService::current()->Notify(
399      chrome::NOTIFICATION_TAB_LANGUAGE_DETERMINED,
400      content::Source<content::WebContents>(web_contents()),
401      content::Details<const LanguageDetectionDetails>(&details));
402}
403
404void ChromeTranslateClient::OnPageTranslated(const std::string& original_lang,
405                                             const std::string& translated_lang,
406                                             TranslateErrors::Type error_type) {
407  DCHECK(web_contents());
408  translate_manager_->PageTranslated(
409      original_lang, translated_lang, error_type);
410
411  PageTranslatedDetails details;
412  details.source_language = original_lang;
413  details.target_language = translated_lang;
414  details.error_type = error_type;
415  content::NotificationService::current()->Notify(
416      chrome::NOTIFICATION_PAGE_TRANSLATED,
417      content::Source<content::WebContents>(web_contents()),
418      content::Details<PageTranslatedDetails>(&details));
419}
420
421void ChromeTranslateClient::ShowBubble(translate::TranslateStep step,
422                                       TranslateErrors::Type error_type) {
423// The bubble is implemented only on the desktop platforms.
424#if !defined(OS_ANDROID) && !defined(OS_IOS)
425  Browser* browser = chrome::FindBrowserWithWebContents(web_contents());
426
427  // |browser| might be NULL when testing. In this case, Show(...) should be
428  // called because the implementation for testing is used.
429  if (!browser) {
430    TranslateBubbleFactory::Show(NULL, web_contents(), step, error_type);
431    return;
432  }
433
434  if (web_contents() != browser->tab_strip_model()->GetActiveWebContents())
435    return;
436
437  // This ShowBubble function is also used for upating the existing bubble.
438  // However, with the bubble shown, any browser windows are NOT activated
439  // because the bubble takes the focus from the other widgets including the
440  // browser windows. So it is checked that |browser| is the last activated
441  // browser, not is now activated.
442  if (browser !=
443      chrome::FindLastActiveWithHostDesktopType(browser->host_desktop_type())) {
444    return;
445  }
446
447  // During auto-translating, the bubble should not be shown.
448  if (step == translate::TRANSLATE_STEP_TRANSLATING ||
449      step == translate::TRANSLATE_STEP_AFTER_TRANSLATE) {
450    if (GetLanguageState().InTranslateNavigation())
451      return;
452  }
453
454  TranslateBubbleFactory::Show(
455      browser->window(), web_contents(), step, error_type);
456#else
457  NOTREACHED();
458#endif
459}
460