Relieve SyncerSession,SyncCycleState, SyncProcessState, SyncerSession, Syncer...

chrome/browser/sync/engine/syncer_thread.h

 // Copyright (c) 2009 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_
 
 #include <list>
 #include <map>
 #include <queue>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/condition_variable.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/thread.h"
 #include "base/time.h"
 #include "base/waitable_event.h"
 #include "chrome/browser/sync/engine/all_status.h"
-#include "chrome/browser/sync/engine/client_command_channel.h"
+#include "chrome/browser/sync/sessions/sync_session.h"
 #include "chrome/browser/sync/util/event_sys-inl.h"
 #include "testing/gtest/include/gtest/gtest_prod.h"  // For FRIEND_TEST
 
 class EventListenerHookup;
 
 namespace syncable {
 class DirectoryManager;
 struct DirectoryManagerEvent;
 }
 
 namespace browser_sync {
 
 class ModelSafeWorker;
 class ServerConnectionManager;
 class Syncer;
 class TalkMediator;
 class URLFactory;
 struct ServerConnectionEvent;
 struct SyncerEvent;
 struct SyncerShutdownEvent;
 struct TalkMediatorEvent;
 
-class SyncerThreadFactory {
- public:
-  // Creates a SyncerThread based on the default (or user-overridden)
-  // implementation.  The thread does not start running until you call Start(),
-  // which will cause it to check-and-wait for certain conditions to be met
-  // (such as valid connection with Server established, syncable::Directory has
-  // been opened) before performing an intial sync with a server.  It uses
-  // |connection_manager| to detect valid connections, and |mgr| to detect the
-  // opening of a Directory, which will cause it to create a Syncer object for
-  // said Directory, and assign |model_safe_worker| to it.  |connection_manager|
-  // and |mgr| should outlive the SyncerThread.  You must stop the thread by
-  // calling Stop before destroying the object.  Stopping will first tear down
-  // the Syncer object, allowing it to finish work in progress, before joining
-  // the Stop-calling thread with the internal thread.
-  static SyncerThread* Create(ClientCommandChannel* command_channel,
-      syncable::DirectoryManager* mgr,
-      ServerConnectionManager* connection_manager, AllStatus* all_status,
-      ModelSafeWorker* model_safe_worker);
- private:
-  DISALLOW_IMPLICIT_CONSTRUCTORS(SyncerThreadFactory);
-};
-
-class SyncerThread : public base::RefCountedThreadSafe<SyncerThread> {
+class SyncerThread : public base::RefCountedThreadSafe<SyncerThread>,
+                     public sessions::SyncSession::Delegate {
   FRIEND_TEST(SyncerThreadTest, CalculateSyncWaitTime);
   FRIEND_TEST(SyncerThreadTest, CalculatePollingWaitTime);
   FRIEND_TEST(SyncerThreadWithSyncerTest, Polling);
   FRIEND_TEST(SyncerThreadWithSyncerTest, Nudge);
   FRIEND_TEST(SyncerThreadWithSyncerTest, Throttling);
   friend class SyncerThreadWithSyncerTest;
   friend class SyncerThreadFactory;
  public:
   // Encapsulates the parameters that make up an interval on which the
   // syncer thread is sleeping.
@@ skipping 30 matching lines @@
   };
   // Server can overwrite these values via client commands.
   // Standard short poll. This is used when XMPP is off.
   static const int kDefaultShortPollIntervalSeconds;
   // Long poll is used when XMPP is on.
   static const int kDefaultLongPollIntervalSeconds;
   // 30 minutes by default. If exponential backoff kicks in, this is the
   // longest possible poll interval.
   static const int kDefaultMaxPollIntervalMs;
 
+  SyncerThread(sessions::SyncSessionContext* context, AllStatus* all_status);
   virtual ~SyncerThread();
 
   virtual void WatchConnectionManager(ServerConnectionManager* conn_mgr);
 
   // Starts a syncer thread.
   // Returns true if it creates a thread or if there's currently a thread
   // running and false otherwise.
   virtual bool Start();
 
   // Stop processing. |max_wait| doesn't do anything in this version.
   virtual bool Stop(int max_wait);
 
   // 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);
 
   // Registers this thread to watch talk mediator events.
   virtual void WatchTalkMediator(TalkMediator* talk_mediator);
 
-  virtual void WatchClientCommands(ClientCommandChannel* channel);
-
-  virtual SyncerEventChannel* channel();
+  virtual SyncerEventChannel* relay_channel();
 
  protected:
-  SyncerThread();  // Necessary for temporary pthreads-based PIMPL impl.
-  SyncerThread(ClientCommandChannel* command_channel,
-      syncable::DirectoryManager* mgr,
-      ServerConnectionManager* connection_manager, AllStatus* all_status,
-      ModelSafeWorker* model_safe_worker);
   virtual void ThreadMain();
   void ThreadMainLoop();
 
   virtual void SetConnected(bool connected) {
     DCHECK(!thread_.IsRunning());
     vault_.connected_ = connected;
   }
 
   virtual void SetSyncerPollingInterval(base::TimeDelta interval) {
     // TODO(timsteele): Use TimeDelta internally.
@@ skipping 61 matching lines @@
 
  private:
   // Threshold multipler for how long before user should be considered idle.
   static const int kPollBackoffThresholdMultiplier = 10;
 
   friend void* RunSyncerThread(void* syncer_thread);
   void* Run();
   void HandleDirectoryManagerEvent(
       const syncable::DirectoryManagerEvent& event);
   void HandleSyncerEvent(const SyncerEvent& event);
-  void HandleClientCommand(ClientCommandChannel::EventType event);
+
+  // SyncSession::Delegate implementation.
+  virtual void OnSilencedUntil(const base::TimeTicks& silenced_until);
+  virtual bool IsSyncingCurrentlySilenced();
+  virtual void OnReceivedShortPollIntervalUpdate(
+      const base::TimeDelta& new_interval);
+  virtual void OnReceivedLongPollIntervalUpdate(
+      const base::TimeDelta& new_interval);
 
   void HandleServerConnectionEvent(const ServerConnectionEvent& event);
 
   void HandleTalkMediatorEvent(const TalkMediatorEvent& event);
 
   void SyncMain(Syncer* syncer);
 
   // Calculates the next sync wait time and exponential backoff state.
   // last_poll_wait is the time duration of the previous polling timeout which
   // was used. user_idle_milliseconds is updated by this method, and is a report
@@ skipping 26 matching lines @@
   void SetUpdatesSource(bool nudged, NudgeSource nudge_source,
                         bool* initial_sync);
 
   // For unit tests only.
   virtual void DisableIdleDetection() { disable_idle_detection_ = true; }
 
   // State of the notification framework is tracked by these values.
   bool p2p_authenticated_;
   bool p2p_subscribed_;
 
-  scoped_ptr<EventListenerHookup> client_command_hookup_;
   scoped_ptr<EventListenerHookup> conn_mgr_hookup_;
   const AllStatus* allstatus_;
 
-  syncable::DirectoryManager* dirman_;
-  ServerConnectionManager* scm_;
-
   // Modifiable versions of kDefaultLongPollIntervalSeconds which can be
   // updated by the server.
   int syncer_short_poll_interval_seconds_;
   int syncer_long_poll_interval_seconds_;
 
   // The time we wait between polls in seconds. This is used as lower bound on
   // our wait time. Updated once per loop from the command line flag.
   int syncer_polling_interval_;
 
   // The upper bound on the nominal wait between polls in seconds. Note that
   // this bounds the "nominal" poll interval, while the the actual interval
   // also takes previous failures into account.
   int syncer_max_interval_;
 
-  scoped_ptr<SyncerEventChannel> syncer_event_channel_;
-
   // 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);
 
   scoped_ptr<EventListenerHookup> talk_mediator_hookup_;
-  ClientCommandChannel* const command_channel_;
   scoped_ptr<EventListenerHookup> directory_manager_hookup_;
   scoped_ptr<EventListenerHookup> syncer_events_;
 
-  // Handles any tasks that will result in model changes (modifications of
-  // syncable::Entries). Pass this to the syncer created and managed by |this|.
-  // Only non-null in syncapi case.
-  scoped_ptr<ModelSafeWorker> model_safe_worker_;
+  scoped_ptr<sessions::SyncSessionContext> session_context_;
+
+  // Events from the Syncer's syncer_event_channel are first processed by the
+  // SyncerThread and then get relayed onto this channel for consumers.
+  // TODO(timsteele): Wow did this confused me. I had removed the channel from
+  // here thinking there was only one, and then realized this relay was
+  // happening. Is this strict event handling order needed?!
+  scoped_ptr<SyncerEventChannel> syncer_event_relay_channel_;
+
+  // 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_