Refactor WebApkServiceConnectionManager.

chrome/browser/notifications/notification_platform_bridge_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_platform_bridge_android.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
+#include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/strings/nullable_string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/notifications/notification.h"
 #include "chrome/browser/notifications/notification_common.h"
 #include "chrome/browser/notifications/notification_display_service.h"
 #include "chrome/browser/notifications/notification_display_service_factory.h"
@@ skipping 14 matching lines @@
 using base::android::AttachCurrentThread;
 using base::android::ConvertJavaStringToUTF8;
 using base::android::ConvertJavaStringToUTF16;
 using base::android::ConvertUTF16ToJavaString;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::JavaParamRef;
 using base::android::ScopedJavaLocalRef;
 
 namespace {
 
+// Callback to call after querying WebAPK package name is done.
+// The parameter is the package name of the WebAPK that matches the query.
+using QueryWebApkPackageCallback = base::Callback<void(const std::string&)>;
+
 // A Java counterpart will be generated for this enum.
 // GENERATED_JAVA_ENUM_PACKAGE: org.chromium.chrome.browser.notifications
 enum NotificationActionType {
   // NB. Making this a one-line enum breaks code generation! crbug.com/657847
   BUTTON,
   TEXT
 };
 
 ScopedJavaLocalRef<jobject> ConvertToJavaBitmap(JNIEnv* env,
                                                 const gfx::Image& icon) {
@@ skipping 76 matching lines @@
     JNIEnv* env,
     const JavaParamRef<jclass>& clazz) {
   g_browser_process->notification_platform_bridge();
 }
 
 // static
 NotificationPlatformBridge* NotificationPlatformBridge::Create() {
   return new NotificationPlatformBridgeAndroid();
 }
 
-NotificationPlatformBridgeAndroid::NotificationPlatformBridgeAndroid() {
+NotificationPlatformBridgeAndroid::NotificationPlatformBridgeAndroid()
+    : weak_ptr_factory_(this) {
   java_object_.Reset(Java_NotificationPlatformBridge_create(
       AttachCurrentThread(), reinterpret_cast<intptr_t>(this)));
 }
 
 NotificationPlatformBridgeAndroid::~NotificationPlatformBridgeAndroid() {
   Java_NotificationPlatformBridge_destroy(AttachCurrentThread(), java_object_);
 }
 
 void NotificationPlatformBridgeAndroid::OnNotificationClicked(
     JNIEnv* env,
@@ skipping 52 matching lines @@
   DCHECK(profile_manager);
 
   profile_manager->LoadProfile(
       profile_id, incognito,
       base::Bind(&ProfileLoadedCallback, NotificationCommon::CLOSE,
                  NotificationCommon::PERSISTENT,
                  ConvertJavaStringToUTF8(env, java_origin), notification_id,
                  -1 /* action index */, base::NullableString16() /* reply */));
 }
 
+void NotificationPlatformBridgeAndroid::OnQueryWebApkPackage(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& java_object,
+    const JavaParamRef<jstring>& java_webapk_package,
+    const jlong jcallback_pointer) {
+  DCHECK(jcallback_pointer);
+  std::string webapk_package =
+      ConvertJavaStringToUTF8(env, java_webapk_package);
+  QueryWebApkPackageCallback* callback =
+      reinterpret_cast<QueryWebApkPackageCallback*>(jcallback_pointer);
+  callback->Run(webapk_package);
+  delete callback;
+}
+
 void NotificationPlatformBridgeAndroid::Display(
     NotificationCommon::Type notification_type,
     const std::string& notification_id,
     const std::string& profile_id,
     bool incognito,
     const Notification& notification) {
   JNIEnv* env = AttachCurrentThread();
   // TODO(miguelg): Store the notification type in java instead of assuming it's
   // persistent once/if non persistent notifications are ever implemented on
   // Android.
   DCHECK_EQ(notification_type, NotificationCommon::PERSISTENT);
 
-  GURL origin_url(notification.origin_url().GetOrigin());
-
   GURL scope_url(notification.service_worker_scope());
   if (!scope_url.is_valid())
-    scope_url = origin_url;
+    scope_url = GURL(notification.origin_url().GetOrigin());
   ScopedJavaLocalRef<jstring> j_scope_url =
         ConvertUTF8ToJavaString(env, scope_url.spec());
-  ScopedJavaLocalRef<jstring> webapk_package =
-      Java_NotificationPlatformBridge_queryWebApkPackage(
-          env, java_object_, j_scope_url);
+  uintptr_t callback_pointer =
+      reinterpret_cast<uintptr_t>(new QueryWebApkPackageCallback(
+          base::Bind(&NotificationPlatformBridgeAndroid::DisplayInternal,
+                     weak_ptr_factory_.GetWeakPtr(), notification_id,
+                     profile_id, incognito, notification)));
+  Java_NotificationPlatformBridge_queryWebApkPackage(
+      env, java_object_, j_scope_url, callback_pointer);
+}
 
+void NotificationPlatformBridgeAndroid::DisplayInternal(

[pkotwicz, 2017/07/20 01:32:05]

.cc and .h order applies to DisplayInternal() too

[Xi Han, 2017/07/21 20:36:35]

Done.

+    const std::string& notification_id,
+    const std::string& profile_id,
+    bool incognito,
+    const Notification& notification,
+    const std::string& webapk_package) {
+  JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_notification_id =
       ConvertUTF8ToJavaString(env, notification_id);
+
+  GURL origin_url(notification.origin_url().GetOrigin());
   ScopedJavaLocalRef<jstring> j_origin =
       ConvertUTF8ToJavaString(env, origin_url.spec());
   ScopedJavaLocalRef<jstring> tag =
       ConvertUTF8ToJavaString(env, notification.tag());
   ScopedJavaLocalRef<jstring> title =
       ConvertUTF16ToJavaString(env, notification.title());
   ScopedJavaLocalRef<jstring> body =
       ConvertUTF16ToJavaString(env, notification.message());
 
   ScopedJavaLocalRef<jobject> image;
@@ skipping 12 matching lines @@
     badge = gfx::ConvertToJavaBitmap(&badge_bitmap);
 
   ScopedJavaLocalRef<jobjectArray> actions =
       ConvertToJavaActionInfos(notification.buttons());
 
   ScopedJavaLocalRef<jintArray> vibration_pattern =
       base::android::ToJavaIntArray(env, notification.vibration_pattern());
 
   ScopedJavaLocalRef<jstring> j_profile_id =
       ConvertUTF8ToJavaString(env, profile_id);
+  ScopedJavaLocalRef<jstring> j_webapk_package =
+      ConvertUTF8ToJavaString(env, webapk_package);
 
   Java_NotificationPlatformBridge_displayNotification(
       env, java_object_, j_notification_id, j_origin, j_profile_id, incognito,
-      tag, webapk_package, title, body, image, notification_icon, badge,
+      tag, j_webapk_package, title, body, image, notification_icon, badge,
       vibration_pattern, notification.timestamp().ToJavaTime(),
       notification.renotify(), notification.silent(), actions);
 
   regenerated_notification_infos_[notification_id] =
       RegeneratedNotificationInfo(origin_url.spec(), notification.tag(),
-                                  ConvertJavaStringToUTF8(env, webapk_package));
+                                  webapk_package);
 }
 
 void NotificationPlatformBridgeAndroid::Close(
     const std::string& profile_id,
     const std::string& notification_id) {
   const auto iterator = regenerated_notification_infos_.find(notification_id);
   if (iterator == regenerated_notification_infos_.end())
     return;
 
   const RegeneratedNotificationInfo& notification_info = iterator->second;
@@ skipping 51 matching lines @@
     RegeneratedNotificationInfo() {}
 
 NotificationPlatformBridgeAndroid::RegeneratedNotificationInfo::
     RegeneratedNotificationInfo(const std::string& origin,
                                 const std::string& tag,
                                 const std::string& webapk_package)
     : origin(origin), tag(tag), webapk_package(webapk_package) {}
 
 NotificationPlatformBridgeAndroid::RegeneratedNotificationInfo::
     ~RegeneratedNotificationInfo() {}