Turn on and use the AppInfo data.

chrome/browser/notifications/sync_notifier/synced_notification.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/sync_notifier/synced_notification.h"
 
 #include "base/basictypes.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 102 matching lines @@
 
   return app_icon_ready && images_ready && sender_picture_ready &&
       button_bitmaps_ready;
 }
 
 // TODO(petewil): The fetch mechanism appears to be returning two bitmaps on the
 // mac - perhaps one is regular, one is high dpi?  If so, ensure we use the high
 // dpi bitmap when appropriate.
 void SyncedNotification::OnFetchComplete(const GURL url,
                                          const SkBitmap* bitmap) {
-  // TODO(petewil): Add timeout mechanism in case bitmaps take too long.  Do we
-  // already have one built into URLFetcher?
   // Make sure we are on the thread we expect.
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   gfx::Image downloaded_image;
   if (bitmap != NULL)
     downloaded_image = gfx::Image::CreateFrom1xBitmap(*bitmap);
 
   // Match the incoming bitmaps to URLs.  In case this is a dup, make sure to
   // try all potentially matching urls.
   if (GetAppIconUrl() == url) {
@@ skipping 19 matching lines @@
         button_bitmaps_[i] = gfx::Image::CreateFrom1xBitmap(*bitmap);
       }
       button_bitmaps_fetch_pending_[i] = false;
     }
   }
 
   DVLOG(2) << __FUNCTION__ << " popping bitmap " << url;
 
   // See if all bitmaps are already accounted for, if so call Show.
   if (AreAllBitmapsFetched()) {
-    Show(notification_manager_, notifier_service_, profile_);
+    Show(profile_);
   }
 }
 
 void SyncedNotification::QueueBitmapFetchJobs(
-    NotificationUIManager* notification_manager,
     ChromeNotifierService* notifier_service,
     Profile* profile) {
   // If we are not using the MessageCenter, call show now, and the existing
   // code will handle the bitmap fetch for us.
   if (!UseRichNotifications()) {
-    Show(notification_manager, notifier_service, profile);
+    Show(profile);
     return;
   }
 
   // Save off the arguments for the call to Show.
-  notification_manager_ = notification_manager;
   notifier_service_ = notifier_service;
   profile_ = profile;
 
   // Ensure our bitmap vector has as many entries as there are buttons,
   // so that when the bitmaps arrive the vector has a slot for them.
   for (unsigned int i = 0; i < GetButtonCount(); ++i) {
     button_bitmaps_.push_back(gfx::Image());
     button_bitmaps_fetch_pending_.push_back(true);
-    AddBitmapToFetchQueue(GetButtonIconUrl(i));
+    CreateBitmapFetcher(GetButtonIconUrl(i));
   }
 
   // If there is a profile image bitmap, fetch it
   if (GetProfilePictureCount() > 0) {
     // TODO(petewil): When we have the capacity to display more than one bitmap,
     // modify this code to fetch as many as we can display
-    AddBitmapToFetchQueue(GetProfilePictureUrl(0));
+    CreateBitmapFetcher(GetProfilePictureUrl(0));
   }
 
   // If the URL is non-empty, add it to our queue of URLs to fetch.
-  AddBitmapToFetchQueue(GetAppIconUrl());
-  AddBitmapToFetchQueue(GetImageUrl());
+  CreateBitmapFetcher(GetAppIconUrl());
+  CreateBitmapFetcher(GetImageUrl());
 
   // Check to see if we don't need to fetch images, either because we already
   // did, or because the URLs are empty. If so, we can display the notification.
 
   // See if all bitmaps are accounted for, if so call Show().
   if (AreAllBitmapsFetched()) {
-    Show(notification_manager_, notifier_service_, profile_);
+    Show(profile_);
   }
 }
 
 void SyncedNotification::StartBitmapFetch() {
   // Now that we have queued and counted them all, start the fetching.
   ScopedVector<chrome::BitmapFetcher>::iterator iter;
   for (iter = fetchers_.begin(); iter != fetchers_.end(); ++iter) {
     (*iter)->Start(profile_);
   }
 }
 
