Refactor sync-specific parts out of SyncNotifier/SyncNotifierObserver

sync/notifier/p2p_notifier.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 "sync/notifier/p2p_notifier.h"
 
 #include <algorithm>
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/values.h"
 #include "jingle/notifier/listener/push_client.h"
 #include "sync/internal_api/public/base/model_type_payload_map.h"
+#include "sync/notifier/invalidation_util.h"
 #include "sync/notifier/sync_notifier_observer.h"
 
 namespace syncer {
 
 const char* kSyncP2PNotificationChannel = "http://www.google.com/chrome/sync";
 
 namespace {
 
 const char kNotifySelf[] = "notifySelf";
 const char kNotifyOthers[] = "notifyOthers";
@@ skipping 124 matching lines @@
   DCHECK(send_notification_target_ == NOTIFY_OTHERS ||
          send_notification_target_ == NOTIFY_ALL);
   push_client_->AddObserver(this);
 }
 
 P2PNotifier::~P2PNotifier() {
   DCHECK(thread_checker_.CalledOnValidThread());
   push_client_->RemoveObserver(this);
 }
 
-void P2PNotifier::AddObserver(SyncNotifierObserver* observer) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  observer_list_.AddObserver(observer);
-}
-
-void P2PNotifier::RemoveObserver(SyncNotifierObserver* observer) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  observer_list_.RemoveObserver(observer);
+void P2PNotifier::UpdateRegisteredIds(SyncNotifierObserver* handler,
+                                      const ObjectIdSet& ids) {
+  const ModelTypeSet& enabled_types = ObjectIdSetToModelTypeSet(
+      helper_.UpdateRegisteredIds(handler, ids));
+  const ModelTypeSet& new_enabled_types =
+      Difference(enabled_types, enabled_types_);
+  const P2PNotificationData notification_data(
+      unique_id_, NOTIFY_SELF, new_enabled_types);
+  SendNotificationData(notification_data);
+  enabled_types_ = enabled_types;
 }
 
 void P2PNotifier::SetUniqueId(const std::string& unique_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   unique_id_ = unique_id;
 }
 
 void P2PNotifier::SetStateDeprecated(const std::string& state) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Do nothing.
 }
 
 void P2PNotifier::UpdateCredentials(
     const std::string& email, const std::string& token) {
   DCHECK(thread_checker_.CalledOnValidThread());
   notifier::Subscription subscription;
   subscription.channel = kSyncP2PNotificationChannel;
   // There may be some subtle issues around case sensitivity of the
   // from field, but it doesn't matter too much since this is only
   // used in p2p mode (which is only used in testing).
   subscription.from = email;
   push_client_->UpdateSubscriptions(
       notifier::SubscriptionList(1, subscription));
   // If already logged in, the new credentials will take effect on the
   // next reconnection.
   push_client_->UpdateCredentials(email, token);
   logged_in_ = true;
 }
 
-void P2PNotifier::UpdateEnabledTypes(
-    syncer::ModelTypeSet enabled_types) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  const syncer::ModelTypeSet new_enabled_types =
-      Difference(enabled_types, enabled_types_);
-  enabled_types_ = enabled_types;
-  const P2PNotificationData notification_data(
-      unique_id_, NOTIFY_SELF, new_enabled_types);
-  SendNotificationData(notification_data);
-}
-
 void P2PNotifier::SendNotification(
     syncer::ModelTypeSet changed_types) {
   DCHECK(thread_checker_.CalledOnValidThread());
   const P2PNotificationData notification_data(
       unique_id_, send_notification_target_, changed_types);
   SendNotificationData(notification_data);
 }
 
 void P2PNotifier::OnNotificationsEnabled() {
   DCHECK(thread_checker_.CalledOnValidThread());
   bool just_turned_on = (notifications_enabled_ == false);
   notifications_enabled_ = true;
-  FOR_EACH_OBSERVER(
-      SyncNotifierObserver, observer_list_,
-      OnNotificationsEnabled());
+  helper_.OnNotificationsEnabled();
   if (just_turned_on) {
     const P2PNotificationData notification_data(
         unique_id_, NOTIFY_SELF, enabled_types_);
     SendNotificationData(notification_data);
   }
 }
 
 void P2PNotifier::OnNotificationsDisabled(
     notifier::NotificationsDisabledReason reason) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  FOR_EACH_OBSERVER(
-      SyncNotifierObserver, observer_list_,
-      OnNotificationsDisabled(FromNotifierReason(reason)));
+  helper_.OnNotificationsDisabled(FromNotifierReason(reason));
 }
 
 void P2PNotifier::OnIncomingNotification(
     const notifier::Notification& notification) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "Received notification " << notification.ToString();
   if (!logged_in_) {
     DVLOG(1) << "Not logged in yet -- not emitting notification";
     return;
   }
@@ skipping 14 matching lines @@
   }
   if (!notification_data.IsTargeted(unique_id_)) {
     DVLOG(1) << "Not a target of the notification -- "
              << "not emitting notification";
     return;
   }
   if (notification_data.GetChangedTypes().Empty()) {
     DVLOG(1) << "No changed types -- not emitting notification";
     return;
   }
-  const syncer::ModelTypePayloadMap& type_payloads =
-      syncer::ModelTypePayloadMapFromEnumSet(
-          notification_data.GetChangedTypes(), std::string());
-  FOR_EACH_OBSERVER(SyncNotifierObserver, observer_list_,
-                    OnIncomingNotification(type_payloads, REMOTE_NOTIFICATION));
+  const ModelTypePayloadMap& type_payloads = ModelTypePayloadMapFromEnumSet(
+      notification_data.GetChangedTypes(), std::string());
+  helper_.DispatchInvalidationsToHandlers(
+      ModelTypePayloadMapToObjectIdPayloadMap(type_payloads),
+      REMOTE_NOTIFICATION);
 }
 
 void P2PNotifier::SendNotificationDataForTest(
     const P2PNotificationData& notification_data) {
   DCHECK(thread_checker_.CalledOnValidThread());
   SendNotificationData(notification_data);
 }
 
 void P2PNotifier::SendNotificationData(
     const P2PNotificationData& notification_data) {
   DCHECK(thread_checker_.CalledOnValidThread());
   notifier::Notification notification;
   notification.channel = kSyncP2PNotificationChannel;
   notification.data = notification_data.ToString();
   DVLOG(1) << "Sending XMPP notification: " << notification.ToString();
   push_client_->SendNotification(notification);
 }
 
 }  // namespace syncer