Check |errorCode| of translate.js and notify to Browser

chrome/browser/translate/translate_manager_browsertest.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 "components/translate/core/browser/translate_manager.h"
 
 #include <memory>
 
 #include "build/build_config.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/prefs/session_startup_pref.h"
 #include "chrome/browser/translate/chrome_translate_client.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
+#include "components/translate/core/browser/translate_error_details.h"
 #include "components/translate/core/common/language_detection_details.h"
 #include "content/public/browser/notification_service.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "url/gurl.h"
 
+namespace {
+
+static const char kTestValidScript[] =
+    "var google = {};"
+    "google.translate = (function() {"
+    "  return {"
+    "    TranslateService: function() {"
+    "      return {"
+    "        isAvailable : function() {"
+    "          return true;"
+    "        },"
+    "        restore : function() {"
+    "          return;"
+    "        },"
+    "        getDetectedLanguage : function() {"
+    "          return \"fr\";"
+    "        },"
+    "        translatePage : function(originalLang, targetLang,"
+    "                                 onTranslateProgress) {"
+    "          var error = (originalLang == 'auto') ? true : false;"
+    "          onTranslateProgress(100, true, error);"
+    "        }"
+    "      };"
+    "    }"
+    "  };"
+    "})();"
+    "cr.googleTranslate.onTranslateElementLoad();";
+
+static const char kTestScriptInitializationError[] =
+    "var google = {};"
+    "google.translate = (function() {"
+    "  return {"
+    "    TranslateService: function() {"
+    "      return error;"
+    "    }"
+    "  };"
+    "})();"
+    "cr.googleTranslate.onTranslateElementLoad();";
+
+static const char kTestScriptIdenticalLanguages[] =
+    "var google = {};"
+    "google.translate = (function() {"
+    "  return {"
+    "    TranslateService: function() {"
+    "      return {"
+    "        isAvailable : function() {"
+    "          return true;"
+    "        },"
+    "        restore : function() {"
+    "          return;"
+    "        },"
+    "        getDetectedLanguage : function() {"
+    "          return \"aa\";"
+    "        },"
+    "        translatePage : function(originalLang, targetLang,"
+    "                                 onTranslateProgress) {"
+    "          onTranslateProgress(100, true, 0);"
+    "        }"
+    "      };"
+    "    }"
+    "  };"
+    "})();"
+    "cr.googleTranslate.onTranslateElementLoad();";
+
+static const char kTestScriptTimeout[] =
+    "var google = {};"
+    "google.translate = (function() {"
+    "  return {"
+    "    TranslateService: function() {"
+    "      return {"
+    "        isAvailable : function() {"
+    "          return false;"
+    "        },"
+    "      };"
+    "    }"
+    "  };"
+    "})();"
+    "cr.googleTranslate.onTranslateElementLoad();";
+
+static const char kTestScriptUnexpectedScriptError[] =
+    "var google = {};"
+    "google.translate = (function() {"
+    "  return {"
+    "    TranslateService: function() {"
+    "      return {"
+    "        isAvailable : function() {"
+    "          return true;"
+    "        },"
+    "        restore : function() {"
+    "          return;"
+    "        },"
+    "        getDetectedLanguage : function() {"
+    "          return \"fr\";"
+    "        },"
+    "        translatePage : function(originalLang, targetLang,"
+    "                                 onTranslateProgress) {"
+    "          return error;"
+    "        }"
+    "      };"
+    "    }"
+    "  };"
+    "})();"
+    "cr.googleTranslate.onTranslateElementLoad();";
+
+static const char kTestScriptBadOrigin[] =
+    "var google = {};"
+    "google.translate = (function() {"
+    "  return {"
+    "    TranslateService: function() {"
+    "      return {"
+    "        isAvailable : function() {"
+    "          return true;"
+    "        },"
+    "        restore : function() {"
+    "          return;"
+    "        },"
+    "        getDetectedLanguage : function() {"
+    "          return \"fr\";"
+    "        },"
+    "        translatePage : function(originalLang, targetLang,"
+    "                                 onTranslateProgress) {"
+    "          var url = \"\";"
+    "          cr.googleTranslate.onLoadJavascript(url);"
+    "        }"
+    "      };"
+    "    }"
+    "  };"
+    "})();"
+    "cr.googleTranslate.onTranslateElementLoad();";
+
+static const char kTestScriptLoadError[] =
+    "var google = {};"
+    "google.translate = (function() {"
+    "  return {"
+    "    TranslateService: function() {"
+    "      return {"
+    "        isAvailable : function() {"
+    "          return true;"
+    "        },"
+    "        restore : function() {"
+    "          return;"
+    "        },"
+    "        getDetectedLanguage : function() {"
+    "          return \"fr\";"
+    "        },"
+    "        translatePage : function(originalLang, targetLang,"
+    "                                 onTranslateProgress) {"
+    "          var url = \"https://translate.googleapis.com/INVALID\";"
+    "          cr.googleTranslate.onLoadJavascript(url);"
+    "        }"
+    "      };"
+    "    }"
+    "  };"
+    "})();"
+    "cr.googleTranslate.onTranslateElementLoad();";
+
+}  // namespace
+
 class TranslateManagerBrowserTest : public InProcessBrowserTest {
  public:
-  TranslateManagerBrowserTest() {}
+  TranslateManagerBrowserTest() {
+    error_subscription_ =
+        translate::TranslateManager::RegisterTranslateErrorCallback(
+            base::Bind(&TranslateManagerBrowserTest::OnTranslateError,
+                       base::Unretained(this)));
+  }
   ~TranslateManagerBrowserTest() override {}
 
   void WaitUntilLanguageDetected() { language_detected_signal_->Wait(); }
   void WaitUntilPageTranslated() { page_translated_signal_->Wait(); }
 
   void ResetObserver() {
     language_detected_signal_.reset(new LangageDetectionObserver(
         chrome::NOTIFICATION_TAB_LANGUAGE_DETERMINED,
         content::NotificationService::AllSources()));
     page_translated_signal_.reset(new content::WindowedNotificationObserver(
         chrome::NOTIFICATION_PAGE_TRANSLATED,
         content::NotificationService::AllSources()));
   }
 
-  void SimulateURLFetch(bool success) {
+  void SimulateURLFetch(const std::string& script, bool success) {
     net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
     ASSERT_TRUE(fetcher);
     net::Error error = success ? net::OK : net::ERR_FAILED;
 
-    std::string script =
-        " var google = {};"
-        "google.translate = (function() {"
-        "  return {"
-        "    TranslateService: function() {"
-        "      return {"
-        "        isAvailable : function() {"
-        "          return true;"
-        "        },"
-        "        restore : function() {"
-        "          return;"
-        "        },"
-        "        getDetectedLanguage : function() {"
-        "          return \"fr\";"
-        "        },"
-        "        translatePage : function(originalLang, targetLang,"
-        "                                 onTranslateProgress) {"
-        "          var error = (originalLang == 'auto') ? true : false;"
-        "          onTranslateProgress(100, true, error);"
-        "        }"
-        "      };"
-        "    }"
-        "  };"
-        "})();"
-        "cr.googleTranslate.onTranslateElementLoad();";
-
     fetcher->set_url(fetcher->GetOriginalURL());
     fetcher->set_status(net::URLRequestStatus::FromError(error));
     fetcher->set_response_code(success ? 200 : 500);
     fetcher->SetResponseString(script);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
   }
 
+  void OnTranslateError(const translate::TranslateErrorDetails& details) {
+    error_type_ = details.error;
+  }
+
+  translate::TranslateErrors::Type GetPageTranslatedResult() {
+    return error_type_;
+  }
+
+  ChromeTranslateClient* GetChromeTranslateClient() {
+    return ChromeTranslateClient::FromWebContents(
+        browser()->tab_strip_model()->GetActiveWebContents());
+  }
+
  protected:
   // InProcessBrowserTest members.
   void SetUp() override {
     InProcessBrowserTest::SetUp();
   }
   void SetUpOnMainThread() override {
     ResetObserver();
     InProcessBrowserTest::SetUpOnMainThread();
   }
 
  private:
   net::TestURLFetcherFactory url_fetcher_factory_;
 
+  translate::TranslateErrors::Type error_type_;
+
+  std::unique_ptr<
+      translate::TranslateManager::TranslateErrorCallbackList::Subscription>
+      error_subscription_;
+
   using LangageDetectionObserver =
       ui_test_utils::WindowedNotificationObserverWithDetails<
           translate::LanguageDetectionDetails>;
 
   std::unique_ptr<LangageDetectionObserver> language_detected_signal_;
   std::unique_ptr<content::WindowedNotificationObserver>
       page_translated_signal_;
 };
 
 // Tests that the CLD (Compact Language Detection) works properly.
 IN_PROC_BROWSER_TEST_F(TranslateManagerBrowserTest, PageLanguageDetection) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
-  content::WebContents* current_web_contents =
-      browser()->tab_strip_model()->GetActiveWebContents();
-  ChromeTranslateClient* chrome_translate_client =
-      ChromeTranslateClient::FromWebContents(current_web_contents);
+  ChromeTranslateClient* chrome_translate_client = GetChromeTranslateClient();
+
   // The InProcessBrowserTest opens a new tab, let's wait for that first.
   // There is a possible race condition, when the language is not yet detected,
   // so we check for that and wait if necessary.
   if (chrome_translate_client->GetLanguageState().original_language().empty())
     WaitUntilLanguageDetected();
 
   EXPECT_EQ("und",
             chrome_translate_client->GetLanguageState().original_language());
 
   // Open a new tab with a page in English.
   ResetObserver();
   AddTabAtIndex(0, GURL(embedded_test_server()->GetURL("/english_page.html")),
                 ui::PAGE_TRANSITION_TYPED);
-  current_web_contents = browser()->tab_strip_model()->GetActiveWebContents();
-  chrome_translate_client =
-      ChromeTranslateClient::FromWebContents(current_web_contents);
+  chrome_translate_client = GetChromeTranslateClient();
   WaitUntilLanguageDetected();
 
   EXPECT_EQ("en",
             chrome_translate_client->GetLanguageState().original_language());
 
   ResetObserver();
   // Now navigate to a page in French.
   ui_test_utils::NavigateToURL(
       browser(), GURL(embedded_test_server()->GetURL("/french_page.html")));
   WaitUntilLanguageDetected();
 
   EXPECT_EQ("fr",
             chrome_translate_client->GetLanguageState().original_language());
 }
 
 // Test that the translation was successful.
 IN_PROC_BROWSER_TEST_F(TranslateManagerBrowserTest, PageTranslationSuccess) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
-  content::WebContents* current_web_contents =
-      browser()->tab_strip_model()->GetActiveWebContents();
-  ChromeTranslateClient* chrome_translate_client =
-      ChromeTranslateClient::FromWebContents(current_web_contents);
+  ChromeTranslateClient* chrome_translate_client = GetChromeTranslateClient();
 
   // There is a possible race condition, when the language is not yet detected,
   // so we check for that and wait if necessary.
   if (chrome_translate_client->GetLanguageState().original_language().empty())
     WaitUntilLanguageDetected();
 
   EXPECT_EQ("und",
             chrome_translate_client->GetLanguageState().original_language());
 
   // Open a new tab with a page in French.
   ResetObserver();
   AddTabAtIndex(0, GURL(embedded_test_server()->GetURL("/french_page.html")),
                 ui::PAGE_TRANSITION_TYPED);
-  current_web_contents = browser()->tab_strip_model()->GetActiveWebContents();
-  chrome_translate_client =
-      ChromeTranslateClient::FromWebContents(current_web_contents);
+  chrome_translate_client = GetChromeTranslateClient();
   WaitUntilLanguageDetected();
 
   EXPECT_EQ("fr",
             chrome_translate_client->GetLanguageState().original_language());
 
   // Translate the page through TranslateManager.
   translate::TranslateManager* manager =
       chrome_translate_client->GetTranslateManager();
   manager->TranslatePage(
       chrome_translate_client->GetLanguageState().original_language(), "en",
       true);
 
-  SimulateURLFetch(true);
+  SimulateURLFetch(kTestValidScript, true);
 
   // Wait for NOTIFICATION_PAGE_TRANSLATED notification.
   WaitUntilPageTranslated();
 
   EXPECT_FALSE(chrome_translate_client->GetLanguageState().translation_error());
+  EXPECT_EQ(translate::TranslateErrors::NONE, GetPageTranslatedResult());

[Takashi Toyoshima, 2017/06/27 12:04:55]

This check fails because error_type_ wasn't initialized in
TranslateManagerBrowserTest and OnTranslateError() wasn't called on successful
case?

[Gaja, 2017/06/28 03:43:31]

This check does not fail with your suggestion i.e

"So, could you change the following condition not to check "error =
TranslateErrors::INITIALIZATION_ERROR" but to check "error !=
TranslateErrors:NONE" so that it can be robust for translate.js side code
changes?"

All the test cases in translate_manager_browsertest.cc passes, but two of the
test cases in translate_helper_browsertest.cc fails. They are 1)
TranslateHelperBrowserTest.TranslateLibNeverReady & 2)
TranslateHelperBrowserTest.TranslateSuccess

The reason is that, in TranslateLibNeverReady test case :

  EXPECT_CALL(*translate_helper_, IsTranslateLibReady())
      .Times(AtLeast(5))  // See kMaxTranslateInitCheckAttempts in
                          // translate_helper.cc
      .WillRepeatedly(Return(false));

