Implement Android UI of web notification inline replies

chrome/browser/notifications/notification_ui_manager_android.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 "chrome/browser/notifications/notification_ui_manager_android.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/android/context_utils.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
+#include "base/strings/nullable_string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/notifications/notification.h"
 #include "chrome/browser/notifications/persistent_notification_delegate.h"
 #include "chrome/browser/notifications/platform_notification_service_impl.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "content/public/common/persistent_notification_status.h"
 #include "content/public/common/platform_notification_data.h"
 #include "jni/NotificationUIManager_jni.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/android/java_bitmap.h"
 #include "ui/gfx/image/image.h"
 
 using base::android::AttachCurrentThread;
 using base::android::ConvertJavaStringToUTF8;
 using base::android::ConvertUTF16ToJavaString;
 using base::android::ConvertUTF8ToJavaString;
 
 namespace {
 
+ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfNullableStrings(
+    JNIEnv* env,
+    const std::vector<base::NullableString16>& strings) {
+  ScopedJavaLocalRef<jclass> string_clazz =
+      base::android::GetClass(env, "java/lang/String");
+  jobjectArray array =
+      env->NewObjectArray(strings.size(), string_clazz.obj(), nullptr);
+  base::android::CheckException(env);
+
+  for (size_t i = 0; i < strings.size(); ++i) {
+    if (strings[i].is_null())
+      continue;
+    env->SetObjectArrayElement(
+        array, i, ConvertUTF16ToJavaString(env, strings[i].string()).obj());
+  }
+  return ScopedJavaLocalRef<jobjectArray>(env, array);
+}
+
 ScopedJavaLocalRef<jobjectArray> ConvertToJavaBitmaps(
     const std::vector<message_center::ButtonInfo>& buttons) {
   std::vector<SkBitmap> skbitmaps;
   for (const message_center::ButtonInfo& button : buttons)
     skbitmaps.push_back(button.icon.AsBitmap());
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jclass> clazz =
       base::android::GetClass(env, "android/graphics/Bitmap");
   jobjectArray array = env->NewObjectArray(skbitmaps.size(), clazz.obj(),
@@ skipping 118 matching lines @@
   ScopedJavaLocalRef<jobject> notification_icon;
   SkBitmap notification_icon_bitmap = notification.icon().AsBitmap();
   if (!notification_icon_bitmap.drawsNothing())
     notification_icon = gfx::ConvertToJavaBitmap(&notification_icon_bitmap);
 
   ScopedJavaLocalRef<jobject> badge;
   SkBitmap badge_bitmap = notification.small_image().AsBitmap();
   if (!badge_bitmap.drawsNothing())
     badge = gfx::ConvertToJavaBitmap(&badge_bitmap);
 
+  std::vector<int> action_types_vector;
   std::vector<base::string16> action_titles_vector;
-  for (const message_center::ButtonInfo& button : notification.buttons())
+  std::vector<base::NullableString16> action_placeholders_vector;
+  for (const message_center::ButtonInfo& button : notification.buttons()) {
+    action_types_vector.push_back(static_cast<int>(button.type));
     action_titles_vector.push_back(button.title);
+    action_placeholders_vector.push_back(button.placeholder);
+  }
+
+  ScopedJavaLocalRef<jintArray> action_types =
+      base::android::ToJavaIntArray(env, action_types_vector);
+
   ScopedJavaLocalRef<jobjectArray> action_titles =
       base::android::ToJavaArrayOfStrings(env, action_titles_vector);
 
   ScopedJavaLocalRef<jobjectArray> action_icons =
       ConvertToJavaBitmaps(notification.buttons());
 
+  ScopedJavaLocalRef<jobjectArray> action_placeholders =
+      ToJavaArrayOfNullableStrings(env, action_placeholders_vector);
+
   ScopedJavaLocalRef<jintArray> vibration_pattern =
       base::android::ToJavaIntArray(env, notification.vibration_pattern());
 
   ScopedJavaLocalRef<jstring> profile_id =
       ConvertUTF8ToJavaString(env, profile->GetPath().BaseName().value());
 
   Java_NotificationUIManager_displayNotification(
       env, java_object_.obj(), persistent_notification_id, origin.obj(),
       profile_id.obj(), profile->IsOffTheRecord(), tag.obj(), title.obj(),
       body.obj(), notification_icon.obj(), badge.obj(), vibration_pattern.obj(),
       notification.timestamp().ToJavaTime(), notification.renotify(),
-      notification.silent(), action_titles.obj(), action_icons.obj());
+      notification.silent(), action_types.obj(), action_titles.obj(),
+      action_icons.obj(), action_placeholders.obj());
 
   regenerated_notification_infos_[persistent_notification_id] =
       std::make_pair(origin_url.spec(), notification.tag());
 
   notification.delegate()->Display();
 }
 
 bool NotificationUIManagerAndroid::Update(const Notification& notification,
                                           Profile* profile) {
   NOTREACHED();
@@ skipping 65 matching lines @@
   return false;
 }
 
 void NotificationUIManagerAndroid::CancelAll() {
   NOTREACHED();
 }
 
 bool NotificationUIManagerAndroid::RegisterNotificationUIManager(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }