[Translate] Migrate IPCs to Mojo interfaces.

components/translate/content/renderer/translate_helper.h

 // Copyright (c) 2011 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.
 
 #ifndef COMPONENTS_TRANSLATE_CONTENT_RENDERER_TRANSLATE_HELPER_H_
 #define COMPONENTS_TRANSLATE_CONTENT_RENDERER_TRANSLATE_HELPER_H_
 
 #include <memory>
 #include <string>
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/strings/string16.h"
 #include "base/time/time.h"
+#include "components/translate/content/common/translate.mojom.h"
 #include "components/translate/core/common/translate_errors.h"
 #include "content/public/renderer/render_frame_observer.h"
+#include "mojo/public/cpp/bindings/binding.h"
 #include "url/gurl.h"
 
 namespace blink {
 class WebDocument;
 class WebLocalFrame;
 }
 
 namespace translate {
 
 // This class deals with page translation.
 // There is one TranslateHelper per RenderView.
-class TranslateHelper : public content::RenderFrameObserver {
+class TranslateHelper : public content::RenderFrameObserver,
+                        public mojom::Page {
  public:
-  explicit TranslateHelper(content::RenderFrame* render_frame,
-                           int world_id,
-                           int extension_group,
-                           const std::string& extension_scheme);
+  TranslateHelper(content::RenderFrame* render_frame,
+                  int world_id,
+                  int extension_group,
+                  const std::string& extension_scheme);
   ~TranslateHelper() override;
 
   // Informs us that the page's text has been extracted.
   void PageCaptured(const base::string16& contents);
 
   // Lets the translation system know that we are preparing to navigate to
   // the specified URL. If there is anything that can or should be done before
   // 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,
+                 const TranslateCallback& callback) override;
+  void RevertTranslation() override;
+
  protected:
-  // The following methods are protected so they can be overridden in
-  // unit-tests.
-  void OnTranslatePage(int page_seq_no,
-                       const std::string& translate_script,
-                       const std::string& source_lang,
-                       const std::string& target_lang);
-  void OnRevertTranslation(int page_seq_no);
-
   // Returns true if the translate library is available, meaning the JavaScript
   // has already been injected in that page.
   virtual bool IsTranslateLibAvailable();
 
   // Returns true if the translate library has been initialized successfully.
   virtual bool IsTranslateLibReady();
 
   // Returns true if the translation script has finished translating the page.
   virtual bool HasTranslationFinished();
 
@@ skipping 32 matching lines @@
 
   // Executes the JavaScript code in |script| in the main frame of RenderView.
   // and returns the number returned by the script evaluation if the script was
   // run successfully. Otherwise, returns 0.0.
   virtual double ExecuteScriptAndGetDoubleResult(const std::string& script);
 
  private:
   // Converts language code to the one used in server supporting list.
   static void ConvertLanguageCodeSynonym(std::string* code);
 
+  const mojom::ContentTranslateDriverPtr& GetTranslateDriver();
+
   // RenderFrameObserver implementation.
-  bool OnMessageReceived(const IPC::Message& message) override;
   void OnDestruct() override;
 
-  // Informs us that the page's text has been extracted.
-  void PageCapturedImpl(int page_seq_no, const base::string16& contents);
-
   // Cancels any translation that is currently being performed.  This does not
   // revert existing translations.
   void CancelPendingTranslation();
 
   // Checks if the current running page translation is finished or errored and
   // notifies the browser accordingly.  If the translation has not terminated,
   // posts a task to check again later.
-  void CheckTranslateStatus(int page_seq_no);
+  void CheckTranslateStatus();
 
   // Called by TranslatePage to do the actual translation.  |count| is used to
   // limit the number of retries.
-  void TranslatePageImpl(int page_seq_no, int count);
+  void TranslatePageImpl(int count);
 
   // Sends a message to the browser to notify it that the translation failed
   // with |error|.
   void NotifyBrowserTranslationFailed(TranslateErrors::Type error);
 
   // Convenience method to access the main frame.  Can return NULL, typically
   // if the page is being closed.
   blink::WebLocalFrame* GetMainFrame();
 
-  // An ever-increasing sequence number of the current page, used to match up
-  // translation requests with responses.
-  int page_seq_no_;
-
   // The states associated with the current translation.
-  bool translation_pending_;
+  TranslateCallback translate_callback_pending_;
   std::string source_lang_;
   std::string target_lang_;
 
   // Time when a page langauge is determined. This is used to know a duration
   // time from showing infobar to requesting translation.
   base::TimeTicks language_determined_time_;
 
   // The world ID to use for script execution.
   int world_id_;
 
   // The extension group.
   int extension_group_;
 
   // The URL scheme for translate extensions.
   std::string extension_scheme_;
 
+  mojom::ContentTranslateDriverPtr translate_driver_;
+
+  mojo::Binding<mojom::Page> binding_;
+
   // Method factory used to make calls to TranslatePageImpl.
   base::WeakPtrFactory<TranslateHelper> weak_method_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TranslateHelper);
 };
 
 }  // namespace translate
 
 #endif  // COMPONENTS_TRANSLATE_CONTENT_RENDERER_TRANSLATE_HELPER_H_