Creates translate_compact_infobar class, which holds the logic for the new translate UI

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

 // Copyright 2013 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_infobar.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #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/chrome_translate_client.h"
+#include "chrome/browser/ui/android/infobars/translate_compact_infobar.h"
+#include "chrome/browser/ui/android/infobars/translate_utils.h"
 #include "components/translate/core/browser/translate_infobar_delegate.h"
-#include "jni/TranslateCompactInfoBar_jni.h"
 #include "jni/TranslateInfoBar_jni.h"
 
 using base::android::JavaParamRef;
 using base::android::ScopedJavaLocalRef;
 
 // ChromeTranslateClient
 // ----------------------------------------------------------
 
 std::unique_ptr<infobars::InfoBar> ChromeTranslateClient::CreateInfoBar(
     std::unique_ptr<translate::TranslateInfoBarDelegate> delegate) const {
-  return base::MakeUnique<TranslateInfoBar>(std::move(delegate));
+  if (translate::TranslateInfoBarDelegate::IsCompactUIEnabled())
+    return base::MakeUnique<TranslateCompactInfoBar>(std::move(delegate));
+  else
+    return base::MakeUnique<TranslateInfoBar>(std::move(delegate));
 }
 
 
 // TranslateInfoBar -----------------------------------------------------------
 
 TranslateInfoBar::TranslateInfoBar(
     std::unique_ptr<translate::TranslateInfoBarDelegate> delegate)
     : InfoBarAndroid(std::move(delegate)) {}
 
 TranslateInfoBar::~TranslateInfoBar() {
 }
 
 ScopedJavaLocalRef<jobject> TranslateInfoBar::CreateRenderInfoBar(JNIEnv* env) {
   translate::TranslateInfoBarDelegate* delegate = GetDelegate();
-  std::vector<base::string16> languages;
-  std::vector<std::string> codes;
-  languages.reserve(delegate->num_languages());
-  codes.reserve(delegate->num_languages());
-  for (size_t i = 0; i < delegate->num_languages(); ++i) {
-    languages.push_back(delegate->language_name_at(i));
-    codes.push_back(delegate->language_code_at(i));
-  }
-  DCHECK(codes.size() == languages.size());
   base::android::ScopedJavaLocalRef<jobjectArray> java_languages =
-      base::android::ToJavaArrayOfStrings(env, languages);
+      TranslateUtils::GetJavaLanguages(env, delegate);
   base::android::ScopedJavaLocalRef<jobjectArray> java_codes =
-      base::android::ToJavaArrayOfStrings(env, codes);
+      TranslateUtils::GetJavaLanguageCodes(env, delegate);
 
   ScopedJavaLocalRef<jstring> source_language_code =
-      base::android::ConvertUTF8ToJavaString(
-          env, delegate->original_language_code());
+      TranslateUtils::GetLanguageCode(env, delegate->original_language_code());

[gone, 2017/03/24 20:34:30]

Why does this need to be pulled out?  It's a single line call that's pretty
standard for converting strings.

[ramyasharma, 2017/03/27 03:36:59]

Done.

 
   ScopedJavaLocalRef<jstring> target_language_code =
-      base::android::ConvertUTF8ToJavaString(env,
-                                             delegate->target_language_code());
+      TranslateUtils::GetLanguageCode(env, delegate->target_language_code());
 
-  if (translate::TranslateInfoBarDelegate::IsCompactUIEnabled()) {
-    return Java_TranslateCompactInfoBar_create(env);
-  } else {
-    return Java_TranslateInfoBar_show(
-        env, delegate->translate_step(), source_language_code,
-        target_language_code, delegate->ShouldAlwaysTranslate(),
-        ShouldDisplayNeverTranslateInfoBarOnCancel(),
-        delegate->triggered_from_menu(), java_languages, java_codes);
-  }
+  return Java_TranslateInfoBar_show(
+      env, delegate->translate_step(), source_language_code,
+      target_language_code, delegate->ShouldAlwaysTranslate(),
+      ShouldDisplayNeverTranslateInfoBarOnCancel(),
+      delegate->triggered_from_menu(), java_languages, java_codes);
 }
 
 void TranslateInfoBar::ProcessButton(int action) {
   if (!owner())
     return;  // We're closing; don't call anything, it might access the owner.
 
   translate::TranslateInfoBarDelegate* delegate = GetDelegate();
   if (action == InfoBarAndroid::ACTION_TRANSLATE) {
     delegate->Translate();
     return;
@@ skipping 17 matching lines @@
   // Ask the former bar to transfer ownership to us.
   DCHECK(source != NULL);
   static_cast<TranslateInfoBar*>(source)->TransferOwnership(
       this, delegate->translate_step());
 }
 
 void TranslateInfoBar::SetJavaInfoBar(
     const base::android::JavaRef<jobject>& java_info_bar) {
   InfoBarAndroid::SetJavaInfoBar(java_info_bar);
   JNIEnv* env = base::android::AttachCurrentThread();
-  if (translate::TranslateInfoBarDelegate::IsCompactUIEnabled()) {
-    Java_TranslateCompactInfoBar_setNativePtr(env, java_info_bar,
-                                              reinterpret_cast<intptr_t>(this));
-  } else {
     Java_TranslateInfoBar_setNativePtr(env, java_info_bar,
                                        reinterpret_cast<intptr_t>(this));
-  }
 }
 
 void TranslateInfoBar::ApplyTranslateOptions(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj,
     const JavaParamRef<jstring>& source_language_code,
     const JavaParamRef<jstring>& target_language_code,
     bool always_translate,
     bool never_translate_language,
     bool never_translate_site) {
@@ skipping 34 matching lines @@
 translate::TranslateInfoBarDelegate* TranslateInfoBar::GetDelegate() {
   return delegate()->AsTranslateInfoBarDelegate();
 }
 
 
 // Native JNI methods ---------------------------------------------------------
 
 bool RegisterTranslateInfoBarDelegate(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }