[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"
 
@@ skipping 27 matching lines @@
 // 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 std::vector<std::string>& payloads) {
+  base::AutoLock lock(lock_);
+  if (vault_.syncer_ == NULL) {
+    return;
+  }
+
+  syncable::ModelTypeBitSet model_types;  // All false by default.
+  NudgeSyncImpl(milliseconds_from_now, source, model_types, 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);
+  std::vector<std::string> empty_payload;
+  NudgeSyncImpl(milliseconds_from_now, source, model_types, empty_payload);
 }
 
 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);
+  syncable::ModelTypeBitSet model_types;
+  model_types.set();  // The default nudge acts on all datatypes.
+  std::vector<std::string> empty_payload;  // No payloads.
+  NudgeSyncImpl(milliseconds_from_now, source, model_types, empty_payload);
 }
 
 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 202 matching lines @@
     }
 
     // Check if we should be paused or if a pause was requested.  Note
     // that we don't check initial_sync_for_thread here since we want
     // the pause to happen regardless if it is the initial sync or not.
     if (vault_.pause_requested_ || vault_.paused_) {
       PauseUntilResumedOrQuit();
       continue;
     }
 
     const TimeTicks next_poll = last_sync_time +

[akalin, 2011/01/12 09:55:19]

can't last_sync_time be null here to?  If this is a bug, please file a bug or
fix in another CL.

[Nicolas Zea, 2011/01/13 19:17:30]

Filed bug 69558 regarding last_sync_time and PostTimeToTypeHistogram. next_poll
was not affected, although Tim would better be able to say if perhaps we're
doing our first poll earlier than we should be (and if that matters)? I believe
that's a separate issue though.

         vault_.current_wait_interval_.poll_delta;
     bool throttled = vault_.current_wait_interval_.mode ==
         WaitInterval::THROTTLED;
     // If we are throttled, we must wait.  Otherwise, wait until either the next
     // nudge (if one exists) or the poll interval.
     TimeTicks end_wait = next_poll;
     if (!throttled && !vault_.pending_nudge_time_.is_null()) {
       end_wait = std::min(end_wait, vault_.pending_nudge_time_);
     }
     VLOG(1) << "end_wait is " << end_wait.ToInternalValue()
@@ skipping 23 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),
-                                          now - last_sync_time);
+    if (!last_sync_time.is_null()) {
+      for (size_t i = syncable::FIRST_REAL_MODEL_TYPE;
+           i < session->source().types().size();
+           ++i) {
+        if (session->source().types()[i]) {
+          syncable::PostTimeToTypeHistogram(syncable::ModelType(i),
+                                            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 @@
   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;
+  std::vector<std::string> 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_;
+      payloads = vault_.datatype_payloads_;
       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_.datatype_payloads_.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, payloads, initial_sync);
 }
 
 SyncSourceInfo SyncerThread::MakeSyncSourceInfo(bool nudged,
     NudgeSource nudge_source, const syncable::ModelTypeBitSet& nudge_types,
-    bool* initial_sync) {
+    const std::vector<std::string>& 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);
+
+  syncable::ModelTypeBitSet sync_source_types;
+  if (nudge_types.none()) {
+    // No datatypes requested. This must be a poll so set all enabled datatypes.
+    DCHECK(payloads.empty());  // There should be no payloads
+    ModelSafeRoutingInfo routes;
+    session_context_->registrar()->GetModelSafeRoutingInfo(&routes);
+    for (ModelSafeRoutingInfo::const_iterator i = routes.begin();
+         i != routes.end(); ++i) {
+      sync_source_types.set(i->first);
+    }
+
+  } else {
+    sync_source_types = nudge_types;
+  }
+
+  return SyncSourceInfo(updates_source, sync_source_types, payloads);
 }
 
 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 83 matching lines @@
     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) {
+                                 const syncable::ModelTypeBitSet& model_types,
+                                 const std::vector<std::string>& 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
   // 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;
 
+  // Any nudge results in the payloads vector at least having an empty string
+  // for each datatype. Any datatype that does actually have a payload signifies
+  // that we are requesting that datatype (and hence the corresponding
+  // |pending_nudge_types_| slot should be set).
+  vault_.datatype_payloads_.resize(syncable::MODEL_TYPE_COUNT);
+  for (size_t i = syncable::FIRST_REAL_MODEL_TYPE;
+       i < payloads.size();
+       ++i) {
+    if (!payloads[i].empty()) {
+      // This datatype has a payload we should hold on to.
+      vault_.pending_nudge_types_.set(i);
+      vault_.datatype_payloads_[i] = payloads[i];  // Overwrite old payloads.

[akalin, 2011/01/12 09:55:19]

why can we get away with overwriting?  Don't we need to merge (or is it already
merged)?

[Nicolas Zea, 2011/01/13 19:17:30]

We merge across datatypes, but if we receive a payload for datatype x at time 1,
then a different payload for datatype x at time 2, we're only concerned about
the most recent version of datatype x, which is based on the most recent
payload. Feel free to correct if my logic is wrong.

[akalin, 2011/01/13 19:47:41]

Okay, if that's the case, maybe expand the comment, like "// Overwrite old
payloads as we only need to send the most recent one."

[Nicolas Zea, 2011/01/18 06:07:23]

Done.

+    }
+  }
+
   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
           << " at " << nudge_time.ToInternalValue();
@@ skipping 76 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