Replace OnPageTranslate Obsever by a responder of delegate.

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

 // Copyright 2017 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 "chrome/browser/ui/android/infobars/translate_compact_infobar.h"
 
 #include <stddef.h>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/android/jni_weak_ref.h"
 #include "base/memory/ptr_util.h"
 #include "chrome/browser/translate/android/translate_utils.h"
 #include "components/translate/core/browser/translate_infobar_delegate.h"
 #include "jni/TranslateCompactInfoBar_jni.h"
 
 using base::android::JavaParamRef;
 using base::android::ScopedJavaLocalRef;
 
 // TranslateInfoBar -----------------------------------------------------------
 
 TranslateCompactInfoBar::TranslateCompactInfoBar(
     std::unique_ptr<translate::TranslateInfoBarDelegate> delegate)
-    : InfoBarAndroid(std::move(delegate)) {
-  // |translate_driver| must already be bound.
-  DCHECK(GetDelegate()->GetTranslateDriver());
-  translate_driver_ = static_cast<translate::ContentTranslateDriver*>(
-      GetDelegate()->GetTranslateDriver());
-  translate_driver_->AddObserver(this);
+    : InfoBarAndroid(std::move(delegate)), action_flags_(FLAG_NONE) {
+  GetDelegate()->SetResponder(this);
 }
 
 TranslateCompactInfoBar::~TranslateCompactInfoBar() {
-  DCHECK(translate_driver_);
-  translate_driver_->RemoveObserver(this);
+  GetDelegate()->SetResponder(nullptr);
 }
 
 ScopedJavaLocalRef<jobject> TranslateCompactInfoBar::CreateRenderInfoBar(
     JNIEnv* env) {
   translate::TranslateInfoBarDelegate* delegate = GetDelegate();
 
   base::android::ScopedJavaLocalRef<jobjectArray> java_languages =
       TranslateUtils::GetJavaLanguages(env, delegate);
   base::android::ScopedJavaLocalRef<jobjectArray> java_codes =
       TranslateUtils::GetJavaLanguageCodes(env, delegate);
@@ skipping 14 matching lines @@
       java_hash_codes);
 }
 
 void TranslateCompactInfoBar::ProcessButton(int action) {
   if (!owner())
     return;  // We're closing; don't call anything, it might access the owner.
 
   // TODO(ramyasharma): Handle other button clicks.
   translate::TranslateInfoBarDelegate* delegate = GetDelegate();
   if (action == InfoBarAndroid::ACTION_TRANSLATE) {
+    action_flags_ |= FLAG_TRANSLATE;

[groby-ooo-7-16, 2017/05/20 21:30:39]

SHould this flag be traced on the delegate instead?

[Leo, 2017/05/21 04:15:20]

The actions traced here are mostly frontend-specific behaviors. Since the new
user flow is very different from the original one, it's hard to integrate the
different flow in the same delegate used by all original clients.

What's more, the tracing is only used in new UX, tracing them here are easier
and straightforward. 

     delegate->Translate();
     if (!delegate->ShouldAlwaysTranslate() && ShouldAutoAlwaysTranslate()) {
       JNIEnv* env = base::android::AttachCurrentThread();
       Java_TranslateCompactInfoBar_setAutoAlwaysTranslate(env,
                                                           GetJavaInfoBar());
     }
   } else if (action == InfoBarAndroid::ACTION_TRANSLATE_SHOW_ORIGINAL) {
+    action_flags_ |= FLAG_REVERT;
     delegate->RevertTranslation();
   } else if (action == InfoBarAndroid::ACTION_CANCEL) {
     delegate->TranslationDeclined();
   } else {
     DCHECK_EQ(InfoBarAndroid::ACTION_NONE, action);
   }
 }
 
 void TranslateCompactInfoBar::SetJavaInfoBar(
     const base::android::JavaRef<jobject>& java_info_bar) {
@@ skipping 25 matching lines @@
 }
 
 void TranslateCompactInfoBar::ApplyBoolTranslateOption(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj,
     int option,
     jboolean value) {
   translate::TranslateInfoBarDelegate* delegate = GetDelegate();
   if (option == TranslateUtils::OPTION_ALWAYS_TRANSLATE) {
     if (delegate->ShouldAlwaysTranslate() != value) {
+      action_flags_ |= FLAG_ALWAYS_TRANSLATE;
       delegate->ToggleAlwaysTranslate();
     }
   } else if (option == TranslateUtils::OPTION_NEVER_TRANSLATE) {
     if (value && delegate->IsTranslatableLanguageByPrefs()) {
+      action_flags_ |= FLAG_NEVER_LANGUAGE;
       delegate->ToggleTranslatableLanguageByPrefs();
     }
   } else if (option == TranslateUtils::OPTION_NEVER_TRANSLATE_SITE) {
     if (value && !delegate->IsSiteBlacklisted()) {
+      action_flags_ |= FLAG_NEVER_SITE;
       delegate->ToggleSiteBlacklist();
     }
   } else {
     DCHECK(false);
   }
 }
 
-void TranslateCompactInfoBar::OnPageTranslated(
-    const std::string& original_lang,
-    const std::string& translated_lang,
-    translate::TranslateErrors::Type error_type) {
-  if (!owner())
-    return;  // We're closing; don't call anything, it might access the owner.
-
-  DCHECK(translate_driver_);
-  JNIEnv* env = base::android::AttachCurrentThread();
-  Java_TranslateCompactInfoBar_onPageTranslated(env, GetJavaInfoBar(),
-                                                error_type);
-}
-
 bool TranslateCompactInfoBar::ShouldAutoAlwaysTranslate() {
   translate::TranslateInfoBarDelegate* delegate = GetDelegate();
   return (delegate->GetTranslationAcceptedCount() == kAcceptCountThreshold);
 }
 
 jboolean TranslateCompactInfoBar::ShouldAutoNeverTranslate(
     JNIEnv* env,
     const base::android::JavaParamRef<jobject>& obj) {
   translate::TranslateInfoBarDelegate* delegate = GetDelegate();
   return (delegate->GetTranslationDeniedCount() == kDeniedCountThreshold);
 }
 
 translate::TranslateInfoBarDelegate* TranslateCompactInfoBar::GetDelegate() {
   return delegate()->AsTranslateInfoBarDelegate();
 }
 
+void TranslateCompactInfoBar::ActionOnStep(
+    translate::TranslateStep step,
+    translate::TranslateErrors::Type error_type) {
+  if (!owner())
+    return;  // We're closing; don't call anything.
+
+  if ((step == translate::TRANSLATE_STEP_AFTER_TRANSLATE) ||
+      (step == translate::TRANSLATE_STEP_TRANSLATE_ERROR)) {
+    JNIEnv* env = base::android::AttachCurrentThread();
+    Java_TranslateCompactInfoBar_onPageTranslated(env, GetJavaInfoBar(),
+                                                  error_type);
+  }
+}
+
+bool TranslateCompactInfoBar::Declined() {
+  return action_flags_ == FLAG_NONE;
+};
+
 // Native JNI methods ---------------------------------------------------------
 
 // static
 bool RegisterTranslateCompactInfoBar(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }