[Download Notification] Show preview if downloaded file is image

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/files/file_util.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"
 #include "chrome/browser/notifications/notification.h"
 #include "chrome/browser/notifications/notification_ui_manager.h"
 #include "chrome/browser/notifications/profile_notification.h"
 #include "chrome/browser/ui/scoped_tabbed_browser_displayer.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/chromium_strings.h"
 #include "chrome/grit/generated_resources.h"
+#include "components/mime_util/mime_util.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/download_interrupt_reasons.h"
 #include "content/public/browser/download_item.h"
 #include "content/public/browser/page_navigator.h"
 #include "content/public/browser/web_contents.h"
 #include "grit/theme_resources.h"
+#include "net/base/mime_util.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
+#include "ui/gfx/codec/jpeg_codec.h"
+#include "ui/gfx/image/image.h"
 #include "ui/message_center/message_center.h"
 
 namespace {
 
 const char kDownloadNotificationNotifierId[] =
     "chrome://downloads/notification/id-notifier";
 
+// Maximum size of preview image. If the image exceeds this size, don't show the
+// preview image.
+const int64 kMaxImagePreviewSize = 10 * 1024 * 1024;  // 10 MB
+
+std::string ReadNotificationImage(const base::FilePath& file_path) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::FILE);
+
+  std::string data;
+  bool ret = base::ReadFileToString(file_path, &data);
+  if (!ret)
+    return std::string();
+
+  DCHECK_NE(data.size(), static_cast<size_t>(kMaxImagePreviewSize));

[Lei Zhang, 2015/06/13 00:27:26]

Did you mean DCHECK_LE() ?

[yoshiki, 2015/06/16 16:41:42]

Oh, sorry. Done

+
+  return data;
+}
+
 }  // anonymous namespace
 
 // static
 const char DownloadNotificationItem::kDownloadNotificationOrigin[] =
     "chrome://downloads";
 
 // static
 StubNotificationUIManager*
     DownloadNotificationItem::stub_notification_ui_manager_for_testing_ =
         nullptr;
 
 DownloadNotificationItem::NotificationWatcher::NotificationWatcher(
     DownloadNotificationItem* item)
     : item_(item) {
 }
 
 DownloadNotificationItem::NotificationWatcher::~NotificationWatcher() {
 }
 
 void DownloadNotificationItem::NotificationWatcher::Close(bool by_user) {
-  // Do nothing.
+  item_->OnNotificationClose(by_user);
 }
 
 void DownloadNotificationItem::NotificationWatcher::Click() {
   item_->OnNotificationClick();
 }
 
 bool DownloadNotificationItem::NotificationWatcher::HasClickedListener() {
   return true;
 }
 
 void DownloadNotificationItem::NotificationWatcher::ButtonClick(
     int button_index) {
   item_->OnNotificationButtonClick(button_index);
 }
 
 std::string DownloadNotificationItem::NotificationWatcher::id() const {
   return base::UintToString(item_->item_->GetId());
 }
 
 DownloadNotificationItem::DownloadNotificationItem(content::DownloadItem* item,
                                                    Profile* profile,
                                                    Delegate* delegate)
     : profile_(profile),
       watcher_(new NotificationWatcher(this)),
       item_(item),
