Turn on and use the AppInfo data.

chrome/browser/notifications/sync_notifier/synced_notification_app_info_service.cc

 // Copyright 2014 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 SyncedNotificationAppInfoService brings down read only metadata from the
 // sync server with information about the services sending synced notifications.
 
 #include "chrome/browser/notifications/sync_notifier/synced_notification_app_info_service.h"
 
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/notifications/sync_notifier/chrome_notifier_service.h"
+#include "chrome/browser/notifications/sync_notifier/chrome_notifier_service_factory.h"
 #include "chrome/browser/profiles/profile.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_app_info_specifics.pb.h"
 #include "url/gurl.h"
 
 namespace notifier {
 
+bool SyncedNotificationAppInfoService::avoid_bitmap_fetching_for_test_ = false;
+
 SyncedNotificationAppInfoService::SyncedNotificationAppInfoService(
     Profile* profile)
-    : profile_(profile) {}
+    : profile_(profile), chrome_notifier_service_(NULL) {}
 
 SyncedNotificationAppInfoService::~SyncedNotificationAppInfoService() {}
 
 // Methods from BrowserContextKeyedService.
 void SyncedNotificationAppInfoService::Shutdown() {}
 
 // syncer::SyncableService implementation.
 
 // This is called at startup to sync with the sync data. This code is not thread
 // safe, it should only be called by sync on the browser thread.
@@ skipping 98 matching lines @@
 
   // TODO(petewil): Recreate this from internal data instead,
   // it improves code maintainability.
 
   // make a copy for the list we give back to the caller.
   sync_data_list.push_back(sync_data_);
 
   return sync_data_list;
 }
 
 void SyncedNotificationAppInfoService::ProcessIncomingAppInfoProtobuf(

[dewittj, 2014/03/20 18:00:28]

I think this code is resilient to the race conditions I've thought of so far but
it would be nice to comment how that is achieved here.  Something about how
duplicate URL fetchers are deduped, and that if multiple appinfoprotobufs come
in then no callbacks to the chromenotifierservice will happen until all the
unique urls have finished downloading.

[Pete Williamson, 2014/03/25 00:08:37]

Done.

     const sync_pb::SyncedNotificationAppInfo& app_info) {
   // Build a local app_info object from the sync data.
   scoped_ptr<SyncedNotificationAppInfo> incoming(
       CreateSyncedNotificationAppInfoFromProtobuf(app_info));
   DCHECK(incoming.get());
 
   // Process each incoming app_info protobuf.
   const std::string& name = incoming->settings_display_name();
   DCHECK_GT(name.length(), 0U);
   if (name.length() == 0) {
     // If there is no unique id (name), there is nothing we can do.
     return;
   }
 
   SyncedNotificationAppInfo* found = FindSyncedNotificationAppInfoByName(name);
 
-  if (NULL != found) {
+  std::vector<std::string> old_app_ids;
+  std::vector<std::string> new_app_ids;
+  std::vector<std::string> added_app_ids;
+  std::vector<std::string> removed_app_ids;
+
+  new_app_ids = incoming->GetAppIdList();
+
+  if (NULL == found) {
+    added_app_ids = new_app_ids;
+  } else {
     // When we have an update, some app id types may be added or removed.
     // Append to lists of added and removed types.
+    old_app_ids = found->GetAppIdList();
+    new_app_ids = incoming->GetAppIdList();
     FreeSyncedNotificationAppInfoByName(name);
+
+    // Set up for a set difference by sorting the lists.
+    std::sort(old_app_ids.begin(), old_app_ids.end());

[dewittj, 2014/03/20 18:00:28]

is it better to maintain a sorted order within SyncedNotificationAppInfo?

[Pete Williamson, 2014/03/25 00:08:37]

Adding a new app info is incredibly rare, as is removing one.  I prefer the code
to be less complicated, and spend a bit more time in this rare case.

+    std::sort(new_app_ids.begin(), new_app_ids.end());
+
+    // Calculate which app ids are removed (in old, but not in new app ids).
+    std::set_difference(old_app_ids.begin(),
+                        old_app_ids.end(),
+                        new_app_ids.begin(),
+                        new_app_ids.end(),
+                        std::back_inserter(removed_app_ids));
+
+    // Calculate which app_ids are added (in new, but not in old app ids).
+    std::set_difference(new_app_ids.begin(),
+                        new_app_ids.end(),
+                        old_app_ids.begin(),
+                        old_app_ids.end(),
+                        std::back_inserter(added_app_ids));
+  }
+
+  // Put these lists into the app_info object.
+  incoming->SetAddedAppIds(added_app_ids);
+  incoming->SetRemovedAppIds(removed_app_ids);
+
+  // Start bitmap fetch.
+  if (!avoid_bitmap_fetching_for_test_) {
+    incoming->QueueBitmapFetchJobs();
+    incoming->StartBitmapFetch();
+  } else {
+    OnBitmapFetchesDone(incoming->added_app_ids(), incoming->removed_app_ids());
   }
 
   sending_service_infos_.push_back(incoming.release());
+}
 
+void SyncedNotificationAppInfoService::OnBitmapFetchesDone(
+    std::vector<std::string> added_app_ids,
+    std::vector<std::string> removed_app_ids) {
   // Tell the Chrome Notifier Service so it can show any notifications that were
   // waiting for the app id to arrive, and to remave any notifications that are
   // no longer supported.
-  // TODO(petewil): Notify CNS of added ids
-  // TODO(petewil): Notify CNS of deleted ids.
+  if (chrome_notifier_service_ != NULL) {
+    chrome_notifier_service_->SetAddedAppIds(added_app_ids);
+    chrome_notifier_service_->SetRemovedAppIds(removed_app_ids);
+  }
 }
 
 // Static Method.  Convert from a server protobuf to our internal format.
 scoped_ptr<SyncedNotificationAppInfo>
 SyncedNotificationAppInfoService::CreateSyncedNotificationAppInfoFromProtobuf(
     const sync_pb::SyncedNotificationAppInfo& server_app_info) {
 
   // Check for mandatory fields in the sync_data object.
   std::string display_name;
   if (server_app_info.has_settings_display_name()) {
     display_name = server_app_info.settings_display_name();
   }
   scoped_ptr<SyncedNotificationAppInfo> app_info;
   if (display_name.length() == 0)
     return app_info.Pass();
 
   // Create a new app info object based on the supplied protobuf.
-  app_info.reset(new SyncedNotificationAppInfo(display_name));
+  app_info.reset(new SyncedNotificationAppInfo(profile_, display_name, this));
 
   // TODO(petewil): Eventually we will add the monochrome icon here, and we may
   // need to fetch the correct url for the current DPI.
   // Add the icon URL, if any.
   if (server_app_info.has_icon()) {
     std::string icon_url = server_app_info.icon().url();
     app_info->SetSettingsIcon(GURL(icon_url));
   }
 
   // Add all the AppIds from the protobuf.
@@ skipping 15 matching lines @@
        it != sending_service_infos_.end();
        ++it) {
     SyncedNotificationAppInfo* app_info = *it;
     if (name == app_info->settings_display_name())
       return *it;
   }
 
   return NULL;
 }
 