-void SyncedNotification::AddBitmapToFetchQueue(const GURL& url) {
+void SyncedNotification::CreateBitmapFetcher(const GURL& url) {
   // Check for dups, ignore any request for a dup.
   ScopedVector<chrome::BitmapFetcher>::iterator iter;
   for (iter = fetchers_.begin(); iter != fetchers_.end(); ++iter) {
     if ((*iter)->url() == url)
       return;
   }
 
   if (url.is_valid()) {
     fetchers_.push_back(new chrome::BitmapFetcher(url, this));
     DVLOG(2) << __FUNCTION__ << "Pushing bitmap " << url;
   }
 }
 
-void SyncedNotification::Show(NotificationUIManager* notification_manager,
-                              ChromeNotifierService* notifier_service,
-                              Profile* profile) {
+void SyncedNotification::Show(Profile* profile) {
   // Let NotificationUIManager know that the notification has been dismissed.
   if (SyncedNotification::kRead == GetReadState() ||
       SyncedNotification::kDismissed == GetReadState() ) {
-    notification_manager->CancelById(GetKey());
+    notification_manager_->CancelById(GetKey());
     DVLOG(2) << "Dismissed or read notification arrived"
              << GetHeading() << " " << GetText();
     return;
   }
 
   // |notifier_service| can be NULL in tests.
-  if (UseRichNotifications() && notifier_service) {
-    notifier_service->ShowWelcomeToastIfNecessary(this, notification_manager);
+  if (UseRichNotifications() && notifier_service_) {
+    notifier_service_->ShowWelcomeToastIfNecessary(this, notification_manager_);
   }
 
   // Set up the fields we need to send and create a Notification object.
   GURL image_url = GetImageUrl();
   base::string16 text = base::UTF8ToUTF16(GetText());
   base::string16 heading = base::UTF8ToUTF16(GetHeading());
   base::string16 description = base::UTF8ToUTF16(GetDescription());
   base::string16 annotation = base::UTF8ToUTF16(GetAnnotation());
   // TODO(petewil): Eventually put the display name of the sending service here.
   base::string16 display_source = base::UTF8ToUTF16(GetAppId());
   base::string16 replace_key = base::UTF8ToUTF16(GetKey());
   base::string16 notification_heading = heading;
   base::string16 notification_text = description;
   base::string16 newline = base::UTF8ToUTF16("\n");
 
   // The delegate will eventually catch calls that the notification
   // was read or deleted, and send the changes back to the server.
   scoped_refptr<NotificationDelegate> delegate =
-      new ChromeNotifierDelegate(GetKey(), notifier_service);
+      new ChromeNotifierDelegate(GetKey(), notifier_service_);
 
   // Some inputs and fields are only used if there is a notification center.
   if (UseRichNotifications()) {
     base::Time creation_time =
         base::Time::FromDoubleT(static_cast<double>(GetCreationTime()));
     int priority = GetPriority();
     unsigned int button_count = GetButtonCount();
 
     // Deduce which notification template to use from the data.
     message_center::NotificationType notification_type =
@@ skipping 79 matching lines @@
                                  blink::WebTextDirectionDefault,
                                  message_center::NotifierId(GetOriginUrl()),
                                  display_source,
                                  replace_key,
                                  rich_notification_data,
                                  delegate.get());
     // In case the notification is not supposed to be toasted, pretend that it
     // has already been shown.
     ui_notification.set_shown_as_popup(!toast_state_);
 
-    notification_manager->Add(ui_notification, profile);
+    notification_manager_->Add(ui_notification, profile);
   } else {
     // In this case we have a Webkit Notification, not a Rich Notification.
     Notification ui_notification(GetOriginUrl(),
                                  GetAppIconUrl(),
                                  notification_heading,
                                  notification_text,
                                  blink::WebTextDirectionDefault,
                                  display_source,
                                  replace_key,
                                  delegate.get());
 
-    notification_manager->Add(ui_notification, profile);
+    notification_manager_->Add(ui_notification, profile);
   }
 
   DVLOG(1) << "Showing Synced Notification! " << heading << " " << text
            << " " << GetAppIconUrl() << " " << replace_key << " "
            << GetProfilePictureUrl(0) << " " << GetReadState();
 
   return;
 }
 
+// Display the notification if it has the specified app_id_name.
+void SyncedNotification::ShowAllForAppId(Profile* profile,
+                                         std::string app_id_name) {
+  if (app_id_name == GetAppId())
+    Show(profile);
+}
+
+// Remove the notification if it has the specified app_id_name.
+void SyncedNotification::HideAllForAppId(std::string app_id_name) {
+  if (app_id_name == GetAppId()) {
+    notification_manager_->CancelById(GetKey());
+  }
+}
+
 // This should detect even small changes in case the server updated the
 // notification.  We ignore the timestamp if other fields match.
 bool SyncedNotification::EqualsIgnoringReadState(
     const SyncedNotification& other) const {
   if (GetTitle() == other.GetTitle() &&
       GetHeading() == other.GetHeading() &&
       GetDescription() == other.GetDescription() &&
       GetAnnotation() == other.GetAnnotation() &&
       GetAppId() == other.GetAppId() &&
       GetKey() == other.GetKey() &&
@@ skipping 340 matching lines @@
 std::string SyncedNotification::GetContainedNotificationMessage(
     int index) const {
   if (specifics_.coalesced_notification().render_info().expanded_info().
       collapsed_info_size() < index + 1)
     return std::string();
 
   return specifics_.coalesced_notification().render_info().expanded_info().
       collapsed_info(index).simple_collapsed_layout().description();
 }
 
-std::string SyncedNotification::GetSendingServiceId() const {
-  // TODO(petewil): We are building a new protocol (a new sync datatype) to send
-  // the service name and icon from the server.  For now this method is
-  // hardcoded to the name of our first service using synced notifications.
-  // Once the new protocol is built, remove this hardcoding.
-  return kFirstSyncedNotificationServiceId;
-}
-
 const gfx::Image& SyncedNotification::GetAppIcon() const {
   return app_icon_bitmap_;
 }
 
 void SyncedNotification::SetToastState(bool toast_state) {
   toast_state_ = toast_state;
 }
 
 }  // namespace notifier