when false if returned for first call, it goes inside below 'if' check

   if (!IsTranslateLibReady()) {
    // There was an error during initialization of library.
    TranslateErrors::Type error =
static_cast<translate::TranslateErrors::Type>(GetErrorCode());
    if (error != TranslateErrors::NONE) { //  Change suggested by you
      NotifyBrowserTranslationFailed(error);
      return;
    }

The GetErrorCode function returns default fallback value i.e TRANSLATION_ERROR
and exits from the function and test case fails with below error message.

  Actual function call count doesn't match EXPECT_CALL(*translate_helper_,
IsTranslateLibReady())...
         Expected: to be called at least 5 times
           Actual: called once - unsatisfied and active

This is the reason, why I added check only for INITIALIZATION_ERROR in Patch Set
6, like below, so that it does return from function on first call itself
(!IsTranslateLibReady()).

   TranslateErrors::Type error =
        static_cast<translate::TranslateErrors::Type>(GetErrorCode());
    if (error == TranslateErrors::INITIALIZATION_ERROR) {
      NotifyBrowserTranslationFailed(error);
      return;
    }

GetErrorCode returns fallback value is because we are passing empty string as
translate_script in the TranslateLibNeverReady test case.

  translate_helper_->TranslatePage("en", "fr", std::string());

Please correct me if I am wrong in any of the case above.

I think that the Patch Set 6 was more appropriate in error handling for all
cases (TranslateManagerBrowserTest & TranslateHelperBrowserTest), IMHO. Please
let me know your opinions and suggestions.

 }
 
 // Test if there was an error during translation.
 IN_PROC_BROWSER_TEST_F(TranslateManagerBrowserTest, PageTranslationError) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
