New pyauto hook for the translate feature.

Review URL: http://codereview.chromium.org/3026016

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@53791 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 262 insertions, 0 deletions

diff --git a/chrome/browser/automation/automation_provider.cc b/chrome/browser/automation/automation_provider.cc
index 5b3fe45..e29f025 100644
--- a/chrome/browser/automation/automation_provider.cc
+++ b/chrome/browser/automation/automation_provider.cc
@@ -2744,6 +2744,131 @@ void AutomationProvider::ClearBrowsingData(Browser* browser,
   // The observer also deletes itself after sending the reply.
 }
 
+namespace {
+
+  // Get the TabContents from a dictionary of arguments.
+  TabContents* GetTabContentsFromDict(const Browser* browser,
+                                      const DictionaryValue* args,
+                                      std::string* error_message) {
+    int tab_index;
+    if (!args->GetInteger(L"tab_index", &tab_index)) {
+      *error_message = "Must include tab_index.";
+      return NULL;
+    }
+
+    TabContents* tab_contents = browser->GetTabContentsAt(tab_index);
+    if (!tab_contents) {
+      *error_message = StringPrintf("No tab at index %d.", tab_index);
+      return NULL;
+    }
+    return tab_contents;
+  }
+
+  // Get the TranslateInfoBarDelegate from TabContents.
+  TranslateInfoBarDelegate* GetTranslateInfoBarDelegate(
+      TabContents* tab_contents) {
+    for (int i = 0; i < tab_contents->infobar_delegate_count(); i++) {
+      InfoBarDelegate* infobar = tab_contents->GetInfoBarDelegateAt(i);
+      if (infobar->AsTranslateInfoBarDelegate())
+        return infobar->AsTranslateInfoBarDelegate();
+    }
+    // No translate infobar.
+    return NULL;
+  }
+
+}  // namespace
+
+// See GetTranslateInfo() in chrome/test/pyautolib/pyauto.py for sample json
+// input and output.
+void AutomationProvider::GetTranslateInfo(Browser* browser,
+                                          DictionaryValue* args,
+                                          IPC::Message* reply_message) {
+  std::string error_message;
+  TabContents* tab_contents = GetTabContentsFromDict(browser, args,
+                                                     &error_message);
+  if (!tab_contents) {
+    AutomationJSONReply(this, reply_message).SendError(error_message);
+    return;
+  }
+
+  // Get the translate bar if there is one and pass it to the observer.
+  // The observer will check for null and populate the information accordingly.
+  TranslateInfoBarDelegate* translate_bar =
+      GetTranslateInfoBarDelegate(tab_contents);
+
+  TabLanguageDeterminedObserver* observer = new TabLanguageDeterminedObserver(
+      this, reply_message, tab_contents, translate_bar);
+  // If the language for the page hasn't been loaded yet, then just make
+  // the observer, otherwise call observe directly.
+  std::string language = tab_contents->language_state().original_language();
+  if (!language.empty()) {
+    observer->Observe(NotificationType::TAB_LANGUAGE_DETERMINED,
+                      Source<TabContents>(tab_contents),
+                      Details<std::string>(&language));
+  }
+}
+
+// See SelectTranslateOption() in chrome/test/pyautolib/pyauto.py for sample
+// json input.
+// Sample json output: {}
+void AutomationProvider::SelectTranslateOption(Browser* browser,
+                                               DictionaryValue* args,
+                                               IPC::Message* reply_message) {
+  std::string option;
+  std::string error_message;
+  TabContents* tab_contents = GetTabContentsFromDict(browser, args,
+                                                     &error_message);
+  if (!tab_contents) {
+    AutomationJSONReply(this, reply_message).SendError(error_message);
+    return;
+  }
+
+  TranslateInfoBarDelegate* translate_bar =
+      GetTranslateInfoBarDelegate(tab_contents);
+  if (!translate_bar) {
+    AutomationJSONReply(this, reply_message)
+        .SendError("There is no translate bar open.");
+    return;
+  }
+
+  if (!args->GetString(L"option", &option)) {
+    AutomationJSONReply(this, reply_message).SendError("Must include option");
+    return;
+  }
+
+  if (option == "translate_page") {
+    // Make a new notification observer which will send the reply.
+    new PageTranslatedObserver(this, reply_message, tab_contents);
+    translate_bar->Translate();
+    return;
+  }
+
+  AutomationJSONReply reply(this, reply_message);
+  if (option == "never_translate_language") {
+    if (translate_bar->IsLanguageBlacklisted()) {
+      reply.SendError("The language was already blacklisted.");
+      return;
+    }
+    translate_bar->ToggleLanguageBlacklist();
+    reply.SendSuccess(NULL);
+  } else if (option == "never_translate_site") {
+    if (translate_bar->IsSiteBlacklisted()) {
+      reply.SendError("The site was already blacklisted.");
+      return;
+    }
+    translate_bar->ToggleSiteBlacklist();
+    reply.SendSuccess(NULL);
+  } else if (option == "toggle_always_translate") {
+    translate_bar->ToggleAlwaysTranslate();
+    reply.SendSuccess(NULL);
+  } else if (option == "revert_translation") {
+    translate_bar->RevertTranslation();
+    reply.SendSuccess(NULL);
+  } else {
+    reply.SendError("Invalid string found for option.");
+  }
+}
+
 // Sample json input: { "command": "GetThemeInfo" }
 // Refer GetThemeInfo() in chrome/test/pyautolib/pyauto.py for sample output.
 void AutomationProvider::GetThemeInfo(Browser* browser,
@@ -3091,6 +3216,10 @@ void AutomationProvider::SendJSONRequest(int handle,
   // SetTheme() implemented using InstallExtension().
   handler_map["GetThemeInfo"] = &AutomationProvider::GetThemeInfo;
 
+  handler_map["SelectTranslateOption"] =
+      &AutomationProvider::SelectTranslateOption;
+  handler_map["GetTranslateInfo"] =  &AutomationProvider::GetTranslateInfo;
+
   handler_map["GetAutoFillProfile"] = &AutomationProvider::GetAutoFillProfile;
   handler_map["FillAutoFillProfile"] = &AutomationProvider::FillAutoFillProfile;
 
diff --git a/chrome/browser/automation/automation_provider.h b/chrome/browser/automation/automation_provider.h
index 1286e2b..4095ab9 100644
--- a/chrome/browser/automation/automation_provider.h
+++ b/chrome/browser/automation/automation_provider.h
@@ -57,6 +57,7 @@ class LoginHandler;
 class MetricEventDurationObserver;
 class InitialLoadObserver;
 class NavigationControllerRestoredObserver;
+class TranslateInfoBarDelegate;
 struct AutocompleteMatchData;
 
 namespace gfx {
@@ -506,6 +507,18 @@ class AutomationProvider : public base::RefCounted<AutomationProvider>,
                     DictionaryValue* args,
                     IPC::Message* reply_message);
 
+  // Returns information about translation for a given tab. Includes
+  // information about the translate bar if it is showing.
+  void GetTranslateInfo(Browser* browser,
+                        DictionaryValue* args,
+                        IPC::Message* reply_message);
+
+  // Takes the specified action on the translate bar.
+  // Uses the JSON interface for input/output.
+  void SelectTranslateOption(Browser* browser,
+                             DictionaryValue* args,
+                             IPC::Message* reply_message);
+
   // Get the profiles that are currently saved to the DB.
   // Uses the JSON interface for input/output.
   void GetAutoFillProfile(Browser* browser,
diff --git a/chrome/browser/automation/automation_provider_observers.cc b/chrome/browser/automation/automation_provider_observers.cc
index a9414be..a6a6b2a 100644
--- a/chrome/browser/automation/automation_provider_observers.cc
+++ b/chrome/browser/automation/automation_provider_observers.cc
@@ -23,6 +23,8 @@
 #include "chrome/browser/profile.h"
 #include "chrome/browser/tab_contents/navigation_controller.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
+#include "chrome/browser/translate/page_translated_details.h"
+#include "chrome/browser/translate/translate_infobar_delegate.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/test/automation/automation_constants.h"
@@ -929,6 +931,82 @@ void MetricEventDurationObserver::Observe(NotificationType type,
       metric_event_duration->duration_ms;
 }
 
+PageTranslatedObserver::PageTranslatedObserver(AutomationProvider* automation,
+                                               IPC::Message* reply_message,
+                                               TabContents* tab_contents)
+  : automation_(automation),
+    reply_message_(reply_message) {
+  registrar_.Add(this, NotificationType::PAGE_TRANSLATED,
+                 Source<TabContents>(tab_contents));
+}
+
+void PageTranslatedObserver::Observe(NotificationType type,
+                                     const NotificationSource& source,
+                                     const NotificationDetails& details) {
+  DCHECK(type == NotificationType::PAGE_TRANSLATED);
+  AutomationJSONReply reply(automation_, reply_message_);
+
+  PageTranslatedDetails* translated_details =
+      Details<PageTranslatedDetails>(details).ptr();
+  scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
+  return_value->SetBoolean(
+      L"translation_success",
+      translated_details->error_type == TranslateErrors::NONE);
+  reply.SendSuccess(return_value.get());
+  delete this;
+}
+
+TabLanguageDeterminedObserver::TabLanguageDeterminedObserver(
+    AutomationProvider* automation, IPC::Message* reply_message,
+    TabContents* tab_contents, TranslateInfoBarDelegate* translate_bar)
+  : automation_(automation),
+    reply_message_(reply_message),
+    tab_contents_(tab_contents),
+    translate_bar_(translate_bar) {
+  registrar_.Add(this, NotificationType::TAB_LANGUAGE_DETERMINED,
+                 Source<TabContents>(tab_contents));
+}
+
+void TabLanguageDeterminedObserver::Observe(
+    NotificationType type, const NotificationSource& source,
+    const NotificationDetails& details) {
+  DCHECK(type == NotificationType::TAB_LANGUAGE_DETERMINED);
+
+  scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
+  return_value->SetBoolean(L"page_translated",
+                           tab_contents_->language_state().IsPageTranslated());
+  return_value->SetBoolean(
+      L"can_translate_page", TranslatePrefs::CanTranslate(
+          automation_->profile()->GetPrefs(),
+          tab_contents_->language_state().original_language(),
+          tab_contents_->GetURL()));
+  return_value->SetString(
+      L"original_language",
+      tab_contents_->language_state().original_language());
+  if (translate_bar_) {
+    DictionaryValue* bar_info = new DictionaryValue;
+    std::map<TranslateInfoBarDelegate::Type, std::string> type_to_string;
+    type_to_string[TranslateInfoBarDelegate::BEFORE_TRANSLATE] =
+        "BEFORE_TRANSLATE";
+    type_to_string[TranslateInfoBarDelegate::TRANSLATING] =
+        "TRANSLATING";
+    type_to_string[TranslateInfoBarDelegate::AFTER_TRANSLATE] =
+        "AFTER_TRANSLATE";
+    type_to_string[TranslateInfoBarDelegate::TRANSLATION_ERROR] =
+        "TRANSLATION_ERROR";
+
+    bar_info->SetString(L"bar_state", type_to_string[translate_bar_->type()]);
+    bar_info->SetString(L"target_lang_code",
+                        translate_bar_->GetTargetLanguageCode());
+    bar_info->SetString(L"original_lang_code",
+                        translate_bar_->GetOriginalLanguageCode());
+    return_value->Set(L"translate_bar", bar_info);
+  }
+  AutomationJSONReply(automation_, reply_message_)
+      .SendSuccess(return_value.get());
+  delete this;
+}
+
 #if defined(OS_CHROMEOS)
 LoginManagerObserver::LoginManagerObserver(
     AutomationProvider* automation,
diff --git a/chrome/browser/automation/automation_provider_observers.h b/chrome/browser/automation/automation_provider_observers.h
index 90e2045..5d53cd3 100644
--- a/chrome/browser/automation/automation_provider_observers.h
+++ b/chrome/browser/automation/automation_provider_observers.h
@@ -30,6 +30,7 @@ class ExtensionProcessManager;
 class NavigationController;
 class SavePackage;
 class TabContents;
+class TranslateInfoBarDelegate;
 
 namespace IPC {
 class Message;
@@ -487,6 +488,47 @@ class MetricEventDurationObserver : public NotificationObserver {
   DISALLOW_COPY_AND_ASSIGN(MetricEventDurationObserver);
 };
 
+class PageTranslatedObserver : public NotificationObserver {
+ public:
+  PageTranslatedObserver(AutomationProvider* automation,
+                         IPC::Message* reply_message,
+                         TabContents* tab_contents);
+
+  // NotificationObserver interface.
+  virtual void Observe(NotificationType type,
+                       const NotificationSource& source,
+                       const NotificationDetails& details);
+
+ private:
+  NotificationRegistrar registrar_;
+  scoped_refptr<AutomationProvider> automation_;
+  IPC::Message* reply_message_;
+
+  DISALLOW_COPY_AND_ASSIGN(PageTranslatedObserver);
+};
+
+class TabLanguageDeterminedObserver : public NotificationObserver {
+ public:
+  TabLanguageDeterminedObserver(AutomationProvider* automation,
+                                IPC::Message* reply_message,
+                                TabContents* tab_contents,
+                                TranslateInfoBarDelegate* translate_bar);
+
+  // NotificationObserver interface.
+  virtual void Observe(NotificationType type,
+                       const NotificationSource& source,
+                       const NotificationDetails& details);
+
+ private:
+  NotificationRegistrar registrar_;
+  AutomationProvider* automation_;
+  IPC::Message* reply_message_;
+  TabContents* tab_contents_;
+  TranslateInfoBarDelegate* translate_bar_;
+
+  DISALLOW_COPY_AND_ASSIGN(TabLanguageDeterminedObserver);
+};
+
 #if defined(OS_CHROMEOS)
 // Collects LOGIN_AUTHENTICATION notifications and returns
 // whether authentication succeeded to the automation provider.