Translate: New Bubble UX (for the view toolkit)

chrome/browser/translate/translate_manager.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/browser/translate/translate_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/singleton.h"
 #include "base/metrics/histogram.h"
@@ skipping 14 matching lines @@
 #include "chrome/browser/translate/translate_event_details.h"
 #include "chrome/browser/translate/translate_infobar_delegate.h"
 #include "chrome/browser/translate/translate_language_list.h"
 #include "chrome/browser/translate/translate_prefs.h"
 #include "chrome/browser/translate/translate_script.h"
 #include "chrome/browser/translate/translate_tab_helper.h"
 #include "chrome/browser/translate/translate_url_util.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/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/translate/language_detection_details.h"
 #include "chrome/common/url_constants.h"
 #include "components/translate/common/translate_constants.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "net/base/url_util.h"
 #include "net/http/http_status_code.h"
 
 #ifdef FILE_MANAGER_EXTENSION
 #include "chrome/browser/chromeos/file_manager/app_id.h"
 #include "extensions/common/constants.h"
 #endif
 
 using content::NavigationController;
 using content::NavigationEntry;
 using content::WebContents;
 
+namespace {
+
 const char kReportLanguageDetectionErrorURL[] =
     "https://translate.google.com/translate_error?client=cr&action=langidc";
 
 // Used in kReportLanguageDetectionErrorURL to specify the original page
 // language.
 const char kSourceLanguageQueryName[] = "sl";
 
 // Used in kReportLanguageDetectionErrorURL to specify the page URL.
 const char kUrlQueryName[] = "u";
 
 // 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;
 
+bool IsEnabledTranslateNewUX() {
+  return CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kEnableTranslateNewUX);
+}
+
+}  // namespace
+
 TranslateManager::~TranslateManager() {
 }
 
 // static
 TranslateManager* TranslateManager::GetInstance() {
   return Singleton<TranslateManager>::get();
 }
 
 // static
 bool TranslateManager::IsTranslatableURL(const GURL& url) {
@@ skipping 207 matching lines @@
                               content::NotificationService::AllSources());
   notification_registrar_.Add(this, chrome::NOTIFICATION_PAGE_TRANSLATED,
                               content::NotificationService::AllSources());
   language_list_.reset(new TranslateLanguageList);
   accept_languages_.reset(new TranslateAcceptLanguages);
   script_.reset(new TranslateScript);
 }
 
 void TranslateManager::InitiateTranslation(WebContents* web_contents,
                                            const std::string& page_lang) {
+  TranslateTabHelper* translate_tab_helper =
+      TranslateTabHelper::FromWebContents(web_contents);
+  if (!translate_tab_helper)
+    return;
+
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
   Profile* original_profile = profile->GetOriginalProfile();
   PrefService* prefs = original_profile->GetPrefs();
   if (!prefs->GetBoolean(prefs::kEnableTranslate)) {
     TranslateBrowserMetrics::ReportInitiationStatus(
         TranslateBrowserMetrics::INITIATION_STATUS_DISABLED_BY_PREFS);
     const std::string& locale = g_browser_process->GetApplicationLocale();
     TranslateBrowserMetrics::ReportLocalesOnDisabledByPrefs(locale);
     return;
@@ skipping 73 matching lines @@
     // Also, GetLanguageCode will take care of removing country code if any.
     auto_target_lang = GetLanguageCode(auto_target_lang);
     if (IsSupportedLanguage(auto_target_lang)) {
       TranslateBrowserMetrics::ReportInitiationStatus(
           TranslateBrowserMetrics::INITIATION_STATUS_AUTO_BY_CONFIG);
       TranslatePage(web_contents, language_code, auto_target_lang);
       return;
     }
   }
 
-  TranslateTabHelper* translate_tab_helper =
-      TranslateTabHelper::FromWebContents(web_contents);
-  if (!translate_tab_helper)
-    return;
-  std::string auto_translate_to =
-      translate_tab_helper->language_state().AutoTranslateTo();
+  LanguageState& language_state = translate_tab_helper->language_state();
+  std::string auto_translate_to = language_state.AutoTranslateTo();
   if (!auto_translate_to.empty()) {
     // This page was navigated through a click from a translated page.
     TranslateBrowserMetrics::ReportInitiationStatus(
         TranslateBrowserMetrics::INITIATION_STATUS_AUTO_BY_LINK);
     TranslatePage(web_contents, language_code, auto_translate_to);
     return;
   }
 
-  // Prompts the user if he/she wants the page translated.
   TranslateBrowserMetrics::ReportInitiationStatus(
       TranslateBrowserMetrics::INITIATION_STATUS_SHOW_INFOBAR);
-  TranslateInfoBarDelegate::Create(
-      false, InfoBarService::FromWebContents(web_contents),
-      TranslateInfoBarDelegate::BEFORE_TRANSLATE, language_code, target_lang,
-      TranslateErrors::NONE, profile->GetPrefs(), ShortcutConfig());
+
+  if (IsEnabledTranslateNewUX()) {
+    language_state.SetTranslateEnabled(true);
+    if (language_state.HasLanguageChanged())
+      ShowBubble(web_contents,
+                 TranslateBubbleModel::VIEW_STATE_BEFORE_TRANSLATE);
+  } else {
+    // Prompts the user if he/she wants the page translated.
+    TranslateInfoBarDelegate::Create(
+        false, InfoBarService::FromWebContents(web_contents),
+        TranslateInfoBarDelegate::BEFORE_TRANSLATE, language_code, target_lang,
+        TranslateErrors::NONE, profile->GetPrefs(), ShortcutConfig());
+  }
 }
 
 void TranslateManager::InitiateTranslationPosted(int process_id,
                                                  int render_id,
                                                  const std::string& page_lang,
                                                  int attempt) {
   // The tab might have been closed.
   WebContents* web_contents =
       tab_util::GetWebContentsByID(process_id, render_id);
   if (!web_contents)
@@ skipping 31 matching lines @@
   }
 
   // Translation can be kicked by context menu against unsupported languages.
   // Unsupported language strings should be replaced with
   // kUnknownLanguageCode in order to send a translation request with enabling
   // server side auto language detection.
   std::string source_lang(original_source_lang);
   if (!IsSupportedLanguage(source_lang))
     source_lang = std::string(translate::kUnknownLanguageCode);
 
