Enable users of NotificationUIManager to specify binary images.

chrome/browser/notifications/message_center_notification_manager.cc

 // Copyright (c) 2012 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/notifications/message_center_notification_manager.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/extensions/extension_info_map.h"
@@ skipping 145 matching lines @@
         old_notification->profile()->IsSameProfile(profile)) {
       std::string old_id =
           old_notification->notification().notification_id();
       DCHECK(message_center_->HasNotification(old_id));
 
       // Add/remove notification in the local list but just update the same
       // one in MessageCenter.
       old_notification->notification().Close(false); // Not by user.
       delete old_notification;
       profile_notifications_.erase(old_id);
-      ProfileNotification* new_notification =
-          new ProfileNotification(profile, notification, message_center_);
+      ProfileNotification* new_notification = new ProfileNotification(
+          profile, notification, message_center_, old_id);
       profile_notifications_[notification.notification_id()] = new_notification;
-      message_center_->UpdateNotification(old_id,
-                                          notification.notification_id(),
-                                          notification.title(),
-                                          notification.body(),
-                                          notification.optional_fields(),
-                                          notification.delegate());
-      new_notification->StartDownloads();
       return true;
     }
   }
   return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // MessageCenter::Delegate
 
 void MessageCenterNotificationManager::DisableExtension(
@@ skipping 73 matching lines @@
   NotificationMap::const_iterator iter =
       profile_notifications_.find(notification_id);
   if (iter != profile_notifications_.end())
     RemoveProfileNotification(iter->second, by_user);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ImageDownloads
 
 MessageCenterNotificationManager::ImageDownloads::ImageDownloads(
-    message_center::MessageCenter* message_center,
+    message_center::Notification* notification,
     ImageDownloadsObserver* observer)
-    : message_center_(message_center),
+    : message_center_notification_(notification),
       pending_downloads_(0),
-      observer_(observer) {
-}
+      observer_(observer) {}
 
 MessageCenterNotificationManager::ImageDownloads::~ImageDownloads() { }
 
 void MessageCenterNotificationManager::ImageDownloads::StartDownloads(
     const Notification& notification) {
+
   // In case all downloads are synchronous, assume a pending download.
   AddPendingDownload();
 
-  // Notification primary icon.
-  StartDownloadWithImage(
-      notification,
-      &notification.icon(),
-      notification.icon_url(),
-      message_center::kNotificationIconSize,
-      base::Bind(&message_center::MessageCenter::SetNotificationIcon,
-                 base::Unretained(message_center_),
-                 notification.notification_id()));
+  content::RenderViewHost* host = notification.GetRenderViewHost();
+  if (!host) {
+    DVLOG(1) << "Unable to download images due to a missing RenderViewHost.";
+    PendingDownloadCompleted();
+    return;
+  }
+
+  if (notification.icon().IsEmpty()) {
+    // Notification primary icon.
+    StartDownloadByURL(host,
+                       notification.icon_url(),
+                       message_center::kNotificationIconSize,
+                       base::Bind(&ImageDownloads::SetIcon, AsWeakPtr()));
+  } else {
+    SetIcon(notification.icon());
+  }
+
+  const base::DictionaryValue* optional_fields = notification.optional_fields();
+  if (!optional_fields) {
+    // Unable to download anything else because no URLs were specified in
+    // optional_fields.
+    PendingDownloadCompleted();
+    return;
+  }
 
   // Notification image.
-  StartDownloadByKey(
-      notification,
-      message_center::kImageUrlKey,
-      message_center::kNotificationPreferredImageSize,
-      base::Bind(&message_center::MessageCenter::SetNotificationImage,
-                 base::Unretained(message_center_),
-                 notification.notification_id()));
+  StartDownloadByKey(host,
+                     optional_fields,
+                     message_center::kImageUrlKey,
+                     message_center::kNotificationPreferredImageSize,
+                     base::Bind(&ImageDownloads::SetImage, AsWeakPtr()));
 
   // Notification button icons.
   StartDownloadByKey(
-      notification,
+      host,
+      optional_fields,
       message_center::kButtonOneIconUrlKey,
       message_center::kNotificationButtonIconSize,
-      base::Bind(&message_center::MessageCenter::SetNotificationButtonIcon,
-                 base::Unretained(message_center_),
-                 notification.notification_id(), 0));
+      base::Bind(&ImageDownloads::SetButtonIcon, AsWeakPtr(), 0));
   StartDownloadByKey(
-      notification, message_center::kButtonTwoIconUrlKey,
+      host,
+      optional_fields,
+      message_center::kButtonTwoIconUrlKey,
       message_center::kNotificationButtonIconSize,
-      base::Bind(&message_center::MessageCenter::SetNotificationButtonIcon,
-                 base::Unretained(message_center_),
-                 notification.notification_id(), 1));
+      base::Bind(&ImageDownloads::SetButtonIcon, AsWeakPtr(), 1));
 
   // This should tell the observer we're done if everything was synchronous.
   PendingDownloadCompleted();
 }
 
