Renames TranslateHelper to TranslateAgent for consistency

Also renames translate::mojom::Page interface to
translate::mojom::TranslateAgent

No functional changes.

Bug: 1043351
Change-Id: I2994e1219ff95aadd3fd650ebb1ee79e7d7b37e1
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2007319Reviewed-by: Ken Buchanan <kenrb@chromium.org>
Reviewed-by: Theresa  <twellington@chromium.org>
Reviewed-by: anthonyvd <anthonyvd@chromium.org>
Commit-Queue: Doug Arnett <dougarnett@chromium.org>
Cr-Commit-Position: refs/heads/master@{#735496}

chrome/browser/translate/translate_fake_page.cc

@@ -37,20 +37,21 @@
 
 FakePageImpl::FakePageImpl()
     : called_translate_(false), called_revert_translation_(false) {}
+
 FakePageImpl::~FakePageImpl() {}
 
-mojo::PendingRemote<translate::mojom::Page>
+mojo::PendingRemote<translate::mojom::TranslateAgent>
 FakePageImpl::BindToNewPageRemote() {
   receiver_.reset();
   translate_callback_pending_.Reset();
   return receiver_.BindNewPipeAndPassRemote();
 }
 
-// translate::mojom::Page implementation.
-void FakePageImpl::Translate(const std::string& translate_script,
-                             const std::string& source_lang,
-                             const std::string& target_lang,
-                             TranslateCallback callback) {
+// translate::mojom::TranslateAgent implementation.
+void FakePageImpl::TranslateFrame(const std::string& translate_script,
+                                  const std::string& source_lang,
+                                  const std::string& target_lang,
+                                  TranslateFrameCallback callback) {
   // Ensure pending callback gets called.
   if (translate_callback_pending_) {
     std::move(translate_callback_pending_)

chrome/browser/translate/translate_fake_page.h

@@ -40,18 +40,18 @@
 #include "mojo/public/cpp/bindings/receiver.h"
 #include "url/gurl.h"
 
-class FakePageImpl : public translate::mojom::Page {
+class FakePageImpl : public translate::mojom::TranslateAgent {
  public:
   FakePageImpl();
   ~FakePageImpl() override;
 
-  mojo::PendingRemote<translate::mojom::Page> BindToNewPageRemote();
+  mojo::PendingRemote<translate::mojom::TranslateAgent> BindToNewPageRemote();
 
-  // translate::mojom::Page implementation.
-  void Translate(const std::string& translate_script,
-                 const std::string& source_lang,
-                 const std::string& target_lang,
-                 TranslateCallback callback) override;
+  // translate::mojom::TranslateAgent implementation.
+  void TranslateFrame(const std::string& translate_script,
+                      const std::string& source_lang,
+                      const std::string& target_lang,
+                      TranslateFrameCallback callback) override;
 
   void RevertTranslation() override;
 
@@ -66,8 +66,8 @@ class FakePageImpl : public translate::mojom::Page {
   bool called_revert_translation_;
 
  private:
-  TranslateCallback translate_callback_pending_;
-  mojo::Receiver<translate::mojom::Page> receiver_{this};
+  TranslateFrameCallback translate_callback_pending_;
+  mojo::Receiver<translate::mojom::TranslateAgent> receiver_{this};
   DISALLOW_COPY_AND_ASSIGN(FakePageImpl);
 };
 

chrome/renderer/chrome_render_frame_observer.cc

@@ -29,7 +29,7 @@
 #include "components/crash/core/common/crash_key.h"
 #include "components/offline_pages/buildflags/buildflags.h"
 #include "components/safe_browsing/buildflags.h"
-#include "components/translate/content/renderer/translate_helper.h"
+#include "components/translate/content/renderer/translate_agent.h"
 #include "components/web_cache/renderer/web_cache_impl.h"
 #include "content/public/common/bindings_policy.h"
 #include "content/public/renderer/render_frame.h"
@@ -137,7 +137,7 @@ ChromeRenderFrameObserver::ChromeRenderFrameObserver(
     content::RenderFrame* render_frame,
     web_cache::WebCacheImpl* web_cache_impl)
     : content::RenderFrameObserver(render_frame),
-      translate_helper_(nullptr),
+      translate_agent_(nullptr),
       phishing_classifier_(nullptr),
       web_cache_impl_(web_cache_impl) {
   render_frame->GetAssociatedInterfaceRegistry()->AddInterface(
@@ -153,7 +153,7 @@ ChromeRenderFrameObserver::ChromeRenderFrameObserver(
   if (!command_line.HasSwitch(switches::kDisableClientSidePhishingDetection))
     SetClientSidePhishingDetection(true);
 #endif
-  translate_helper_ = new translate::TranslateHelper(
+  translate_agent_ = new translate::TranslateAgent(
       render_frame, ISOLATED_WORLD_ID_TRANSLATE, extensions::kExtensionScheme);
 }
 
@@ -375,11 +375,11 @@ void ChromeRenderFrameObserver::ReadyToCommitNavigation(
   if (render_frame()->IsMainFrame() && web_cache_impl_)
     web_cache_impl_->ExecutePendingClearCache();
 
-  // Let translate_helper do any preparatory work for loading a URL.
-  if (!translate_helper_)
+  // Let translate_agent do any preparatory work for loading a URL.
+  if (!translate_agent_)
     return;
 
-  translate_helper_->PrepareForUrl(
+  translate_agent_->PrepareForUrl(
       render_frame()->GetWebFrame()->GetDocument().Url());
 }
 
@@ -453,8 +453,8 @@ void ChromeRenderFrameObserver::CapturePageText(TextCaptureType capture_type) {
 
   // We should run language detection only once. Parsing finishes before
   // the page loads, so let's pick that timing.
-  if (translate_helper_ && capture_type == PRELIMINARY_CAPTURE) {
-    translate_helper_->PageCaptured(contents);
+  if (translate_agent_ && capture_type == PRELIMINARY_CAPTURE) {
+    translate_agent_->PageCaptured(contents);
   }
 
   TRACE_EVENT0("renderer", "ChromeRenderFrameObserver::CapturePageText");

chrome/renderer/chrome_render_frame_observer.h

@@ -25,7 +25,7 @@ class PhishingClassifierDelegate;
 }
 
 namespace translate {
-class TranslateHelper;
+class TranslateAgent;
 }
 
 namespace web_cache {
@@ -104,7 +104,7 @@ class ChromeRenderFrameObserver : public content::RenderFrameObserver,
                             base::TimeDelta delay);
 
   // Have the same lifetime as us.
-  translate::TranslateHelper* translate_helper_;
+  translate::TranslateAgent* translate_agent_;
   safe_browsing::PhishingClassifierDelegate* phishing_classifier_;
 
   // Owned by ChromeContentRendererClient and outlive us.

chrome/renderer/chrome_render_frame_observer_browsertest.cc

@@ -11,7 +11,7 @@
 #include "base/test/metrics/histogram_tester.h"
 #include "chrome/test/base/chrome_render_view_test.h"
 #include "components/translate/content/common/translate.mojom.h"
-#include "components/translate/content/renderer/translate_helper.h"
+#include "components/translate/content/renderer/translate_agent.h"
 #include "components/translate/core/common/translate_constants.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_view.h"
@@ -38,9 +38,10 @@ class FakeContentTranslateDriver
   }
 
   // translate::mojom::ContentTranslateDriver implementation.
-  void RegisterPage(mojo::PendingRemote<translate::mojom::Page> page,
-                    const translate::LanguageDetectionDetails& details,
-                    bool page_needs_translation) override {
+  void RegisterPage(
+      mojo::PendingRemote<translate::mojom::TranslateAgent> translate_agent,
+      const translate::LanguageDetectionDetails& details,
+      bool page_needs_translation) override {
     called_new_page_ = true;
     page_needs_translation_ = page_needs_translation;
   }

chrome/renderer/translate/translate_helper_browsertest.cc → chrome/renderer/translate/translate_agent_browsertest.cc

@@ -11,7 +11,7 @@
 #include "chrome/common/chrome_isolated_world_ids.h"
 #include "chrome/test/base/chrome_render_view_test.h"
 #include "components/translate/content/common/translate.mojom.h"
-#include "components/translate/content/renderer/translate_helper.h"
+#include "components/translate/content/renderer/translate_agent.h"
 #include "components/translate/core/common/translate_constants.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_view.h"
@@ -24,9 +24,9 @@
 #include "third_party/blink/public/common/browser_interface_broker_proxy.h"
 #include "third_party/blink/public/web/web_local_frame.h"
 
+using testing::_;
 using testing::AtLeast;
 using testing::Return;
-using testing::_;
 
 namespace {
 
@@ -44,9 +44,10 @@ class FakeContentTranslateDriver
   }
 
   // translate::mojom::ContentTranslateDriver implementation.
-  void RegisterPage(mojo::PendingRemote<translate::mojom::Page> page,
-                    const translate::LanguageDetectionDetails& details,
-                    bool page_needs_translation) override {
+  void RegisterPage(
+      mojo::PendingRemote<translate::mojom::TranslateAgent> translate_agent,
+      const translate::LanguageDetectionDetails& details,
+      bool page_needs_translation) override {
     called_new_page_ = true;
     details_ = details;
     page_needs_translation_ = page_needs_translation;
@@ -68,12 +69,12 @@ class FakeContentTranslateDriver
 
 }  // namespace
 
-class TestTranslateHelper : public translate::TranslateHelper {
+class TestTranslateAgent : public translate::TranslateAgent {
  public:
-  explicit TestTranslateHelper(content::RenderFrame* render_frame)
-      : translate::TranslateHelper(render_frame,
-                                   ISOLATED_WORLD_ID_TRANSLATE,
-                                   extensions::kExtensionScheme) {}
+  explicit TestTranslateAgent(content::RenderFrame* render_frame)
+      : translate::TranslateAgent(render_frame,
+                                  ISOLATED_WORLD_ID_TRANSLATE,
+                                  extensions::kExtensionScheme) {}
 
   base::TimeDelta AdjustDelay(int delayInMs) override {
     // Just returns base::TimeDelta() which has initial value 0.
@@ -92,9 +93,9 @@ class TestTranslateHelper : public translate::TranslateHelper {
     trans_result_error_type_ = translate::TranslateErrors::NONE;
 
     // Will get new result values via OnPageTranslated.
-    Translate(translate_script, source_lang, target_lang,
-              base::Bind(&TestTranslateHelper::OnPageTranslated,
-                         base::Unretained(this)));
+    TranslateFrame(translate_script, source_lang, target_lang,
+                   base::Bind(&TestTranslateAgent::OnPageTranslated,
+                              base::Unretained(this)));
   }
 
   bool GetPageTranslatedResult(std::string* original_lang,
@@ -143,17 +144,17 @@ class TestTranslateHelper : public translate::TranslateHelper {
   base::Optional<std::string> trans_result_translated_lang_;
   translate::TranslateErrors::Type trans_result_error_type_;
 
-  DISALLOW_COPY_AND_ASSIGN(TestTranslateHelper);
+  DISALLOW_COPY_AND_ASSIGN(TestTranslateAgent);
 };
 
-class TranslateHelperBrowserTest : public ChromeRenderViewTest {
+class TranslateAgentBrowserTest : public ChromeRenderViewTest {
  public:
-  TranslateHelperBrowserTest() : translate_helper_(NULL) {}
+  TranslateAgentBrowserTest() : translate_agent_(nullptr) {}
 
  protected:
   void SetUp() override {
     ChromeRenderViewTest::SetUp();
-    translate_helper_ = new TestTranslateHelper(view_->GetMainRenderFrame());
+    translate_agent_ = new TestTranslateAgent(view_->GetMainRenderFrame());
 
     view_->GetMainRenderFrame()
         ->GetBrowserInterfaceBroker()
@@ -169,82 +170,82 @@ class TranslateHelperBrowserTest : public ChromeRenderViewTest {
         ->SetBinderForTesting(translate::mojom::ContentTranslateDriver::Name_,
                               {});
 
-    delete translate_helper_;
+    delete translate_agent_;
     ChromeRenderViewTest::TearDown();
   }
 
-  TestTranslateHelper* translate_helper_;
+  TestTranslateAgent* translate_agent_;
   FakeContentTranslateDriver fake_translate_driver_;
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(TranslateHelperBrowserTest);
+  DISALLOW_COPY_AND_ASSIGN(TranslateAgentBrowserTest);
 };
 
 // Tests that the browser gets notified of the translation failure if the
 // translate library fails/times-out during initialization.
-TEST_F(TranslateHelperBrowserTest, TranslateLibNeverReady) {
+TEST_F(TranslateAgentBrowserTest, TranslateLibNeverReady) {
   // We make IsTranslateLibAvailable true so we don't attempt to inject the
   // library.
-  EXPECT_CALL(*translate_helper_, IsTranslateLibAvailable())
+  EXPECT_CALL(*translate_agent_, IsTranslateLibAvailable())
       .Times(AtLeast(1))
       .WillRepeatedly(Return(true));
 
-  EXPECT_CALL(*translate_helper_, IsTranslateLibReady())
+  EXPECT_CALL(*translate_agent_, IsTranslateLibReady())
       .Times(AtLeast(5))  // See kMaxTranslateInitCheckAttempts in
-                          // translate_helper.cc
+                          // translate_agent.cc
       .WillRepeatedly(Return(false));
 
-  EXPECT_CALL(*translate_helper_, GetErrorCode())
+  EXPECT_CALL(*translate_agent_, GetErrorCode())
       .Times(AtLeast(5))
       .WillRepeatedly(Return(translate::TranslateErrors::NONE));
 
-  translate_helper_->TranslatePage("en", "fr", std::string());
+  translate_agent_->TranslatePage("en", "fr", std::string());
   base::RunLoop().RunUntilIdle();
 
   translate::TranslateErrors::Type error;
-  ASSERT_TRUE(translate_helper_->GetPageTranslatedResult(NULL, NULL, &error));
+  ASSERT_TRUE(
+      translate_agent_->GetPageTranslatedResult(nullptr, nullptr, &error));
   EXPECT_EQ(translate::TranslateErrors::TRANSLATION_TIMEOUT, error);
 }
 
 // Tests that the browser gets notified of the translation success when the
 // translation succeeds.
-TEST_F(TranslateHelperBrowserTest, TranslateSuccess) {
+TEST_F(TranslateAgentBrowserTest, TranslateSuccess) {
   // We make IsTranslateLibAvailable true so we don't attempt to inject the
   // library.
-  EXPECT_CALL(*translate_helper_, IsTranslateLibAvailable())
+  EXPECT_CALL(*translate_agent_, IsTranslateLibAvailable())
       .Times(AtLeast(1))
       .WillRepeatedly(Return(true));
 
-  EXPECT_CALL(*translate_helper_, IsTranslateLibReady())
+  EXPECT_CALL(*translate_agent_, IsTranslateLibReady())
       .WillOnce(Return(false))
       .WillOnce(Return(true));
 
-  EXPECT_CALL(*translate_helper_, GetErrorCode())
+  EXPECT_CALL(*translate_agent_, GetErrorCode())
       .WillOnce(Return(translate::TranslateErrors::NONE));
 
-  EXPECT_CALL(*translate_helper_, StartTranslation()).WillOnce(Return(true));
+  EXPECT_CALL(*translate_agent_, StartTranslation()).WillOnce(Return(true));
 
   // Succeed after few checks.
-  EXPECT_CALL(*translate_helper_, HasTranslationFailed())
+  EXPECT_CALL(*translate_agent_, HasTranslationFailed())
       .WillRepeatedly(Return(false));
-  EXPECT_CALL(*translate_helper_, HasTranslationFinished())
+  EXPECT_CALL(*translate_agent_, HasTranslationFinished())
       .WillOnce(Return(false))
       .WillOnce(Return(false))
       .WillOnce(Return(true));
 
   // V8 call for performance monitoring should be ignored.
-  EXPECT_CALL(*translate_helper_,
-              ExecuteScriptAndGetDoubleResult(_)).Times(3);
+  EXPECT_CALL(*translate_agent_, ExecuteScriptAndGetDoubleResult(_)).Times(3);
 
   std::string original_lang("en");
   std::string target_lang("fr");
-  translate_helper_->TranslatePage(original_lang, target_lang, std::string());
+  translate_agent_->TranslatePage(original_lang, target_lang, std::string());
   base::RunLoop().RunUntilIdle();
 
   std::string received_original_lang;
   std::string received_target_lang;
   translate::TranslateErrors::Type error;
-  ASSERT_TRUE(translate_helper_->GetPageTranslatedResult(
+  ASSERT_TRUE(translate_agent_->GetPageTranslatedResult(
       &received_original_lang, &received_target_lang, &error));
   EXPECT_EQ(original_lang, received_original_lang);
   EXPECT_EQ(target_lang, received_target_lang);
@@ -253,80 +254,76 @@ TEST_F(TranslateHelperBrowserTest, TranslateSuccess) {
 
 // Tests that the browser gets notified of the translation failure when the
 // translation fails.
-TEST_F(TranslateHelperBrowserTest, TranslateFailure) {
+TEST_F(TranslateAgentBrowserTest, TranslateFailure) {
   // We make IsTranslateLibAvailable true so we don't attempt to inject the
   // library.
-  EXPECT_CALL(*translate_helper_, IsTranslateLibAvailable())
+  EXPECT_CALL(*translate_agent_, IsTranslateLibAvailable())
       .Times(AtLeast(1))
       .WillRepeatedly(Return(true));
 
-  EXPECT_CALL(*translate_helper_, IsTranslateLibReady())
-      .WillOnce(Return(true));
+  EXPECT_CALL(*translate_agent_, IsTranslateLibReady()).WillOnce(Return(true));
 
-  EXPECT_CALL(*translate_helper_, StartTranslation()).WillOnce(Return(true));
+  EXPECT_CALL(*translate_agent_, StartTranslation()).WillOnce(Return(true));
 
   // Fail after few checks.
-  EXPECT_CALL(*translate_helper_, HasTranslationFailed())
+  EXPECT_CALL(*translate_agent_, HasTranslationFailed())
       .WillOnce(Return(false))
       .WillOnce(Return(false))
       .WillOnce(Return(false))
       .WillOnce(Return(true));
 
-  EXPECT_CALL(*translate_helper_, HasTranslationFinished())
+  EXPECT_CALL(*translate_agent_, HasTranslationFinished())
       .Times(AtLeast(1))
       .WillRepeatedly(Return(false));
 
-  EXPECT_CALL(*translate_helper_, GetErrorCode())
+  EXPECT_CALL(*translate_agent_, GetErrorCode())
       .WillOnce(Return(translate::TranslateErrors::TRANSLATION_ERROR));
 
   // V8 call for performance monitoring should be ignored.
-  EXPECT_CALL(*translate_helper_,
-              ExecuteScriptAndGetDoubleResult(_)).Times(2);
+  EXPECT_CALL(*translate_agent_, ExecuteScriptAndGetDoubleResult(_)).Times(2);
 
-  translate_helper_->TranslatePage("en", "fr", std::string());
+  translate_agent_->TranslatePage("en", "fr", std::string());
   base::RunLoop().RunUntilIdle();
 
   translate::TranslateErrors::Type error;
-  ASSERT_TRUE(translate_helper_->GetPageTranslatedResult(NULL, NULL, &error));
+  ASSERT_TRUE(
+      translate_agent_->GetPageTranslatedResult(nullptr, nullptr, &error));
   EXPECT_EQ(translate::TranslateErrors::TRANSLATION_ERROR, error);
 }
 
 // Tests that when the browser translate a page for which the language is
 // undefined we query the translate element to get the language.
-TEST_F(TranslateHelperBrowserTest, UndefinedSourceLang) {
+TEST_F(TranslateAgentBrowserTest, UndefinedSourceLang) {
   // We make IsTranslateLibAvailable true so we don't attempt to inject the
   // library.
-  EXPECT_CALL(*translate_helper_, IsTranslateLibAvailable())
+  EXPECT_CALL(*translate_agent_, IsTranslateLibAvailable())
       .Times(AtLeast(1))
       .WillRepeatedly(Return(true));
 
-  EXPECT_CALL(*translate_helper_, IsTranslateLibReady())
-      .WillOnce(Return(true));
+  EXPECT_CALL(*translate_agent_, IsTranslateLibReady()).WillOnce(Return(true));
 
-  EXPECT_CALL(*translate_helper_, GetOriginalPageLanguage())
+  EXPECT_CALL(*translate_agent_, GetOriginalPageLanguage())
       .WillOnce(Return("de"));
 
-  EXPECT_CALL(*translate_helper_, StartTranslation()).WillOnce(Return(true));
-  EXPECT_CALL(*translate_helper_, HasTranslationFailed())
+  EXPECT_CALL(*translate_agent_, StartTranslation()).WillOnce(Return(true));
+  EXPECT_CALL(*translate_agent_, HasTranslationFailed())
       .WillOnce(Return(false));
-  EXPECT_CALL(*translate_helper_, HasTranslationFinished())
+  EXPECT_CALL(*translate_agent_, HasTranslationFinished())
       .Times(AtLeast(1))
       .WillRepeatedly(Return(true));
 
   // V8 call for performance monitoring should be ignored.
-  EXPECT_CALL(*translate_helper_,
-              ExecuteScriptAndGetDoubleResult(_)).Times(3);
+  EXPECT_CALL(*translate_agent_, ExecuteScriptAndGetDoubleResult(_)).Times(3);
 
-  translate_helper_->TranslatePage(translate::kUnknownLanguageCode,
-                                   "fr",
-                                   std::string());
+  translate_agent_->TranslatePage(translate::kUnknownLanguageCode, "fr",
+                                  std::string());
   base::RunLoop().RunUntilIdle();
 
   translate::TranslateErrors::Type error;
   std::string original_lang;
   std::string target_lang;
-  ASSERT_TRUE(translate_helper_->GetPageTranslatedResult(&original_lang,
-                                                         &target_lang, &error));
+  ASSERT_TRUE(translate_agent_->GetPageTranslatedResult(&original_lang,
+                                                        &target_lang, &error));
   EXPECT_EQ("de", original_lang);
   EXPECT_EQ("fr", target_lang);
   EXPECT_EQ(translate::TranslateErrors::NONE, error);
@@ -334,38 +331,37 @@ TEST_F(TranslateHelperBrowserTest, UndefinedSourceLang) {
 
 // Tests that starting a translation while a similar one is pending does not
 // break anything.
-TEST_F(TranslateHelperBrowserTest, MultipleSimilarTranslations) {
+TEST_F(TranslateAgentBrowserTest, MultipleSimilarTranslations) {
   // We make IsTranslateLibAvailable true so we don't attempt to inject the
   // library.
-  EXPECT_CALL(*translate_helper_, IsTranslateLibAvailable())
+  EXPECT_CALL(*translate_agent_, IsTranslateLibAvailable())
       .Times(AtLeast(1))
       .WillRepeatedly(Return(true));
 
-  EXPECT_CALL(*translate_helper_, IsTranslateLibReady())
+  EXPECT_CALL(*translate_agent_, IsTranslateLibReady())
       .WillRepeatedly(Return(true));
-  EXPECT_CALL(*translate_helper_, StartTranslation())
+  EXPECT_CALL(*translate_agent_, StartTranslation())
       .WillRepeatedly(Return(true));
-  EXPECT_CALL(*translate_helper_, HasTranslationFailed())
+  EXPECT_CALL(*translate_agent_, HasTranslationFailed())
       .WillRepeatedly(Return(false));
-  EXPECT_CALL(*translate_helper_, HasTranslationFinished())
+  EXPECT_CALL(*translate_agent_, HasTranslationFinished())
       .WillOnce(Return(true));
 
   // V8 call for performance monitoring should be ignored.
-  EXPECT_CALL(*translate_helper_,
-              ExecuteScriptAndGetDoubleResult(_)).Times(3);
+  EXPECT_CALL(*translate_agent_, ExecuteScriptAndGetDoubleResult(_)).Times(3);
 
   std::string original_lang("en");
   std::string target_lang("fr");
-  translate_helper_->TranslatePage(original_lang, target_lang, std::string());
+  translate_agent_->TranslatePage(original_lang, target_lang, std::string());
   // While this is running call again TranslatePage to make sure noting bad
   // happens.
-  translate_helper_->TranslatePage(original_lang, target_lang, std::string());
+  translate_agent_->TranslatePage(original_lang, target_lang, std::string());
   base::RunLoop().RunUntilIdle();
 
   std::string received_original_lang;
   std::string received_target_lang;
   translate::TranslateErrors::Type error;
-  ASSERT_TRUE(translate_helper_->GetPageTranslatedResult(
+  ASSERT_TRUE(translate_agent_->GetPageTranslatedResult(
       &received_original_lang, &received_target_lang, &error));
   EXPECT_EQ(original_lang, received_original_lang);
   EXPECT_EQ(target_lang, received_target_lang);
@@ -373,36 +369,35 @@ TEST_F(TranslateHelperBrowserTest, MultipleSimilarTranslations) {
 }
 
 // Tests that starting a translation while a different one is pending works.
-TEST_F(TranslateHelperBrowserTest, MultipleDifferentTranslations) {
-  EXPECT_CALL(*translate_helper_, IsTranslateLibAvailable())
+TEST_F(TranslateAgentBrowserTest, MultipleDifferentTranslations) {
+  EXPECT_CALL(*translate_agent_, IsTranslateLibAvailable())
       .Times(AtLeast(1))
       .WillRepeatedly(Return(true));
-  EXPECT_CALL(*translate_helper_, IsTranslateLibReady())
+  EXPECT_CALL(*translate_agent_, IsTranslateLibReady())
       .WillRepeatedly(Return(true));
-  EXPECT_CALL(*translate_helper_, StartTranslation())
+  EXPECT_CALL(*translate_agent_, StartTranslation())
       .WillRepeatedly(Return(true));
-  EXPECT_CALL(*translate_helper_, HasTranslationFailed())
+  EXPECT_CALL(*translate_agent_, HasTranslationFailed())
       .WillRepeatedly(Return(false));
-  EXPECT_CALL(*translate_helper_, HasTranslationFinished())
+  EXPECT_CALL(*translate_agent_, HasTranslationFinished())
       .WillOnce(Return(true));
 
   // V8 call for performance monitoring should be ignored.
-  EXPECT_CALL(*translate_helper_,
-              ExecuteScriptAndGetDoubleResult(_)).Times(5);
+  EXPECT_CALL(*translate_agent_, ExecuteScriptAndGetDoubleResult(_)).Times(5);
 
   std::string original_lang("en");
   std::string target_lang("fr");
-  translate_helper_->TranslatePage(original_lang, target_lang, std::string());
+  translate_agent_->TranslatePage(original_lang, target_lang, std::string());
   // While this is running call again TranslatePage with a new target lang.
   std::string new_target_lang("de");
-  translate_helper_->TranslatePage(
-      original_lang, new_target_lang, std::string());
+  translate_agent_->TranslatePage(original_lang, new_target_lang,
+                                  std::string());
   base::RunLoop().RunUntilIdle();
 
   std::string received_original_lang;
   std::string received_target_lang;
   translate::TranslateErrors::Type error;
-  ASSERT_TRUE(translate_helper_->GetPageTranslatedResult(
+  ASSERT_TRUE(translate_agent_->GetPageTranslatedResult(
       &received_original_lang, &received_target_lang, &error));
   EXPECT_EQ(original_lang, received_original_lang);
   EXPECT_EQ(new_target_lang, received_target_lang);
@@ -411,7 +406,7 @@ TEST_F(TranslateHelperBrowserTest, MultipleDifferentTranslations) {
 
 // Tests that we send the right translate language message for a page and that
 // we respect the "no translate" meta-tag.
-TEST_F(TranslateHelperBrowserTest, TranslatablePage) {
+TEST_F(TranslateAgentBrowserTest, TranslatablePage) {
   LoadHTML("<html><body>A random page with random content.</body></html>");
 
   base::RunLoop().RunUntilIdle();
@@ -421,8 +416,9 @@ TEST_F(TranslateHelperBrowserTest, TranslatablePage) {
   fake_translate_driver_.ResetNewPageValues();
 
   // Now the page specifies the META tag to prevent translation.
-  LoadHTML("<html><head><meta name=\"google\" value=\"notranslate\"></head>"
-           "<body>A random page with random content.</body></html>");
+  LoadHTML(
+      "<html><head><meta name=\"google\" value=\"notranslate\"></head>"
+      "<body>A random page with random content.</body></html>");
 
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(fake_translate_driver_.called_new_page_);
@@ -431,8 +427,9 @@ TEST_F(TranslateHelperBrowserTest, TranslatablePage) {
   fake_translate_driver_.ResetNewPageValues();
 
   // Try the alternate version of the META tag (content instead of value).
-  LoadHTML("<html><head><meta name=\"google\" content=\"notranslate\"></head>"
-           "<body>A random page with random content.</body></html>");
+  LoadHTML(
+      "<html><head><meta name=\"google\" content=\"notranslate\"></head>"
+      "<body>A random page with random content.</body></html>");
 
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(fake_translate_driver_.called_new_page_);
@@ -442,9 +439,10 @@ TEST_F(TranslateHelperBrowserTest, TranslatablePage) {
 
 // Tests that the language meta tag takes precedence over the CLD when reporting
 // the page's language.
-TEST_F(TranslateHelperBrowserTest, LanguageMetaTag) {
-  LoadHTML("<html><head><meta http-equiv=\"content-language\" content=\"es\">"
-           "</head><body>A random page with random content.</body></html>");
+TEST_F(TranslateAgentBrowserTest, LanguageMetaTag) {
+  LoadHTML(
+      "<html><head><meta http-equiv=\"content-language\" content=\"es\">"
+      "</head><body>A random page with random content.</body></html>");
 
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(fake_translate_driver_.called_new_page_);
@@ -452,9 +450,10 @@ TEST_F(TranslateHelperBrowserTest, LanguageMetaTag) {
   fake_translate_driver_.ResetNewPageValues();
 
   // Makes sure we support multiple languages specified.
-  LoadHTML("<html><head><meta http-equiv=\"content-language\" "
-           "content=\" fr , es,en \">"
-           "</head><body>A random page with random content.</body></html>");
+  LoadHTML(
+      "<html><head><meta http-equiv=\"content-language\" "
+      "content=\" fr , es,en \">"
+      "</head><body>A random page with random content.</body></html>");
 
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(fake_translate_driver_.called_new_page_);
@@ -463,18 +462,20 @@ TEST_F(TranslateHelperBrowserTest, LanguageMetaTag) {
 
 // Tests that the language meta tag works even with non-all-lower-case.
 // http://code.google.com/p/chromium/issues/detail?id=145689
-TEST_F(TranslateHelperBrowserTest, LanguageMetaTagCase) {
-  LoadHTML("<html><head><meta http-equiv=\"Content-Language\" content=\"es\">"
-           "</head><body>A random page with random content.</body></html>");
+TEST_F(TranslateAgentBrowserTest, LanguageMetaTagCase) {
+  LoadHTML(
+      "<html><head><meta http-equiv=\"Content-Language\" content=\"es\">"
+      "</head><body>A random page with random content.</body></html>");
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(fake_translate_driver_.called_new_page_);
   EXPECT_EQ("es", fake_translate_driver_.details_->adopted_language);
   fake_translate_driver_.ResetNewPageValues();
 
   // Makes sure we support multiple languages specified.
-  LoadHTML("<html><head><meta http-equiv=\"Content-Language\" "
-           "content=\" fr , es,en \">"
-           "</head><body>A random page with random content.</body></html>");
+  LoadHTML(
+      "<html><head><meta http-equiv=\"Content-Language\" "
+      "content=\" fr , es,en \">"
+      "</head><body>A random page with random content.</body></html>");
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(fake_translate_driver_.called_new_page_);
   EXPECT_EQ("fr", fake_translate_driver_.details_->adopted_language);
@@ -483,25 +484,28 @@ TEST_F(TranslateHelperBrowserTest, LanguageMetaTagCase) {
 // Tests that the language meta tag is converted to Chrome standard of dashes
 // instead of underscores and proper capitalization.
 // http://code.google.com/p/chromium/issues/detail?id=159487
-TEST_F(TranslateHelperBrowserTest, LanguageCommonMistakesAreCorrected) {
-  LoadHTML("<html><head><meta http-equiv='Content-Language' content='EN_us'>"
-           "</head><body>A random page with random content.</body></html>");
+TEST_F(TranslateAgentBrowserTest, LanguageCommonMistakesAreCorrected) {
+  LoadHTML(
+      "<html><head><meta http-equiv='Content-Language' content='EN_us'>"
+      "</head><body>A random page with random content.</body></html>");
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(fake_translate_driver_.called_new_page_);
   EXPECT_EQ("en", fake_translate_driver_.details_->adopted_language);
   fake_translate_driver_.ResetNewPageValues();
 
-  LoadHTML("<html><head><meta http-equiv='Content-Language' content='ZH_tw'>"
-           "</head><body>A random page with random content.</body></html>");
+  LoadHTML(
+      "<html><head><meta http-equiv='Content-Language' content='ZH_tw'>"
+      "</head><body>A random page with random content.</body></html>");
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(fake_translate_driver_.called_new_page_);
   EXPECT_EQ("zh-TW", fake_translate_driver_.details_->adopted_language);
 }
 
 // Tests that a back navigation gets a translate language message.
-TEST_F(TranslateHelperBrowserTest, BackToTranslatablePage) {
-  LoadHTML("<html><head><meta http-equiv=\"content-language\" content=\"es\">"
-           "</head><body>This page is in Spanish.</body></html>");
+TEST_F(TranslateAgentBrowserTest, BackToTranslatablePage) {
+  LoadHTML(
+      "<html><head><meta http-equiv=\"content-language\" content=\"es\">"
+      "</head><body>This page is in Spanish.</body></html>");
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(fake_translate_driver_.called_new_page_);
   EXPECT_EQ("es", fake_translate_driver_.details_->adopted_language);
@@ -509,8 +513,9 @@ TEST_F(TranslateHelperBrowserTest, BackToTranslatablePage) {
 
   content::PageState back_state = GetCurrentPageState();
 
-  LoadHTML("<html><head><meta http-equiv=\"content-language\" content=\"fr\">"
-           "</head><body>This page is in French.</body></html>");
+  LoadHTML(
+      "<html><head><meta http-equiv=\"content-language\" content=\"fr\">"
+      "</head><body>This page is in French.</body></html>");
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(fake_translate_driver_.called_new_page_);
   EXPECT_EQ("fr", fake_translate_driver_.details_->adopted_language);

chrome/renderer/translate/translate_script_browsertest.cc

@@ -114,7 +114,7 @@ class TranslateScriptBrowserTest : public ChromeRenderViewTest {
     if (result.IsEmpty() || !result->IsNumber()) {
       NOTREACHED();
       // TODO(toyoshim): Return NaN here and the real implementation in
-      // TranslateHelper::ExecuteScriptAndGetDoubleResult().
+      // TranslateAgent::ExecuteScriptAndGetDoubleResult().
       return 0.0;
     }
     return result.As<v8::Number>()->Value();

chrome/test/BUILD.gn

@@ -1401,7 +1401,7 @@ if (!is_android) {
       "../renderer/chrome_render_frame_observer_browsertest.cc",
       "../renderer/content_settings_agent_impl_browsertest.cc",
       "../renderer/media/cast_session_browsertest.cc",
-      "../renderer/translate/translate_helper_browsertest.cc",
+      "../renderer/translate/translate_agent_browsertest.cc",
       "../renderer/translate/translate_script_browsertest.cc",
       "base/chrome_render_view_test.cc",
       "base/chrome_render_view_test.h",

components/translate/content/browser/content_translate_driver.cc

@@ -126,19 +126,19 @@ void ContentTranslateDriver::TranslatePage(int page_seq_no,
                                            const std::string& translate_script,
                                            const std::string& source_lang,
                                            const std::string& target_lang) {
-  auto it = pages_.find(page_seq_no);
-  if (it == pages_.end())
+  auto it = translate_agents_.find(page_seq_no);
+  if (it == translate_agents_.end())
     return;  // This page has navigated away.
 
-  it->second->Translate(
+  it->second->TranslateFrame(
       translate_script, source_lang, target_lang,
       base::BindOnce(&ContentTranslateDriver::OnPageTranslated,
                      base::Unretained(this)));
 }
 
 void ContentTranslateDriver::RevertTranslation(int page_seq_no) {
-  auto it = pages_.find(page_seq_no);
-  if (it == pages_.end())
+  auto it = translate_agents_.find(page_seq_no);
+  if (it == translate_agents_.end())
     return;  // This page has navigated away.
 
   it->second->RevertTranslation();
@@ -266,7 +266,7 @@ void ContentTranslateDriver::DidFinishNavigation(
 }
 
 void ContentTranslateDriver::OnPageAway(int page_seq_no) {
-  pages_.erase(page_seq_no);
+  translate_agents_.erase(page_seq_no);
 }
 
 void ContentTranslateDriver::AddReceiver(
@@ -275,7 +275,7 @@ void ContentTranslateDriver::AddReceiver(
 }
 
 void ContentTranslateDriver::RegisterPage(
-    mojo::PendingRemote<translate::mojom::Page> page,
+    mojo::PendingRemote<translate::mojom::TranslateAgent> translate_agent,
     const translate::LanguageDetectionDetails& details,
     const bool page_needs_translation) {
   // If we have a language histogram (i.e. we're not in incognito), update it
@@ -283,8 +283,8 @@ void ContentTranslateDriver::RegisterPage(
   if (language_histogram_ && details.is_cld_reliable)
     language_histogram_->OnPageVisited(details.cld_language);
 
-  pages_[++next_page_seq_no_].Bind(std::move(page));
-  pages_[next_page_seq_no_].set_disconnect_handler(
+  translate_agents_[++next_page_seq_no_].Bind(std::move(translate_agent));
+  translate_agents_[next_page_seq_no_].set_disconnect_handler(
       base::BindOnce(&ContentTranslateDriver::OnPageAway,
                      base::Unretained(this), next_page_seq_no_));
   translate_manager_->set_current_seq_no(next_page_seq_no_);

components/translate/content/browser/content_translate_driver.h

@@ -117,9 +117,10 @@ class ContentTranslateDriver : public TranslateDriver,
   void AddReceiver(
       mojo::PendingReceiver<translate::mojom::ContentTranslateDriver> receiver);
   // Called when a page has been loaded and can be potentially translated.
-  void RegisterPage(mojo::PendingRemote<translate::mojom::Page> page,
-                    const translate::LanguageDetectionDetails& details,
-                    bool page_needs_translation) override;
+  void RegisterPage(
+      mojo::PendingRemote<translate::mojom::TranslateAgent> translate_agent,
+      const translate::LanguageDetectionDetails& details,
+      bool page_needs_translation) override;
 
  private:
   void OnPageAway(int page_seq_no);
@@ -136,17 +137,17 @@ class ContentTranslateDriver : public TranslateDriver,
 
   // Records mojo connections with all current alive pages.
   int next_page_seq_no_;
-  // mojo::Remote<Page> is the connection between this driver and a
-  // TranslateHelper (which are per RenderFrame). Each TranslateHelper has a
+  // mojo::Remote<TranslateAgent> is the connection between this driver and a
+  // TranslateAgent (which are per RenderFrame). Each TranslateAgent has a
   // |binding_| member, representing the other end of this pipe.
-  std::map<int, mojo::Remote<mojom::Page>> pages_;
+  std::map<int, mojo::Remote<mojom::TranslateAgent>> translate_agents_;
 
   // Histogram to be notified about detected language of every page visited. Not
   // owned here.
   language::UrlLanguageHistogram* const language_histogram_;
 
   // ContentTranslateDriver is a singleton per web contents but multiple render
-  // frames may be contained in a single web contents. TranslateHelpers get the
+  // frames may be contained in a single web contents. TranslateAgents get the
   // other end of this receiver in the form of a ContentTranslateDriver.
   mojo::ReceiverSet<translate::mojom::ContentTranslateDriver> receivers_;
 

components/translate/content/common/translate.mojom

@@ -35,8 +35,11 @@ struct LanguageDetectionDetails {
   mojo_base.mojom.String16 contents;
 };
 
-interface Page {
-  // Requests that the page be translated from |source_lang| to
+// Handles language translation. This is used by the browser process to
+// direct a renderer to translate the language of a frame (or revert a
+// previous translation of the contents of a frame).
+interface TranslateAgent {
+  // Requests that the frame be translated from |source_lang| to
   // |target_lang|.
   //
   // If a Translate request is already in progress with a matching
@@ -49,18 +52,22 @@ interface Page {
   //
   // If |cancelled| is |true| all other response values should be
   // ignored.
-  Translate(string translate_script, string source_lang, string target_lang)
+  TranslateFrame(string translate_script, string source_lang,
+                 string target_lang)
       => (bool cancelled, string original_lang, string translated_lang,
           TranslateError error);
 
-  // Requests that the page be reverted to its original language with
+  // Requests that the frame be reverted to its original language with
   // no translation applied.
   RevertTranslation();
 };
 
+// Reports when page is ready for translation. This is used by the
+// renderer of a main frame to report its detected language to the
+// browser process and provides the translation interface back to itself.
 interface ContentTranslateDriver {
   // Notification that a new page is ready to translate,
   // and the language for it has been determined.
-  RegisterPage(pending_remote<Page> page, LanguageDetectionDetails details,
-               bool page_needs_translation);
+  RegisterPage(pending_remote<TranslateAgent> translate_agent,
+               LanguageDetectionDetails details, bool page_needs_translation);
 };

components/translate/content/renderer/BUILD.gn

@@ -6,8 +6,8 @@ import("//build/config/features.gni")
 
 static_library("renderer") {
   sources = [
-    "translate_helper.cc",
-    "translate_helper.h",
+    "translate_agent.cc",
+    "translate_agent.h",
   ]
 
   deps = [
@@ -28,7 +28,7 @@ static_library("renderer") {
 
 source_set("unit_tests") {
   testonly = true
-  sources = [ "translate_helper_unittest.cc" ]
+  sources = [ "translate_agent_unittest.cc" ]
   deps = [
     ":renderer",
     "//base",

components/translate/content/renderer/translate_helper.cc → components/translate/content/renderer/translate_agent.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "components/translate/content/renderer/translate_helper.h"
+#include "components/translate/content/renderer/translate_agent.h"
 
 #include <utility>
 
@@ -34,12 +34,12 @@
 #include "v8/include/v8.h"
 
 using blink::WebDocument;
+using blink::WebLanguageDetectionDetails;
 using blink::WebLocalFrame;
 using blink::WebScriptSource;
 using blink::WebSecurityOrigin;
 using blink::WebString;
 using blink::WebVector;
-using blink::WebLanguageDetectionDetails;
 
 namespace {
 
@@ -66,10 +66,10 @@ const char kContentSecurityPolicy[] = "script-src 'self' 'unsafe-eval'";
 namespace translate {
 
 ////////////////////////////////////////////////////////////////////////////////
-// TranslateHelper, public:
-TranslateHelper::TranslateHelper(content::RenderFrame* render_frame,
-                                 int world_id,
-                                 const std::string& extension_scheme)
+// TranslateAgent, public:
+TranslateAgent::TranslateAgent(content::RenderFrame* render_frame,
+                               int world_id,
+                               const std::string& extension_scheme)
     : content::RenderFrameObserver(render_frame),
       world_id_(world_id),
       extension_scheme_(extension_scheme) {
@@ -77,15 +77,14 @@ TranslateHelper::TranslateHelper(content::RenderFrame* render_frame,
       blink::TaskType::kInternalTranslation);
 }
 
-TranslateHelper::~TranslateHelper() {
-}
+TranslateAgent::~TranslateAgent() {}
 
-void TranslateHelper::PrepareForUrl(const GURL& url) {
+void TranslateAgent::PrepareForUrl(const GURL& url) {
   // Navigated to a new url, reset current page translation.
   ResetPage();
 }
 
-void TranslateHelper::PageCaptured(const base::string16& contents) {
+void TranslateAgent::PageCaptured(const base::string16& contents) {
   // Get the document language as set by WebKit from the http-equiv
   // meta tag for "content-language".  This may or may not also
   // have a value derived from the actual Content-Language HTTP
@@ -137,7 +136,7 @@ void TranslateHelper::PageCaptured(const base::string16& contents) {
       details, !details.has_notranslate && !language.empty());
 }
 
-void TranslateHelper::CancelPendingTranslation() {
+void TranslateAgent::CancelPendingTranslation() {
   weak_method_factory_.InvalidateWeakPtrs();
   // Make sure to send the cancelled response back.
   if (translate_callback_pending_) {
@@ -149,48 +148,49 @@ void TranslateHelper::CancelPendingTranslation() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// TranslateHelper, protected:
-bool TranslateHelper::IsTranslateLibAvailable() {
+// TranslateAgent, protected:
+bool TranslateAgent::IsTranslateLibAvailable() {
   return ExecuteScriptAndGetBoolResult(
       "typeof cr != 'undefined' && typeof cr.googleTranslate != 'undefined' && "
-      "typeof cr.googleTranslate.translate == 'function'", false);
+      "typeof cr.googleTranslate.translate == 'function'",
+      false);
 }
 
-bool TranslateHelper::IsTranslateLibReady() {
+bool TranslateAgent::IsTranslateLibReady() {
   return ExecuteScriptAndGetBoolResult("cr.googleTranslate.libReady", false);
 }
 
-bool TranslateHelper::HasTranslationFinished() {
+bool TranslateAgent::HasTranslationFinished() {
   return ExecuteScriptAndGetBoolResult("cr.googleTranslate.finished", true);
 }
 
-bool TranslateHelper::HasTranslationFailed() {
+bool TranslateAgent::HasTranslationFailed() {
   return ExecuteScriptAndGetBoolResult("cr.googleTranslate.error", true);
 }
 
-int64_t TranslateHelper::GetErrorCode() {
+int64_t TranslateAgent::GetErrorCode() {
   int64_t error_code =
       ExecuteScriptAndGetIntegerResult("cr.googleTranslate.errorCode");
   DCHECK_LT(error_code, static_cast<int>(TranslateErrors::TRANSLATE_ERROR_MAX));
   return error_code;
 }
 
-bool TranslateHelper::StartTranslation() {
+bool TranslateAgent::StartTranslation() {
   return ExecuteScriptAndGetBoolResult(
       BuildTranslationScript(source_lang_, target_lang_), false);
 }
 
-std::string TranslateHelper::GetOriginalPageLanguage() {
+std::string TranslateAgent::GetOriginalPageLanguage() {
   return ExecuteScriptAndGetStringResult("cr.googleTranslate.sourceLang");
 }
 
-base::TimeDelta TranslateHelper::AdjustDelay(int delayInMs) {
+base::TimeDelta TranslateAgent::AdjustDelay(int delayInMs) {
   // Just converts |delayInMs| without any modification in practical cases.
   // Tests will override this function to return modified value.
   return base::TimeDelta::FromMilliseconds(delayInMs);
 }
 
-void TranslateHelper::ExecuteScript(const std::string& script) {
+void TranslateAgent::ExecuteScript(const std::string& script) {
   WebLocalFrame* main_frame = render_frame()->GetWebFrame();
   if (!main_frame)
     return;
@@ -199,8 +199,8 @@ void TranslateHelper::ExecuteScript(const std::string& script) {
   main_frame->ExecuteScriptInIsolatedWorld(world_id_, source);
 }
 
-bool TranslateHelper::ExecuteScriptAndGetBoolResult(const std::string& script,
-                                                    bool fallback) {
+bool TranslateAgent::ExecuteScriptAndGetBoolResult(const std::string& script,
+                                                   bool fallback) {
   WebLocalFrame* main_frame = render_frame()->GetWebFrame();
   if (!main_frame)
     return fallback;
@@ -217,7 +217,7 @@ bool TranslateHelper::ExecuteScriptAndGetBoolResult(const std::string& script,
   return result.As<v8::Boolean>()->Value();
 }
 
-std::string TranslateHelper::ExecuteScriptAndGetStringResult(
+std::string TranslateAgent::ExecuteScriptAndGetStringResult(
     const std::string& script) {
   WebLocalFrame* main_frame = render_frame()->GetWebFrame();
   if (!main_frame)
@@ -240,7 +240,7 @@ std::string TranslateHelper::ExecuteScriptAndGetStringResult(
   return std::string(str.get());
 }
 
-double TranslateHelper::ExecuteScriptAndGetDoubleResult(
+double TranslateAgent::ExecuteScriptAndGetDoubleResult(
     const std::string& script) {
   WebLocalFrame* main_frame = render_frame()->GetWebFrame();
   if (!main_frame)
@@ -258,7 +258,7 @@ double TranslateHelper::ExecuteScriptAndGetDoubleResult(
   return result.As<v8::Number>()->Value();
 }
 
-int64_t TranslateHelper::ExecuteScriptAndGetIntegerResult(
+int64_t TranslateAgent::ExecuteScriptAndGetIntegerResult(
     const std::string& script) {
   WebLocalFrame* main_frame = render_frame()->GetWebFrame();
   if (!main_frame)
@@ -276,12 +276,11 @@ int64_t TranslateHelper::ExecuteScriptAndGetIntegerResult(
   return result.As<v8::Integer>()->Value();
 }
 
-// mojom::Page implementations.
-void TranslateHelper::Translate(
-    const std::string& translate_script,
-    const std::string& source_lang,
-    const std::string& target_lang,
-    TranslateCallback callback) {
+// mojom::TranslateAgent implementations.
+void TranslateAgent::TranslateFrame(const std::string& translate_script,
+                                    const std::string& source_lang,
+                                    const std::string& target_lang,
+                                    TranslateFrameCallback callback) {
   WebLocalFrame* main_frame = render_frame()->GetWebFrame();
   if (!main_frame) {
     // Cancelled.
@@ -333,7 +332,7 @@ void TranslateHelper::Translate(
   TranslatePageImpl(0);
 }
 
-void TranslateHelper::RevertTranslation() {
+void TranslateAgent::RevertTranslation() {
   if (!IsTranslateLibAvailable()) {
     NOTREACHED();
     return;
@@ -345,8 +344,8 @@ void TranslateHelper::RevertTranslation() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// TranslateHelper, private:
-void TranslateHelper::CheckTranslateStatus() {
+// TranslateAgent, private:
+void TranslateAgent::CheckTranslateStatus() {
   // First check if there was an error.
   if (HasTranslationFailed()) {
     NotifyBrowserTranslationFailed(
@@ -389,12 +388,12 @@ void TranslateHelper::CheckTranslateStatus() {
   // The translation is still pending, check again later.
   translate_task_runner_->PostDelayedTask(
       FROM_HERE,
-      base::BindOnce(&TranslateHelper::CheckTranslateStatus,
+      base::BindOnce(&TranslateAgent::CheckTranslateStatus,
                      weak_method_factory_.GetWeakPtr()),
       AdjustDelay(kTranslateStatusCheckDelayMs));
 }
 
-void TranslateHelper::TranslatePageImpl(int count) {
+void TranslateAgent::TranslatePageImpl(int count) {
   DCHECK_LT(count, kMaxTranslateInitCheckAttempts);
   if (!IsTranslateLibReady()) {
     // There was an error during initialization of library.
@@ -413,7 +412,7 @@ void TranslateHelper::TranslatePageImpl(int count) {
     }
     translate_task_runner_->PostDelayedTask(
         FROM_HERE,
-        base::BindOnce(&TranslateHelper::TranslatePageImpl,
+        base::BindOnce(&TranslateAgent::TranslatePageImpl,
                        weak_method_factory_.GetWeakPtr(), count),
         AdjustDelay(count * kTranslateInitCheckDelayMs));
     return;
@@ -433,12 +432,12 @@ void TranslateHelper::TranslatePageImpl(int count) {
   // Check the status of the translation.
   translate_task_runner_->PostDelayedTask(
       FROM_HERE,
-      base::BindOnce(&TranslateHelper::CheckTranslateStatus,
+      base::BindOnce(&TranslateAgent::CheckTranslateStatus,
                      weak_method_factory_.GetWeakPtr()),
       AdjustDelay(kTranslateStatusCheckDelayMs));
 }
 
-void TranslateHelper::NotifyBrowserTranslationFailed(
+void TranslateAgent::NotifyBrowserTranslationFailed(
     TranslateErrors::Type error) {
   DCHECK(translate_callback_pending_);
   // Notify the browser there was an error.
@@ -447,7 +446,7 @@ void TranslateHelper::NotifyBrowserTranslationFailed(
 }
 
 const mojo::Remote<mojom::ContentTranslateDriver>&
-TranslateHelper::GetTranslateHandler() {
+TranslateAgent::GetTranslateHandler() {
   if (!translate_handler_) {
     render_frame()->GetBrowserInterfaceBroker()->GetInterface(
         translate_handler_.BindNewPipeAndPassReceiver());
@@ -456,18 +455,18 @@ TranslateHelper::GetTranslateHandler() {
   return translate_handler_;
 }
 
-void TranslateHelper::ResetPage() {
+void TranslateAgent::ResetPage() {
   receiver_.reset();
   translate_callback_pending_.Reset();
   CancelPendingTranslation();
 }
 
-void TranslateHelper::OnDestruct() {
+void TranslateAgent::OnDestruct() {
   delete this;
 }
 
 /* static */
-std::string TranslateHelper::BuildTranslationScript(
+std::string TranslateAgent::BuildTranslationScript(
     const std::string& source_lang,
     const std::string& target_lang) {
   return "cr.googleTranslate.translate(" +

components/translate/content/renderer/translate_helper.h → components/translate/content/renderer/translate_agent.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef COMPONENTS_TRANSLATE_CONTENT_RENDERER_TRANSLATE_HELPER_H_
-#define COMPONENTS_TRANSLATE_CONTENT_RENDERER_TRANSLATE_HELPER_H_
+#ifndef COMPONENTS_TRANSLATE_CONTENT_RENDERER_TRANSLATE_AGENT_H_
+#define COMPONENTS_TRANSLATE_CONTENT_RENDERER_TRANSLATE_AGENT_H_
 
 #include <memory>
 #include <string>
@@ -27,14 +27,14 @@ class WebLocalFrame;
 namespace translate {
 
 // This class deals with page translation.
-// There is one TranslateHelper per RenderView.
-class TranslateHelper : public content::RenderFrameObserver,
-                        public mojom::Page {
+// There is one TranslateAgent per RenderView.
+class TranslateAgent : public content::RenderFrameObserver,
+                       public mojom::TranslateAgent {
  public:
-  TranslateHelper(content::RenderFrame* render_frame,
-                  int world_id,
-                  const std::string& extension_scheme);
-  ~TranslateHelper() override;
+  TranslateAgent(content::RenderFrame* render_frame,
+                 int world_id,
+                 const std::string& extension_scheme);
+  ~TranslateAgent() override;
 
   // Informs us that the page's text has been extracted.
   void PageCaptured(const base::string16& contents);
@@ -44,11 +44,11 @@ class TranslateHelper : public content::RenderFrameObserver,
   // this URL loads, this is the time to prepare for it.
   void PrepareForUrl(const GURL& url);
 
-  // mojom::Page implementation.
-  void Translate(const std::string& translate_script,
-                 const std::string& source_lang,
-                 const std::string& target_lang,
-                 TranslateCallback callback) override;
+  // mojom::TranslateAgent implementation.
+  void TranslateFrame(const std::string& translate_script,
+                      const std::string& source_lang,
+                      const std::string& target_lang,
+                      TranslateFrameCallback callback) override;
   void RevertTranslation() override;
 
  protected:
@@ -109,7 +109,7 @@ class TranslateHelper : public content::RenderFrameObserver,
   virtual int64_t ExecuteScriptAndGetIntegerResult(const std::string& script);
 
  private:
-  FRIEND_TEST_ALL_PREFIXES(TranslateHelperTest, TestBuildTranslationScript);
+  FRIEND_TEST_ALL_PREFIXES(TranslateAgentTest, TestBuildTranslationScript);
 
   // Converts language code to the one used in server supporting list.
   static void ConvertLanguageCodeSynonym(std::string* code);
@@ -145,12 +145,12 @@ class TranslateHelper : public content::RenderFrameObserver,
   // with |error|.
   void NotifyBrowserTranslationFailed(TranslateErrors::Type error);
 
-  // Convenience method to access the main frame.  Can return NULL, typically
+  // Convenience method to access the main frame.  Can return nullptr, typically
   // if the page is being closed.
   blink::WebLocalFrame* GetMainFrame();
 
   // The states associated with the current translation.
-  TranslateCallback translate_callback_pending_;
+  TranslateFrameCallback translate_callback_pending_;
   std::string source_lang_;
   std::string target_lang_;
 
@@ -174,14 +174,14 @@ class TranslateHelper : public content::RenderFrameObserver,
   // Mojo interface).
   mojo::Remote<mojom::ContentTranslateDriver> translate_handler_;
 
-  mojo::Receiver<mojom::Page> receiver_{this};
+  mojo::Receiver<mojom::TranslateAgent> receiver_{this};
 
   // Method factory used to make calls to TranslatePageImpl.
-  base::WeakPtrFactory<TranslateHelper> weak_method_factory_{this};
+  base::WeakPtrFactory<TranslateAgent> weak_method_factory_{this};
 
-  DISALLOW_COPY_AND_ASSIGN(TranslateHelper);
+  DISALLOW_COPY_AND_ASSIGN(TranslateAgent);
 };
 
 }  // namespace translate
 
-#endif  // COMPONENTS_TRANSLATE_CONTENT_RENDERER_TRANSLATE_HELPER_H_
+#endif  // COMPONENTS_TRANSLATE_CONTENT_RENDERER_TRANSLATE_AGENT_H_

components/translate/content/renderer/translate_helper_unittest.cc → components/translate/content/renderer/translate_agent_unittest.cc

@@ -2,27 +2,27 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "components/translate/content/renderer/translate_helper.h"
+#include "components/translate/content/renderer/translate_agent.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace translate {
 
-class TranslateHelperTest : public testing::Test {};
+class TranslateAgentTest : public testing::Test {};
 
-TEST_F(TranslateHelperTest, TestBuildTranslationScript) {
+TEST_F(TranslateAgentTest, TestBuildTranslationScript) {
   // Test expected cases.
-  EXPECT_EQ(TranslateHelper::BuildTranslationScript("en", "es"),
+  EXPECT_EQ(TranslateAgent::BuildTranslationScript("en", "es"),
             "cr.googleTranslate.translate(\"en\",\"es\")");
-  EXPECT_EQ(TranslateHelper::BuildTranslationScript("en-US", "zh-TW"),
+  EXPECT_EQ(TranslateAgent::BuildTranslationScript("en-US", "zh-TW"),
             "cr.googleTranslate.translate(\"en-US\",\"zh-TW\")");
 
   // Test that quote gets quoted.
-  EXPECT_EQ(TranslateHelper::BuildTranslationScript("en\"", "es"),
+  EXPECT_EQ(TranslateAgent::BuildTranslationScript("en\"", "es"),
             "cr.googleTranslate.translate(\"en\\\"\",\"es\")");
 
   // Test that < gets quoted.
-  EXPECT_EQ(TranslateHelper::BuildTranslationScript("en<", "es"),
+  EXPECT_EQ(TranslateAgent::BuildTranslationScript("en<", "es"),
             "cr.googleTranslate.translate(\"en\\u003C\",\"es\")");
 }
 

components/translate/core/common/translate_metrics.h

@@ -30,7 +30,7 @@ extern const char kTranslateLanguageDetectionConflict[];
 }  // namespace metrics_internal
 
 // A page may provide a Content-Language HTTP header or a META tag.
-// TranslateHelper checks if a server provides a valid Content-Language.
+// TranslateAgent checks if a server provides a valid Content-Language.
 enum LanguageCheckType {
   LANGUAGE_NOT_PROVIDED,
   LANGUAGE_VALID,
@@ -38,7 +38,7 @@ enum LanguageCheckType {
   LANGUAGE_MAX,
 };
 
-// When a valid Content-Language is provided, TranslateHelper checks if a
+// When a valid Content-Language is provided, TranslateAgent checks if a
 // server provided Content-Language matches to a language CLD determined.
 enum LanguageVerificationType {
   LANGUAGE_VERIFICATION_CLD_DISABLED,  // obsolete
@@ -59,14 +59,14 @@ enum SchemeType {
   SCHEME_MAX,
 };
 
-// Called after TranslateHelper verifies a server providing Content-Language
+// Called after TranslateAgent verifies a server providing Content-Language
 // header. |provided_code| contains a Content-Language header value which a
 // server provides. It can be empty string when a server doesn't provide it.
 // |revised_code| is a value modified by format error corrector.
 void ReportContentLanguage(const std::string& provided_code,
                            const std::string& revised_code);
 
-// Called after TranslateHelper verifies a page providing html lang attribute.
+// Called after TranslateAgent verifies a page providing html lang attribute.
 // |provided_code| contains a html lang attribute which a page provides. It can
 // be empty string when a page doesn't provide it. |revised_code| is a value
 // modified by format error corrector.

components/translate/ios/browser/ios_translate_driver.h

@@ -113,7 +113,7 @@ class IOSTranslateDriver
 
   // An ever-increasing sequence number of the current page, used to match up
   // translation requests with responses.
-  // This matches the similar field in TranslateHelper in the renderer on other
+  // This matches the similar field in TranslateAgent in the renderer on other
   // platforms.
   int page_seq_no_;
 

components/translate/ios/browser/js_translate_manager.h

@@ -14,8 +14,8 @@
 @class NSString;
 
 // Manager for the injection of the Translate JavaScript.
-// Replicates functionality from TranslateHelper in
-// chrome/renderer/translate/translate_helper.cc.
+// Replicates functionality from TranslateAgent in
+// chrome/renderer/translate/translate_agent.cc.
 // JsTranslateManager injects the script in the page and calls it, but is not
 // responsible for loading it or caching it.
 @interface JsTranslateManager : CRWJSInjectionManager
@@ -25,7 +25,7 @@
 @property(nonatomic, copy) NSString* script;
 
 // Starts translation of the page from |source| language to |target| language.
-// Equivalent to TranslateHelper::StartTranslation().
+// Equivalent to TranslateAgent::StartTranslation().
 - (void)startTranslationFrom:(const std::string&)source
                           to:(const std::string&)target;