[SYNC] Refactor SyncSourceInfo and add support in chrome invalidation client ...

chrome/browser/sync/engine/syncer_thread.cc

 // Copyright (c) 2010 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 "chrome/browser/sync/engine/syncer_thread.h"
 
 #include <algorithm>
-#include <map>
 #include <queue>
+#include <string>
+#include <vector>
 
 #include "base/rand_util.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "build/build_config.h"
 #include "chrome/browser/sync/engine/model_safe_worker.h"
 #include "chrome/browser/sync/engine/net/server_connection_manager.h"
 #include "chrome/browser/sync/engine/syncer.h"
 #include "chrome/browser/sync/sessions/sync_session.h"
 #include "jingle/notifier/listener/notification_constants.h"
 
 #if defined(OS_MACOSX)
 #include <CoreFoundation/CFNumber.h>
 #include <IOKit/IOTypes.h>
 #include <IOKit/IOKitLib.h>
 #endif
 
 using std::priority_queue;
 using std::min;
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace browser_sync {
 
 using sessions::SyncSession;
 using sessions::SyncSessionSnapshot;
 using sessions::SyncSourceInfo;
+using sessions::TypePayloadMap;
 
 // We use high values here to ensure that failure to receive poll updates from
 // the server doesn't result in rapid-fire polling from the client due to low
 // local limits.
 const int SyncerThread::kDefaultShortPollIntervalSeconds = 3600 * 8;
 const int SyncerThread::kDefaultLongPollIntervalSeconds = 3600 * 12;
 
 // TODO(tim): This is used to regulate the short poll (when notifications are
 // disabled) based on user idle time.  If it is set to a smaller value than
 // the short poll interval, it basically does nothing; for now, this is what
 // we want and allows stronger control over the poll rate from the server. We
 // should probably re-visit this code later and figure out if user idle time
 // is really something we want and make sure it works, if it is.
 const int SyncerThread::kDefaultMaxPollIntervalMs = 30 * 60 * 1000;
 
 // Backoff interval randomization factor.
 static const int kBackoffRandomizationFactor = 2;
 
 const int SyncerThread::kMaxBackoffSeconds = 60 * 60 * 4;  // 4 hours.
 
+void SyncerThread::NudgeSyncerWithPayloads(
+    int milliseconds_from_now,
+    NudgeSource source,
+    const TypePayloadMap& model_types_with_payloads) {
+  base::AutoLock lock(lock_);
+  if (vault_.syncer_ == NULL) {
+    return;
+  }
+
+  NudgeSyncImpl(milliseconds_from_now, source, model_types_with_payloads);
+}
+
 void SyncerThread::NudgeSyncerWithDataTypes(
     int milliseconds_from_now,
     NudgeSource source,
     const syncable::ModelTypeBitSet& model_types) {
   base::AutoLock lock(lock_);
   if (vault_.syncer_ == NULL) {
     return;
   }
 
-  NudgeSyncImpl(milliseconds_from_now, source, model_types);
+  TypePayloadMap model_types_with_payloads =
+      sessions::ModelTypeBitSetToTypePayloadMap(model_types, std::string());
+  NudgeSyncImpl(milliseconds_from_now, source, model_types_with_payloads);
 }
 
 void SyncerThread::NudgeSyncer(
     int milliseconds_from_now,
     NudgeSource source) {
   base::AutoLock lock(lock_);
   if (vault_.syncer_ == NULL) {
     return;
   }
 
-  syncable::ModelTypeBitSet model_types;  // All false by default.
-  NudgeSyncImpl(milliseconds_from_now, source, model_types);
+  // Set all enabled datatypes.
+  ModelSafeRoutingInfo routes;
+  session_context_->registrar()->GetModelSafeRoutingInfo(&routes);
+  TypePayloadMap model_types_with_payloads =
+      sessions::RoutingInfoToTypePayloadMap(routes, std::string());
+  NudgeSyncImpl(milliseconds_from_now, source, model_types_with_payloads);
 }
 
 SyncerThread::SyncerThread(sessions::SyncSessionContext* context)
     : thread_main_started_(false, false),
       thread_("SyncEngine_SyncerThread"),
       vault_field_changed_(&lock_),
       conn_mgr_hookup_(NULL),
       syncer_short_poll_interval_seconds_(kDefaultShortPollIntervalSeconds),
       syncer_long_poll_interval_seconds_(kDefaultLongPollIntervalSeconds),
       syncer_polling_interval_(kDefaultShortPollIntervalSeconds),
@@ skipping 246 matching lines @@
     // event.  This will also update the source of the following SyncMain call.
     VLOG(1) << "Calling Sync Main at time " << Time::Now().ToInternalValue();
     bool nudged = false;
     scoped_ptr<SyncSession> session;
     session.reset(SyncMain(vault_.syncer_,
         throttled, continue_sync_cycle, &initial_sync_for_thread, &nudged));
 
     // Update timing information for how often these datatypes are triggering
     // nudges.
     base::TimeTicks now = TimeTicks::Now();
-    for (size_t i = syncable::FIRST_REAL_MODEL_TYPE;
-         i < session->source().second.size();
-         ++i) {
-      if (session->source().second[i]) {
-        syncable::PostTimeToTypeHistogram(syncable::ModelType(i),
+    if (!last_sync_time.is_null()) {
+      TypePayloadMap::const_iterator iter;
+      for (iter = session->source().types.begin();
+           iter != session->source().types.end();
+           ++iter) {
+        syncable::PostTimeToTypeHistogram(iter->first,
                                           now - last_sync_time);
       }
     }
 
     last_sync_time = now;
 
     VLOG(1) << "Updating the next polling time after SyncMain";
     vault_.current_wait_interval_ = CalculatePollingWaitTime(
         static_cast<int>(vault_.current_wait_interval_.poll_delta.InSeconds()),
         &user_idle_milliseconds, &continue_sync_cycle, nudged);
@@ skipping 207 matching lines @@
   VLOG(1) << "Done calling SyncShare.";
   return session.release();
 }
 
 SyncSourceInfo SyncerThread::GetAndResetNudgeSource(bool was_throttled,
                                                     bool continue_sync_cycle,
                                                     bool* initial_sync,
                                                     bool* was_nudged) {
   bool nudged = false;
   NudgeSource nudge_source = kUnknown;
-  syncable::ModelTypeBitSet model_types;
+  TypePayloadMap model_types_with_payloads;
   // Has the previous sync cycle completed?
   if (continue_sync_cycle)
     nudge_source = kContinuation;
   // Update the nudge source if a new nudge has come through during the
   // previous sync cycle.
   if (!vault_.pending_nudge_time_.is_null()) {
     if (!was_throttled) {
       nudge_source = vault_.pending_nudge_source_;
-      model_types = vault_.pending_nudge_types_;
+      model_types_with_payloads = vault_.pending_nudge_types_;
       nudged = true;
     }
     VLOG(1) << "Clearing pending nudge from " << vault_.pending_nudge_source_
             << " at tick " << vault_.pending_nudge_time_.ToInternalValue();
     vault_.pending_nudge_source_ = kUnknown;
-    vault_.pending_nudge_types_.reset();
+    vault_.pending_nudge_types_.clear();
     vault_.pending_nudge_time_ = base::TimeTicks();
   }
 
   *was_nudged = nudged;
 
   // TODO(tim): Hack for bug 64136 to correctly tag continuations that result
   // from syncer having more work to do.  This will be handled properly with
   // the message loop based syncer thread, bug 26339.
   return MakeSyncSourceInfo(nudged || nudge_source == kContinuation,
-      nudge_source, model_types, initial_sync);
+      nudge_source, model_types_with_payloads, initial_sync);
 }
 
 SyncSourceInfo SyncerThread::MakeSyncSourceInfo(bool nudged,
-    NudgeSource nudge_source, const syncable::ModelTypeBitSet& nudge_types,
+    NudgeSource nudge_source,
+    const TypePayloadMap& model_types_with_payloads,
     bool* initial_sync) {
   sync_pb::GetUpdatesCallerInfo::GetUpdatesSource updates_source =
       sync_pb::GetUpdatesCallerInfo::UNKNOWN;
   if (*initial_sync) {
     updates_source = sync_pb::GetUpdatesCallerInfo::FIRST_UPDATE;
     *initial_sync = false;
   } else if (!nudged) {
     updates_source = sync_pb::GetUpdatesCallerInfo::PERIODIC;
   } else {
     switch (nudge_source) {
       case kNotification:
         updates_source = sync_pb::GetUpdatesCallerInfo::NOTIFICATION;
         break;
       case kLocal:
         updates_source = sync_pb::GetUpdatesCallerInfo::LOCAL;
         break;
       case kContinuation:
         updates_source = sync_pb::GetUpdatesCallerInfo::SYNC_CYCLE_CONTINUATION;
         break;
       case kClearPrivateData:
         updates_source = sync_pb::GetUpdatesCallerInfo::CLEAR_PRIVATE_DATA;
         break;
       case kUnknown:
       default:
         updates_source = sync_pb::GetUpdatesCallerInfo::UNKNOWN;
         break;
     }
   }
-  return SyncSourceInfo(updates_source, nudge_types);
+
+  TypePayloadMap sync_source_types;
+  if (model_types_with_payloads.empty()) {
+    // No datatypes requested. This must be a poll so set all enabled datatypes.
+    ModelSafeRoutingInfo routes;
+    session_context_->registrar()->GetModelSafeRoutingInfo(&routes);
+    sync_source_types = sessions::RoutingInfoToTypePayloadMap(routes,
+                                                              std::string());
+  } else {
+    sync_source_types = model_types_with_payloads;
+  }
+
+  return SyncSourceInfo(updates_source, sync_source_types);
 }
 
 void SyncerThread::CreateSyncer(const std::string& dirname) {
   base::AutoLock lock(lock_);
   VLOG(1) << "Creating syncer up for: " << dirname;
   // The underlying database structure is ready, and we should create
   // the syncer.
   CHECK(vault_.syncer_ == NULL);
   session_context_->set_account_name(dirname);
   vault_.syncer_ = new Syncer();
@@ skipping 81 matching lines @@
   // rate.
   if (idle >= kPollBackoffThresholdMultiplier * syncer_polling_interval_ms) {
     next_wait = std::min(GetRecommendedDelaySeconds(
         last_interval / 1000), syncer_max_interval_ / 1000) * 1000;
   }
 
   return next_wait;
 }
 
 // Called with mutex_ already locked.
-void SyncerThread::NudgeSyncImpl(int milliseconds_from_now,
-                                 NudgeSource source,
-                                 const syncable::ModelTypeBitSet& model_types) {
+void SyncerThread::NudgeSyncImpl(
+    int milliseconds_from_now,
+    NudgeSource source,
+    const TypePayloadMap& model_types_with_payloads) {
   // TODO(sync): Add the option to reset the backoff state machine.
   // This is needed so nudges that are a result of the user's desire
   // to download updates for a new data type can be satisfied quickly.
   if (vault_.current_wait_interval_.mode == WaitInterval::THROTTLED ||
       vault_.current_wait_interval_.had_nudge_during_backoff) {
     // Drop nudges on the floor if we've already had one since starting this
     // stage of exponential backoff or we are throttled.
     return;
   }
 
-  // Union the current bitset with any from nudges that may have already
+  // Union the current TypePayloadMap with any from nudges that may have already
   // posted (coalesce the nudge datatype information).
   // TODO(tim): It seems weird to do this if the sources don't match up (e.g.
   // if pending_source is kLocal and |source| is kClearPrivateData).
-  vault_.pending_nudge_types_ |= model_types;
+  sessions::CoalescePayloads(&vault_.pending_nudge_types_,
+                             model_types_with_payloads);
 
   const TimeTicks nudge_time = TimeTicks::Now() +
       TimeDelta::FromMilliseconds(milliseconds_from_now);
   if (nudge_time <= vault_.pending_nudge_time_) {
     VLOG(1) << "Nudge for source " << source
             << " dropped due to existing later pending nudge";
     return;
   }
 
   VLOG(1) << "Replacing pending nudge for source " << source
@@ skipping 77 matching lines @@
     was_logged = true;
     VLOG(1) << "UserIdleTime unimplemented on this platform, synchronization "
                "will not throttle when user idle";
   }
 #endif
 
   return 0;
 }
 
 }  // namespace browser_sync