Turn on and use the AppInfo data.

chrome/browser/notifications/sync_notifier/chrome_notifier_service.h

 // 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.
 
 #ifndef CHROME_BROWSER_NOTIFICATIONS_SYNC_NOTIFIER_CHROME_NOTIFIER_SERVICE_H_
 #define CHROME_BROWSER_NOTIFICATIONS_SYNC_NOTIFIER_CHROME_NOTIFIER_SERVICE_H_
 
 #include <set>
 #include <string>
 
@@ skipping 12 matching lines @@
 
 namespace user_prefs {
 class PrefRegistrySyncable;
 }
 
 namespace message_center {
 struct Notifier;
 }
 
 namespace notifier {
-class SyncedNotificationAppInfoTemp;
+class SyncedNotificationAppInfo;
+class SyncedNotificationAppInfoService;
 
 // The name of our first synced notification service.
-// TODO(petewil): remove this hardcoding once we have the synced notification
-// signalling sync data type set up to provide this.
-// crbug.com/248337
+// TODO(petewil): Remove this once we figure out how to do UMA for each sending
+// service name without knowing the name in advance.
 extern const char kFirstSyncedNotificationServiceId[];
 extern const char kServiceEnabledOnce[];
 extern const char kSyncedNotificationFirstRun[];
 extern const char kSyncedNotificationsWelcomeOrigin[];
 
 enum ChromeNotifierServiceActionType {
   CHROME_NOTIFIER_SERVICE_ACTION_UNKNOWN,
   CHROME_NOTIFIER_SERVICE_ACTION_FIRST_SERVICE_ENABLED,
   CHROME_NOTIFIER_SERVICE_ACTION_FIRST_SERVICE_DISABLED,
   // NOTE: Add new action types only immediately above this line. Also,
@@ skipping 25 matching lines @@
       syncer::ModelType type) const OVERRIDE;
   virtual syncer::SyncError ProcessSyncChanges(
       const tracked_objects::Location& from_here,
       const syncer::SyncChangeList& change_list) OVERRIDE;
 
   // Convert from internal representation to SyncData representation.
   static syncer::SyncData CreateSyncDataFromNotification(
       const SyncedNotification& notification);
 
   // Convert from SyncData representation to internal representation.
-  static scoped_ptr<SyncedNotification> CreateNotificationFromSyncData(
+  scoped_ptr<SyncedNotification> CreateNotificationFromSyncData(
       const syncer::SyncData& sync_data);
 
   // Get a pointer to a notification.  ChromeNotifierService owns this pointer.
   virtual notifier::SyncedNotification* FindNotificationById(
       const std::string& notification_id);
 
   // Get the list of synced notification services and fill their meta data to
   // |notifiers|.
   void GetSyncedNotificationServices(
       std::vector<message_center::Notifier*>* notifiers);
 
   // Called when we dismiss a notification.  This is virtual so that test
   // subclasses can override it.
   virtual void MarkNotificationAsRead(const std::string& id);
 
   // Called when a notier is enabled or disabled.
   void OnSyncedNotificationServiceEnabled(
       const std::string& notifier_id,
       bool enabled);
 
+  // When app ids are added or removed, unblock or remove associated messages.
+  void OnAddedAppIds(std::vector<std::string> added_app_ids);
+  void OnRemovedAppIds(std::vector<std::string> removed_app_ids);
+
   // Register the preferences we use to save state.
   static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
 
   Profile* profile() const { return profile_; }
 
+  // Find and retun the sending service Id for this notification.
+  std::string GetSendingServiceId(
+      const SyncedNotification* synced_notification);
+
   // Functions for test.
   void AddForTest(scoped_ptr<notifier::SyncedNotification> notification);
 
+  void SetSyncedNotificationAppInfoServiceForTest(
+      SyncedNotificationAppInfoService* synced_notification_app_info_service);
+
   // If we allow the tests to do bitmap fetching, they will attempt to fetch
   // a URL from the web, which will fail.  We can already test the majority
   // of what we want without also trying to fetch bitmaps.  Other tests will
   // cover bitmap fetching.
   static void set_avoid_bitmap_fetching_for_test(bool avoid) {
     avoid_bitmap_fetching_for_test_ = avoid;
   }
 
   // Initialize the preferences we use for the ChromeNotificationService.
   void InitializePrefs();
@@ skipping 36 matching lines @@
       std::set<std::string>* ids_field);
 
   // Called when our "first run" boolean pref has been changed.
   void OnSyncedNotificationFirstRunBooleanPrefChanged(bool* new_value);
 
   // Convert our internal set of strings to a list value.
   // The second param is an outparam which the function fills in.
   void BuildServiceListValueInplace(
       std::set<std::string> services, base::ListValue* list_value);
 
-  SyncedNotificationAppInfoTemp* FindAppInfo(const std::string& app_id) const;
+  // Finds an app info by using the AppId
+  notifier::SyncedNotificationAppInfo* FindAppInfoByAppId(
+      const std::string& app_id) const;
 
+  // Builds a welcome notification for the listed sending service.
   const Notification CreateWelcomeNotificationForService(
-      SyncedNotificationAppInfoTemp* app_info);
+      SyncedNotificationAppInfo* app_info);
 
   // Preferences for storing which SyncedNotificationServices are enabled
   StringListPrefMember enabled_sending_services_prefs_;
   StringListPrefMember initialized_sending_services_prefs_;
 
   // Preferences to avoid toasting on SyncedNotification first run.
   BooleanPrefMember synced_notification_first_run_prefs_;
 
   // Back pointer to the owning profile.
   Profile* const profile_;
   NotificationUIManager* const notification_manager_;
   scoped_ptr<syncer::SyncChangeProcessor> sync_processor_;
   std::set<std::string> enabled_sending_services_;
   std::set<std::string> initialized_sending_services_;
   bool synced_notification_first_run_;
   static bool avoid_bitmap_fetching_for_test_;
   base::ThreadChecker thread_checker_;
