sync: hook up ServerConnectionManager <> SyncerThread2 and tie up more loose ends

chrome/browser/sync/engine/syncer_thread2.h

 // Copyright (c) 2011 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.
 #ifndef CHROME_BROWSER_SYNC_ENGINE_SYNCER_THREAD2_H_
 #define CHROME_BROWSER_SYNC_ENGINE_SYNCER_THREAD2_H_
 #pragma once
 
+#include "base/callback.h"
 #include "base/linked_ptr.h"
 #include "base/observer_list.h"
 #include "base/scoped_ptr.h"
 #include "base/task.h"
 #include "base/threading/thread.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "chrome/browser/sync/engine/nudge_source.h"
 #include "chrome/browser/sync/engine/polling_constants.h"
 #include "chrome/browser/sync/engine/syncer.h"
 #include "chrome/browser/sync/syncable/model_type_payload_map.h"
+#include "chrome/browser/sync/engine/net/server_connection_manager.h"
 #include "chrome/browser/sync/sessions/sync_session.h"
 #include "chrome/browser/sync/sessions/sync_session_context.h"
 
 namespace browser_sync {
 
 struct ServerConnectionEvent;
 
 namespace s3 {
 
-class SyncerThread : public sessions::SyncSession::Delegate {
+class SyncerThread : public sessions::SyncSession::Delegate,
+                     public ServerConnectionEventListener {
  public:
   enum Mode {
     // In this mode, the thread only performs configuration tasks.  This is
     // designed to make the case where we want to download updates for a
     // specific type only, and not continue syncing until we are moved into
     // normal mode.
     CONFIGURATION_MODE,
     // Resumes polling and allows nudges, drops configuration tasks.  Runs
     // through entire sync cycle.
     NORMAL_MODE,
   };
 
   // Takes ownership of both |context| and |syncer|.
   SyncerThread(sessions::SyncSessionContext* context, Syncer* syncer);
   virtual ~SyncerThread();
 
+  typedef Callback0::Type ModeChangeCallback;
+
   // Change the mode of operation.
   // We don't use a lock when changing modes, so we won't cause currently
   // scheduled jobs to adhere to the new mode.  We could protect it, but it
   // doesn't buy very much as a) a session could already be in progress and it
   // will continue no matter what, b) the scheduled sessions already contain
   // all their required state and won't be affected by potential change at
   // higher levels (i.e. the registrar), and c) we service tasks FIFO, so once
   // the mode changes all future jobs will be run against the updated mode.
-  void Start(Mode mode);
+  // If supplied, |callback| will be invoked when the mode has been
+  // changed to |mode| *from the SyncerThread*, and not from the caller
+  // thread.
+  void Start(Mode mode, ModeChangeCallback* callback);
 
   // Joins on the thread as soon as possible (currently running session
   // completes).
   void Stop();
 
   // The meat and potatoes.
   void ScheduleNudge(const base::TimeDelta& delay, NudgeSource source,
                      const syncable::ModelTypeBitSet& types);
   void ScheduleNudgeWithPayloads(
       const base::TimeDelta& delay, NudgeSource source,
@@ skipping 11 matching lines @@
 
   // 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);
   virtual void OnShouldStopSyncingPermanently();
 
+  // ServerConnectionEventListener implementation.
+  // TODO(tim): schedule a nudge when valid connection detected? in 1 minute?
+  virtual void OnServerConnectionEvent(const ServerConnectionEvent2& event);
+
  private:
   friend class SyncerThread2Test;
 
   // State pertaining to exponential backoff or throttling periods.
   struct WaitInterval;
 
   // An enum used to describe jobs for scheduling purposes.
   enum SyncSessionJobPurpose {
     // Our poll timer schedules POLL jobs periodically based on a server
     // assigned poll interval.
@@ skipping 29 matching lines @@
                               SyncSessionJobPurpose purpose,
                               sessions::SyncSession* session);
 
   // Invoke the Syncer to perform a sync.
   void DoSyncSessionJob(const SyncSessionJob& job);
 
   // Called after the Syncer has performed the sync represented by |job|, to
   // reset our state.
   void FinishSyncSessionJob(const SyncSessionJob& job);
 
+  void UpdateCarryoverSessionState(const SyncSessionJob& old_job);

[Nicolas Zea, 2011/03/25 18:53:03]

Why is it important to do this?

[tim (not reviewing), 2011/03/28 20:02:25]

added comment.

+
   // Helper to FinishSyncSessionJob to schedule the next sync operation.
   void ScheduleNextSync(const SyncSessionJob& old_job);
 
   // Helper to configure polling intervals. Used by Start and ScheduleNextSync.
   void AdjustPolling(const SyncSessionJob* old_job);
 
   // Helper to ScheduleNextSync in case of consecutive sync errors.
   void HandleConsecutiveContinuationError(const SyncSessionJob& old_job);
 
   // Determines if it is legal to run a sync job for |purpose| at
   // |scheduled_start|.  This checks current operational mode, backoff or
   // throttling, freshness (so we don't make redundant syncs), and connection.
   bool ShouldRunJob(SyncSessionJobPurpose purpose,
                     const base::TimeTicks& scheduled_start);
 
   // 'Impl' here refers to real implementation of public functions, running on
   // |thread_|.
-  void StartImpl(Mode mode);
+  void StartImpl(Mode mode, linked_ptr<ModeChangeCallback> callback);
   void ScheduleNudgeImpl(
       const base::TimeDelta& delay,
       NudgeSource source,
       const syncable::ModelTypePayloadMap& types_with_payloads);
   void ScheduleConfigImpl(const ModelSafeRoutingInfo& routing_info,
                           const std::vector<ModelSafeWorker*>& workers);
   void ScheduleClearUserDataImpl();
 
   // Returns true if the client is currently in exponential backoff.
   bool IsBackingOff() const;
 
   // Helper to signal all listeners registered with |session_context_|.
   void Notify(SyncEngineEvent::EventCause cause);
 
-  // ServerConnectionEventListener implementation.
-  // TODO(tim): schedule a nudge when valid connection detected? in 1 minute?
-  virtual void OnServerConnectionEvent(const ServerConnectionEvent& event);
-
   // Callback to change backoff state.
   void DoCanaryJob();
   void Unthrottle();
 
   // Creates a session for a poll and performs the sync.
   void PollTimerCallback();
 
   // Assign |start| and |end| to appropriate SyncerStep values for the
   // specified |purpose|.
   void SetSyncerStepsForPurpose(SyncSessionJobPurpose purpose,
                                 SyncerStep* start,
                                 SyncerStep* end);
 
+  // Initializes the hookup between the ServerConnectionManager and us.
+  void WatchConnectionManager();
+
+  // Used to update |server_connection_ok_|, see below.
+  void CheckServerConnectionManagerStatus(
+      HttpResponse::ServerConnectionCode code);
+
+  // Called once the first time thread_ is started to broadcast an initial
+  // session snapshot containing data like initial_sync_ended.  Important when
+  // the client starts up and does not need to perform an initial sync.
+  void SendInitialSnapshot();
+
   base::Thread thread_;
 
   // Modifiable versions of kDefaultLongPollIntervalSeconds which can be
   // updated by the server.
   base::TimeDelta syncer_short_poll_interval_seconds_;
   base::TimeDelta syncer_long_poll_interval_seconds_;
 
   // Periodic timer for polling.  See AdjustPolling.
   base::RepeatingTimer<SyncerThread> poll_timer_;
 
@@ skipping 25 matching lines @@
 
 }  // namespace s3
 
 }  // namespace browser_sync
 
 // The SyncerThread manages its own internal thread and thus outlives it. We
 // don't need refcounting for posting tasks to this internal thread.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(browser_sync::s3::SyncerThread);
 
 #endif  // CHROME_BROWSER_SYNC_ENGINE_SYNCER_THREAD2_H_