-  Profile* profile =
-      Profile::FromBrowserContext(web_contents->GetBrowserContext());
-  TranslateInfoBarDelegate::Create(
-      true, InfoBarService::FromWebContents(web_contents),
-      TranslateInfoBarDelegate::TRANSLATING, source_lang, target_lang,
-      TranslateErrors::NONE, profile->GetPrefs(), ShortcutConfig());
+  if (IsEnabledTranslateNewUX()) {
+    ShowBubble(web_contents, TranslateBubbleModel::VIEW_STATE_TRANSLATING);
+  } else {
+    Profile* profile =
+        Profile::FromBrowserContext(web_contents->GetBrowserContext());
+    TranslateInfoBarDelegate::Create(
+        true, InfoBarService::FromWebContents(web_contents),
+        TranslateInfoBarDelegate::TRANSLATING, source_lang, target_lang,
+        TranslateErrors::NONE, profile->GetPrefs(), ShortcutConfig());
+  }
 
   DCHECK(script_.get() != NULL);
 
   const std::string& translate_script = script_->data();
   if (!translate_script.empty()) {
     DoTranslatePage(web_contents, translate_script, source_lang, target_lang);
     return;
   }
 
   // The script is not available yet.  Queue that request and query for the
@@ skipping 91 matching lines @@
 }
 
 void TranslateManager::PageTranslated(WebContents* web_contents,
                                       PageTranslatedDetails* details) {
   if ((details->error_type == TranslateErrors::NONE) &&
       details->source_language != translate::kUnknownLanguageCode &&
       !IsSupportedLanguage(details->source_language)) {
     details->error_type = TranslateErrors::UNSUPPORTED_LANGUAGE;
   }
 
-  PrefService* prefs = Profile::FromBrowserContext(
-      web_contents->GetBrowserContext())->GetPrefs();
-  TranslateInfoBarDelegate::Create(
-      true, InfoBarService::FromWebContents(web_contents),
-      (details->error_type == TranslateErrors::NONE) ?
-          TranslateInfoBarDelegate::AFTER_TRANSLATE :
-          TranslateInfoBarDelegate::TRANSLATION_ERROR,
-      details->source_language, details->target_language, details->error_type,
-      prefs, ShortcutConfig());
+  if (IsEnabledTranslateNewUX()) {
+    TranslateBubbleModel::ViewState view_state =
+        (details->error_type == TranslateErrors::NONE) ?
+        TranslateBubbleModel::VIEW_STATE_AFTER_TRANSLATE :
+        TranslateBubbleModel::VIEW_STATE_ERROR;
+    ShowBubble(web_contents, view_state);
+  } else {
+    PrefService* prefs = Profile::FromBrowserContext(
+        web_contents->GetBrowserContext())->GetPrefs();
+    TranslateInfoBarDelegate::Create(
+        true, InfoBarService::FromWebContents(web_contents),
+        (details->error_type == TranslateErrors::NONE) ?
+        TranslateInfoBarDelegate::AFTER_TRANSLATE :
+        TranslateInfoBarDelegate::TRANSLATION_ERROR,
+        details->source_language, details->target_language, details->error_type,
+        prefs, ShortcutConfig());
+  }
 
   if (details->error_type != TranslateErrors::NONE &&
       !web_contents->GetBrowserContext()->IsOffTheRecord()) {
     TranslateErrorDetails error_details;
     error_details.time = base::Time::Now();
     error_details.url = web_contents->GetLastCommittedURL();
     error_details.error = details->error_type;
     NotifyTranslateError(error_details);
   }
 }
@@ skipping 37 matching lines @@
       // We navigated away from the page the translation was triggered on.
       continue;
     }
 
     if (success) {
       // Translate the page.
       const std::string& translate_script = script_->data();
       DoTranslatePage(web_contents, translate_script,
                       request.source_lang, request.target_lang);
     } else {
-      Profile* profile =
-          Profile::FromBrowserContext(web_contents->GetBrowserContext());
-      TranslateInfoBarDelegate::Create(
-          true, InfoBarService::FromWebContents(web_contents),
-          TranslateInfoBarDelegate::TRANSLATION_ERROR, request.source_lang,
-          request.target_lang, TranslateErrors::NETWORK, profile->GetPrefs(),
-          ShortcutConfig());
+      if (IsEnabledTranslateNewUX()) {
+        ShowBubble(web_contents, TranslateBubbleModel::VIEW_STATE_ERROR);
+      } else {
+        Profile* profile =
+            Profile::FromBrowserContext(web_contents->GetBrowserContext());
+        TranslateInfoBarDelegate::Create(
+            true, InfoBarService::FromWebContents(web_contents),
+            TranslateInfoBarDelegate::TRANSLATION_ERROR, request.source_lang,
+            request.target_lang, TranslateErrors::NETWORK, profile->GetPrefs(),
+            ShortcutConfig());
+      }
 
       if (!web_contents->GetBrowserContext()->IsOffTheRecord()) {
         TranslateErrorDetails error_details;
         error_details.time = base::Time::Now();
         error_details.url = entry->GetURL();
         error_details.error = TranslateErrors::NETWORK;
         NotifyTranslateError(error_details);
       }
     }
   }
   pending_requests_.clear();
 }
 
+void TranslateManager::ShowBubble(WebContents* web_contents,
+                                  TranslateBubbleModel::ViewState view_state) {
+  // The bubble is implemented only on the desktop platforms.
+#if !defined(OS_ANDROID) && !defined(OS_IOS)
+  Browser* browser = chrome::FindBrowserWithWebContents(web_contents);
+  BrowserWindow* window = browser ? browser->window() : NULL;
+  TranslateBubbleFactory::Show(window, web_contents, view_state);
+#else
+  NOTREACHED();
+#endif
+}
+
 // static
 std::string TranslateManager::GetTargetLanguage(PrefService* prefs) {
   std::string ui_lang =
       GetLanguageCode(g_browser_process->GetApplicationLocale());
   if (IsSupportedLanguage(ui_lang))
     return ui_lang;
 
   // Getting the accepted languages list
   std::string accept_langs_str = prefs->GetString(prefs::kAcceptLanguages);
 
@@ skipping 20 matching lines @@
   // so we are more aggressive about showing the shortcut to never translate.
   #if defined(OS_ANDROID)
   config.never_translate_min_count = 1;
   #else
   config.never_translate_min_count = 3;
   #endif  // defined(OS_ANDROID)
 
   config.always_translate_min_count = 3;
   return config;
 }