blob: af846d430c86b5663e4b9ea18040a79ad6862f54 [file] [log] [blame]
// Copyright 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 representing an attempt to synchronize the local syncable data
// store with a sync server. A SyncSession instance is passed as a stateful
// bundle to and from various SyncerCommands with the goal of converging the
// client view of data with that of the server. The commands twiddle with
// session status in response to events and hiccups along the way, set and
// query session progress with regards to conflict resolution and applying
// server updates, and access the SyncSessionContext for the current session
// via SyncSession instances.
#include <map>
#include <set>
#include <string>
#include <utility>
#include <vector>
#include "base/basictypes.h"
#include "base/memory/scoped_ptr.h"
#include "base/time/time.h"
#include "sync/base/sync_export.h"
#include "sync/internal_api/public/base/model_type.h"
#include "sync/internal_api/public/engine/model_safe_worker.h"
#include "sync/internal_api/public/sessions/sync_session_snapshot.h"
#include "sync/sessions/status_controller.h"
#include "sync/sessions/sync_session_context.h"
namespace syncer {
class ModelSafeWorker;
namespace sessions {
class NudgeTracker;
class SYNC_EXPORT_PRIVATE SyncSession {
// The Delegate services events that occur during the session requiring an
// explicit (and session-global) action, as opposed to events that are simply
// recorded in per-session state.
class SYNC_EXPORT_PRIVATE Delegate {
// The client was throttled and should cease-and-desist syncing activity
// until the specified time.
virtual void OnThrottled(const base::TimeDelta& throttle_duration) = 0;
// Some of the client's types were throttled.
virtual void OnTypesThrottled(
ModelTypeSet types,
const base::TimeDelta& throttle_duration) = 0;
// Silenced intervals can be out of phase with individual sessions, so the
// delegate is the only thing that can give an authoritative answer for
// "is syncing silenced right now". This shouldn't be necessary very often
// as the delegate ensures no session is started if syncing is silenced.
// ** Note ** This will return true if silencing commenced during this
// session and the interval has not yet elapsed, but the contract here is
// solely based on absolute time values. So, this cannot be used to infer
// that any given session _instance_ is silenced. An example of reasonable
// use is for UI reporting.
virtual bool IsCurrentlyThrottled() = 0;
// The client has been instructed to change its short poll interval.
virtual void OnReceivedShortPollIntervalUpdate(
const base::TimeDelta& new_interval) = 0;
// The client has been instructed to change its long poll interval.
virtual void OnReceivedLongPollIntervalUpdate(
const base::TimeDelta& new_interval) = 0;
// The client has been instructed to change its sessions commit
// delay.
virtual void OnReceivedSessionsCommitDelay(
const base::TimeDelta& new_delay) = 0;
// Called for the syncer to respond to the error sent by the server.
virtual void OnSyncProtocolError(
const sessions::SyncSessionSnapshot& snapshot) = 0;
// Called when the server wants to change the number of hints the client
// will buffer locally.
virtual void OnReceivedClientInvalidationHintBufferSize(int size) = 0;
virtual ~Delegate() {}
// Build a session without a nudge tracker. Used for poll or configure type
// sync cycles.
static SyncSession* Build(SyncSessionContext* context,
Delegate* delegate);
// Builds a thread-safe and read-only copy of the current session state.
SyncSessionSnapshot TakeSnapshot() const;
SyncSessionSnapshot TakeSnapshotWithSource(
sync_pb::GetUpdatesCallerInfo::GetUpdatesSource legacy_updates_source)
// Builds and sends a snapshot to the session context's listeners.
void SendSyncCycleEndEventNotification(
sync_pb::GetUpdatesCallerInfo::GetUpdatesSource source);
void SendEventNotification(SyncEngineEvent::EventCause cause);
// TODO(akalin): Split this into context() and mutable_context().
SyncSessionContext* context() const { return context_; }
Delegate* delegate() const { return delegate_; }
const StatusController& status_controller() const {
return *status_controller_.get();
StatusController* mutable_status_controller() {
return status_controller_.get();
SyncSession(SyncSessionContext* context, Delegate* delegate);
// The context for this session, guaranteed to outlive |this|.
SyncSessionContext* const context_;
// The delegate for this session, must never be NULL.
Delegate* const delegate_;
// Our controller for various status and error counters.
scoped_ptr<StatusController> status_controller_;
} // namespace sessions
} // namespace syncer