-      delegate_(delegate) {
+      delegate_(delegate),
+      weak_factory_(this)  {
   item->AddObserver(this);
 
   // Notify that the instance is just created.
   delegate_->OnCreated(this);
 
   ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance();
 
   message_center::RichNotificationData data;
   // Creates the notification instance. |title| and |body| will be overridden
   // by UpdateNotificationData() below.
   notification_.reset(new Notification(
       message_center::NOTIFICATION_TYPE_PROGRESS,
       GURL(kDownloadNotificationOrigin),  // origin_url
       base::string16(),                   // title
       base::string16(),                   // body
       bundle.GetImageNamed(IDR_DOWNLOAD_NOTIFICATION_DOWNLOADING),
       message_center::NotifierId(message_center::NotifierId::SYSTEM_COMPONENT,
                                  kDownloadNotificationNotifierId),
       base::string16(),                    // display_source
       base::UintToString(item_->GetId()),  // tag
       data, watcher_.get()));
 
   notification_->set_progress(0);
   notification_->set_never_timeout(false);
 
   UpdateNotificationData(ADD_NEW);
 }
 
 DownloadNotificationItem::~DownloadNotificationItem() {
+  if (image_decode_status_ == IN_PROGRESS)
+    ImageDecoder::Cancel(this);
+
   if (item_)
     item_->RemoveObserver(this);
 }
 
 void DownloadNotificationItem::OnNotificationClick() {
   if (item_->IsDangerous()) {
 #if defined(FULL_SAFE_BROWSING)
     DownloadCommands(item_).ExecuteCommand(
         DownloadCommands::LEARN_MORE_SCANNING);
 #else
@@ skipping 37 matching lines @@
     CloseNotificationByUser();
   }
 
   DownloadCommands(item_).ExecuteCommand(command);
 
   // Shows the notification again after clicking "Keep" on dangerous download.
   if (command == DownloadCommands::KEEP)
     UpdateNotificationData(ADD_NEW);
 }
 
+void DownloadNotificationItem::OnNotificationClose(bool by_user) {
+  if (image_decode_status_ == IN_PROGRESS) {
+    image_decode_status_ = NOT_STARTED;
+    ImageDecoder::Cancel(this);
+  }
+}
+
 // 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_);
@@ skipping 16 matching lines @@
   // 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) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
   DownloadItemModel model(item_);
   DownloadCommands command(item_);
 
   if (previous_download_state_ != content::DownloadItem::IN_PROGRESS) {
     if (item_->GetState() == content::DownloadItem::IN_PROGRESS)
       delegate_->OnDownloadStarted(this);
   } else {
     if (item_->GetState() != content::DownloadItem::IN_PROGRESS)
       delegate_->OnDownloadStopped(this);
   }
 
   if (item_->IsDangerous()) {
     notification_->set_type(message_center::NOTIFICATION_TYPE_BASE_FORMAT);
     notification_->set_title(GetTitle());
     notification_->set_message(GetWarningText());
 
     // Show icon.
-    SetNotificationImage(IDR_DOWNLOAD_NOTIFICATION_MALICIOUS);
+    SetNotificationIcon(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);
+          SetNotificationIcon(IDR_DOWNLOAD_NOTIFICATION_INCOGNITO);
         } else {
-          SetNotificationImage(IDR_DOWNLOAD_NOTIFICATION_DOWNLOADING);
+          SetNotificationIcon(IDR_DOWNLOAD_NOTIFICATION_DOWNLOADING);
         }
         break;
       case content::DownloadItem::COMPLETE:
         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);
+          SetNotificationIcon(IDR_DOWNLOAD_NOTIFICATION_INCOGNITO);
         } else {
-          SetNotificationImage(IDR_DOWNLOAD_NOTIFICATION_DOWNLOADING);
+          SetNotificationIcon(IDR_DOWNLOAD_NOTIFICATION_DOWNLOADING);
         }
         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:
         // 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);
+        SetNotificationIcon(IDR_DOWNLOAD_NOTIFICATION_WARNING);
         break;
       case content::DownloadItem::MAX_DOWNLOAD_STATE:  // sentinel
         NOTREACHED();
     }
   }
 
   std::vector<message_center::ButtonInfo> notification_actions;
   scoped_ptr<std::vector<DownloadCommands::Command>> actions(
       GetExtraActions().Pass());
 
   button_actions_.reset(new std::vector<DownloadCommands::Command>);
   for (auto it = actions->begin(); it != actions->end(); it++) {
     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) {
     notification_ui_manager()->Add(*notification_, profile_);
   } else if (type == UPDATE_EXISTING) {
     notification_ui_manager()->Update(*notification_, profile_);
 
     // When the download is just completed (or interrupted), close the
     // notification once and re-show it immediately so it'll pop up.
     if ((item_->GetState() == content::DownloadItem::COMPLETE &&
          previous_download_state_ != content::DownloadItem::COMPLETE) ||
         (item_->GetState() == content::DownloadItem::INTERRUPTED &&
          previous_download_state_ != content::DownloadItem::INTERRUPTED)) {
       CloseNotificationByNonUser();
       // Changes the type from PROGRESS to BASE_FORMAT.
       notification_->set_type(message_center::NOTIFICATION_TYPE_BASE_FORMAT);
       notification_ui_manager()->Add(*notification_, profile_);
     }
   } else {
     NOTREACHED();
   }
 
   previous_download_state_ = item_->GetState();
