Refactor common invalidation framework types

sync/internal_api/sync_manager_impl.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/internal_api/sync_manager_impl.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 987 matching lines @@
   js_message_handlers_[name] =
       base::Bind(unbound_message_handler, base::Unretained(this));
 }
 
 base::DictionaryValue* SyncManagerImpl::NotificationInfoToValue(
     const NotificationInfoMap& notification_info) {
   base::DictionaryValue* value = new base::DictionaryValue();
 
   for (NotificationInfoMap::const_iterator it = notification_info.begin();
       it != notification_info.end(); ++it) {
-    const std::string& model_type_str = ModelTypeToString(it->first);
+    const std::string model_type_str = ModelTypeToString(it->first);
     value->Set(model_type_str, it->second.ToValue());
   }
 
   return value;
 }
 
 std::string SyncManagerImpl::NotificationInfoToString(
     const NotificationInfoMap& notification_info) {
   scoped_ptr<base::DictionaryValue> value(
       NotificationInfoToValue(notification_info));
@@ skipping 122 matching lines @@
     for (syncable::Directory::Metahandles::const_iterator it =
              child_handles.begin(); it != child_handles.end(); ++it) {
       child_ids->Append(new base::StringValue(base::Int64ToString(*it)));
     }
   }
   return JsArgList(&return_args);
 }
 
 void SyncManagerImpl::UpdateNotificationInfo(
     const ObjectIdInvalidationMap& invalidation_map) {
-  for (ObjectIdInvalidationMap::const_iterator it = invalidation_map.begin();
-       it != invalidation_map.end(); ++it) {
+  ObjectIdSet ids = invalidation_map.GetObjectIds();
+  for (ObjectIdSet::const_iterator it = ids.begin(); it != ids.end(); ++it) {
     ModelType type = UNSPECIFIED;
-    if (ObjectIdToRealModelType(it->first, &type)) {
+    if (!ObjectIdToRealModelType(*it, &type)) {
+      continue;
+    }
+    const SingleObjectInvalidationSet& type_invalidations =
+        invalidation_map.ForObject(*it);
+    for (SingleObjectInvalidationSet::const_iterator inv_it =
+         type_invalidations.begin(); inv_it != type_invalidations.end();
+         ++inv_it) {
       NotificationInfo* info = &notification_info_map_[type];
       info->total_count++;
-      info->payload = it->second.payload;
+      std::string payload =
+          inv_it->is_unknown_version() ? "UNKNOWN" : inv_it->payload();
+      info->payload = payload;
     }
   }
 }
 
 void SyncManagerImpl::OnInvalidatorStateChange(InvalidatorState state) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   const std::string& state_str = InvalidatorStateToString(state);
   invalidator_state_ = state;
   DVLOG(1) << "Invalidator state changed to: " << state_str;
@@ skipping 10 matching lines @@
                            "onNotificationStateChange",
                            JsEventDetails(&details));
   }
 }
 
 void SyncManagerImpl::OnIncomingInvalidation(
     const ObjectIdInvalidationMap& invalidation_map) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // We should never receive IDs from non-sync objects.
-  ObjectIdSet ids = ObjectIdInvalidationMapToSet(invalidation_map);
+  ObjectIdSet ids = invalidation_map.GetObjectIds();
   for (ObjectIdSet::const_iterator it = ids.begin(); it != ids.end(); ++it) {
     ModelType type;
     if (!ObjectIdToRealModelType(*it, &type)) {
       DLOG(WARNING) << "Notification has invalid id: " << ObjectIdToString(*it);
     }
   }
 
-  if (invalidation_map.empty()) {
+  if (invalidation_map.Empty()) {
     LOG(WARNING) << "Sync received invalidation without any type information.";
   } else {
     allstatus_.IncrementNudgeCounter(NUDGE_SOURCE_NOTIFICATION);
     scheduler_->ScheduleInvalidationNudge(
         TimeDelta::FromMilliseconds(kSyncSchedulerDelayMsec),
         invalidation_map, FROM_HERE);
     allstatus_.IncrementNotificationsReceived();
     UpdateNotificationInfo(invalidation_map);
     debug_info_event_listener_.OnIncomingNotification(invalidation_map);
   }
 
   if (js_event_handler_.IsInitialized()) {
     base::DictionaryValue details;
     base::ListValue* changed_types = new base::ListValue();
     details.Set("changedTypes", changed_types);
-    ObjectIdSet id_set = ObjectIdInvalidationMapToSet(invalidation_map);
+
+    ObjectIdSet id_set = invalidation_map.GetObjectIds();
     ModelTypeSet nudged_types = ObjectIdSetToModelTypeSet(id_set);
     DCHECK(!nudged_types.Empty());
     for (ModelTypeSet::Iterator it = nudged_types.First();
          it.Good(); it.Inc()) {
       const std::string model_type_str = ModelTypeToString(it.Get());
       changed_types->Append(new base::StringValue(model_type_str));
     }
     details.SetString("source", "REMOTE_INVALIDATION");
     js_event_handler_.Call(FROM_HERE,
                            &JsEventHandler::HandleJsEvent,
@@ skipping 104 matching lines @@
 int SyncManagerImpl::GetDefaultNudgeDelay() {
   return kDefaultNudgeDelayMilliseconds;
 }
 
 // static.
 int SyncManagerImpl::GetPreferencesNudgeDelay() {
   return kPreferencesNudgeDelayMilliseconds;
 }
 
 }  // namespace syncer