Move Translate browser-side IPC handling to the component.

components/translate/content/browser/content_translate_driver.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 "components/translate/content/browser/content_translate_driver.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "components/translate/content/common/translate_messages.h"
 #include "components/translate/core/browser/translate_download_manager.h"
@@ skipping 17 matching lines @@
 
 }  // namespace
 
 namespace translate {
 
 ContentTranslateDriver::ContentTranslateDriver(
     content::NavigationController* nav_controller)
     : content::WebContentsObserver(nav_controller->GetWebContents()),
       navigation_controller_(nav_controller),
       translate_manager_(NULL),
-      observer_(NULL),
       max_reload_check_attempts_(kMaxTranslateLoadCheckAttempts),
       weak_pointer_factory_(this) {
   DCHECK(navigation_controller_);
 }
 
 ContentTranslateDriver::~ContentTranslateDriver() {}
 
+void ContentTranslateDriver::AddObserver(Observer* observer) {
+  observer_list_.AddObserver(observer);
+}
+
+void ContentTranslateDriver::RemoveObserver(Observer* observer) {
+  observer_list_.RemoveObserver(observer);
+}
+
 void ContentTranslateDriver::InitiateTranslation(const std::string& page_lang,
                                                  int attempt) {
   if (translate_manager_->GetLanguageState().translation_pending())
     return;
 
   // During a reload we need web content to be available before the
   // translate script is executed. Otherwise we will run the translate script on
   // an empty DOM which will fail. Therefore we wait a bit to see if the page
   // has finished.
   if (web_contents()->IsLoading() && attempt < max_reload_check_attempts_) {
@@ skipping 14 matching lines @@
 
 // TranslateDriver methods
 
 bool ContentTranslateDriver::IsLinkNavigation() {
   return navigation_controller_ && navigation_controller_->GetActiveEntry() &&
          navigation_controller_->GetActiveEntry()->GetTransitionType() ==
              content::PAGE_TRANSITION_LINK;
 }
 
 void ContentTranslateDriver::OnTranslateEnabledChanged() {
-  if (observer_) {
-    content::WebContents* web_contents =
-        navigation_controller_->GetWebContents();
-    observer_->OnTranslateEnabledChanged(web_contents);
-  }
+  content::WebContents* web_contents = navigation_controller_->GetWebContents();
+  FOR_EACH_OBSERVER(
+      Observer, observer_list_, OnTranslateEnabledChanged(web_contents));
 }
 
 void ContentTranslateDriver::OnIsPageTranslatedChanged() {
-  if (observer_) {
     content::WebContents* web_contents =
         navigation_controller_->GetWebContents();
-    observer_->OnIsPageTranslatedChanged(web_contents);
-  }
+    FOR_EACH_OBSERVER(
+        Observer, observer_list_, OnIsPageTranslatedChanged(web_contents));
 }
 
 void ContentTranslateDriver::TranslatePage(int page_seq_no,
                                            const std::string& translate_script,
                                            const std::string& source_lang,
                                            const std::string& target_lang) {
   content::WebContents* web_contents = navigation_controller_->GetWebContents();
   web_contents->GetRenderViewHost()->Send(
       new ChromeViewMsg_TranslatePage(
           web_contents->GetRenderViewHost()->GetRoutingID(),
@@ skipping 102 matching lines @@
     const content::LoadCommittedDetails& details,
     const content::FrameNavigateParams& params) {
   // Let the LanguageState clear its state.
   const bool reload =
       details.entry->GetTransitionType() == content::PAGE_TRANSITION_RELOAD ||
       details.type == content::NAVIGATION_TYPE_SAME_PAGE;
   translate_manager_->GetLanguageState().DidNavigate(
       details.is_in_page, details.is_main_frame, reload);
 }
 
+bool ContentTranslateDriver::OnMessageReceived(const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(ContentTranslateDriver, message)
+  IPC_MESSAGE_HANDLER(ChromeViewHostMsg_TranslateAssignedSequenceNumber,
+                      OnTranslateAssignedSequenceNumber)
+  IPC_MESSAGE_HANDLER(ChromeViewHostMsg_TranslateLanguageDetermined,
+                      OnLanguageDetermined)
+  IPC_MESSAGE_HANDLER(ChromeViewHostMsg_PageTranslated, OnPageTranslated)
+  IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+void ContentTranslateDriver::OnTranslateAssignedSequenceNumber(
+    int page_seq_no) {
+  translate_manager_->set_current_seq_no(page_seq_no);
+}
+
+void ContentTranslateDriver::OnLanguageDetermined(
+    const LanguageDetectionDetails& details,
+    bool page_needs_translation) {
+  translate_manager_->GetLanguageState().LanguageDetermined(
+      details.adopted_language, page_needs_translation);
+
+  if (web_contents())
+    translate_manager_->InitiateTranslation(details.adopted_language);
+
+  FOR_EACH_OBSERVER(Observer, observer_list_, OnLanguageDetermined(details));
+}
+
+void ContentTranslateDriver::OnPageTranslated(
+    const std::string& original_lang,
+    const std::string& translated_lang,
+    TranslateErrors::Type error_type) {
+  translate_manager_->PageTranslated(
+      original_lang, translated_lang, error_type);
+  FOR_EACH_OBSERVER(
+      Observer,
+      observer_list_,
+      OnPageTranslated(original_lang, translated_lang, error_type));
+}
+
 }  // namespace translate