Pop up the notification when the download is interrupted or completed

chrome/browser/download/notification/download_notification_item.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/download/notification/download_notification_item.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/download/download_crx_util.h"
 #include "chrome/browser/download/download_item_model.h"
@@ skipping 54 matching lines @@
 }
 
 std::string DownloadNotificationItem::NotificationWatcher::id() const {
   return base::UintToString(item_->item_->GetId());
 }
 
 DownloadNotificationItem::DownloadNotificationItem(content::DownloadItem* item,
                                                    Profile* profile,
                                                    Delegate* delegate)
     : openable_(false),
-      downloading_(false),
       image_resource_id_(0),
       profile_(profile),
       watcher_(new NotificationWatcher(this)),
       item_(item),
       delegate_(delegate) {
   item->AddObserver(this);
 
   // Notify that the instance is just created.
   delegate_->OnCreated(this);
 
@@ skipping 54 matching lines @@
   DownloadCommands(item_).ExecuteCommand(command);
 }
 
 // DownloadItem::Observer methods
 void DownloadNotificationItem::OnDownloadUpdated(content::DownloadItem* item) {
   DCHECK_EQ(item, item_);
 
   UpdateNotificationData(UPDATE_EXISTING);
 }
 
+void DownloadNotificationItem::CloseNotificationByNonUser() {
+  const std::string& notification_id = watcher_->id();
+  const ProfileID profile_id = NotificationUIManager::GetProfileID(profile_);
+  const std::string notification_id_in_message_center =
+      ProfileNotification::GetProfileNotificationId(notification_id,
+                                                    profile_id);
+
+  notification_ui_manager()->CancelById(notification_id, profile_id);
+}
+
 void DownloadNotificationItem::CloseNotificationByUser() {
   const std::string& notification_id = watcher_->id();
   const ProfileID profile_id = NotificationUIManager::GetProfileID(profile_);
   const std::string notification_id_in_message_center =
       ProfileNotification::GetProfileNotificationId(notification_id,
                                                     profile_id);
 
   notification_ui_manager()->CancelById(notification_id, profile_id);
 
   // When the message center is visible, |NotificationUIManager::CancelByID()|
   // delays the close hence the notification is not closed at this time. But
   // from the viewpoint of UX of MessageCenter, we should close it immediately
   // because it's by user action. So, we request closing of it directlly to
   // MessageCenter instance.
   // Note that: this calling has no side-effect even when the message center
   // is not opened.
   g_browser_process->message_center()->RemoveNotification(
       notification_id_in_message_center, true /* by_user */);
 }
 
 void DownloadNotificationItem::UpdateNotificationData(
     NotificationUpdateType type) {
   DownloadItemModel model(item_);
   DownloadCommands command(item_);
 
-  if (!downloading_) {
-    if (item_->GetState() == content::DownloadItem::IN_PROGRESS) {
+  if (previous_download_state_ != content::DownloadItem::IN_PROGRESS) {

[yoshiki, 2015/05/12 14:49:33]

The semantics is same as the previous. Just rewrite with
|previous_download_state_| instead of |downloading_|.

+    if (item_->GetState() == content::DownloadItem::IN_PROGRESS)
       delegate_->OnDownloadStarted(this);
-      downloading_ = true;
-    }
   } else {
-    if (item_->GetState() != content::DownloadItem::IN_PROGRESS) {
+    if (item_->GetState() != content::DownloadItem::IN_PROGRESS)
       delegate_->OnDownloadStopped(this);
-      downloading_ = false;
-    }
   }
 
   if (item_->IsDangerous()) {
     notification_->set_type(message_center::NOTIFICATION_TYPE_SIMPLE);
     notification_->set_title(GetTitle());
     notification_->set_message(GetWarningText());
 
     // Show icon.
     SetNotificationImage(IDR_DOWNLOAD_NOTIFICATION_MALICIOUS);
   } else {
     notification_->set_title(GetTitle());
     notification_->set_message(model.GetStatusText());
 
     bool is_off_the_record = item_->GetBrowserContext() &&
                              item_->GetBrowserContext()->IsOffTheRecord();
 
     switch (item_->GetState()) {
       case content::DownloadItem::IN_PROGRESS:
         notification_->set_type(message_center::NOTIFICATION_TYPE_PROGRESS);
         notification_->set_progress(item_->PercentComplete());
         if (is_off_the_record) {
           // TODO(yoshiki): Replace the tentative image.
           SetNotificationImage(IDR_DOWNLOAD_NOTIFICATION_INCOGNITO);
         } else {
           SetNotificationImage(IDR_DOWNLOAD_NOTIFICATION_DOWNLOADING);
         }
         break;
       case content::DownloadItem::COMPLETE:
-        notification_->set_type(message_center::NOTIFICATION_TYPE_SIMPLE);
+        DCHECK_EQ(100, item_->PercentComplete());
+        DCHECK(item_->IsDone());
+
+        // Shows a notifiation as progress type once so the visible content will
+        // be updated.
+        // Note: only progress-type notification's content will be updated
+        // immediately when the message center is visible.
+        notification_->set_type(message_center::NOTIFICATION_TYPE_PROGRESS);
+        notification_->set_progress(100);
+
         if (is_off_the_record) {
           // TODO(yoshiki): Replace the tentative image.
           SetNotificationImage(IDR_DOWNLOAD_NOTIFICATION_INCOGNITO);
         } else {
           SetNotificationImage(IDR_DOWNLOAD_NOTIFICATION_DOWNLOADING);
         }
-
-        // TODO(yoshiki): Popup a notification again.
         break;
       case content::DownloadItem::CANCELLED:
         // Confgirms that a download is cancelled by user action.
         DCHECK(item_->GetLastReason() ==
                    content::DOWNLOAD_INTERRUPT_REASON_USER_CANCELED ||
                item_->GetLastReason() ==
                    content::DOWNLOAD_INTERRUPT_REASON_USER_SHUTDOWN);
 
         CloseNotificationByUser();
+
+        previous_download_state_ = item_->GetState();
         return;  // Skips the remaining since the notification has closed.
       case content::DownloadItem::INTERRUPTED:
-        notification_->set_type(message_center::NOTIFICATION_TYPE_SIMPLE);
+        // Shows a notifiation as progress type once so the visible content will
+        // be updated. (same as the case of type = COMPLETE)
+        notification_->set_type(message_center::NOTIFICATION_TYPE_PROGRESS);
+        notification_->set_progress(0);
         SetNotificationImage(IDR_DOWNLOAD_NOTIFICATION_WARNING);
-
-        // TODO(yoshiki): Popup a notification again.
         break;
       case content::DownloadItem::MAX_DOWNLOAD_STATE:  // sentinel
         NOTREACHED();
     }
   }
 
   std::vector<message_center::ButtonInfo> notification_actions;
   scoped_ptr<std::vector<DownloadCommands::Command>> actions(
       GetPossibleActions().Pass());
 
   openable_ = false;
   button_actions_.reset(new std::vector<DownloadCommands::Command>);
   for (auto it = actions->begin(); it != actions->end(); it++) {
     if (*it == DownloadCommands::OPEN_WHEN_COMPLETE) {
       openable_ = true;
     } else {
       button_actions_->push_back(*it);
       message_center::ButtonInfo button_info =
           message_center::ButtonInfo(GetCommandLabel(*it));
       button_info.icon = command.GetCommandIcon(*it);
       notification_actions.push_back(button_info);
     }
   }
   notification_->set_buttons(notification_actions);
 
   if (item_->IsDone()) {
     // TODO(yoshiki): If the downloaded file is an image, show the thumbnail.
   }
 
-  if (type == ADD_NEW)
+  if (type == ADD_NEW) {
     notification_ui_manager()->Add(*notification_, profile_);
-  else if (type == UPDATE_EXISTING)
+  } else if (type == UPDATE_EXISTING) {
     notification_ui_manager()->Update(*notification_, profile_);
-  else
+
+    // When the download is just completed, close the notification once and
+    // re-show it immediately so it'll be poped up.
+    if (item_->GetState() == content::DownloadItem::COMPLETE &&
+        previous_download_state_ != content::DownloadItem::COMPLETE) {
+      CloseNotificationByNonUser();
+      // Changes the type from PROGRESS to SIMPLE.
+      notification_->set_type(message_center::NOTIFICATION_TYPE_SIMPLE);
+      notification_ui_manager()->Add(*notification_, profile_);
+    }
+
+    // When the download is just interruppted, close the notification once and
+    // re-show it immediately so it'll be poped up.
+    if (item_->GetState() == content::DownloadItem::INTERRUPTED &&
+        previous_download_state_ != content::DownloadItem::INTERRUPTED) {
+      CloseNotificationByNonUser();
+      notification_ui_manager()->Add(*notification_, profile_);
+    }
+  } else {
     NOTREACHED();
+  }
+
+  previous_download_state_ = item_->GetState();
 }
 
 void DownloadNotificationItem::OnDownloadOpened(content::DownloadItem* item) {
   DCHECK_EQ(item, item_);
   // Do nothing.
 }
 
 void DownloadNotificationItem::OnDownloadRemoved(content::DownloadItem* item) {
   DCHECK_EQ(item, item_);
 
@@ skipping 67 matching lines @@
   switch (item_->GetState()) {
     case content::DownloadItem::IN_PROGRESS:
       title_text = l10n_util::GetStringFUTF16(
           IDS_DOWNLOAD_STATUS_IN_PROGRESS_TITLE, file_name);
       break;
     case content::DownloadItem::COMPLETE:
       title_text = l10n_util::GetStringFUTF16(
           IDS_DOWNLOAD_STATUS_DOWNLOADED_TITLE, file_name);
     case content::DownloadItem::INTERRUPTED:
       title_text = l10n_util::GetStringFUTF16(
-          IDS_DOWNLOAD_STATUS_DOWNLOADED_TITLE, file_name);
+          IDS_DOWNLOAD_STATUS_DOWNLOAD_FAILED_TITLE, file_name);

[yoshiki, 2015/05/12 14:49:33]

just fixing wrong ID for failure download.

       break;
     case content::DownloadItem::CANCELLED:
       title_text = l10n_util::GetStringFUTF16(
           IDS_DOWNLOAD_STATUS_DOWNLOAD_FAILED_TITLE, file_name);
       break;
     case content::DownloadItem::MAX_DOWNLOAD_STATE:
       NOTREACHED();
   }
   return title_text;
 }
@@ skipping 78 matching lines @@
     case content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS:
     case content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT:
     case content::DOWNLOAD_DANGER_TYPE_USER_VALIDATED:
     case content::DOWNLOAD_DANGER_TYPE_MAX: {
       break;
     }
   }
   NOTREACHED();
   return base::string16();
 }