Infobar system refactor.

chrome/browser/ui/android/infobars/translate_infobar.cc

Index: chrome/browser/ui/android/infobars/translate_infobar.cc
===================================================================
--- chrome/browser/ui/android/infobars/translate_infobar.cc	(revision 226624)
+++ chrome/browser/ui/android/infobars/translate_infobar.cc	(working copy)
@@ -12,131 +12,133 @@
 #include "jni/TranslateInfoBarDelegate_jni.h"
 #include "ui/base/l10n/l10n_util.h"
 
-using base::android::AttachCurrentThread;
-using base::android::ScopedJavaLocalRef;
 
+// TranslateInfoBarDelegate ---------------------------------------------------
+
 // static
-InfoBar* TranslateInfoBarDelegate::CreateInfoBar(InfoBarService* owner) {
-  return new TranslateInfoBar(owner, this);
+scoped_ptr<InfoBar> TranslateInfoBarDelegate::CreateInfoBar(
+    scoped_ptr<TranslateInfoBarDelegate> delegate) {
+  return scoped_ptr<InfoBar>(new TranslateInfoBar(delegate.Pass()));
 }
 
-TranslateInfoBar::TranslateInfoBar(InfoBarService* owner,
-                                   TranslateInfoBarDelegate* delegate)
-    : InfoBarAndroid(owner, delegate),
-      delegate_(delegate),
+
+// TranslateInfoBar -----------------------------------------------------------
+
+TranslateInfoBar::TranslateInfoBar(
+    scoped_ptr<TranslateInfoBarDelegate> delegate)
+    : InfoBarAndroid(delegate.PassAs<InfoBarDelegate>()),
       java_translate_delegate_() {}
 
 TranslateInfoBar::~TranslateInfoBar() {
 }
 
-ScopedJavaLocalRef<jobject> TranslateInfoBar::CreateRenderInfoBar(JNIEnv* env) {
+void TranslateInfoBar::ApplyTranslateOptions(
+    JNIEnv* env,
+    jobject obj,
+    int source_language_index,
+    int target_language_index,
+    bool always_translate,
+    bool never_translate_language,
+    bool never_translate_site) {
+  TranslateInfoBarDelegate* delegate = GetDelegate();
+  delegate->set_original_language_index(source_language_index);
+  delegate->set_target_language_index(target_language_index);
+  if (delegate->ShouldAlwaysTranslate() != always_translate)
+    delegate->ToggleAlwaysTranslate();
+  if (never_translate_language && delegate->IsTranslatableLanguageByPrefs())
+    delegate->ToggleTranslatableLanguageByPrefs();
+  if (never_translate_site && !delegate->IsSiteBlacklisted())
+    delegate->ToggleSiteBlacklist();
+}
+
+base::android::ScopedJavaLocalRef<jobject>
+    TranslateInfoBar::CreateRenderInfoBar(JNIEnv* env) {
   java_translate_delegate_.Reset(Java_TranslateInfoBarDelegate_create(env));
-  ScopedJavaLocalRef<jobject> java_infobar;
-  std::vector<string16> languages(delegate_->num_languages());
-  for (size_t i = 0; i < delegate_->num_languages(); ++i) {
-    languages[i] = delegate_->language_name_at(i);
-  }
-  ScopedJavaLocalRef<jobjectArray> java_languages =
+  base::android::ScopedJavaLocalRef<jobject> java_infobar;
+  TranslateInfoBarDelegate* delegate = GetDelegate();
+  std::vector<string16> languages;
+  languages.reserve(delegate->num_languages());
+  for (size_t i = 0; i < delegate->num_languages(); ++i)
+    languages.push_back(delegate->language_name_at(i));
+  base::android::ScopedJavaLocalRef<jobjectArray> java_languages =
       base::android::ToJavaArrayOfStrings(env, languages);
+  return Java_TranslateInfoBarDelegate_showTranslateInfoBar(
+      env, java_translate_delegate_.obj(), reinterpret_cast<jint>(this),
+      delegate->infobar_type(), delegate->original_language_index(),
+      delegate->target_language_index(), delegate->ShouldAlwaysTranslate(),
+      ShouldDisplayNeverInfoBarOnNope(), java_languages.obj());
+}
 
-  java_infobar = Java_TranslateInfoBarDelegate_showTranslateInfoBar(
-      env,
-      java_translate_delegate_.obj(),
-      reinterpret_cast<jint>(this),
-      delegate_->infobar_type(),
-      delegate_->original_language_index(),
-      delegate_->target_language_index(),
-      delegate_->ShouldAlwaysTranslate(),
-      ShouldDisplayNeverInfoBarOnNope(),
-      java_languages.obj());
+void TranslateInfoBar::ProcessButton(int action,
+                                     const std::string& action_value) {
+  // TODO(pkasting): The subsequent check isn't necessary if Android infobar
+  // buttons become unclickable once the infobar is unowned.
+  if (!owner())
+    return;  // We're closing; don't call anything, it might access the owner.
 
-  return java_infobar;
-}
-
-void TranslateInfoBar::ProcessButton(
-    int action, const std::string& action_value) {
+  TranslateInfoBarDelegate* delegate = GetDelegate();
   if (action == InfoBarAndroid::ACTION_TRANSLATE) {
-    delegate_->Translate();
-  } else if (action == InfoBarAndroid::ACTION_CANCEL) {
-    delegate_->TranslationDeclined();
-  } else if (action == InfoBarAndroid::ACTION_TRANSLATE_SHOW_ORIGINAL) {
-    delegate_->RevertTranslation();
-  } else if (action != InfoBarAndroid::ACTION_NONE) {
-    NOTREACHED();
+    delegate->Translate();
+    return;
   }
 
-  if (action != InfoBarAndroid::ACTION_TRANSLATE) {
-    // do not close the infobar upon translate
-    // since it will be replaced by a different one
-    // which will close this current infobar.
-    CloseInfoBar();
-  }
-}
+  if (action == InfoBarAndroid::ACTION_CANCEL)
+    delegate->TranslationDeclined();
+  else if (action == InfoBarAndroid::ACTION_TRANSLATE_SHOW_ORIGINAL)
+    delegate->RevertTranslation();
+  else
+    DCHECK_EQ(InfoBarAndroid::ACTION_NONE, action);
 
-void TranslateInfoBar::SetJavaDelegate(jobject delegate) {
-  JNIEnv* env = AttachCurrentThread();
-  java_translate_delegate_.Reset(env, delegate);
+  // Do not close the infobar upon translate, since it will be replaced by a
+  // different one which will close this infobar.
+  CloseInfoBar();
 }
 
 void TranslateInfoBar::PassJavaInfoBar(InfoBarAndroid* source) {
-  if (delegate_->infobar_type() != TranslateInfoBarDelegate::TRANSLATING &&
-      delegate_->infobar_type() != TranslateInfoBarDelegate::AFTER_TRANSLATE &&
-      delegate_->infobar_type() !=
-          TranslateInfoBarDelegate::TRANSLATION_ERROR) {
+  TranslateInfoBarDelegate* delegate = GetDelegate();
+  if (delegate->infobar_type() != TranslateInfoBarDelegate::TRANSLATING &&
+      delegate->infobar_type() != TranslateInfoBarDelegate::AFTER_TRANSLATE &&
+      delegate->infobar_type() != TranslateInfoBarDelegate::TRANSLATION_ERROR)
     return;
-  }
-  DCHECK(source != NULL);
-  TranslateInfoBar* source_infobar = static_cast<TranslateInfoBar*>(source);
 
   // Ask the former bar to transfer ownership to us.
-  source_infobar->TransferOwnership(this, delegate_->infobar_type());
+  DCHECK(source != NULL);
+  static_cast<TranslateInfoBar*>(source)->TransferOwnership(
+      this, delegate->infobar_type());
 }
 
+bool TranslateInfoBar::ShouldDisplayNeverInfoBarOnNope() {
+  TranslateInfoBarDelegate* delegate = GetDelegate();
+  return
+      (delegate->infobar_type() ==
+          TranslateInfoBarDelegate::BEFORE_TRANSLATE) &&
+      delegate->ShouldShowNeverTranslateShortcut();
+}
+
+void TranslateInfoBar::SetJavaDelegate(jobject delegate) {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  java_translate_delegate_.Reset(env, delegate);
+}
+
 void TranslateInfoBar::TransferOwnership(
     TranslateInfoBar* destination,
     TranslateInfoBarDelegate::Type new_type) {
-  JNIEnv* env = AttachCurrentThread();
+  JNIEnv* env = base::android::AttachCurrentThread();
   if (Java_TranslateInfoBarDelegate_changeTranslateInfoBarTypeAndPointer(
-          env,
-          java_translate_delegate_.obj(),
-          reinterpret_cast<jint>(destination),
-          new_type)) {
+      env, java_translate_delegate_.obj(), reinterpret_cast<jint>(destination),
+      new_type)) {
     ReassignJavaInfoBar(destination);
     destination->SetJavaDelegate(java_translate_delegate_.Release());
   }
 }
 
-bool TranslateInfoBar::ShouldDisplayNeverInfoBarOnNope() {
-  return
-      (delegate_->infobar_type() == TranslateInfoBarDelegate::BEFORE_TRANSLATE)
-      && (delegate_->ShouldShowNeverTranslateShortcut());
+TranslateInfoBarDelegate* TranslateInfoBar::GetDelegate() {
+  return delegate()->AsTranslateInfoBarDelegate();
 }
 
-// -----------------------------------------------------------------------------
-// Native JNI methods for the translate delegate.
-// -----------------------------------------------------------------------------
-void TranslateInfoBar::ApplyTranslateOptions(JNIEnv* env, jobject obj,
-    int source_language_index, int target_language_index,
-    bool always_translate, bool never_translate_language,
-    bool never_translate_site) {
-  if (delegate_->original_language_index() !=
-      static_cast<size_t>(source_language_index))
-    delegate_->set_original_language_index(source_language_index);
 
-  if (delegate_->target_language_index() !=
-      static_cast<size_t>(target_language_index))
-     delegate_->set_target_language_index(target_language_index);
+// Native JNI methods ---------------------------------------------------------
 
-  if (delegate_->ShouldAlwaysTranslate() != always_translate)
-    delegate_->ToggleAlwaysTranslate();
-
-  if (never_translate_language && delegate_->IsTranslatableLanguageByPrefs())
-    delegate_->ToggleTranslatableLanguageByPrefs();
-
-  if (never_translate_site && !delegate_->IsSiteBlacklisted())
-    delegate_->ToggleSiteBlacklist();
-}
-
 bool RegisterTranslateInfoBarDelegate(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }