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;
 
   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() {

[pkotwicz, 2017/02/14 20:02:08]

Nit: You can replace lines 166-170 with
InstallableParams params = AppBannerManager::ParamsToPerformInstallableCheck()

[F, 2017/02/14 20:11:20]

Done. Thanks!

+  InstallableParams params;
+  params.ideal_primary_icon_size_in_px = GetIdealPrimaryIconSizeInPx();
+  params.minimum_primary_icon_size_in_px = GetMinimumPrimaryIconSizeInPx();
+  params.check_installable = true;
+  params.fetch_valid_primary_icon = true;
+
+  if (ChromeWebApkHost::CanInstallWebApk()) {
+    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 (!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) {
+    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