components/cryptauth/sync_scheduler.h

// Copyright 2015 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.

#ifndef COMPONENTS_CRYPTAUTH_SYNC_SCHEDULER_H_
#define COMPONENTS_CRYPTAUTH_SYNC_SCHEDULER_H_

#include <memory>

#include "base/macros.h"
#include "base/memory/weak_ptr.h"
#include "base/time/time.h"

namespace cryptauth {

// Interface for scheduling the next CryptAuth sync (e.g. enrollment or device
// sync). The scheduler has two different strategies affecting when to perform
// the next operation:
//     PERIODIC_REFRESH: The last sync was made successfully, so we can wait a
//         relatively long time before making another sync.
//     AGGRESSIVE_RECOVERY: The last sync failed, so we try more aggressively to
//         make enrollment attempts with subsequent backoff for repeated
//         failures.
// A random jitter is applied to each sync period to smooth qps to the server.
class SyncScheduler {
 public:
  // The sync strategies mentioned in the class comments.
  enum class Strategy { PERIODIC_REFRESH, AGGRESSIVE_RECOVERY };

  // The states that the scheduler can be in.
  enum class SyncState { NOT_STARTED, WAITING_FOR_REFRESH, SYNC_IN_PROGRESS };

  // An instance is passed to the delegate when the scheduler fires for each
  // sync attempt. The delegate should call |Complete()| when the sync succeeds
  // or fails to resume the scheduler.
  class SyncRequest {
   public:
    explicit SyncRequest(base::WeakPtr<SyncScheduler> sync_scheduler);
    ~SyncRequest();

    void OnDidComplete(bool success);

   protected:
    // The parent scheduler that dispatched this request.
    base::WeakPtr<SyncScheduler> sync_scheduler_;

    // True if |OnDidComplete()| has been called.
    bool completed_;

    DISALLOW_COPY_AND_ASSIGN(SyncRequest);
  };

  // Handles the actual sync operation.
  class Delegate {
   public:
    virtual ~Delegate() {}

    // Called when the scheduler fires and requests a sync attempt. The delegate
    // should call sync_request->Complete() when the request finishes.
    virtual void OnSyncRequested(std::unique_ptr<SyncRequest> sync_request) = 0;
  };

  virtual ~SyncScheduler() {}

  // Starts the scheduler with an aggressive recovery strategy if
  // |strategy| is true; otherwise, it will be started with
  // periodic refresh.
  //
  // |elapsed_time_since_last_sync| is the time since the last successful sync,
  // so we can determine the duration of the first sync period. For example, the
  // scheduler will immediately issue a sync request if the elapsed time is
  // greater than the refresh period.
  virtual void Start(const base::TimeDelta& elapsed_time_since_last_sync,
                     Strategy strategy) = 0;

  // Cancels the current scheduled sync, and forces a sync immediately. Note
  // that if this sync fails, the scheduler will adopt the AGGRESSIVE_RECOVERY
  // strategy.
  virtual void ForceSync() = 0;

  // Returns the time until the next scheduled sync operation. If no sync is
  // scheduled, a TimeDelta of zero will be returned.
  virtual base::TimeDelta GetTimeToNextSync() const = 0;

  // Returns the current sync strategy.
  virtual Strategy GetStrategy() const = 0;

  // Returns the current state of the scheduler.
  virtual SyncState GetSyncState() const = 0;

 protected:
  // Called by SyncRequest instances when the sync completes.
  virtual void OnSyncCompleted(bool success) = 0;
};

}  // namespace cryptauth

#endif  // COMPONENTS_CRYPTAUTH_SYNC_SCHEDULER_H_