+  // Unowned pointer to the App Info service.  The lifetime is managed by the
+  // profile service, this service depends on the App Info service, so it should
+  // always be in scope whenever our service is active.
+  SyncedNotificationAppInfoService* synced_notification_app_info_service_;
 
-  ScopedVector<SyncedNotificationAppInfoTemp> app_info_data_;
   // TODO(petewil): Consider whether a map would better suit our data.
   // If there are many entries, lookup time may trump locality of reference.
   ScopedVector<SyncedNotification> notification_data_;
 
   friend class ChromeNotifierServiceTest;
   FRIEND_TEST_ALL_PREFIXES(ChromeNotifierServiceTest, ServiceEnabledTest);
   FRIEND_TEST_ALL_PREFIXES(ChromeNotifierServiceTest,
                            AddNewSendingServicesTest);
   FRIEND_TEST_ALL_PREFIXES(ChromeNotifierServiceTest,
                            CheckInitializedServicesTest);
   FRIEND_TEST_ALL_PREFIXES(ChromeNotifierServiceTest,
                            GetEnabledSendingServicesFromPreferencesTest);
   FRIEND_TEST_ALL_PREFIXES(ChromeNotifierServiceTest, CheckFindAppInfo);
+  FRIEND_TEST_ALL_PREFIXES(ChromeNotifierServiceTest, SetAddedAppIdsTest);
+  FRIEND_TEST_ALL_PREFIXES(ChromeNotifierServiceTest, SetRemovedAppIdsTest);
 
   DISALLOW_COPY_AND_ASSIGN(ChromeNotifierService);
 };
 
 }  // namespace notifier
 
 #endif  // CHROME_BROWSER_NOTIFICATIONS_SYNC_NOTIFIER_CHROME_NOTIFIER_SERVICE_H_