-void MessageCenterNotificationManager::ImageDownloads::StartDownloadWithImage(
-    const Notification& notification,
-    const gfx::Image* image,
+void MessageCenterNotificationManager::ImageDownloads::StartDownloadByKey(
+    content::RenderViewHost* host,
+    const base::DictionaryValue* optional_fields,
+    const char* key,
+    int size,
+    const SetImageCallback& callback) {
+  DCHECK(optional_fields);
+  DCHECK(key);
+
+  if (!optional_fields->HasKey(key)) {
+    return;
+  }
+
+  string16 url_str;
+  optional_fields->GetString(key, &url_str);
+
+  GURL url(url_str);
+
+  // Leave the image null if there's no URL.
+  if (!url.is_valid())
+    return;
+
+  StartDownloadByURL(host, url, size, callback);
+}
+
+void MessageCenterNotificationManager::ImageDownloads::StartDownloadByURL(
+    content::RenderViewHost* host,
     const GURL& url,
     int size,
     const SetImageCallback& callback) {
-  // Set the image directly if we have it.
-  if (image && !image->IsEmpty()) {
-    callback.Run(*image);
+
+  if (!host) {
+    LOG(WARNING) << "Notification needs an image but has no RenderViewHost";
+    callback.Run(gfx::Image());
     return;
   }
 
-  // Leave the image null if there's no URL.
-  if (url.is_empty())
-    return;
-
-  content::RenderViewHost* host = notification.GetRenderViewHost();
-  if (!host) {
-    LOG(WARNING) << "Notification needs an image but has no RenderViewHost";
-    return;
-  }
-
   content::WebContents* contents =
       content::WebContents::FromRenderViewHost(host);
   if (!contents) {
     LOG(WARNING) << "Notification needs an image but has no WebContents";
+    callback.Run(gfx::Image());
     return;
   }
 
   AddPendingDownload();
 
   contents->DownloadImage(
       url,
       false,
       size,
       base::Bind(
           &MessageCenterNotificationManager::ImageDownloads::DownloadComplete,
           AsWeakPtr(),
           callback));
 }
 
-void MessageCenterNotificationManager::ImageDownloads::StartDownloadByKey(
-    const Notification& notification,
-    const char* key,
-    int size,
-    const SetImageCallback& callback) {
-  const base::DictionaryValue* optional_fields = notification.optional_fields();
-  if (optional_fields && optional_fields->HasKey(key)) {
-    string16 url;
-    optional_fields->GetString(key, &url);
-    StartDownloadWithImage(notification, NULL, GURL(url), size, callback);
-  }
-}
-
 void MessageCenterNotificationManager::ImageDownloads::DownloadComplete(
     const SetImageCallback& callback,
     int download_id,
     int http_status_code,
     const GURL& image_url,
     int requested_size,
     const std::vector<SkBitmap>& bitmaps) {
+  if (!bitmaps.empty()) {
+    gfx::Image image = gfx::Image::CreateFrom1xBitmap(bitmaps[0]);
+    callback.Run(image);
+  }
+
   PendingDownloadCompleted();
-
-  if (bitmaps.empty())
-    return;
-  gfx::Image image = gfx::Image::CreateFrom1xBitmap(bitmaps[0]);
-  callback.Run(image);
 }
 
 // Private methods.
 
 void MessageCenterNotificationManager::ImageDownloads::AddPendingDownload() {
   ++pending_downloads_;
 }
 
 void
 MessageCenterNotificationManager::ImageDownloads::PendingDownloadCompleted() {
   DCHECK(pending_downloads_ > 0);
   if (--pending_downloads_ == 0 && observer_)
     observer_->OnDownloadsCompleted();
 }
 
+void MessageCenterNotificationManager::ImageDownloads::SetIcon(
+    const gfx::Image& image) {
+  message_center_notification_->set_icon(image);
+}
+void MessageCenterNotificationManager::ImageDownloads::SetImage(
+    const gfx::Image& image) {
+  message_center_notification_->set_image(image);
+}
+void MessageCenterNotificationManager::ImageDownloads::SetButtonIcon(
+    size_t button_number,
+    const gfx::Image& image) {
+  message_center_notification_->SetButtonIcon(button_number, image);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // ProfileNotification
 
 MessageCenterNotificationManager::ProfileNotification::ProfileNotification(
     Profile* profile,
     const Notification& notification,
     message_center::MessageCenter* message_center)
     : profile_(profile),
       notification_(notification),
-      downloads_(new ImageDownloads(message_center, this)) {
-  DCHECK(profile);
+      message_center_(message_center),
+      update_(false),
+      updated_id_(std::string()),
+      downloads_(NULL) {
+  Init();
+}
+
+MessageCenterNotificationManager::ProfileNotification::ProfileNotification(
+    Profile* profile,
+    const Notification& notification,
+    message_center::MessageCenter* message_center,
+    const std::string& updated_id)
+    : profile_(profile),
+      notification_(notification),
+      message_center_(message_center),
+      update_(true),
+      updated_id_(updated_id),
+      downloads_(NULL) {
+  Init();
+}
+
+void MessageCenterNotificationManager::ProfileNotification::Init() {
+  DCHECK(profile_);
+
+  bool has_rich_notification = notification_.has_rich_notification();
+  if (has_rich_notification) {
+    const message_center::RichNotificationData& data =
+        notification_.rich_notification_data();
+    message_center_notification_.reset(
+        new message_center::Notification(notification_.type(),
+                                         notification_.notification_id(),
+                                         notification_.title(),
+                                         notification_.body(),
+                                         notification_.display_source(),
+                                         GetExtensionId(),
+                                         data,
+                                         notification_.delegate()));
+    OnDownloadsCompleted();
+  } else {
+    message_center_notification_.reset(
+        new message_center::Notification(notification_.type(),
+                                         notification_.notification_id(),
+                                         notification_.title(),
+                                         notification_.body(),
+                                         notification_.icon(),
+                                         notification_.display_source(),
+                                         GetExtensionId(),
+                                         notification_.optional_fields(),
+                                         notification_.delegate()));
+    StartDownloads();
+  }
 }
 
 MessageCenterNotificationManager::ProfileNotification::~ProfileNotification() {
 }
 
 void MessageCenterNotificationManager::ProfileNotification::StartDownloads() {
+  DCHECK(message_center_notification_.get());
+  downloads_.reset(
+      new ImageDownloads(message_center_notification_.get(), this));
   downloads_->StartDownloads(notification_);
 }
 
 void
 MessageCenterNotificationManager::ProfileNotification::OnDownloadsCompleted() {
   notification_.DoneRendering();
+  if (update_) {
+    message_center_->UpdateNotification(updated_id_,

[Jun Mukai, 2013/05/31 17:08:10]

It seems that UpdateNotification will still be called even though it's still not
yet added, if the app invokes update before the images are fully downloaded.

+                                        message_center_notification_.Pass());
+  } else {
+    message_center_->AddNotification(message_center_notification_.Pass());
+  }
 }
 
 std::string
     MessageCenterNotificationManager::ProfileNotification::GetExtensionId() {
   ExtensionInfoMap* extension_info_map =
       extensions::ExtensionSystem::Get(profile())->info_map();
   ExtensionSet extensions;
   extension_info_map->GetExtensionsWithAPIPermissionForSecurityOrigin(
       notification().origin_url(), notification().process_id(),
       extensions::APIPermission::kNotification, &extensions);
@@ skipping 12 matching lines @@
 // private
 
 void MessageCenterNotificationManager::AddProfileNotification(
     ProfileNotification* profile_notification) {
   const Notification& notification = profile_notification->notification();
   std::string id = notification.notification_id();
   // Notification ids should be unique.
   DCHECK(profile_notifications_.find(id) == profile_notifications_.end());
   profile_notifications_[id] = profile_notification;
 
-  message_center_->AddNotification(notification.type(),
-                                   notification.notification_id(),
-                                   notification.title(),
-                                   notification.body(),
-                                   notification.display_source(),
-                                   profile_notification->GetExtensionId(),
-                                   notification.optional_fields(),
-                                   notification.delegate());
-  profile_notification->StartDownloads();
 }
 
 void MessageCenterNotificationManager::RemoveProfileNotification(
     ProfileNotification* profile_notification,
     bool by_user) {
   profile_notification->notification().Close(by_user);
   std::string id = profile_notification->notification().notification_id();
   profile_notifications_.erase(id);
   delete profile_notification;
 }
 
 MessageCenterNotificationManager::ProfileNotification*
     MessageCenterNotificationManager::FindProfileNotification(
         const std::string& id) const {
   NotificationMap::const_iterator iter = profile_notifications_.find(id);
   if (iter == profile_notifications_.end())
     return NULL;
 
   return (*iter).second;
 }