Update AppBannerManager & AppBannerManagerAndroid to request badge icon.

chrome/browser/android/banners/app_banner_manager_android.cc

 // Copyright 2015 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/android/banners/app_banner_manager_android.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/android/jni_android.h"
@@ skipping 88 matching lines @@
 bool AppBannerManagerAndroid::OnAppDetailsRetrieved(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj,
     const JavaParamRef<jobject>& japp_data,
     const JavaParamRef<jstring>& japp_title,
     const JavaParamRef<jstring>& japp_package,
     const JavaParamRef<jstring>& jicon_url) {
   native_app_data_.Reset(japp_data);
   app_title_ = ConvertJavaStringToUTF16(env, japp_title);
   native_app_package_ = ConvertJavaStringToUTF8(env, japp_package);
-  icon_url_ = GURL(ConvertJavaStringToUTF8(env, jicon_url));
+  primary_icon_url_ = GURL(ConvertJavaStringToUTF8(env, jicon_url));
 
   if (!CheckIfShouldShowBanner())
     return false;
 
   return ManifestIconDownloader::Download(
-      web_contents(), icon_url_, GetIdealIconSizeInPx(),
-      GetMinimumIconSizeInPx(),
+      web_contents(), primary_icon_url_, GetIdealPrimaryIconSizeInPx(),
+      GetMinimumPrimaryIconSizeInPx(),
       base::Bind(&AppBannerManager::OnAppIconFetched, GetWeakPtr()));
 }
 
 void AppBannerManagerAndroid::RequestAppBanner(const GURL& validated_url,
                                                bool is_debug_mode) {
   JNIEnv* env = base::android::AttachCurrentThread();
   if (!Java_AppBannerManager_isEnabledForTab(env, java_banner_manager_))
     return;
 
+  can_install_webapk_ = ChromeWebApkHost::CanInstallWebApk();

[dominickn, 2017/02/15 23:38:04]

Set this in the constructor, not in RequestAppBanner. I think pkotwicz and I
agree that the value won't change over the lifetime of this class.

[pkotwicz, 2017/02/16 15:43:03]

Dominick, I differ to your judgement

I am ok with either option. Setting this in
AppBannerManagerAndroid::RequestAppBanner() has the nice property of the JNI
call not being done if the banner is never shown because engagement is not high
enough. It is possible to make it clearer that
ChromeWebApkHost::CanInstallWebApk() is called here for this reason.

[dominickn, 2017/02/17 00:54:44]

This class already makes a JNI call when it's initialised, and the engagement
threshold is low enough that it's likely RequestAppBanner will be called
multiple times over the lifetime of the AppBannerManagerAndroid class. So
calling this method once in the constructor should result in the least number of
calls to CanInstallWebApk() overall. Otherwise we're redundantly calling
CanInstallWebApk() once per banner flow, which could be as often as once per
navigation if you're going through a bunch of sites you visit a lot.

[F, 2017/02/21 15:53:36]

Done. Thanks for the explanation :)

+
   AppBannerManager::RequestAppBanner(validated_url, is_debug_mode);
 }
 
+int AppBannerManagerAndroid::GetIdealBadgeIconSizeInPx() {
+  return ShortcutHelper::GetIdealBadgeIconSizeInPx();
+}
+
 std::string AppBannerManagerAndroid::GetAppIdentifier() {
   return native_app_data_.is_null() ? AppBannerManager::GetAppIdentifier()
                                     : native_app_package_;
 }
 
 std::string AppBannerManagerAndroid::GetBannerType() {
   return native_app_data_.is_null() ? AppBannerManager::GetBannerType()
                                     : "play";
 }
 
