Refactor ModelTypePayloadMap and ObjectIdPayloadMap to StateMaps.

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"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/json/json_writer.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
 #include "base/observer_list.h"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
 #include "sync/engine/sync_scheduler.h"
 #include "sync/engine/syncer_types.h"
 #include "sync/internal_api/change_reorder_buffer.h"
 #include "sync/internal_api/public/base/model_type.h"
-#include "sync/internal_api/public/base/model_type_payload_map.h"
+#include "sync/internal_api/public/base/model_type_state_map.h"
 #include "sync/internal_api/public/base_node.h"
 #include "sync/internal_api/public/configure_reason.h"
 #include "sync/internal_api/public/engine/polling_constants.h"
 #include "sync/internal_api/public/http_post_provider_factory.h"
 #include "sync/internal_api/public/internal_components_factory.h"
 #include "sync/internal_api/public/read_node.h"
 #include "sync/internal_api/public/read_transaction.h"
 #include "sync/internal_api/public/user_share.h"
 #include "sync/internal_api/public/util/experiments.h"
 #include "sync/internal_api/public/write_node.h"
@@ skipping 1524 matching lines @@
 
     // This is here for tests, which are still using p2p notifications.
     //
     // TODO(chron): Consider changing this back to track has_more_to_sync
     // only notify peers if a successful commit has occurred.
     bool is_notifiable_commit =
         (event.snapshot.model_neutral_state().num_successful_commits > 0);
     if (is_notifiable_commit) {
       if (sync_notifier_.get()) {
         const ModelTypeSet changed_types =
-            ModelTypePayloadMapToEnumSet(event.snapshot.source().types);
+            ModelTypeStateMapToEnumSet(event.snapshot.source().types);
         sync_notifier_->SendNotification(changed_types);
       } else {
         DVLOG(1) << "Not sending notification: sync_notifier_ is NULL";
       }
     }
   }
 
   if (event.what_happened == SyncEngineEvent::STOP_SYNCING_PERMANENTLY) {
     FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                       OnStopSyncingPermanently());
@@ skipping 229 matching lines @@
 void SyncManagerImpl::OnEncryptedTypesChanged(
     ModelTypeSet encrypted_types,
     bool encrypt_everything) {
   // NOTE: We're in a transaction.
   FOR_EACH_OBSERVER(
       SyncManager::Observer, observers_,
       OnEncryptedTypesChanged(encrypted_types, encrypt_everything));
 }
 
 void SyncManagerImpl::UpdateNotificationInfo(
-    const ModelTypePayloadMap& type_payloads) {
-  for (ModelTypePayloadMap::const_iterator it = type_payloads.begin();
-       it != type_payloads.end(); ++it) {
+    const ModelTypeStateMap& type_state_map) {
+  for (ModelTypeStateMap::const_iterator it = type_state_map.begin();
+       it != type_state_map.end(); ++it) {
     NotificationInfo* info = &notification_info_map_[it->first];
     info->total_count++;
-    info->payload = it->second;
+    info->payload = it->second.payload;
   }
 }
 
 void SyncManagerImpl::OnNotificationsEnabled() {
   OnNotificationStateChange(NO_NOTIFICATION_ERROR);
 }
 
 void SyncManagerImpl::OnNotificationsDisabled(
     NotificationsDisabledReason reason) {
   OnNotificationStateChange(reason);
 }
 
 void SyncManagerImpl::OnIncomingNotification(
-    const ObjectIdPayloadMap& id_payloads,
+    const ObjectIdStateMap& id_state_map,
     IncomingNotificationSource source) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  const ModelTypePayloadMap& type_payloads =
-      ObjectIdPayloadMapToModelTypePayloadMap(id_payloads);
+  const ModelTypeStateMap& type_state_map =
+      ObjectIdStateMapToModelTypeStateMap(id_state_map);
   if (source == LOCAL_NOTIFICATION) {
-    scheduler_->ScheduleNudgeWithPayloadsAsync(
+    scheduler_->ScheduleNudgeWithStatesAsync(
         TimeDelta::FromMilliseconds(kSyncRefreshDelayMsec),
         NUDGE_SOURCE_LOCAL_REFRESH,
-        type_payloads, FROM_HERE);
-  } else if (!type_payloads.empty()) {
-    scheduler_->ScheduleNudgeWithPayloadsAsync(
+        type_state_map, FROM_HERE);
+  } else if (!type_state_map.empty()) {
+    scheduler_->ScheduleNudgeWithStatesAsync(
         TimeDelta::FromMilliseconds(kSyncSchedulerDelayMsec),
         NUDGE_SOURCE_NOTIFICATION,
-        type_payloads, FROM_HERE);
+        type_state_map, FROM_HERE);
     allstatus_.IncrementNotificationsReceived();
-    UpdateNotificationInfo(type_payloads);
-    debug_info_event_listener_.OnIncomingNotification(type_payloads);
+    UpdateNotificationInfo(type_state_map);
+    debug_info_event_listener_.OnIncomingNotification(type_state_map);
   } else {
     LOG(WARNING) << "Sync received notification without any type information.";
   }
 
   if (js_event_handler_.IsInitialized()) {
     DictionaryValue details;
     ListValue* changed_types = new ListValue();
     details.Set("changedTypes", changed_types);
-    for (ModelTypePayloadMap::const_iterator it = type_payloads.begin();
-         it != type_payloads.end(); ++it) {
+    for (ModelTypeStateMap::const_iterator it = type_state_map.begin();
+         it != type_state_map.end(); ++it) {
       const std::string& model_type_str =
           ModelTypeToString(it->first);
       changed_types->Append(Value::CreateStringValue(model_type_str));
     }
     details.SetString("source", (source == LOCAL_NOTIFICATION) ?
         "LOCAL_NOTIFICATION" : "REMOTE_NOTIFICATION");
     js_event_handler_.Call(FROM_HERE,
                            &JsEventHandler::HandleJsEvent,
                            "onIncomingNotification",
                            JsEventDetails(&details));
@@ skipping 41 matching lines @@
 int SyncManagerImpl::GetDefaultNudgeDelay() {
   return kDefaultNudgeDelayMilliseconds;
 }
 
 // static.
 int SyncManagerImpl::GetPreferencesNudgeDelay() {
   return kPreferencesNudgeDelayMilliseconds;
 }
 
 }  // namespace syncer