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

chrome/browser/sync/engine/syncer_thread.h

 // 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.
 //
 // A class to run the syncer on a thread.
 // This is the default implementation of SyncerThread whose Stop implementation
 // does not support a timeout, but is greatly simplified.
 #ifndef CHROME_BROWSER_SYNC_ENGINE_SYNCER_THREAD_H_
 #define CHROME_BROWSER_SYNC_ENGINE_SYNCER_THREAD_H_
 #pragma once
@@ skipping 31 matching lines @@
 
 class SyncerThread : public base::RefCountedThreadSafe<SyncerThread>,
                      public sessions::SyncSession::Delegate {
   FRIEND_TEST_ALL_PREFIXES(SyncerThreadTest, CalculateSyncWaitTime);
   FRIEND_TEST_ALL_PREFIXES(SyncerThreadTest, CalculatePollingWaitTime);
   FRIEND_TEST_ALL_PREFIXES(SyncerThreadWithSyncerTest, Polling);
   FRIEND_TEST_ALL_PREFIXES(SyncerThreadWithSyncerTest, Nudge);
   FRIEND_TEST_ALL_PREFIXES(SyncerThreadWithSyncerTest, NudgeWithDataTypes);
   FRIEND_TEST_ALL_PREFIXES(SyncerThreadWithSyncerTest,
                            NudgeWithDataTypesCoalesced);
+  FRIEND_TEST_ALL_PREFIXES(SyncerThreadWithSyncerTest, NudgeWithPayloads);
+  FRIEND_TEST_ALL_PREFIXES(SyncerThreadWithSyncerTest,
+                           NudgeWithPayloadsCoalesced);
   FRIEND_TEST_ALL_PREFIXES(SyncerThreadWithSyncerTest, Throttling);
   FRIEND_TEST_ALL_PREFIXES(SyncerThreadWithSyncerTest, AuthInvalid);
   FRIEND_TEST_ALL_PREFIXES(SyncerThreadWithSyncerTest, Pause);
   FRIEND_TEST_ALL_PREFIXES(SyncerThreadWithSyncerTest, StartWhenNotConnected);
   FRIEND_TEST_ALL_PREFIXES(SyncerThreadWithSyncerTest, PauseWhenNotConnected);
   FRIEND_TEST_ALL_PREFIXES(SyncerThreadWithSyncerTest, StopSyncPermanently);
   friend class SyncerThreadWithSyncerTest;
   friend class SyncerThreadFactory;
  public:
   // Encapsulates the parameters that make up an interval on which the
@@ skipping 64 matching lines @@
   // request can not be completed (e.g. the thread is not running or
   // is not currently paused).  When the thread actually resumes, a
   // SyncEngineEvent::RESUMED event notification will be sent to the relay
   // channel.
   virtual bool RequestResume();
 
   // Nudges the syncer to sync with a delay specified. This API is for access
   // from the SyncerThread's controller and will cause a mutex lock.
   virtual void NudgeSyncer(int milliseconds_from_now, NudgeSource source);
 
   // Same as |NudgeSyncer|, but supports tracking the datatypes that caused

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

I think we can combine these two Nudge functions into one and simplify the API a
bit by using a std::map<syncable::model_type, std::string>.  The keys of the map
would be the data types, and the non-zero values would be any payloads to send.

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

My only hesitancy with this is that it then fully couples the notion of payloads
with a nudge. At the moment, nudges originating from internal causes (local
changes, etc.) don't need payloads and so use a method that doesn't involve
payloads.

On the other hand, nudges with external origin, which is where payloads come
into play, have their own nudge method.

So in my mind it makes sense to have two separate methods, due to their
different origins. Perhaps I should add some comments to that effect though.

On 2011/01/12 09:55:19, akalin wrote:

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

Fair point.  I'm fine with two different methods.  I'd like the
nudge-with-payloads method to use a map<> though, as it makes the code more
understandable.

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

Done.

   // the nudge to occur.
   virtual void NudgeSyncerWithDataTypes(
       int milliseconds_from_now,
       NudgeSource source,
       const syncable::ModelTypeBitSet& model_type);
 
+  virtual void NudgeSyncerWithPayloads(
+      int milliseconds_from_now,
+      NudgeSource source,
+      const std::vector<std::string>& payloads);
+
+
   void SetNotificationsEnabled(bool notifications_enabled);
 
   // Call this when a directory is opened
   void CreateSyncer(const std::string& dirname);
 
   // DDOS avoidance function.  The argument and return value is in seconds
   static int GetRecommendedDelaySeconds(int base_delay_seconds);
 
  protected:
   virtual void ThreadMain();
@@ skipping 33 matching lines @@
 
     // kUnknown if there is no pending nudge.  (Theoretically, there
     // could be a pending nudge of type kUnknown, so it's better to
     // check pending_nudge_time_.)
     NudgeSource pending_nudge_source_;
 
     // BitSet of the datatypes that have triggered the current nudge
     // (can be union of various bitsets when multiple nudges are coalesced)
     syncable::ModelTypeBitSet pending_nudge_types_;
 
+    // Payloads associated with each of the datatypes we're polling on.
+    // These payloads are used by the download updates command and can contain
+    // datatype specific information the server might use.
+    std::vector<std::string> datatype_payloads_;
+
     // null iff there is no pending nudge.
     base::TimeTicks pending_nudge_time_;
 
     // The wait interval for to the current iteration of our main loop.  This is
     // only written to by the syncer thread, and since the only reader from a
     // different thread (NudgeSync) is called at totally random times, we don't
     // really need to access mutually exclusively as the data races that exist
     // are intrinsic, but do so anyway and avoid using 'volatile'.
     WaitInterval current_wait_interval_;
 
@@ skipping 68 matching lines @@
   // |was_nudged| parameter.
   sessions::SyncSourceInfo GetAndResetNudgeSource(bool was_throttled,
                                                   bool continue_sync_cycle,
                                                   bool* initial_sync,
                                                   bool* was_nudged);
 
   sessions::SyncSourceInfo MakeSyncSourceInfo(
       bool nudged,
       NudgeSource nudge_source,
       const syncable::ModelTypeBitSet& nudge_types,
+      const std::vector<std::string>& payloads,
       bool* initial_sync);
 
   int UserIdleTime();
 
   void WaitUntilConnectedOrQuit();
 
   // The thread will remain in this method until a resume is requested
   // or shutdown is started.
   void PauseUntilResumedOrQuit();
 
@@ skipping 26 matching lines @@
   // this bounds the "nominal" poll interval, while the the actual interval
   // also takes previous failures into account.
   int syncer_max_interval_;
 
   // This causes syncer to start syncing ASAP. If the rate of requests is too
   // high the request will be silently dropped.  mutex_ should be held when
   // this is called.
   void NudgeSyncImpl(
       int milliseconds_from_now,
       NudgeSource source,
-      const syncable::ModelTypeBitSet& model_types);
+      const syncable::ModelTypeBitSet& model_types,
+      const std::vector<std::string>& payloads);
 
 #if defined(OS_LINUX)
   // On Linux, we need this information in order to query idle time.
   scoped_ptr<IdleQueryLinux> idle_query_;
 #endif
 
   scoped_ptr<sessions::SyncSessionContext> session_context_;
 
   // Set whenever the server instructs us to stop sending it requests until
   // a specified time, and reset for each call to SyncShare. (Note that the
   // WaitInterval::THROTTLED contract is such that we don't call SyncShare at
   // all until the "silenced until" embargo expires.)
   base::TimeTicks silenced_until_;
 
   // Useful for unit tests
   bool disable_idle_detection_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncerThread);
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_ENGINE_SYNCER_THREAD_H_