Update the download summary icon

chrome/android/java/src/org/chromium/chrome/browser/download/DownloadNotificationService.java

 // 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.
 
 package org.chromium.chrome.browser.download;
 
 import android.annotation.TargetApi;
 import android.app.DownloadManager;
 import android.app.Notification;
 import android.app.NotificationManager;
 import android.app.PendingIntent;
 import android.app.Service;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.SharedPreferences;
 import android.content.res.Resources;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
 import android.graphics.Canvas;
 import android.graphics.Paint;
 import android.graphics.Rect;
 import android.graphics.drawable.shapes.OvalShape;
 import android.os.Binder;
 import android.os.Build;
+import android.os.Bundle;
 import android.os.IBinder;
 import android.service.notification.StatusBarNotification;
 import android.text.TextUtils;
+import android.util.Pair;
 
 import org.chromium.base.ApiCompatibilityUtils;
 import org.chromium.base.ApplicationStatus;
 import org.chromium.base.BuildInfo;
 import org.chromium.base.ContextUtils;
 import org.chromium.base.Log;
 import org.chromium.base.ObserverList;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.library_loader.LibraryLoader;
 import org.chromium.base.library_loader.ProcessInitException;
@@ skipping 13 matching lines @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 
 /**
  * Service responsible for creating and updating download notifications even after
  * Chrome gets killed.
  *
  * On O and above, this service will receive {@link Service#startForeground(int, Notification)}
  * calls when containing active downloads.  The foreground notification will be the summary
- * notification generated by {@link DownloadNotificationService#getSummaryNotification(Context)}.
+ * notification generated by {@link DownloadNotificationService#buildSummaryNotification(Context)}.
  * The service will receive a {@link Service#stopForeground(boolean)} call when all active downloads
  * are paused.  The summary notification will be hidden when there are no other notifications in the
  * {@link NotificationConstants#GROUP_DOWNLOADS} group.  This gets checked after every notification
  * gets removed from the {@link NotificationManager}.
  */
 public class DownloadNotificationService extends Service {
     static final String EXTRA_DOWNLOAD_GUID = "DownloadGuid";
     static final String EXTRA_DOWNLOAD_FILE_PATH = "DownloadFilePath";
     static final String EXTRA_NOTIFICATION_DISMISSED = "NotificationDismissed";
     static final String EXTRA_IS_SUPPORTED_MIME_TYPE = "IsSupportedMimeType";
     static final String EXTRA_IS_OFF_THE_RECORD =
             "org.chromium.chrome.browser.download.IS_OFF_THE_RECORD";
     static final String EXTRA_IS_OFFLINE_PAGE =
             "org.chromium.chrome.browser.download.IS_OFFLINE_PAGE";
 
     public static final String ACTION_DOWNLOAD_CANCEL =
             "org.chromium.chrome.browser.download.DOWNLOAD_CANCEL";
     public static final String ACTION_DOWNLOAD_PAUSE =
             "org.chromium.chrome.browser.download.DOWNLOAD_PAUSE";
     public static final String ACTION_DOWNLOAD_RESUME =
             "org.chromium.chrome.browser.download.DOWNLOAD_RESUME";
     static final String ACTION_DOWNLOAD_RESUME_ALL =
             "org.chromium.chrome.browser.download.DOWNLOAD_RESUME_ALL";
     public static final String ACTION_DOWNLOAD_OPEN =
             "org.chromium.chrome.browser.download.DOWNLOAD_OPEN";
+    public static final String ACTION_UPDATE_SUMMARY_ICON =
+            "org.chromium.chrome.browser.download.UPDATE_SUMMARY_ICON";
 
     static final String NOTIFICATION_NAMESPACE = "DownloadNotificationService";
     private static final String TAG = "DownloadNotification";
     // Limit file name to 25 characters. TODO(qinmin): use different limit for different devices?
     private static final int MAX_FILE_NAME_LENGTH = 25;
 
     /** Notification Id starting value, to avoid conflicts from IDs used in prior versions. */
 
+    private static final String EXTRA_NOTIFICATION_BUNDLE_ICON_ID =
+            "Chrome.NotificationBundleIconIdExtra";
     private static final int STARTING_NOTIFICATION_ID = 1000000;
     private static final int MAX_RESUMPTION_ATTEMPT_LEFT = 5;
     @VisibleForTesting static final long SECONDS_PER_MINUTE = TimeUnit.MINUTES.toSeconds(1);
     @VisibleForTesting static final long SECONDS_PER_HOUR = TimeUnit.HOURS.toSeconds(1);
     @VisibleForTesting static final long SECONDS_PER_DAY = TimeUnit.DAYS.toSeconds(1);
 
     private static final String KEY_AUTO_RESUMPTION_ATTEMPT_LEFT = "ResumptionAttemptLeft";
     private static final String KEY_NEXT_DOWNLOAD_NOTIFICATION_ID = "NextDownloadNotificationId";
 
     /**
@@ skipping 32 matching lines @@
      * Start this service with a summary {@link Notification}.  This will start the service in the
      * foreground.
      * @param context The context used to build the notification and to start the service.
      * @param source The {@link Intent} that should be used to build on to start the service.
      */
     public static void startDownloadNotificationService(Context context, Intent source) {
         Intent intent = source != null ? new Intent(source) : new Intent();
         intent.setComponent(new ComponentName(context, DownloadNotificationService.class));
 
         if (BuildInfo.isAtLeastO()) {
-            Notification notification = getSummaryNotification(context);
+            Notification notification = buildSummaryNotification(context);
 
             AppHooks.get().startServiceWithNotification(
                     intent, NotificationConstants.NOTIFICATION_ID_DOWNLOAD_SUMMARY, notification);
         } else {
             context.startService(intent);
         }
     }
 
     /**
-     * Builds a summary notification that represents downloads.  This is the notification passed to
-     * {@link #startForeground(int, Notification)}, which keeps this service in the foreground.
-     * @param context The context used to build the notification and pull specific resources.
-     * @return The {@link Notification} to show for the summary.  Meant to be used by
-     *         {@link NotificationManager#notify(int, Notification)}.
+     * Calculates the suggested icon for the summary notification based on the other notifications
+     * currently showing.
+     * @param context A context to use to query Android-specific information (NotificationManager).
+     * @param removedNotificationId The id of a notification that is currently closing and should be
+     *                              ignored.  -1 if no notifications are being closed.
+     * @param addedNotification     A {@link Pair} of <id, Notification> of a notification that is
+     *                              currently being added and should be used in addition to or in
+     *                              place of the existing icons.
+     * @return                      A {@link Pair} that represents both whether or not the new icon
+     *                              is different from the old one and the icon id itself.
      */
-    private static Notification getSummaryNotification(Context context) {
+    @TargetApi(Build.VERSION_CODES.M)
+    private static Pair<Boolean, Integer> getSummaryIcon(Context context, int removedNotificationId,
+            Pair<Integer, Notification> addedNotification) {
+        if (!BuildInfo.isAtLeastO()) return new Pair<Boolean, Integer>(false, -1);
+        boolean progress = false;
+        boolean paused = false;
+        boolean pending = false;
+        boolean completed = false;
+        boolean failed = false;
+
+        final int progressIcon = android.R.drawable.stat_sys_download;
+        final int pausedIcon = R.drawable.ic_download_pause;
+        final int pendingIcon = R.drawable.ic_download_pending;
+        final int completedIcon = R.drawable.offline_pin;
+        final int failedIcon = android.R.drawable.stat_sys_download_done;
+
+        NotificationManager manager =
+                (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+        StatusBarNotification[] notifications = manager.getActiveNotifications();
+
+        int oldIcon = -1;
+        for (StatusBarNotification notification : notifications) {
+            boolean isDownloadsGroup = TextUtils.equals(notification.getNotification().getGroup(),
+                    NotificationConstants.GROUP_DOWNLOADS);
+            if (!isDownloadsGroup) continue;
+            if (notification.getId() == removedNotificationId) continue;
+
+            boolean isSummaryNotification =
+                    notification.getId() == NotificationConstants.NOTIFICATION_ID_DOWNLOAD_SUMMARY;
+
+            if (addedNotification != null && addedNotification.first == notification.getId())

[qinmin, 2017/03/05 06:48:26]

if addedNotification is not null, this for loop skips the notification that is
the addedNotification.
However, after the for loop, there is an if statement to consider the icon for
this addedNotification.

if (addedNotification != null) {
  ......
 }

So why cannot we remove the latter if statement?

[David Trainor- moved to gerrit, 2017/03/06 16:29:54]

The added notification might not be shown yet, so it might not be in the list of
StatusBarNotifications that we query.

[qinmin, 2017/03/06 21:43:43]

i see, in that case, can we just initialize those booleans to those values from
the addedNotification if it is non null?
It looks ugly to have a lot of redudant code here.

+                continue;
+
+            int icon =
+                    notification.getNotification().extras.getInt(EXTRA_NOTIFICATION_BUNDLE_ICON_ID);
+            if (isSummaryNotification) {
+                oldIcon = icon;
+                continue;
+            }
+
+            progress |= icon == progressIcon;
+            paused |= icon == pausedIcon;
+            pending |= icon == pendingIcon;
+            completed |= icon == completedIcon;
+            failed |= icon == failedIcon;
+        }
+
+        if (addedNotification != null) {
+            int icon = addedNotification.second.extras.getInt(EXTRA_NOTIFICATION_BUNDLE_ICON_ID);
+
+            progress |= icon == progressIcon;
+            paused |= icon == pausedIcon;
+            pending |= icon == pendingIcon;
+            completed |= icon == completedIcon;
+            failed |= icon == failedIcon;
+        }
+
+        int newIcon = android.R.drawable.stat_sys_download_done;
+        if (progress) {
+            newIcon = android.R.drawable.stat_sys_download;
+        } else if (paused) {
+            newIcon = R.drawable.ic_download_pause;
+        } else if (pending) {
+            newIcon = R.drawable.ic_download_pending;
+        } else if (completed) {
+            newIcon = R.drawable.offline_pin;
+        } else if (failed) {
+            newIcon = android.R.drawable.stat_sys_download_done;
+        }
+        return new Pair<Boolean, Integer>(newIcon != oldIcon, newIcon);
+    }
+
+    /**
+     * Builds a summary notification that represents all downloads.
+     * {@see #buildSummaryNotification(Context)}.
+     * @param context A context used to query Android strings and resources.
+     * @param iconId  The id of an icon to use for the notification.
+     * @return        a {@link Notification} that represents the summary icon for all downloads.
+     */
+    private static Notification buildSummaryNotificationWithIcon(Context context, int iconId) {
         String title =
                 context.getResources().getString(R.string.download_notification_summary_title,
                         DownloadSharedPreferenceHelper.getInstance().getEntries().size());
+
         ChromeNotificationBuilder builder =
                 AppHooks.get()
                         .createChromeNotificationBuilder(true /* preferCompat */,
                                 NotificationConstants.CATEGORY_ID_BROWSER,
                                 context.getString(R.string.notification_category_browser),
                                 NotificationConstants.CATEGORY_GROUP_ID_GENERAL,
                                 context.getString(R.string.notification_category_group_general))
                         .setContentTitle(title)
-                        .setSmallIcon(android.R.drawable.stat_sys_download_done)
+                        .setSmallIcon(iconId)
                         .setLocalOnly(true)
                         .setGroup(NotificationConstants.GROUP_DOWNLOADS)
                         .setGroupSummary(true);
+        Bundle extras = new Bundle();
+        extras.putInt(EXTRA_NOTIFICATION_BUNDLE_ICON_ID, iconId);
+        builder.addExtras(extras);
 
         // This notification should not actually be shown.  But if it is, set the click intent to
         // open downloads home.
         Intent downloadHomeIntent = buildActionIntent(
                 context, DownloadManager.ACTION_NOTIFICATION_CLICKED, null, false, false);
         builder.setContentIntent(PendingIntent.getBroadcast(context,
                 NotificationConstants.NOTIFICATION_ID_DOWNLOAD_SUMMARY, downloadHomeIntent,
                 PendingIntent.FLAG_UPDATE_CURRENT));
 
         return builder.build();
     }
 
     /**
+     * Builds a summary notification that represents downloads.  This is the notification passed to
+     * {@link #startForeground(int, Notification)}, which keeps this service in the foreground.
+     * @param context The context used to build the notification and pull specific resources.
+     * @return The {@link Notification} to show for the summary.  Meant to be used by
+     *         {@link NotificationManager#notify(int, Notification)}.
+     */
+    private static Notification buildSummaryNotification(Context context) {
+        Pair<Boolean, Integer> icon = getSummaryIcon(context, -1, null);
+        return buildSummaryNotificationWithIcon(context, icon.second);
+    }
+
+    /**
      * @return Whether or not there are any current resumable downloads being tracked.  These
      *         tracked downloads may not currently be showing notifications.
      */
     public static boolean isTrackingResumableDownloads(Context context) {
         List<DownloadSharedPreferenceEntry> entries =
                 DownloadSharedPreferenceHelper.getInstance().getEntries();
         for (DownloadSharedPreferenceEntry entry : entries) {
             if (canResumeDownload(context, entry)) return true;
         }
         return false;
@@ skipping 58 matching lines @@
             if (ACTION_DOWNLOAD_RESUME_ALL.equals(intent.getAction())) {
                 if (mNumAutoResumptionAttemptLeft > 0) {
                     mNumAutoResumptionAttemptLeft--;
                     updateResumptionAttemptLeft();
                 }
             } else {
                 // Reset number of attempts left if the action is triggered by user.
                 mNumAutoResumptionAttemptLeft = MAX_RESUMPTION_ATTEMPT_LEFT;
                 clearResumptionAttemptLeft();
             }
+        } else if (ACTION_UPDATE_SUMMARY_ICON.equals(intent.getAction())) {
+            updateSummaryIcon(-1, null);
+            hideSummaryNotificationIfNecessary(null);
         }
         // This should restart the service after Chrome gets killed. However, this
         // doesn't work on Android 4.4.2.
         return START_STICKY;
     }
 
     /**
      * Adds an {@link Observer}, which will be notified when this service attempts to
      * start stopping itself.
      */
@@ skipping 17 matching lines @@
      */
     @VisibleForTesting
     @TargetApi(Build.VERSION_CODES.N)
     void stopForegroundInteral(boolean killNotification) {
         if (!BuildInfo.isAtLeastO()) return;
         stopForeground(killNotification ? STOP_FOREGROUND_REMOVE : STOP_FOREGROUND_DETACH);
     }
 
     /**
      * On >= O Android releases, puts this service into a foreground state, binding it to the
-     * {@link Notification} generated by {@link #getSummaryNotification(Context)}.
+     * {@link Notification} generated by {@link #buildSummaryNotification(Context)}.
      */
     @VisibleForTesting
     void startForegroundInternal() {
         if (!BuildInfo.isAtLeastO()) return;
-        Notification notification = getSummaryNotification(getApplicationContext());
+        Notification notification = buildSummaryNotification(getApplicationContext());
         startForeground(NotificationConstants.NOTIFICATION_ID_DOWNLOAD_SUMMARY, notification);
     }
 
     private void rescheduleDownloads() {
         List<DownloadSharedPreferenceEntry> entries = mDownloadSharedPreferenceHelper.getEntries();
         if (entries.isEmpty()) return;
 
         boolean scheduleAutoResumption = false;
         boolean allowMeteredConnection = false;
         for (int i = 0; i < entries.size(); ++i) {
@@ skipping 110 matching lines @@
                     NotificationConstants.GROUP_DOWNLOADS);
             boolean isSummaryNotification =
                     notification.getId() == NotificationConstants.NOTIFICATION_ID_DOWNLOAD_SUMMARY;
             if (isDownloadsGroup && isSummaryNotification) return notification;
         }
 
         return null;
     }
 
     /**
+     * Updates the notification summary with a new icon, if necessary.
+     * @param removedNotificationId The id of a notification that is currently closing and should be
+     *                              ignored.  -1 if no notifications are being closed.
+     * @param addedNotification     A {@link Pair} of <id, Notification> of a notification that is
+     *                              currently being added and should be used in addition to or in
+     *                              place of the existing icons.
+     */
+    @VisibleForTesting
+    void updateSummaryIcon(
+            int removedNotificationId, Pair<Integer, Notification> addedNotification) {
+        if (!BuildInfo.isAtLeastO()) return;
+
+        Pair<Boolean, Integer> icon =
+                getSummaryIcon(mContext, removedNotificationId, addedNotification);
+
+        // Avoid rebuilding the summary notification if the icon hasn't changed or we have (or are
+        // about to have) no active downloads.
+        if (!icon.first || !hasDownloadNotifications(removedNotificationId)) {
+            return;
+        }
+
+        mNotificationManager.notify(NotificationConstants.NOTIFICATION_ID_DOWNLOAD_SUMMARY,
+                buildSummaryNotificationWithIcon(mContext, icon.second));
+    }
+
+    /**
      * Cancels the existing summary notification.  Moved to a helper method for test mocking.
      */
     @VisibleForTesting
     void cancelSummaryNotification() {
         mNotificationManager.cancel(NotificationConstants.NOTIFICATION_ID_DOWNLOAD_SUMMARY);
     }
 
     /**
      * Check all current notifications and hide the summary notification if we have no downloads
      * notifications left.  On Android if the user swipes away the last download notification the
      * summary will be dismissed.  But if the last downloads notification is dismissed via
      * {@link NotificationManager#cancel(int)}, the summary will remain, so we need to check and
      * manually remove it ourselves.
      * @param notificationIdToIgnore Canceling a notification and querying for the current list of
      *                               active notifications isn't synchronous.  Pass a notification id
      *                               here if there is a notification that should be assumed gone.
      *                               Or pass {@code null} if no notification fits that criteria.
      */
     @TargetApi(Build.VERSION_CODES.M)
-    void hideSummaryNotificationIfNecessary(Integer notificationIdToIgnore) {
-        if (!BuildInfo.isAtLeastO()) return;
-        if (mDownloadsInProgress.size() > 0) return;
+    boolean hideSummaryNotificationIfNecessary(Integer notificationIdToIgnore) {
+        if (!BuildInfo.isAtLeastO()) return false;
+        if (mDownloadsInProgress.size() > 0) return false;
 
-        if (hasDownloadNotifications(notificationIdToIgnore)) return;
+        if (hasDownloadNotifications(notificationIdToIgnore)) return false;
 
         StatusBarNotification notification = getSummaryNotification();
         if (notification != null) {
             // We have a valid summary notification, but how we dismiss it depends on whether or not
             // it is currently bound to this service via startForeground(...).
             if ((notification.getNotification().flags & Notification.FLAG_FOREGROUND_SERVICE)
                     != 0) {
                 // If we are a foreground service and we are hiding the notification, we have no
                 // other downloads notifications showing, so we need to remove the notification and
                 // unregister it from this service at the same time.
@@ skipping 10 matching lines @@
             stopForegroundInteral(false);
         }
 
         // Notify all observers that we are requesting a chance to shut down.  This will let any
         // observers unbind from us if necessary.
         for (Observer observer : mObservers) observer.onServiceShutdownRequested();
 
         // Stop the service which should start the destruction process.  At this point we should be
         // (1) a background service and (2) unbound from any clients.
         stopSelf();
+        return true;
     }
 
     @Override
     public IBinder onBind(Intent intent) {
         return mBinder;
     }
 
     /**
      * Helper method to update the remaining number of background resumption attempts left.
      */
@@ skipping 139 matching lines @@
      */
     @VisibleForTesting
     void cancelNotification(int notificationId, String downloadGuid) {
         mNotificationManager.cancel(NOTIFICATION_NAMESPACE, notificationId);
         mDownloadSharedPreferenceHelper.removeSharedPreferenceEntry(downloadGuid);
 
         // Since we are about to go through the process of validating whether or not we can shut
         // down, don't stop foreground if we have no download notifications left to show.  Hiding
         // the summary will take care of that for us.
         stopTrackingInProgressDownload(downloadGuid, hasDownloadNotifications(notificationId));
-        hideSummaryNotificationIfNecessary(notificationId);
+        if (!hideSummaryNotificationIfNecessary(notificationId)) {
+            updateSummaryIcon(notificationId, null);
+        }
     }
 
     /**
      * Called when a download is canceled.
      * @param downloadGuid GUID of the download.
      */
     @VisibleForTesting
     public void notifyDownloadCanceled(String downloadGuid) {
         DownloadSharedPreferenceEntry entry =
                 mDownloadSharedPreferenceHelper.getDownloadSharedPreferenceEntry(downloadGuid);
@@ skipping 94 matching lines @@
         }
         intent.setComponent(component);
         builder.setContentIntent(PendingIntent.getBroadcast(
                 mContext, notificationId, intent, PendingIntent.FLAG_UPDATE_CURRENT));
         if (mDownloadSuccessLargeIcon == null) {
             Bitmap bitmap = BitmapFactory.decodeResource(
                     mContext.getResources(), R.drawable.offline_pin);
             mDownloadSuccessLargeIcon = getLargeNotificationIcon(bitmap);
         }
         builder.setLargeIcon(mDownloadSuccessLargeIcon);
+        builder.setDeleteIntent(buildIconUpdateIntent(notificationId));
         updateNotification(notificationId, builder.build(), downloadGuid, isOfflinePage, null);
         stopTrackingInProgressDownload(downloadGuid, true);
         return notificationId;
     }
 
     /**
      * Add a download failed notification.
      * @param isOfflinePage Whether or not the download was for an offline page.
      * @param downloadGuid GUID of the download.
      * @param fileName GUID of the download.
      */
     @VisibleForTesting
     public void notifyDownloadFailed(boolean isOfflinePage, String downloadGuid, String fileName) {
         // If the download is not in history db, fileName could be empty. Get it from
         // SharedPreferences.
         if (TextUtils.isEmpty(fileName)) {
             DownloadSharedPreferenceEntry entry =
                     mDownloadSharedPreferenceHelper.getDownloadSharedPreferenceEntry(downloadGuid);
             if (entry == null) return;
             fileName = entry.fileName;
         }
 
         int notificationId = getNotificationId(downloadGuid);
         ChromeNotificationBuilder builder =
                 buildNotification(android.R.drawable.stat_sys_download_done, fileName,
                         mContext.getResources().getString(R.string.download_notification_failed));
+        builder.setDeleteIntent(buildIconUpdateIntent(notificationId));
         updateNotification(notificationId, builder.build(), downloadGuid, isOfflinePage, null);
         stopTrackingInProgressDownload(downloadGuid, true);
     }
 
     /**
      * Helper method to build a PendingIntent from the provided intent.
      * @param intent Intent to broadcast.
      * @param notificationId ID of the notification.
      */
     private PendingIntent buildPendingIntent(Intent intent, int notificationId) {
         return PendingIntent.getBroadcast(
                 mContext, notificationId, intent, PendingIntent.FLAG_UPDATE_CURRENT);
     }
 
     /**
+     * Helper method to build a {@link PendingIntent} that will wrap an {@link Intent} that will
+     * update the summary notification icon.
+     * @param notificationId ID of the notification.
+     */
+    // ---- BEFORE LANDING NOTE ----
+    // TODO(dtrainor): This is not firing for the complete notification.  Test or remove this if we
+    // don't need it.
+    // ---- BEFORE LANDING NOTE ----
+    private PendingIntent buildIconUpdateIntent(int notificationId) {
+        Intent intent = new Intent(mContext, DownloadBroadcastReceiver.class);
+        intent.setAction(ACTION_UPDATE_SUMMARY_ICON);
+        return buildPendingIntent(intent, notificationId);
+    }
+
+    /**
      * Helper method to build an download action Intent from the provided information.
      * @param context {@link Context} to pull resources from.
      * @param action Download action to perform.
      * @param downloadGuid GUID of the download.
      * @param isOffTheRecord Whether the download is incognito.
      * @param isOfflinePage Whether the download represents an Offline Page.
      */
     static Intent buildActionIntent(Context context, String action, String downloadGuid,
             boolean isOffTheRecord, boolean isOfflinePage) {
         ComponentName component = new ComponentName(
                 context.getPackageName(), DownloadBroadcastReceiver.class.getName());
         Intent intent = new Intent(action);
         intent.setComponent(component);
         intent.putExtra(EXTRA_DOWNLOAD_GUID, downloadGuid);
         intent.putExtra(EXTRA_IS_OFF_THE_RECORD, isOffTheRecord);
         intent.putExtra(EXTRA_IS_OFFLINE_PAGE, isOfflinePage);
         return intent;
     }
 
     /**
      * Builds a notification to be displayed.
      * @param iconId Id of the notification icon.
      * @param title Title of the notification.
      * @param contentText Notification content text to be displayed.
      * @return notification builder that builds the notification to be displayed
      */
     private ChromeNotificationBuilder buildNotification(
             int iconId, String title, String contentText) {
+        Bundle extras = new Bundle();
+        extras.putInt(EXTRA_NOTIFICATION_BUNDLE_ICON_ID, iconId);
+
         ChromeNotificationBuilder builder =
                 AppHooks.get()
                         .createChromeNotificationBuilder(true /* preferCompat */,
                                 NotificationConstants.CATEGORY_ID_BROWSER,
                                 mContext.getString(R.string.notification_category_browser),
                                 NotificationConstants.CATEGORY_GROUP_ID_GENERAL,
                                 mContext.getString(R.string.notification_category_group_general))
                         .setContentTitle(
                                 DownloadUtils.getAbbreviatedFileName(title, MAX_FILE_NAME_LENGTH))
                         .setSmallIcon(iconId)
                         .setLocalOnly(true)
                         .setAutoCancel(true)
                         .setContentText(contentText)
-                        .setGroup(NotificationConstants.GROUP_DOWNLOADS);
+                        .setGroup(NotificationConstants.GROUP_DOWNLOADS)
+                        .addExtras(extras);
         return builder;
     }
 
     private Bitmap getLargeNotificationIcon(Bitmap bitmap) {
         Resources resources = mContext.getResources();
         int height = (int) resources.getDimension(android.R.dimen.notification_large_icon_height);
         int width = (int) resources.getDimension(android.R.dimen.notification_large_icon_width);
         final OvalShape circle = new OvalShape();
         circle.resize(width, height);
         final Paint paint = new Paint();
@@ skipping 189 matching lines @@
     private void updateNotification(int id, Notification notification, String downloadGuid,
             boolean isOfflinePage, DownloadSharedPreferenceEntry entry) {
         updateNotification(id, notification);
         trackNotificationUma(isOfflinePage, downloadGuid);
 
         if (entry != null) {
             mDownloadSharedPreferenceHelper.addOrReplaceSharedPreferenceEntry(entry);
         } else {
             mDownloadSharedPreferenceHelper.removeSharedPreferenceEntry(downloadGuid);
         }
+        updateSummaryIcon(-1, new Pair<Integer, Notification>(id, notification));
     }
 
     private void trackNotificationUma(boolean isOfflinePage, String downloadGuid) {
         // Check if we already have an entry in the DownloadSharedPreferenceHelper.  This is a
         // reasonable indicator for whether or not a notification is already showing (or at least if
         // we had built one for this download before.
         if (mDownloadSharedPreferenceHelper.hasEntry(downloadGuid)) return;
         NotificationUmaTracker.getInstance().onNotificationShown(isOfflinePage
                         ? NotificationUmaTracker.DOWNLOAD_PAGES
                         : NotificationUmaTracker.DOWNLOAD_FILES);
@@ skipping 109 matching lines @@
             return context.getString(R.string.remaining_duration_minutes, minutes);
         } else if (minutes > 0) {
             return context.getString(R.string.remaining_duration_one_minute);
         } else if (seconds == 1) {
             return context.getString(R.string.remaining_duration_one_second);
         } else {
             return context.getString(R.string.remaining_duration_seconds, seconds);
         }
     }
 }