sync: Remove SyncManager::TestingMode in favour of InternalComponentsFactory.

sync/engine/sync_scheduler_impl.h

 // Copyright (c) 2012 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 schedule syncer tasks intelligently.
-#ifndef SYNC_ENGINE_SYNC_SCHEDULER_H_
-#define SYNC_ENGINE_SYNC_SCHEDULER_H_
+
+#ifndef SYNC_ENGINE_SYNC_SCHEDULER_IMPL_H_
+#define SYNC_ENGINE_SYNC_SCHEDULER_IMPL_H_
 
 #include <string>
 
-#include "base/callback.h"
-#include "base/compiler_specific.h"
-#include "base/gtest_prod_util.h"
-#include "base/memory/linked_ptr.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/memory/weak_ptr.h"
-#include "base/observer_list.h"
-#include "base/time.h"
-#include "base/timer.h"
-#include "sync/engine/net/server_connection_manager.h"
-#include "sync/engine/nudge_source.h"
-#include "sync/engine/syncer.h"
-#include "sync/internal_api/public/base/model_type_payload_map.h"
-#include "sync/internal_api/public/engine/polling_constants.h"
-#include "sync/internal_api/public/util/weak_handle.h"
-#include "sync/sessions/sync_session.h"
-#include "sync/sessions/sync_session_context.h"
-
-class MessageLoop;
-
-namespace tracked_objects {
-class Location;
-}  // namespace tracked_objects
+#include "sync/engine/sync_scheduler.h"
 
 namespace syncer {
 
-struct ServerConnectionEvent;
-
-struct ConfigurationParams {
-  enum KeystoreKeyStatus {
-    KEYSTORE_KEY_UNNECESSARY,
-    KEYSTORE_KEY_NEEDED
-  };
-  ConfigurationParams();
-  ConfigurationParams(
-      const sync_pb::GetUpdatesCallerInfo::GetUpdatesSource& source,
-      const syncer::ModelTypeSet& types_to_download,
-      const syncer::ModelSafeRoutingInfo& routing_info,
-      KeystoreKeyStatus keystore_key_status,
-      const base::Closure& ready_task);
-  ~ConfigurationParams();
-
-  // Source for the configuration.
-  sync_pb::GetUpdatesCallerInfo::GetUpdatesSource source;
-  // The types that should be downloaded.
-  syncer::ModelTypeSet types_to_download;
-  // The new routing info (superset of types to be downloaded).
-  ModelSafeRoutingInfo routing_info;
-  // Whether we need to perform a GetKey command.
-  KeystoreKeyStatus keystore_key_status;
-  // Callback to invoke on configuration completion.
-  base::Closure ready_task;
-};
-
-class SyncScheduler : public sessions::SyncSession::Delegate {
+class SyncSchedulerImpl : public SyncScheduler {
  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,
-  };
-
-  // All methods of SyncScheduler must be called on the same thread
-  // (except for RequestEarlyExit()).
-
   // |name| is a display string to identify the syncer thread.  Takes
   // |ownership of |syncer|.
-  SyncScheduler(const std::string& name,
-                sessions::SyncSessionContext* context, Syncer* syncer);
+  SyncSchedulerImpl(const std::string& name,
+                    sessions::SyncSessionContext* context, Syncer* syncer);
 
   // Calls Stop().
-  virtual ~SyncScheduler();
+  virtual ~SyncSchedulerImpl();
 
-  // Start the scheduler with the given mode.  If the scheduler is
-  // already started, switch to the given mode, although some
-  // scheduled tasks from the old mode may still run.
-  virtual void Start(Mode mode);
-
-  // Schedules the configuration task specified by |params|. Returns true if
-  // the configuration task executed immediately, false if it had to be
-  // scheduled for a later attempt. |params.ready_task| is invoked whenever the
-  // configuration task executes.
-  // Note: must already be in CONFIGURATION mode.
-  virtual bool ScheduleConfiguration(const ConfigurationParams& params);
-
-  // Request that any running syncer task stop as soon as possible and
-  // cancel all scheduled tasks. This function can be called from any thread,
-  // and should in fact be called from a thread that isn't the sync loop to
-  // allow preempting ongoing sync cycles.
-  // Invokes |callback| from the sync loop once syncer is idle and all tasks
-  // are cancelled.
-  void RequestStop(const base::Closure& callback);
-
-  // The meat and potatoes. Both of these methods will post a delayed task
-  // to attempt the actual nudge (see ScheduleNudgeImpl).
-  void ScheduleNudgeAsync(const base::TimeDelta& delay, NudgeSource source,
-                          syncer::ModelTypeSet types,
-                          const tracked_objects::Location& nudge_location);
-  void ScheduleNudgeWithPayloadsAsync(
+  virtual void Start(Mode mode) OVERRIDE;
+  virtual bool ScheduleConfiguration(
+      const ConfigurationParams& params) OVERRIDE;
+  virtual void RequestStop(const base::Closure& callback) OVERRIDE;
+  virtual void ScheduleNudgeAsync(
+      const base::TimeDelta& delay,
+      NudgeSource source,
+      syncer::ModelTypeSet types,
+      const tracked_objects::Location& nudge_location) OVERRIDE;
+  virtual void ScheduleNudgeWithPayloadsAsync(
       const base::TimeDelta& delay, NudgeSource source,
       const syncer::ModelTypePayloadMap& types_with_payloads,
-      const tracked_objects::Location& nudge_location);
+      const tracked_objects::Location& nudge_location) OVERRIDE;
+  virtual void SetNotificationsEnabled(bool notifications_enabled) OVERRIDE;
 
-  void CleanupDisabledTypes();
+  virtual base::TimeDelta GetSessionsCommitDelay() const OVERRIDE;
 
-  // Change status of notifications in the SyncSessionContext.
-  void set_notifications_enabled(bool notifications_enabled);
-
-  base::TimeDelta sessions_commit_delay() const;
-
-  // DDOS avoidance function.  Calculates how long we should wait before trying
-  // again after a failed sync attempt, where the last delay was |base_delay|.
-  // TODO(tim): Look at URLRequestThrottlerEntryInterface.
-  static base::TimeDelta GetRecommendedDelay(const base::TimeDelta& base_delay);
-
-  // Called when credentials are updated by the user.
-  void OnCredentialsUpdated();
-
-  // Called when the network layer detects a connection status change.
-  void OnConnectionStatusChange();
+  virtual void OnCredentialsUpdated() OVERRIDE;
+  virtual void OnConnectionStatusChange() OVERRIDE;
 
   // SyncSession::Delegate implementation.
   virtual void OnSilencedUntil(
       const base::TimeTicks& silenced_until) OVERRIDE;
   virtual bool IsSyncingCurrentlySilenced() OVERRIDE;
   virtual void OnReceivedShortPollIntervalUpdate(
       const base::TimeDelta& new_interval) OVERRIDE;
   virtual void OnReceivedLongPollIntervalUpdate(
       const base::TimeDelta& new_interval) OVERRIDE;
   virtual void OnReceivedSessionsCommitDelay(
       const base::TimeDelta& new_delay) OVERRIDE;
   virtual void OnShouldStopSyncingPermanently() OVERRIDE;
   virtual void OnSyncProtocolError(
       const sessions::SyncSessionSnapshot& snapshot) OVERRIDE;
 
+  // DDOS avoidance function.  Calculates how long we should wait before trying
+  // again after a failed sync attempt, where the last delay was |base_delay|.
+  // TODO(tim): Look at URLRequestThrottlerEntryInterface.
+  static base::TimeDelta GetRecommendedDelay(const base::TimeDelta& base_delay);
+
  private:
   enum JobProcessDecision {
     // Indicates we should continue with the current job.
     CONTINUE,
     // Indicates that we should save it to be processed later.
     SAVE,
     // Indicates we should drop this job.
     DROP,
   };
 
@@ skipping 86 matching lines @@
     WaitInterval(Mode mode, base::TimeDelta length);
 
     static const char* GetModeString(Mode mode);
 
     Mode mode;
 
     // This bool is set to true if we have observed a nudge during this
     // interval and mode == EXPONENTIAL_BACKOFF.
     bool had_nudge;
     base::TimeDelta length;
-    base::OneShotTimer<SyncScheduler> timer;
+    base::OneShotTimer<SyncSchedulerImpl> timer;
 
     // Configure jobs are saved only when backing off or throttling. So we
     // expose the pointer here.
     scoped_ptr<SyncSessionJob> pending_configure_job;
   };
 
   static const char* GetModeString(Mode mode);
 
   static const char* GetDecisionString(JobProcessDecision decision);
 
@@ skipping 95 matching lines @@
   void UpdateServerConnectionManagerStatus(
       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();
 
   virtual void OnActionableError(const sessions::SyncSessionSnapshot& snapshot);
 
-  base::WeakPtrFactory<SyncScheduler> weak_ptr_factory_;
+  base::WeakPtrFactory<SyncSchedulerImpl> weak_ptr_factory_;
 
   // A second factory specially for weak_handle_this_, to allow the handle
   // to be const and alleviate threading concerns.
-  base::WeakPtrFactory<SyncScheduler> weak_ptr_factory_for_weak_handle_;
+  base::WeakPtrFactory<SyncSchedulerImpl> weak_ptr_factory_for_weak_handle_;
 
   // For certain methods that need to worry about X-thread posting.
-  const WeakHandle<SyncScheduler> weak_handle_this_;
+  const WeakHandle<SyncSchedulerImpl> weak_handle_this_;
 
   // Used for logging.
   const std::string name_;
 
   // The message loop this object is on.  Almost all methods have to
   // be called on this thread.
   MessageLoop* const sync_loop_;
 
   // Set in Start(), unset in Stop().
   bool started_;
 
   // 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_;
 
   // Server-tweakable sessions commit delay.
   base::TimeDelta sessions_commit_delay_;
 
   // Periodic timer for polling.  See AdjustPolling.
-  base::RepeatingTimer<SyncScheduler> poll_timer_;
+  base::RepeatingTimer<SyncSchedulerImpl> poll_timer_;
 
   // The mode of operation.
   Mode mode_;
 
   // TODO(tim): Bug 26339. This needs to track more than just time I think,
   // since the nudges could be for different types. Current impl doesn't care.
   base::TimeTicks last_sync_session_end_time_;
 
   // The latest connection code we got while trying to connect.
   HttpResponse::ServerConnectionCode connection_code_;
 
   // Tracks in-flight nudges so we can coalesce.
   scoped_ptr<SyncSessionJob> pending_nudge_;
 
   // Current wait state.  Null if we're not in backoff and not throttled.
   scoped_ptr<WaitInterval> wait_interval_;
 
   scoped_ptr<DelayProvider> delay_provider_;
 
   // Invoked to run through the sync cycle.
   scoped_ptr<Syncer> syncer_;
 
   sessions::SyncSessionContext *session_context_;
 
-  DISALLOW_COPY_AND_ASSIGN(SyncScheduler);
+  DISALLOW_COPY_AND_ASSIGN(SyncSchedulerImpl);
 };
 
 }  // namespace syncer
 
-#endif  // SYNC_ENGINE_SYNC_SCHEDULER_H_
+#endif  // SYNC_ENGINE_SYNC_SCHEDULER_IMPL_H_