+
+  if (item_->IsDone() && image_decode_status_ == NOT_STARTED) {
+    // TODO(yoshiki): Add a metrics to take the satistics of image file sizes.
+
+    if (item_->GetReceivedBytes() > kMaxImagePreviewSize)
+      return;
+
+    DCHECK(notification_->image().IsEmpty());
+
+    image_decode_status_ = IN_PROGRESS;
+
+    bool maybe_image = false;
+    if (mime_util::IsSupportedImageMimeType(item_->GetMimeType())) {
+      maybe_image = true;
+    } else {
+      std::string mime;
+      if (net::GetWellKnownMimeTypeFromExtension(
+              item_->GetTargetFilePath().FinalExtension(),
+              &mime) &&
+          mime_util::IsSupportedImageMimeType(mime)) {
+        maybe_image = true;
+      }
+    }
+
+    if (maybe_image) {
+      base::FilePath file_path = item_->GetFullPath();
+      base::PostTaskAndReplyWithResult(
+          content::BrowserThread::GetBlockingPool(),
+          FROM_HERE,
+          base::Bind(&ReadNotificationImage,
+                     file_path),
+          base::Bind(&DownloadNotificationItem::OnImageLoaded,
+                     weak_factory_.GetWeakPtr()));
+    }
+  }
 }
 
 void DownloadNotificationItem::OnDownloadOpened(content::DownloadItem* item) {
   DCHECK_EQ(item, item_);
   // Do nothing.
 }
 
 void DownloadNotificationItem::OnDownloadRemoved(content::DownloadItem* item) {
   DCHECK_EQ(item, item_);
 
   // Removing the notification causes calling |NotificationDelegate::Close()|.
   notification_ui_manager()->CancelById(
       watcher_->id(), NotificationUIManager::GetProfileID(profile_));
   delegate_->OnDownloadRemoved(this);
 }
 
 void DownloadNotificationItem::OnDownloadDestroyed(
     content::DownloadItem* item) {
   DCHECK_EQ(item, item_);
 
   item_ = nullptr;
 }
 
-void DownloadNotificationItem::SetNotificationImage(int resource_id) {
+void DownloadNotificationItem::SetNotificationIcon(int resource_id) {
   if (image_resource_id_ == resource_id)
     return;
   ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance();
   image_resource_id_ = resource_id;
   notification_->set_icon(bundle.GetImageNamed(image_resource_id_));
 }
 
+void DownloadNotificationItem::OnImageLoaded(const std::string& image_data) {
+  if (image_data.empty())
+    return;
+
+  // TODO(yoshiki): Set option to reduce the image size to supress memory usage.
+  ImageDecoder::Start(this, image_data);
+}
+
+void DownloadNotificationItem::OnImageDecoded(const SkBitmap& decoded_image) {
+  gfx::Image image = gfx::Image::CreateFrom1xBitmap(decoded_image);
+  notification_->set_image(image);
+  image_decode_status_ = DONE;
+  UpdateNotificationData(UPDATE_EXISTING);
+}
+
+void DownloadNotificationItem::OnDecodeImageFailed() {
+  notification_->set_image(gfx::Image());
+  image_decode_status_ = FAILED;
+  UpdateNotificationData(UPDATE_EXISTING);
+}
+
 NotificationUIManager* DownloadNotificationItem::notification_ui_manager()
     const {
   if (stub_notification_ui_manager_for_testing_) {
     return stub_notification_ui_manager_for_testing_;
   }
   return g_browser_process->notification_ui_manager();
 }
 
 scoped_ptr<std::vector<DownloadCommands::Command>>
 DownloadNotificationItem::GetExtraActions() const {
@@ skipping 138 matching lines @@
   NOTREACHED();
   return base::string16();
 }
 
 Browser* DownloadNotificationItem::GetBrowser() {
   chrome::ScopedTabbedBrowserDisplayer browser_displayer(
       profile_, chrome::GetActiveDesktop());
   DCHECK(browser_displayer.browser());
   return browser_displayer.browser();
 }