[Translate] Migrate IPCs to Mojo interfaces.

chrome/browser/translate/translate_manager_render_view_host_unittest.cc

 // 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 <stddef.h>
 
 #include <algorithm>
 #include <memory>
 #include <set>
 #include <tuple>
@@ skipping 18 matching lines @@
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/infobars/core/infobar.h"
 #include "components/prefs/pref_change_registrar.h"
 #include "components/prefs/pref_service.h"
 #include "components/translate/content/browser/content_translate_driver.h"
-#include "components/translate/content/common/translate_messages.h"
+#include "components/translate/content/public/interfaces/translate.mojom.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_language_list.h"
 #include "components/translate/core/browser/translate_manager.h"
 #include "components/translate/core/browser/translate_prefs.h"
 #include "components/translate/core/browser/translate_script.h"
 #include "components/translate/core/browser/translate_ui_delegate.h"
 #include "components/translate/core/common/language_detection_details.h"
 #include "components/translate/core/common/translate_pref_names.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_registrar.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_renderer_host.h"
+#include "mojo/public/cpp/bindings/binding.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "third_party/WebKit/public/web/WebContextMenuData.h"
 #include "url/gurl.h"
 
 #if !defined(USE_AURA)
 #include "components/translate/core/browser/translate_infobar_delegate.h"
@@ skipping 41 matching lines @@
   }
 
   TranslateBubbleModel* model() { return model_.get(); }
 
  private:
   std::unique_ptr<TranslateBubbleModel> model_;
 
   DISALLOW_COPY_AND_ASSIGN(MockTranslateBubbleFactory);
 };
 