-int AppBannerManagerAndroid::GetIdealIconSizeInPx() {
+int AppBannerManagerAndroid::GetIdealPrimaryIconSizeInPx() {
   return ShortcutHelper::GetIdealHomescreenIconSizeInPx();
 }
 
-int AppBannerManagerAndroid::GetMinimumIconSizeInPx() {
+int AppBannerManagerAndroid::GetMinimumPrimaryIconSizeInPx() {
   return ShortcutHelper::GetMinimumHomescreenIconSizeInPx();
 }
 
 bool AppBannerManagerAndroid::IsWebAppInstalled(
     content::BrowserContext* browser_context,
     const GURL& start_url,
     const GURL& manifest_url) {
   // Returns true if a WebAPK is installed or is being installed.
   // Does not check whether a non-WebAPK web app is installed: this is detected
   // by the content settings check in AppBannerSettingsHelper::ShouldShowBanner
   // (due to the lack of an API to detect what is and isn't on the Android
   // homescreen). This method will still detect the presence of a WebAPK even if
   // Chrome's data is cleared.
   return ShortcutHelper::IsWebApkInstalled(browser_context, start_url,
                                            manifest_url);
 }
 
+InstallableParams AppBannerManagerAndroid::ParamsToPerformInstallableCheck() {
+  InstallableParams params =
+      AppBannerManager::ParamsToPerformInstallableCheck();
+
+  if (can_install_webapk_) {
+    params.ideal_badge_icon_size_in_px = GetIdealBadgeIconSizeInPx();
+    params.minimum_badge_icon_size_in_px = GetIdealBadgeIconSizeInPx();
+    params.fetch_valid_badge_icon = true;
+  }
+
+  return params;
+}
+
 void AppBannerManagerAndroid::PerformInstallableCheck() {
   // Check if the manifest prefers that we show a native app banner. If so, call
   // to Java to verify the details.
   if (manifest_.prefer_related_applications &&
       manifest_.related_applications.size()) {
     for (const auto& application : manifest_.related_applications) {
       std::string platform = base::UTF16ToUTF8(application.platform.string());
       std::string id = base::UTF16ToUTF8(application.id.string());
       if (CanHandleNonWebApp(platform, application.url, id))
         return;
     }
     Stop();
   }
 
-  if (ChromeWebApkHost::CanInstallWebApk()) {
+  if (can_install_webapk_) {
     if (!AreWebManifestUrlsWebApkCompatible(manifest_)) {
       ReportStatus(web_contents(), URL_NOT_SUPPORTED_FOR_WEBAPK);
       Stop();
       return;
     }
   }
 
   // No native app banner was requested. Continue checking for a web app banner.
   AppBannerManager::PerformInstallableCheck();
 }
 
+void AppBannerManagerAndroid::OnDidPerformInstallableCheck(
+    const InstallableData& data) {
+  if (data.badge_icon && !data.badge_icon->drawsNothing()) {
+    DCHECK(!data.badge_icon_url.is_empty());
+
+    badge_icon_url_ = data.badge_icon_url;
+    badge_icon_.reset(new SkBitmap(*data.badge_icon));
+  }
+
+  AppBannerManager::OnDidPerformInstallableCheck(data);
+}
+
 void AppBannerManagerAndroid::OnAppIconFetched(const SkBitmap& bitmap) {
   if (bitmap.drawsNothing()) {
     ReportStatus(web_contents(), NO_ICON_AVAILABLE);
     Stop();
   }
 
   if (!is_active())
     return;
 
-  icon_.reset(new SkBitmap(bitmap));
+  primary_icon_.reset(new SkBitmap(bitmap));
   SendBannerPromptRequest();
 }
 
 void AppBannerManagerAndroid::ResetCurrentPageData() {
   AppBannerManager::ResetCurrentPageData();
   native_app_data_.Reset();
   native_app_package_ = "";
 }
 
 void AppBannerManagerAndroid::ShowBanner() {
   content::WebContents* contents = web_contents();
   DCHECK(contents);
 
   if (native_app_data_.is_null()) {
+    // TODO(zpeng): Add badge to WebAPK installation flow.
     if (AppBannerInfoBarDelegateAndroid::Create(
             contents, GetWeakPtr(), app_title_,
-            CreateShortcutInfo(manifest_url_, manifest_, icon_url_),
-            std::move(icon_), event_request_id(),
+            CreateShortcutInfo(manifest_url_, manifest_, primary_icon_url_),
+            std::move(primary_icon_), event_request_id(),
             webapk::INSTALL_SOURCE_BANNER)) {
       RecordDidShowBanner("AppBanner.WebApp.Shown");
       TrackDisplayEvent(DISPLAY_EVENT_WEB_APP_BANNER_CREATED);
       ReportStatus(contents, SHOWING_WEB_APP_BANNER);
     } else {
       ReportStatus(contents, FAILED_TO_CREATE_BANNER);
     }
   } else {
     if (AppBannerInfoBarDelegateAndroid::Create(
-            contents, app_title_, native_app_data_, std::move(icon_),
+            contents, app_title_, native_app_data_, std::move(primary_icon_),
             native_app_package_, referrer_, event_request_id())) {
       RecordDidShowBanner("AppBanner.NativeApp.Shown");
       TrackDisplayEvent(DISPLAY_EVENT_NATIVE_APP_BANNER_CREATED);
       ReportStatus(contents, SHOWING_NATIVE_APP_BANNER);
     } else {
       ReportStatus(contents, FAILED_TO_CREATE_BANNER);
     }
   }
 }
 
@@ skipping 22 matching lines @@
   if (!referrer.empty())
     referrer += "&";
   referrer += "playinline=chrome_inline";
 
   ScopedJavaLocalRef<jstring> jurl(
       ConvertUTF8ToJavaString(env, validated_url_.spec()));
   ScopedJavaLocalRef<jstring> jpackage(ConvertUTF8ToJavaString(env, id));
   ScopedJavaLocalRef<jstring> jreferrer(ConvertUTF8ToJavaString(env, referrer));
   Java_AppBannerManager_fetchAppDetails(env, java_banner_manager_, jurl,
                                         jpackage, jreferrer,
-                                        GetIdealIconSizeInPx());
+                                        GetIdealPrimaryIconSizeInPx());
   return true;
 }
 
 void AppBannerManagerAndroid::CreateJavaBannerManager() {
   JNIEnv* env = base::android::AttachCurrentThread();
   java_banner_manager_.Reset(
       Java_AppBannerManager_create(env, reinterpret_cast<intptr_t>(this)));
 }
 
 bool AppBannerManagerAndroid::CheckPlatformAndId(const std::string& platform,
@@ skipping 56 matching lines @@
 }
 
 // static
 void SetTotalEngagementToTrigger(JNIEnv* env,
                                  const JavaParamRef<jclass>& clazz,
                                  jdouble engagement) {
   AppBannerSettingsHelper::SetTotalEngagementToTrigger(engagement);
 }
 
 }  // namespace banners