Pass the Translate error type to the bubble

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/field_trial.h"
@@ skipping 415 matching lines @@
     return;
   }
 
   TranslateBrowserMetrics::ReportInitiationStatus(
       TranslateBrowserMetrics::INITIATION_STATUS_SHOW_INFOBAR);
 
   if (IsEnabledTranslateNewUX()) {
     language_state.SetTranslateEnabled(true);
     if (language_state.HasLanguageChanged()) {
       ShowBubble(web_contents,
-                 TranslateBubbleModel::VIEW_STATE_BEFORE_TRANSLATE);
+                 TranslateBubbleModel::VIEW_STATE_BEFORE_TRANSLATE,
+                 TranslateErrors::NONE);
     }
   } 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());
   }
 }
 
@@ skipping 40 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);
 
   if (IsEnabledTranslateNewUX()) {
-    ShowBubble(web_contents, TranslateBubbleModel::VIEW_STATE_TRANSLATING);
+    ShowBubble(web_contents, TranslateBubbleModel::VIEW_STATE_TRANSLATING,
+               TranslateErrors::NONE);
   } 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);
@@ skipping 104 matching lines @@
       details->source_language != translate::kUnknownLanguageCode &&
       !IsSupportedLanguage(details->source_language)) {
     details->error_type = TranslateErrors::UNSUPPORTED_LANGUAGE;
   }
 
   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);
+    ShowBubble(web_contents, view_state, details->error_type);
   } 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());
@@ skipping 49 matching lines @@
       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 {
       if (IsEnabledTranslateNewUX()) {
-        ShowBubble(web_contents, TranslateBubbleModel::VIEW_STATE_ERROR);
+        ShowBubble(web_contents, TranslateBubbleModel::VIEW_STATE_ERROR,
+                   TranslateErrors::NETWORK);
       } 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) {
+                                  TranslateBubbleModel::ViewState view_state,
+                                  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, view_state);
+    TranslateBubbleFactory::Show(NULL, web_contents, view_state, error_type);
     return;
   }
 
   if (web_contents != browser->tab_strip_model()->GetActiveWebContents())
     return;
 
   BrowserWindow* window = browser->window();
   if (window && !window->IsActive())
     return;
 
-  TranslateBubbleFactory::Show(window, web_contents, view_state);
+  TranslateBubbleFactory::Show(window, web_contents, view_state, error_type);
 #else
   NOTREACHED();
 #endif
 }
 
 // static
 std::string TranslateManager::GetTargetLanguage(PrefService* prefs) {
   std::string ui_lang =
       TranslatePrefs::ConvertLangCodeForTranslation(
           GetLanguageCode(g_browser_process->GetApplicationLocale()));
@@ skipping 43 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;
 }