-  content::WebContents* current_web_contents =
-      browser()->tab_strip_model()->GetActiveWebContents();
-  ChromeTranslateClient* chrome_translate_client =
-      ChromeTranslateClient::FromWebContents(current_web_contents);
+  ChromeTranslateClient* chrome_translate_client = GetChromeTranslateClient();
 
   // There is a possible race condition, when the language is not yet detected,
   // so we check for that and wait if necessary.
   if (chrome_translate_client->GetLanguageState().original_language().empty())
     WaitUntilLanguageDetected();
 
   EXPECT_EQ("und",
             chrome_translate_client->GetLanguageState().original_language());
 
   // Open a new tab with about:blank page.
   ResetObserver();
   AddTabAtIndex(0, GURL("about:blank"), ui::PAGE_TRANSITION_TYPED);
-  current_web_contents = browser()->tab_strip_model()->GetActiveWebContents();
-  chrome_translate_client =
-      ChromeTranslateClient::FromWebContents(current_web_contents);
-  WaitUntilLanguageDetected();
-
-  EXPECT_EQ("und",
-            chrome_translate_client->GetLanguageState().original_language());
-
-  // Translate the page through TranslateManager.
-  translate::TranslateManager* manager =
-      chrome_translate_client->GetTranslateManager();
+  chrome_translate_client = GetChromeTranslateClient();
+  WaitUntilLanguageDetected();
+
+  EXPECT_EQ("und",
+            chrome_translate_client->GetLanguageState().original_language());
+
+  // Translate the page through TranslateManager.
+  translate::TranslateManager* manager =
+      chrome_translate_client->GetTranslateManager();
+  manager->TranslatePage(
+      chrome_translate_client->GetLanguageState().original_language(), "en",
+      true);
+
+  SimulateURLFetch(kTestValidScript, true);
+
+  // Wait for NOTIFICATION_PAGE_TRANSLATED notification.
+  WaitUntilPageTranslated();
+
+  EXPECT_TRUE(chrome_translate_client->GetLanguageState().translation_error());
+  EXPECT_EQ(translate::TranslateErrors::TRANSLATION_ERROR,
+            GetPageTranslatedResult());
+}
+
+// Test if there was an error during translate library initialization.
+IN_PROC_BROWSER_TEST_F(TranslateManagerBrowserTest,
+                       PageTranslationInitializationError) {
+  ASSERT_TRUE(embedded_test_server()->Start());
+
+  ChromeTranslateClient* chrome_translate_client = GetChromeTranslateClient();
+
+  // There is a possible race condition, when the language is not yet detected,
+  // so we check for that and wait if necessary.
+  if (chrome_translate_client->GetLanguageState().original_language().empty())
+    WaitUntilLanguageDetected();
+
+  EXPECT_EQ("und",
+            chrome_translate_client->GetLanguageState().original_language());
+
+  // Open a new tab with a page in French.
+  ResetObserver();
+  AddTabAtIndex(0, GURL(embedded_test_server()->GetURL("/french_page.html")),
+                ui::PAGE_TRANSITION_TYPED);
+  chrome_translate_client = GetChromeTranslateClient();
+  WaitUntilLanguageDetected();
+
+  EXPECT_EQ("fr",
+            chrome_translate_client->GetLanguageState().original_language());
+
+  // Translate the page through TranslateManager.
+  translate::TranslateManager* manager =
+      chrome_translate_client->GetTranslateManager();
+  manager->TranslatePage(
+      chrome_translate_client->GetLanguageState().original_language(), "en",
+      true);
+
+  SimulateURLFetch(kTestScriptInitializationError, true);
+
+  // Wait for NOTIFICATION_PAGE_TRANSLATED notification.
+  WaitUntilPageTranslated();
+
+  EXPECT_TRUE(chrome_translate_client->GetLanguageState().translation_error());
+  EXPECT_EQ(translate::TranslateErrors::INITIALIZATION_ERROR,
+            GetPageTranslatedResult());
+}
+
+// Test the checks translate lib never gets ready and throws timeout.
+IN_PROC_BROWSER_TEST_F(TranslateManagerBrowserTest,
+                       PageTranslationTimeoutError) {
+  ASSERT_TRUE(embedded_test_server()->Start());
+
+  ChromeTranslateClient* chrome_translate_client = GetChromeTranslateClient();
+
+  // There is a possible race condition, when the language is not yet detected,
+  // so we check for that and wait if necessary.
+  if (chrome_translate_client->GetLanguageState().original_language().empty())
+    WaitUntilLanguageDetected();
+
+  EXPECT_EQ("und",
+            chrome_translate_client->GetLanguageState().original_language());
+
+  // Open a new tab with a page in French.
+  ResetObserver();
+  AddTabAtIndex(0, GURL(embedded_test_server()->GetURL("/french_page.html")),
+                ui::PAGE_TRANSITION_TYPED);
+  chrome_translate_client = GetChromeTranslateClient();
+  WaitUntilLanguageDetected();
+
+  EXPECT_EQ("fr",
+            chrome_translate_client->GetLanguageState().original_language());
+
+  // Translate the page through TranslateManager.
+  translate::TranslateManager* manager =
+      chrome_translate_client->GetTranslateManager();
+  manager->TranslatePage(
+      chrome_translate_client->GetLanguageState().original_language(), "en",
+      true);
+
+  SimulateURLFetch(kTestScriptTimeout, true);
+
+  // Wait for NOTIFICATION_PAGE_TRANSLATED notification.
+  WaitUntilPageTranslated();
+
+  EXPECT_TRUE(chrome_translate_client->GetLanguageState().translation_error());
+  EXPECT_EQ(translate::TranslateErrors::TRANSLATION_TIMEOUT,
+            GetPageTranslatedResult());
+}
+
+// Test the checks if both source and target languages mentioned are identical.
+IN_PROC_BROWSER_TEST_F(TranslateManagerBrowserTest,
+                       PageTranslationIdenticalLanguagesError) {
+  ASSERT_TRUE(embedded_test_server()->Start());
+
+  ChromeTranslateClient* chrome_translate_client = GetChromeTranslateClient();
+
+  // There is a possible race condition, when the language is not yet detected,
+  // so we check for that and wait if necessary.
+  if (chrome_translate_client->GetLanguageState().original_language().empty())
+    WaitUntilLanguageDetected();
+
+  EXPECT_EQ("und",
+            chrome_translate_client->GetLanguageState().original_language());
+
+  // Open a new tab with a page in French.
+  ResetObserver();
+  AddTabAtIndex(0, GURL(embedded_test_server()->GetURL("/french_page.html")),
+                ui::PAGE_TRANSITION_TYPED);
+  chrome_translate_client = GetChromeTranslateClient();
+  WaitUntilLanguageDetected();
+
+  EXPECT_EQ("fr",
+            chrome_translate_client->GetLanguageState().original_language());
+
+  // Translate the page through TranslateManager.
+  translate::TranslateManager* manager =
+      chrome_translate_client->GetTranslateManager();
+  manager->TranslatePage("aa", "aa", true);
+
+  SimulateURLFetch(kTestScriptIdenticalLanguages, true);
+
+  // Wait for NOTIFICATION_PAGE_TRANSLATED notification.
+  WaitUntilPageTranslated();
+
+  EXPECT_TRUE(chrome_translate_client->GetLanguageState().translation_error());
+  EXPECT_EQ(translate::TranslateErrors::IDENTICAL_LANGUAGES,
+            GetPageTranslatedResult());
+}
+
+// Test if there was an error during translatePage script execution.
+IN_PROC_BROWSER_TEST_F(TranslateManagerBrowserTest,
+                       PageTranslationUnexpectedScriptError) {
+  ASSERT_TRUE(embedded_test_server()->Start());
+
+  ChromeTranslateClient* chrome_translate_client = GetChromeTranslateClient();
+
+  // There is a possible race condition, when the language is not yet detected,
+  // so we check for that and wait if necessary.
+  if (chrome_translate_client->GetLanguageState().original_language().empty())
+    WaitUntilLanguageDetected();
+
+  EXPECT_EQ("und",
+            chrome_translate_client->GetLanguageState().original_language());
+
+  // Open a new tab with a page in French.
+  ResetObserver();
+  AddTabAtIndex(0, GURL(embedded_test_server()->GetURL("/french_page.html")),
+                ui::PAGE_TRANSITION_TYPED);
+  chrome_translate_client = GetChromeTranslateClient();
+  WaitUntilLanguageDetected();
+
+  EXPECT_EQ("fr",
+            chrome_translate_client->GetLanguageState().original_language());
+
+  // Translate the page through TranslateManager.
+  translate::TranslateManager* manager =
+      chrome_translate_client->GetTranslateManager();
+  manager->TranslatePage(
+      chrome_translate_client->GetLanguageState().original_language(), "en",
+      true);
+
+  SimulateURLFetch(kTestScriptUnexpectedScriptError, true);
+
+  // Wait for NOTIFICATION_PAGE_TRANSLATED notification.
+  WaitUntilPageTranslated();
+
+  EXPECT_TRUE(chrome_translate_client->GetLanguageState().translation_error());
+  EXPECT_EQ(translate::TranslateErrors::UNEXPECTED_SCRIPT_ERROR,
+            GetPageTranslatedResult());
+}
+
+// Test if securityOrigin mentioned in url is valid.
+IN_PROC_BROWSER_TEST_F(TranslateManagerBrowserTest,
+                       PageTranslationBadOriginError) {
+  ASSERT_TRUE(embedded_test_server()->Start());
+
+  ChromeTranslateClient* chrome_translate_client = GetChromeTranslateClient();
+
+  // There is a possible race condition, when the language is not yet detected,
+  // so we check for that and wait if necessary.
+  if (chrome_translate_client->GetLanguageState().original_language().empty())
+    WaitUntilLanguageDetected();
+
+  EXPECT_EQ("und",
+            chrome_translate_client->GetLanguageState().original_language());
+
+  // Open a new tab with a page in French.
+  ResetObserver();
+  AddTabAtIndex(0, GURL(embedded_test_server()->GetURL("/french_page.html")),
+                ui::PAGE_TRANSITION_TYPED);
+  chrome_translate_client = GetChromeTranslateClient();
+  WaitUntilLanguageDetected();
+
+  EXPECT_EQ("fr",
+            chrome_translate_client->GetLanguageState().original_language());
+
+  // Translate the page through TranslateManager.
+  translate::TranslateManager* manager =
+      chrome_translate_client->GetTranslateManager();
+  manager->TranslatePage(
+      chrome_translate_client->GetLanguageState().original_language(), "en",
+      true);
+
+  SimulateURLFetch(kTestScriptBadOrigin, true);
+
+  // Wait for NOTIFICATION_PAGE_TRANSLATED notification.
+  WaitUntilPageTranslated();
+
+  EXPECT_TRUE(chrome_translate_client->GetLanguageState().translation_error());
+  EXPECT_EQ(translate::TranslateErrors::BAD_ORIGIN, GetPageTranslatedResult());
+}
+
+// Test if there was an error during script load.
+IN_PROC_BROWSER_TEST_F(TranslateManagerBrowserTest,
+                       PageTranslationScriptLoadError) {
+  ASSERT_TRUE(embedded_test_server()->Start());
+
+  ChromeTranslateClient* chrome_translate_client = GetChromeTranslateClient();
+
+  // There is a possible race condition, when the language is not yet detected,
+  // so we check for that and wait if necessary.
+  if (chrome_translate_client->GetLanguageState().original_language().empty())
+    WaitUntilLanguageDetected();
+
+  EXPECT_EQ("und",
+            chrome_translate_client->GetLanguageState().original_language());
+
+  // Open a new tab with a page in French.
+  ResetObserver();
+  AddTabAtIndex(0, GURL(embedded_test_server()->GetURL("/french_page.html")),
+                ui::PAGE_TRANSITION_TYPED);
+  chrome_translate_client = GetChromeTranslateClient();
+  WaitUntilLanguageDetected();
+
+  EXPECT_EQ("fr",
+            chrome_translate_client->GetLanguageState().original_language());
+
+  // Translate the page through TranslateManager.
+  translate::TranslateManager* manager =
+      chrome_translate_client->GetTranslateManager();
   manager->TranslatePage(
       chrome_translate_client->GetLanguageState().original_language(), "en",
       true);
 
-  SimulateURLFetch(true);
+  SimulateURLFetch(kTestScriptLoadError, true);
 
   // Wait for NOTIFICATION_PAGE_TRANSLATED notification.
   WaitUntilPageTranslated();
 
   EXPECT_TRUE(chrome_translate_client->GetLanguageState().translation_error());
+  EXPECT_EQ(translate::TranslateErrors::SCRIPT_LOAD_ERROR,
+            GetPageTranslatedResult());
 }
 
 // Test that session restore restores the translate infobar and other translate
 // settings.
 IN_PROC_BROWSER_TEST_F(TranslateManagerBrowserTest,
                        PRE_TranslateSessionRestore) {
   SessionStartupPref pref(SessionStartupPref::LAST);
   SessionStartupPref::SetStartupPref(browser()->profile(), pref);
 
-  content::WebContents* current_web_contents =
-      browser()->tab_strip_model()->GetActiveWebContents();
-  ChromeTranslateClient* chrome_translate_client =
-      ChromeTranslateClient::FromWebContents(current_web_contents);
+  ChromeTranslateClient* chrome_translate_client = GetChromeTranslateClient();
 
   // There is a possible race condition, when the language is not yet detected,
   // so we check for that and wait if necessary.
   if (chrome_translate_client->GetLanguageState().original_language().empty())
     WaitUntilLanguageDetected();
 
   EXPECT_EQ("und",
             chrome_translate_client->GetLanguageState().original_language());
 
   ResetObserver();
 
   GURL french_url = ui_test_utils::GetTestUrl(
       base::FilePath(), base::FilePath(FILE_PATH_LITERAL("french_page.html")));
   ui_test_utils::NavigateToURL(browser(), french_url);
 
   WaitUntilLanguageDetected();
   EXPECT_EQ("fr",
             chrome_translate_client->GetLanguageState().original_language());
 }
 
 IN_PROC_BROWSER_TEST_F(TranslateManagerBrowserTest,
                        TranslateSessionRestore) {
-  content::WebContents* active_web_contents =
-      browser()->tab_strip_model()->GetActiveWebContents();
-  ChromeTranslateClient* active_translate_client =
-      ChromeTranslateClient::FromWebContents(active_web_contents);
+  ChromeTranslateClient* active_translate_client = GetChromeTranslateClient();
   if (active_translate_client->GetLanguageState().current_language().empty())
     WaitUntilLanguageDetected();
   EXPECT_EQ("und",
             active_translate_client->GetLanguageState().current_language());
 
   // Make restored tab active to (on some platforms) initiate language
   // detection.
   browser()->tab_strip_model()->ActivateTabAt(0, true);
 
   content::WebContents* restored_web_contents =
       browser()->tab_strip_model()->GetWebContentsAt(0);
   ChromeTranslateClient* restored_translate_client =
       ChromeTranslateClient::FromWebContents(restored_web_contents);
   if (restored_translate_client->GetLanguageState()
           .current_language()
           .empty()) {
     ResetObserver();
     WaitUntilLanguageDetected();
   }
   EXPECT_EQ("fr",
             restored_translate_client->GetLanguageState().current_language());
 }