Enable and disable Synced Notification Client Services

chrome/browser/notifications/sync_notifier/chrome_notifier_service.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.
 
 // The ChromeNotifierService works together with sync to maintain the state of
 // user notifications, which can then be presented in the notification center,
 // via the Notification UI Manager.
 
 #include "chrome/browser/notifications/sync_notifier/chrome_notifier_service.h"
 
+#include <string>
+#include <vector>
+
 #include "chrome/browser/notifications/desktop_notification_service.h"
 #include "chrome/browser/notifications/desktop_notification_service_factory.h"
 #include "chrome/browser/notifications/notification.h"
 #include "chrome/browser/notifications/notification_ui_manager.h"
 #include "chrome/browser/profiles/profile.h"
-#include "grit/ui_strings.h"
+#include "grit/generated_resources.h"
+#include "grit/theme_resources.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_change_processor.h"
 #include "sync/api/sync_error_factory.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/protocol/synced_notification_specifics.pb.h"
 #include "third_party/WebKit/public/web/WebTextDirection.h"
 #include "ui/base/l10n/l10n_util.h"
+#include "ui/base/resource/resource_bundle.h"
 #include "ui/message_center/notifier_settings.h"
 #include "url/gurl.h"
 
 namespace notifier {
 namespace {
 
-const char kSampleSyncedNotificationServiceId[] = "sample-synced-service";
+const char kFirstSyncedNotificationServiceId[] = "Google+";
 
 }
 
 bool ChromeNotifierService::avoid_bitmap_fetching_for_test_ = false;
 
 ChromeNotifierService::ChromeNotifierService(Profile* profile,
                                              NotificationUIManager* manager)
-    : profile_(profile), notification_manager_(manager) {}
+    : profile_(profile), notification_manager_(manager) {
+}
 ChromeNotifierService::~ChromeNotifierService() {}
 
 // Methods from BrowserContextKeyedService.
 void ChromeNotifierService::Shutdown() {}
 
 // syncer::SyncableService implementation.
 
 // This is called at startup to sync with the server.
 // This code is not thread safe.
 syncer::SyncMergeResult ChromeNotifierService::MergeDataAndStartSyncing(
@@ skipping 214 matching lines @@
   }
 
   return NULL;
 }
 
 void ChromeNotifierService::GetSyncedNotificationServices(
     std::vector<message_center::Notifier*>* notifiers) {
   // TODO(mukai|petewil): Check the profile's eligibility before adding the
   // sample app.
 
-  // Currently we just use kSampleSyncedNotificationServiceId as a place holder.
-  // TODO(petewil): Really obtain the list of apps from the server and create
-  // the list of ids here.
+  // TODO(petewil): Really obtain the list of synced notification sending
+  // services from the server and create the list of ids here.  Until then, we
+  // are hardcoding the service names.  Once that is done, remove this
+  // hardcoding.
+  // crbug.com/248337
   DesktopNotificationService* desktop_notification_service =
       DesktopNotificationServiceFactory::GetForProfile(profile_);
   message_center::NotifierId notifier_id(
       message_center::NotifierId::SYNCED_NOTIFICATION_SERVICE,
-      kSampleSyncedNotificationServiceId);
-  notifiers->push_back(new message_center::Notifier(
+      kFirstSyncedNotificationServiceId);
+  message_center::Notifier* notifier_service = new message_center::Notifier(
       notifier_id,
       l10n_util::GetStringUTF16(
-          IDS_MESSAGE_CENTER_SAMPLE_SYNCED_NOTIFICATION_SERVICE_NAME),
-      desktop_notification_service->IsNotifierEnabled(notifier_id)));
-  // TODO(mukai): Add icon for the sample app.
+          IDS_FIRST_SYNCED_NOTIFICATION_SERVICE_NAME),
+      desktop_notification_service->IsNotifierEnabled(notifier_id));
+
+  // Add icons for our sending services.
+  // TODO(petewil): Replace this temporary hardcoding with a new sync datatype
+  // to dynamically get the name and icon for each synced notification sending
+  // service.  Until then, we use hardcoded service icons for all services.
+  // crbug.com/248337
+  notifier_service->icon = ui::ResourceBundle::GetSharedInstance().
+      GetImageNamed(IDR_TEMPORARY_GOOGLE_PLUS_ICON);
+
+  notifiers->push_back(notifier_service);
 }
 
 void ChromeNotifierService::MarkNotificationAsDismissed(
     const std::string& key) {
   SyncedNotification* notification = FindNotificationById(key);
   CHECK(notification != NULL);
 
   notification->NotificationHasBeenDismissed();
   syncer::SyncChangeList new_changes;
 
   syncer::SyncData sync_data = CreateSyncDataFromNotification(*notification);
   new_changes.push_back(
       syncer::SyncChange(FROM_HERE,
                          syncer::SyncChange::ACTION_UPDATE,
                          sync_data));
 
   // Send up the changes that were made locally.
   sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes);
 }
 
 // Add a new notification to our data structure.  This takes ownership
 // of the passed in pointer.
 void ChromeNotifierService::Add(scoped_ptr<SyncedNotification> notification) {
   SyncedNotification* notification_copy = notification.get();
   // Take ownership of the object and put it into our local storage.
   notification_data_.push_back(notification.release());
 
+  // If the user is not interested in this type of notification, ignore it.
+  std::vector<std::string>::iterator iter =
+      find(enabled_sending_services_.begin(),
+           enabled_sending_services_.end(),
+           notification_copy->GetSendingServiceId());
+  if (iter == enabled_sending_services_.end()) {
+    return;
+  }
+
   Display(notification_copy);
 }
 
 void ChromeNotifierService::AddForTest(
     scoped_ptr<notifier::SyncedNotification> notification) {
     notification_data_.push_back(notification.release());
   }
 
 void ChromeNotifierService::Display(SyncedNotification* notification) {
+
   // Set up to fetch the bitmaps.
   notification->QueueBitmapFetchJobs(notification_manager_,
                                           this,
                                           profile_);
 
   // Our tests cannot use the network for reliability reasons.
   if (avoid_bitmap_fetching_for_test_) {
     return;
   }
 
   // Start the bitmap fetching, Show() will be called when the last bitmap
   // either arrives or times out.
   notification->StartBitmapFetch();
 }
 
 void ChromeNotifierService::OnSyncedNotificationServiceEnabled(
     const std::string& notifier_id, bool enabled) {
-  // TODO(petewil): start/stop syncing
+  std::vector<std::string>::iterator iter;
+
+  iter = find(enabled_sending_services_.begin(),
+              enabled_sending_services_.end(),
+              notifier_id);
+
+  // Add the notifier_id if it is enabled and not already there.
+  if (iter == enabled_sending_services_.end() && enabled) {
+    enabled_sending_services_.push_back(notifier_id);
+    // TODO(petewil) Check now for any outstanding notifications.
+  // Remove the notifier_id if it is disabled and present.
+  } else if (iter != enabled_sending_services_.end() && !enabled) {
+    enabled_sending_services_.erase(iter);
+  }
+
+  // Otherwise, nothing to do, we can exit.
+  return;
 }
 
 }  // namespace notifier