+// This returns a pointer into a vector that we own.  Caller must not free it.
+// Returns NULL if no match is found.
+notifier::SyncedNotificationAppInfo*
+SyncedNotificationAppInfoService::FindSyncedNotificationAppInfoByAppId(
+    const std::string& app_id) {
+  for (ScopedVector<SyncedNotificationAppInfo>::const_iterator it =
+           sending_service_infos_.begin();
+       it != sending_service_infos_.end();
+       ++it) {
+    SyncedNotificationAppInfo* app_info = *it;
+    if (app_info->HasAppId(app_id))
+      return *it;
+  }
+
+  return NULL;
+}
+
+// Lookup the sending service name for a given app id.
+std::string SyncedNotificationAppInfoService::FindSendingServiceNameFromAppId(
+    const std::string app_id) {
+  for (ScopedVector<SyncedNotificationAppInfo>::const_iterator it =
+           sending_service_infos_.begin();
+       it != sending_service_infos_.end();
+       ++it) {
+    SyncedNotificationAppInfo* app_info = *it;
+    if (app_info->HasAppId(app_id))
+      return app_info->settings_display_name();
+  }
+
+  return std::string();
+}
+
 void SyncedNotificationAppInfoService::FreeSyncedNotificationAppInfoByName(
     const std::string& name) {
   ScopedVector<SyncedNotificationAppInfo>::iterator it =
       sending_service_infos_.begin();
   for (; it != sending_service_infos_.end(); ++it) {
     SyncedNotificationAppInfo* app_info = *it;
     if (name == app_info->settings_display_name()) {
       sending_service_infos_.erase(it);
       return;
     }
   }
 }
 
+std::vector<std::string>
+SyncedNotificationAppInfoService::GetAllSendingServiceNames() {
+  std::vector<std::string> names;
+  ScopedVector<SyncedNotificationAppInfo>::iterator it =
+      sending_service_infos_.begin();
+
+  for (; it != sending_service_infos_.end(); ++it) {
+    SyncedNotificationAppInfo* app_info = *it;
+    names.push_back(app_info->settings_display_name());
+  }
+
+  return names;
+}
+
 // Add a new app info to our data structure.  This takes ownership
 // of the passed in pointer.
 void SyncedNotificationAppInfoService::Add(
     scoped_ptr<SyncedNotificationAppInfo> app_info) {
   sending_service_infos_.push_back(app_info.release());
 }
 
 }  // namespace notifier