+class FakePageImpl : public translate::mojom::Page {
+ public:
+  FakePageImpl()
+      : called_translate_(false),
+        called_revert_translation_(false),
+        trans_callback_cancelled_(false),
+        trans_callback_error_(translate::TranslateErrors::NONE),
+        binding_(this) {}
+  ~FakePageImpl() override {}
+
+  translate::mojom::PagePtr BindToNewPagePtr() {
+    binding_.Close();
+    return binding_.CreateInterfacePtrAndBind();
+  }
+
+  // translate::mojom::Page implementation.
+  void Translate(const mojo::String& translate_script,
+                 const mojo::String& source_lang,
+                 const mojo::String& target_lang,
+                 const TranslateCallback& callback) override {
+    called_translate_ = true;
+    source_lang_ = source_lang.get();
+    target_lang_ = target_lang.get();
+
+    callback.Run(trans_callback_cancelled_, trans_callback_original_lang_,
+                 trans_callback_translated_lang_, trans_callback_error_);
+  }
+
+  void RevertTranslation() override { called_revert_translation_ = true; }
+
+  bool called_translate_;
+  base::Optional<std::string> source_lang_;
+  base::Optional<std::string> target_lang_;
+  bool called_revert_translation_;
+
+  bool trans_callback_cancelled_;
+  std::string trans_callback_original_lang_;
+  std::string trans_callback_translated_lang_;
+  translate::TranslateErrors::Type trans_callback_error_;
+
+ private:
+  mojo::Binding<translate::mojom::Page> binding_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakePageImpl);
+};
+
 }  // namespace
 
 // An observer that keeps track of whether a navigation entry was committed.
 class NavEntryCommittedObserver : public content::NotificationObserver {
  public:
   explicit NavEntryCommittedObserver(content::WebContents* web_contents) {
     registrar_.Add(this,
                    content::NOTIFICATION_NAV_ENTRY_COMMITTED,
                    content::Source<content::NavigationController>(
                        &web_contents->GetController()));
@@ skipping 103 matching lines @@
       Reload();
     else
       NavigateAndCommit(url);
     SimulateOnTranslateLanguageDetermined(lang, page_translatable);
   }
 
   void SimulateOnTranslateLanguageDetermined(const std::string& lang,
                                              bool page_translatable) {
     translate::LanguageDetectionDetails details;
     details.adopted_language = lang;
-    main_rfh()->OnMessageReceived(
-        ChromeFrameHostMsg_TranslateLanguageDetermined(0, details,
-                                                       page_translatable));
+    ChromeTranslateClient::FromWebContents(web_contents())
+        ->translate_driver()
+        .NewPage(fake_page_.BindToNewPagePtr(), details, page_translatable);
   }
 
-  void SimulateOnPageTranslated(int routing_id,
-                                const std::string& source_lang,
-                                const std::string& target_lang,
-                                translate::TranslateErrors::Type error) {
-    main_rfh()->OnMessageReceived(ChromeFrameHostMsg_PageTranslated(
-        routing_id, source_lang, target_lang, error));
+  void PreSetPageTranslatedResult(const std::string& source_lang,
+                                  const std::string& target_lang,
+                                  translate::TranslateErrors::Type error) {
+    fake_page_.trans_callback_cancelled_ = false;
+    fake_page_.trans_callback_original_lang_ = source_lang;
+    fake_page_.trans_callback_translated_lang_ = target_lang;
+    fake_page_.trans_callback_error_ = error;
   }
 
-  void SimulateOnPageTranslated(const std::string& source_lang,
-                                const std::string& target_lang) {
-    SimulateOnPageTranslated(
-        0, source_lang, target_lang, translate::TranslateErrors::NONE);
+  void PreSetPageTranslatedResult(const std::string& source_lang,
+                                  const std::string& target_lang) {
+    PreSetPageTranslatedResult(source_lang, target_lang,
+                               translate::TranslateErrors::NONE);
   }
 
-  bool GetTranslateMessage(std::string* original_lang,
-                           std::string* target_lang) {
-    const IPC::Message* message = process()->sink().GetFirstMessageMatching(
-        ChromeFrameMsg_TranslatePage::ID);
-    if (!message)
+  bool GetTranslateRequestAndReset(std::string* original_lang,
+                                   std::string* target_lang) {
+    if (!fake_page_.called_translate_)
       return false;
-    std::tuple<int, std::string, std::string, std::string> translate_param;
-    ChromeFrameMsg_TranslatePage::Read(message, &translate_param);
-    // Ignore get<0>(translate_param) which is the page seq no.
-    // Ignore get<1>(translate_param) which is the script injected in the page.
+    EXPECT_TRUE(fake_page_.source_lang_);
+    EXPECT_TRUE(fake_page_.target_lang_);
+
     if (original_lang)
-      *original_lang = std::get<2>(translate_param);
+      *original_lang = *fake_page_.source_lang_;
     if (target_lang)
-      *target_lang = std::get<3>(translate_param);
+      *target_lang = *fake_page_.target_lang_;
+
+    // Reset
+    fake_page_.called_translate_ = false;
+    fake_page_.source_lang_ = base::nullopt;
+    fake_page_.target_lang_ = base::nullopt;
+
     return true;
   }
 
   InfoBarService* infobar_service() {
     return InfoBarService::FromWebContents(web_contents());
   }
 
 #if !defined(USE_AURA)
   // Returns the translate infobar if there is 1 infobar and it is a translate
   // infobar.
@@ skipping 201 matching lines @@
 
  private:
   content::NotificationRegistrar notification_registrar_;
   net::TestURLFetcherFactory url_fetcher_factory_;
 
   // The infobars that have been removed.
   // WARNING: the pointers point to deleted objects, use only for comparison.
   std::set<infobars::InfoBarDelegate*> removed_infobars_;
 
   std::unique_ptr<MockTranslateBubbleFactory> bubble_factory_;
+  FakePageImpl fake_page_;
+
   DISALLOW_COPY_AND_ASSIGN(TranslateManagerRenderViewHostTest);
 };
 
 
 // A list of languages to fake being returned by the translate server.
 // Use only langauges for which Chrome's copy of ICU has
 // display names in English locale. To save space, Chrome's copy of ICU
 // does not have the display name for a language unless it's in the
 // Accept-Language list.
 static const char* server_language_list[] =
@@ skipping 90 matching lines @@
     if (lang == "xx")
       continue;
     EXPECT_NE(current_supported_languages.end(),
               std::find(current_supported_languages.begin(),
                         current_supported_languages.end(),
                         lang)) << "lang=" << lang;
     EXPECT_FALSE(translate::TranslateDownloadManager::IsAlphaLanguage(lang))
         << "lang=" << lang;
   }
 }
-
+#if 0
 // The rest of the tests in this file depend on the translate infobar. They
 // should be ported to use the translate bubble. On Aura there is no infobar
 // so the tests are not compiled.
 #if !defined(USE_AURA)

[leonhsl(Using Gerrit), 2016/07/15 12:43:22]

Hi, groby, would you please share with me how to get these test cases built and
run? Seems can't simply set gn args 'use_aura = false'... Thanks~

[groby-ooo-7-16, 2016/07/21 14:41:29]

aura is automatically enabled for Windows/Linux builds (see build/config/ui.gni)

Which means these test cases require to be built on OSX. (If you don't have an
OSX machine handy, just run it on the trybots. )

 TEST_F(TranslateManagerRenderViewHostTest, NormalTranslate) {
   // See BubbleNormalTranslate for corresponding bubble UX testing.
   if (TranslateService::IsTranslateBubbleEnabled())
     return;
 
   SimulateNavigation(GURL("http://www.google.fr"), "fr", true);
 
   // We should have an infobar.
   translate::TranslateInfoBarDelegate* infobar = GetTranslateInfoBar();
   ASSERT_TRUE(infobar != NULL);
   EXPECT_EQ(translate::TRANSLATE_STEP_BEFORE_TRANSLATE,
             infobar->translate_step());
 
+  // Preset the translation result values which will be returned back by fake
+  // render page.
+  PreSetPageTranslatedResult("fr", "en");
+
   // Simulate clicking translate.
-  process()->sink().ClearMessages();
   infobar->Translate();
 
   // The "Translating..." infobar should be showing.
   infobar = GetTranslateInfoBar();
   ASSERT_TRUE(infobar != NULL);
   EXPECT_EQ(translate::TRANSLATE_STEP_TRANSLATING, infobar->translate_step());
 
   // Simulate the translate script being retrieved (it only needs to be done
   // once in the test as it is cached).
   SimulateTranslateScriptURLFetch(true);
 
   // Test that we sent the right message to the renderer.
   std::string original_lang, target_lang;
-  EXPECT_TRUE(GetTranslateMessage(&original_lang, &target_lang));
+  EXPECT_TRUE(GetTranslateRequestAndReset(&original_lang, &target_lang));
   EXPECT_EQ("fr", original_lang);
   EXPECT_EQ("en", target_lang);
 
-  // Simulate the render notifying the translation has been done.
-  SimulateOnPageTranslated("fr", "en");
-
   // The after translate infobar should be showing.
   infobar = GetTranslateInfoBar();
   ASSERT_TRUE(infobar != NULL);
   EXPECT_EQ(translate::TRANSLATE_STEP_AFTER_TRANSLATE,
             infobar->translate_step());
 
   // Simulate changing the original language and translating.
-  process()->sink().ClearMessages();
   std::string new_original_lang = infobar->language_code_at(0);
   infobar->UpdateOriginalLanguage(new_original_lang);
+  // Preset the translation result values which will be returned back by fake
+  // render page.
+  PreSetPageTranslatedResult(new_original_lang, "en");
   infobar->Translate();
-  EXPECT_TRUE(GetTranslateMessage(&original_lang, &target_lang));
+  EXPECT_TRUE(GetTranslateRequestAndReset(&original_lang, &target_lang));
   EXPECT_EQ(new_original_lang, original_lang);
   EXPECT_EQ("en", target_lang);
-  // Simulate the render notifying the translation has been done.
-  SimulateOnPageTranslated(new_original_lang, "en");
   infobar = GetTranslateInfoBar();
   ASSERT_TRUE(infobar != NULL);
 
   // Simulate changing the target language and translating.
-  process()->sink().ClearMessages();
   std::string new_target_lang = infobar->language_code_at(1);
   infobar->UpdateTargetLanguage(new_target_lang);
+  // Preset the translation result values which will be returned back by fake
+  // render page.
+  PreSetPageTranslatedResult(new_original_lang, new_target_lang);
   infobar->Translate();
-  EXPECT_TRUE(GetTranslateMessage(&original_lang, &target_lang));
+  EXPECT_TRUE(GetTranslateRequestAndReset(&original_lang, &target_lang));
   EXPECT_EQ(new_original_lang, original_lang);
   EXPECT_EQ(new_target_lang, target_lang);
-  // Simulate the render notifying the translation has been done.
-  SimulateOnPageTranslated(new_original_lang, new_target_lang);
   infobar = GetTranslateInfoBar();
   ASSERT_TRUE(infobar != NULL);
   EXPECT_EQ(new_target_lang, infobar->target_language_code());
 
   // Reloading should trigger translation iff Always Translate is on.
   ReloadAndWait(true);
   infobar = GetTranslateInfoBar();
   ASSERT_TRUE(infobar != NULL);
   EXPECT_EQ(translate::TRANSLATE_STEP_BEFORE_TRANSLATE,
             infobar->translate_step());
@@ skipping 18 matching lines @@
   ASSERT_TRUE(infobar != NULL);
   EXPECT_EQ(translate::TRANSLATE_STEP_BEFORE_TRANSLATE,
             infobar->translate_step());
 
   // Simulate clicking translate.
   process()->sink().ClearMessages();
   infobar->Translate();
   SimulateTranslateScriptURLFetch(false);
 
   // We should not have sent any message to translate to the renderer.
-  EXPECT_FALSE(GetTranslateMessage(NULL, NULL));
+  EXPECT_FALSE(GetTranslateRequestAndReset(NULL, NULL));
 
   // And we should have an error infobar showing.
   infobar = GetTranslateInfoBar();
   ASSERT_TRUE(infobar != NULL);
   EXPECT_EQ(translate::TRANSLATE_STEP_TRANSLATE_ERROR,
             infobar->translate_step());
 }
 
 // Ensures we deal correctly with pages for which the browser does not recognize
 // the language (the translate server may or not detect the language).
@@ skipping 20 matching lines @@
   translate::TranslateInfoBarDelegate* infobar = GetTranslateInfoBar();
   ASSERT_TRUE(infobar != NULL);
   EXPECT_EQ(translate::TRANSLATE_STEP_TRANSLATE_ERROR,
             infobar->translate_step());
   EXPECT_TRUE(infobar->is_error());
   infobar->MessageInfoBarButtonPressed();
   SimulateTranslateScriptURLFetch(true);  // This time succeed.
 
   // Simulate the render notifying the translation has been done, the server
   // having detected the page was in a known and supported language.
-  SimulateOnPageTranslated("fr", "en");
+  PreSetPageTranslatedResult("fr", "en");
 
   // The after translate infobar should be showing.
   infobar = GetTranslateInfoBar();
   ASSERT_TRUE(infobar != NULL);
   EXPECT_EQ(translate::TRANSLATE_STEP_AFTER_TRANSLATE,
             infobar->translate_step());
   EXPECT_EQ("fr", infobar->original_language_code());
   EXPECT_EQ("en", infobar->target_language_code());
 
   // Let's run the same steps but this time the server detects the page is
   // already in English.
   SimulateNavigation(GURL("http://www.google.com"), "und", true);
   menu.reset(CreateContextMenu());
   menu->Init();
   menu->ExecuteCommand(IDC_CONTENT_CONTEXT_TRANSLATE, 0);
-  SimulateOnPageTranslated(
+  PreSetPageTranslatedResult(
       1, "en", "en", translate::TranslateErrors::IDENTICAL_LANGUAGES);
   infobar = GetTranslateInfoBar();
   ASSERT_TRUE(infobar != NULL);
   EXPECT_EQ(translate::TRANSLATE_STEP_TRANSLATE_ERROR,
             infobar->translate_step());
   EXPECT_EQ(translate::TranslateErrors::IDENTICAL_LANGUAGES,
             infobar->error_type());
 
   // Let's run the same steps again but this time the server fails to detect the
   // page's language (it returns an empty string).
   SimulateNavigation(GURL("http://www.google.com"), "und", true);
   menu.reset(CreateContextMenu());
   menu->Init();
   menu->ExecuteCommand(IDC_CONTENT_CONTEXT_TRANSLATE, 0);
-  SimulateOnPageTranslated(
+  PreSetPageTranslatedResult(
       2, std::string(), "en", translate::TranslateErrors::UNKNOWN_LANGUAGE);
   infobar = GetTranslateInfoBar();
   ASSERT_TRUE(infobar != NULL);
   EXPECT_EQ(translate::TRANSLATE_STEP_TRANSLATE_ERROR,
             infobar->translate_step());
   EXPECT_EQ(translate::TranslateErrors::UNKNOWN_LANGUAGE,
             infobar->error_type());
 }
 
 // Tests that we show/don't show an info-bar for the languages.
@@ skipping 38 matching lines @@
 }
 
 // Tests auto-translate on page.
 TEST_F(TranslateManagerRenderViewHostTest, AutoTranslateOnNavigate) {
   EnableBubbleTest();
 
   SimulateNavigation(GURL("http://www.google.fr"), "fr", true);
 
   SimulateTranslatePress();
   SimulateTranslateScriptURLFetch(true);
-  SimulateOnPageTranslated("fr", "en");
+  PreSetPageTranslatedResult("fr", "en");
 
   // Now navigate to a new page in the same language.
   process()->sink().ClearMessages();
   SimulateNavigation(GURL("http://news.google.fr"), "fr", true);
 
   // This should have automatically triggered a translation.
   std::string original_lang, target_lang;
-  EXPECT_TRUE(GetTranslateMessage(&original_lang, &target_lang));
+  EXPECT_TRUE(GetTranslateRequestAndReset(&original_lang, &target_lang));
   EXPECT_EQ("fr", original_lang);
   EXPECT_EQ("en", target_lang);
 
   // Now navigate to a page in a different language.
   process()->sink().ClearMessages();
   SimulateNavigation(GURL("http://news.google.es"), "es", true);
 
   // This should not have triggered a translate.
-  EXPECT_FALSE(GetTranslateMessage(&original_lang, &target_lang));
+  EXPECT_FALSE(GetTranslateRequestAndReset(&original_lang, &target_lang));
 }
 
 // Tests that multiple OnPageContents do not cause multiple infobars.
 TEST_F(TranslateManagerRenderViewHostTest, MultipleOnPageContents) {
   EnableBubbleTest();
 
   SimulateNavigation(GURL("http://www.google.fr"), "fr", true);
 
   // Simulate clicking 'Nope' (don't translate).
   EXPECT_TRUE(TranslateUiVisible());
@@ skipping 153 matching lines @@
        TranslateCloseInfoBarInPageNavigation) {
   EnableBubbleTest();
 
   SimulateNavigation(GURL("http://www.google.fr"), "fr", true);
 
   // Simulate the user translating.
   SimulateTranslatePress();
 
   // Simulate the translate script being retrieved.
   SimulateTranslateScriptURLFetch(true);
-  SimulateOnPageTranslated("fr", "en");
+  PreSetPageTranslatedResult("fr", "en");
 
   EXPECT_TRUE(CloseTranslateUi());
 
   // Navigate in page, no infobar should be shown.
   SimulateNavigation(GURL("http://www.google.fr/#ref1"), "fr", true);
   EXPECT_FALSE(TranslateUiVisible());
 
   // Navigate out of page, a new infobar should show.
   // Note that we navigate to a page in a different language so we don't trigger
   // the auto-translate feature (it would translate the page automatically and
   // the before translate infobar would not be shown).
   SimulateNavigation(GURL("http://www.google.de"), "de", true);
   EXPECT_TRUE(TranslateUiVisible());
 }
 
 // Tests that the after translate the infobar still shows when navigating
 // in-page.
 TEST_F(TranslateManagerRenderViewHostTest, TranslateInPageNavigation) {
   EnableBubbleTest();
 
   SimulateNavigation(GURL("http://www.google.fr"), "fr", true);
 
   // Simulate the user translating.
   SimulateTranslatePress();
   SimulateTranslateScriptURLFetch(true);
-  SimulateOnPageTranslated("fr", "en");
+  PreSetPageTranslatedResult("fr", "en");
   // The after translate UI is showing.
   EXPECT_TRUE(TranslateUiVisible());
 
   // Remember infobar, so removal can be verified.
   translate::TranslateInfoBarDelegate* infobar = nullptr;
   if (!TranslateService::IsTranslateBubbleEnabled())
     infobar = GetTranslateInfoBar();
 
   // Navigate out of page, a new infobar should show.
   // See note in TranslateCloseInfoBarInPageNavigation test on why it is
@@ skipping 24 matching lines @@
 // The translation server might return a language we don't support.
 TEST_F(TranslateManagerRenderViewHostTest, ServerReportsUnsupportedLanguage) {
   EnableBubbleTest();
 
   SimulateNavigation(GURL("http://mail.google.fr"), "fr", true);
   process()->sink().ClearMessages();
   SimulateTranslatePress();
   SimulateTranslateScriptURLFetch(true);
   // Simulate the render notifying the translation has been done, but it
   // reports a language we don't support.
-  SimulateOnPageTranslated("qbz", "en");
+  PreSetPageTranslatedResult("qbz", "en");
 
   // An error infobar should be showing to report that we don't support this
   // language.
   EXPECT_EQ(translate::TRANSLATE_STEP_TRANSLATE_ERROR, CurrentStep());
 
   // This infobar should have a button (so the string should not be empty).
   // The error string on bubbles is currently not retrievable.
   // TODO(http://crbug.com/589301): OSX does not have an error view (yet).
   if (!TranslateService::IsTranslateBubbleEnabled()) {
     translate::TranslateInfoBarDelegate* infobar = GetTranslateInfoBar();
@@ skipping 247 matching lines @@
   SimulateNavigation(GURL("http://www.google.fr"), "fr", true);
 
   // It should have triggered an automatic translation to English.
 
   // The translating infobar should be showing.
   translate::TranslateInfoBarDelegate* infobar = GetTranslateInfoBar();
   ASSERT_TRUE(infobar != NULL);
   EXPECT_EQ(translate::TRANSLATE_STEP_TRANSLATING, infobar->translate_step());
   SimulateTranslateScriptURLFetch(true);
   std::string original_lang, target_lang;
-  EXPECT_TRUE(GetTranslateMessage(&original_lang, &target_lang));
+  EXPECT_TRUE(GetTranslateRequestAndReset(&original_lang, &target_lang));
   EXPECT_EQ("fr", original_lang);
   EXPECT_EQ("en", target_lang);
   process()->sink().ClearMessages();
 
   // Try another language, it should not be autotranslated.
   SimulateNavigation(GURL("http://www.google.es"), "es", true);
-  EXPECT_FALSE(GetTranslateMessage(&original_lang, &target_lang));
+  EXPECT_FALSE(GetTranslateRequestAndReset(&original_lang, &target_lang));
   EXPECT_TRUE(GetTranslateInfoBar() != NULL);
   EXPECT_TRUE(CloseTranslateInfoBar());
 
   // Let's switch to incognito mode, it should not be autotranslated in that
   // case either.
   TestingProfile* test_profile =
       static_cast<TestingProfile*>(web_contents()->GetBrowserContext());
   test_profile->ForceIncognito(true);
   SimulateNavigation(GURL("http://www.youtube.fr"), "fr", true);
-  EXPECT_FALSE(GetTranslateMessage(&original_lang, &target_lang));
+  EXPECT_FALSE(GetTranslateRequestAndReset(&original_lang, &target_lang));
   EXPECT_TRUE(GetTranslateInfoBar() != NULL);
   EXPECT_TRUE(CloseTranslateInfoBar());
   test_profile->ForceIncognito(false);  // Get back to non incognito.
 
   // Now revert the always translate pref and make sure we go back to expected
   // behavior, which is show a "before translate" infobar.
   SetPrefObserverExpectation(
       translate::TranslatePrefs::kPrefTranslateWhitelists);
   translate_prefs->RemoveLanguagePairFromWhitelist("fr", "en");
   SimulateNavigation(GURL("http://www.google.fr"), "fr", true);
-  EXPECT_FALSE(GetTranslateMessage(&original_lang, &target_lang));
+  EXPECT_FALSE(GetTranslateRequestAndReset(&original_lang, &target_lang));
   infobar = GetTranslateInfoBar();
   ASSERT_TRUE(infobar != NULL);
   EXPECT_EQ(translate::TRANSLATE_STEP_BEFORE_TRANSLATE,
             infobar->translate_step());
 }
 
 // Context menu.
 TEST_F(TranslateManagerRenderViewHostTest, ContextMenu) {
   // TODO(port): Test corresponding bubble translate UX: http://crbug.com/383235
   if (TranslateService::IsTranslateBubbleEnabled())
@@ skipping 28 matching lines @@
   // Use the menu to translate the page.
   menu->ExecuteCommand(IDC_CONTENT_CONTEXT_TRANSLATE, 0);
 
   // That should have triggered a translation.
   // The "translating..." infobar should be showing.
   translate::TranslateInfoBarDelegate* infobar = GetTranslateInfoBar();
   ASSERT_TRUE(infobar != NULL);
   EXPECT_EQ(translate::TRANSLATE_STEP_TRANSLATING, infobar->translate_step());
   SimulateTranslateScriptURLFetch(true);
   std::string original_lang, target_lang;
-  EXPECT_TRUE(GetTranslateMessage(&original_lang, &target_lang));
+  EXPECT_TRUE(GetTranslateRequestAndReset(&original_lang, &target_lang));
   EXPECT_EQ("fr", original_lang);
   EXPECT_EQ("en", target_lang);
   process()->sink().ClearMessages();
 
   // This should also have reverted the blacklisting of this site and language.
   EXPECT_FALSE(translate_prefs->IsBlockedLanguage("fr"));
   EXPECT_FALSE(translate_prefs->IsSiteBlacklisted(url.host()));
 
   // Let's simulate the page being translated.
-  SimulateOnPageTranslated("fr", "en");
+  PreSetPageTranslatedResult("fr", "en");
 
   // The translate menu should now be disabled.
   menu.reset(CreateContextMenu());
   menu->Init();
   EXPECT_TRUE(menu->IsItemPresent(IDC_CONTENT_CONTEXT_TRANSLATE));
   EXPECT_FALSE(menu->IsCommandIdEnabled(IDC_CONTENT_CONTEXT_TRANSLATE));
 
   // Test that selecting translate in the context menu WHILE the page is being
   // translated does nothing (this could happen if autotranslate kicks-in and
   // the user selects the menu while the translation is being performed).
   SimulateNavigation(GURL("http://www.google.es"), "es", true);
   infobar = GetTranslateInfoBar();
   ASSERT_TRUE(infobar != NULL);
   infobar->Translate();
-  EXPECT_TRUE(GetTranslateMessage(&original_lang, &target_lang));
+  EXPECT_TRUE(GetTranslateRequestAndReset(&original_lang, &target_lang));
   process()->sink().ClearMessages();
   menu.reset(CreateContextMenu());
   menu->Init();
   EXPECT_TRUE(menu->IsCommandIdEnabled(IDC_CONTENT_CONTEXT_TRANSLATE));
   menu->ExecuteCommand(IDC_CONTENT_CONTEXT_TRANSLATE, 0);
   // No message expected since the translation should have been ignored.
-  EXPECT_FALSE(GetTranslateMessage(&original_lang, &target_lang));
+  EXPECT_FALSE(GetTranslateRequestAndReset(&original_lang, &target_lang));
 
   // Now test that selecting translate in the context menu AFTER the page has
   // been translated does nothing.
   SimulateNavigation(GURL("http://www.google.de"), "de", true);
   infobar = GetTranslateInfoBar();
   ASSERT_TRUE(infobar != NULL);
   infobar->Translate();
-  EXPECT_TRUE(GetTranslateMessage(&original_lang, &target_lang));
+  EXPECT_TRUE(GetTranslateRequestAndReset(&original_lang, &target_lang));
   process()->sink().ClearMessages();
   menu.reset(CreateContextMenu());
   menu->Init();
   EXPECT_TRUE(menu->IsCommandIdEnabled(IDC_CONTENT_CONTEXT_TRANSLATE));
-  SimulateOnPageTranslated("de", "en");
+  PreSetPageTranslatedResult("de", "en");
   menu->ExecuteCommand(IDC_CONTENT_CONTEXT_TRANSLATE, 0);
   // No message expected since the translation should have been ignored.
-  EXPECT_FALSE(GetTranslateMessage(&original_lang, &target_lang));
+  EXPECT_FALSE(GetTranslateRequestAndReset(&original_lang, &target_lang));
 
   // Test that the translate context menu is enabled when the page is in an
   // unknown language.
   SimulateNavigation(url, "und", true);
   menu.reset(CreateContextMenu());
   menu->Init();
   EXPECT_TRUE(menu->IsItemPresent(IDC_CONTENT_CONTEXT_TRANSLATE));
   EXPECT_TRUE(menu->IsCommandIdEnabled(IDC_CONTENT_CONTEXT_TRANSLATE));
 
   // Test that the translate context menu is enabled even if the page is in an
@@ skipping 47 matching lines @@
       test_profile->ForceIncognito(false);
   }
   // Simulate the user pressing "Always translate French".
   infobar->AlwaysTranslatePageLanguage();
   EXPECT_TRUE(translate_prefs->IsLanguagePairWhitelisted("fr", "en"));
   // Simulate the translate script being retrieved (it only needs to be done
   // once in the test as it is cached).
   SimulateTranslateScriptURLFetch(true);
   // That should have triggered a page translate.
   std::string original_lang, target_lang;
-  EXPECT_TRUE(GetTranslateMessage(&original_lang, &target_lang));
+  EXPECT_TRUE(GetTranslateRequestAndReset(&original_lang, &target_lang));
   process()->sink().ClearMessages();
 
   // Now test that declining the translation causes a "never translate" button
   // to be shown (in non incognito mode only).
   test_profile->ForceIncognito(true);
   for (int i = 0; i < 8; ++i) {
     SCOPED_TRACE(::testing::Message() << "Iteration " << i << " incognito mode="
                                       << test_profile->IsOffTheRecord());
     SimulateNavigation(GURL("http://www.google.de"), "de", true);
     infobar = GetTranslateInfoBar();
     ASSERT_TRUE(infobar != NULL);
     EXPECT_EQ(translate::TRANSLATE_STEP_BEFORE_TRANSLATE,
               infobar->translate_step());
     if (i < 7) {
       EXPECT_FALSE(infobar->ShouldShowNeverTranslateShortcut());
       infobar->TranslationDeclined();
     } else {
       EXPECT_TRUE(infobar->ShouldShowNeverTranslateShortcut());
     }
     if (i == 3)
       test_profile->ForceIncognito(false);
   }
   // Simulate the user pressing "Never translate French".
   infobar->NeverTranslatePageLanguage();
   EXPECT_TRUE(translate_prefs->IsBlockedLanguage("de"));
   // No translation should have occured and the infobar should be gone.
-  EXPECT_FALSE(GetTranslateMessage(&original_lang, &target_lang));
+  EXPECT_FALSE(GetTranslateRequestAndReset(&original_lang, &target_lang));
   process()->sink().ClearMessages();
   ASSERT_TRUE(GetTranslateInfoBar() == NULL);
 }
 
 // Tests that we don't show a translate infobar when a page instructs that it
 // should not be translated.
 TEST_F(TranslateManagerRenderViewHostTest, NonTranslatablePage) {
   // TODO(port): Test corresponding bubble translate UX: http://crbug.com/383235
   if (TranslateService::IsTranslateBubbleEnabled())
     return;
@@ skipping 17 matching lines @@
     return;
 
   ExpireTranslateScriptImmediately();
 
   SimulateNavigation(GURL("http://www.google.fr"), "fr", true);
   translate::TranslateInfoBarDelegate* infobar = GetTranslateInfoBar();
   ASSERT_TRUE(infobar != NULL);
   process()->sink().ClearMessages();
   infobar->Translate();
   SimulateTranslateScriptURLFetch(true);
-  SimulateOnPageTranslated("fr", "en");
+  PreSetPageTranslatedResult("fr", "en");
 
   // A task should have been posted to clear the script, run it.
   base::RunLoop().RunUntilIdle();
 
   // Do another navigation and translation.
   SimulateNavigation(GURL("http://www.google.es"), "es", true);
   infobar = GetTranslateInfoBar();
   ASSERT_TRUE(infobar != NULL);
   process()->sink().ClearMessages();
   infobar->Translate();
   // If we don't simulate the URL fetch, the TranslateManager should be waiting
   // for the script and no message should have been sent to the renderer.
   EXPECT_TRUE(process()->sink().GetFirstMessageMatching(
                   ChromeFrameMsg_TranslatePage::ID) == NULL);
   // Now simulate the URL fetch.
   SimulateTranslateScriptURLFetch(true);
   // Now the message should have been sent.
   std::string original_lang, target_lang;
-  EXPECT_TRUE(GetTranslateMessage(&original_lang, &target_lang));
+  EXPECT_TRUE(GetTranslateRequestAndReset(&original_lang, &target_lang));
   EXPECT_EQ("es", original_lang);
   EXPECT_EQ("en", target_lang);
 }
 
 TEST_F(TranslateManagerRenderViewHostTest, DownloadsAndHistoryNotTranslated) {
   ASSERT_FALSE(
       TranslateService::IsTranslatableURL(GURL(chrome::kChromeUIDownloadsURL)));
   ASSERT_FALSE(
       TranslateService::IsTranslatableURL(GURL(chrome::kChromeUIHistoryURL)));
 }
@@ skipping 25 matching lines @@
   bubble = factory->model();
   ASSERT_TRUE(bubble != NULL);
   EXPECT_EQ(TranslateBubbleModel::VIEW_STATE_TRANSLATING,
             bubble->GetViewState());
 
   // Simulate the translate script being retrieved (it only needs to be done
   // once in the test as it is cached).
   SimulateTranslateScriptURLFetch(true);
 
   // Simulate the render notifying the translation has been done.
-  SimulateOnPageTranslated("fr", "en");
+  PreSetPageTranslatedResult("fr", "en");
 
   // Check the bubble shows "Translated."
   bubble = factory->model();
   ASSERT_TRUE(bubble != NULL);
   EXPECT_EQ(TranslateBubbleModel::VIEW_STATE_AFTER_TRANSLATE,
             bubble->GetViewState());
 }
 
 TEST_F(TranslateManagerRenderViewHostTest, BubbleTranslateScriptNotAvailable) {
   // See TranslateScriptNotAvailable for corresponding infobar UX testing.
@@ skipping 13 matching lines @@
   ASSERT_TRUE(bubble != NULL);
   EXPECT_EQ(TranslateBubbleModel::VIEW_STATE_BEFORE_TRANSLATE,
             bubble->GetViewState());
 
   // Simulate clicking translate.
   process()->sink().ClearMessages();
   bubble->Translate();
   SimulateTranslateScriptURLFetch(false);
 
   // We should not have sent any message to translate to the renderer.
-  EXPECT_FALSE(GetTranslateMessage(NULL, NULL));
+  EXPECT_FALSE(GetTranslateRequestAndReset(NULL, NULL));
 
   // And we should have an error infobar showing.
   bubble = factory->model();
   ASSERT_TRUE(bubble != NULL);
   EXPECT_EQ(TranslateBubbleModel::VIEW_STATE_ERROR, bubble->GetViewState());
 }
 
 TEST_F(TranslateManagerRenderViewHostTest, BubbleUnknownLanguage) {
   // See TranslateUnknownLanguage for corresponding infobar UX testing.
   if (!TranslateService::IsTranslateBubbleEnabled())
@@ skipping 17 matching lines @@
 
   // Check the bubble exists instead of the infobar.
   translate::TranslateInfoBarDelegate* infobar = GetTranslateInfoBar();
   ASSERT_TRUE(infobar == NULL);
   TranslateBubbleModel* bubble = factory->model();
   ASSERT_TRUE(bubble != NULL);
   EXPECT_EQ(TranslateBubbleModel::VIEW_STATE_TRANSLATING,
             bubble->GetViewState());
 }
 #endif  // defined(USE_AURA)
+#endif