src/chrome/browser/sync/glue/sync_backend_host_impl.h

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_IMPL_H_
   6 #define CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_IMPL_H_
   7
   8 #include <string>
   9
  10 #include "base/basictypes.h"
  11 #include "base/callback.h"
  12 #include "base/compiler_specific.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/memory/weak_ptr.h"
  15 #include "base/threading/thread.h"
  16 #include "chrome/browser/sync/glue/extensions_activity_monitor.h"
  17 #include "chrome/browser/sync/glue/sync_backend_host.h"
  18 #include "components/invalidation/invalidation_handler.h"
  19 #include "components/sync_driver/backend_data_type_configurer.h"
  20 #include "content/public/browser/notification_observer.h"
  21 #include "content/public/browser/notification_registrar.h"
  22 #include "sync/internal_api/public/base/model_type.h"
  23 #include "sync/internal_api/public/configure_reason.h"
  24 #include "sync/internal_api/public/sessions/sync_session_snapshot.h"
  25 #include "sync/internal_api/public/sessions/type_debug_info_observer.h"
  26 #include "sync/internal_api/public/sync_manager.h"
  27 #include "sync/internal_api/public/util/report_unrecoverable_error_function.h"
  28 #include "sync/internal_api/public/util/unrecoverable_error_handler.h"
  29 #include "sync/internal_api/public/util/weak_handle.h"
  30 #include "sync/protocol/encryption.pb.h"
  31 #include "sync/protocol/sync_protocol_error.h"
  32 #include "sync/util/extensions_activity.h"
  33
  34 class GURL;
  35 class Profile;
  36
  37 namespace base {
  38 class MessageLoop;
  39 }
  40
  41 namespace invalidation {
  42 class InvalidationService;
  43 }
  44
  45 namespace syncer {
  46 class NetworkResources;
  47 class SyncManagerFactory;
  48 }
  49
  50 namespace sync_driver {
  51 class SyncPrefs;
  52 }
  53
  54 namespace browser_sync {
  55
  56 class ChangeProcessor;
  57 class SyncBackendHostCore;
  58 class SyncBackendRegistrar;
  59 struct DoInitializeOptions;
  60
  61 // The only real implementation of the SyncBackendHost.  See that interface's
  62 // definition for documentation of public methods.
  63 class SyncBackendHostImpl
  64     : public SyncBackendHost,
  65       public content::NotificationObserver,
  66       public syncer::InvalidationHandler {
  67  public:
  68   typedef syncer::SyncStatus Status;
  69
  70   // Create a SyncBackendHost with a reference to the |frontend| that
  71   // it serves and communicates to via the SyncFrontend interface (on
  72   // the same thread it used to call the constructor).  Must outlive
  73   // |sync_prefs|.
  74   SyncBackendHostImpl(const std::string& name,
  75                       Profile* profile,
  76                       invalidation::InvalidationService* invalidator,
  77                       const base::WeakPtr<sync_driver::SyncPrefs>& sync_prefs,
  78                       const base::FilePath& sync_folder);
  79   virtual ~SyncBackendHostImpl();
  80
  81   // SyncBackendHost implementation.
  82   virtual void Initialize(
  83       sync_driver::SyncFrontend* frontend,
  84       scoped_ptr<base::Thread> sync_thread,
  85       const syncer::WeakHandle<syncer::JsEventHandler>& event_handler,
  86       const GURL& service_url,
  87       const syncer::SyncCredentials& credentials,
  88       bool delete_sync_data_folder,
  89       scoped_ptr<syncer::SyncManagerFactory> sync_manager_factory,
  90       scoped_ptr<syncer::UnrecoverableErrorHandler> unrecoverable_error_handler,
  91       syncer::ReportUnrecoverableErrorFunction
  92           report_unrecoverable_error_function,
  93       syncer::NetworkResources* network_resources) OVERRIDE;
  94   virtual void UpdateCredentials(
  95       const syncer::SyncCredentials& credentials) OVERRIDE;
  96   virtual void StartSyncingWithServer() OVERRIDE;
  97   virtual void SetEncryptionPassphrase(
  98       const std::string& passphrase,
  99       bool is_explicit) OVERRIDE;
 100   virtual bool SetDecryptionPassphrase(const std::string& passphrase)
 101       OVERRIDE WARN_UNUSED_RESULT;
 102   virtual void StopSyncingForShutdown() OVERRIDE;
 103   virtual scoped_ptr<base::Thread> Shutdown(syncer::ShutdownReason reason)
 104       OVERRIDE;
 105   virtual void UnregisterInvalidationIds() OVERRIDE;
 106   virtual void ConfigureDataTypes(
 107       syncer::ConfigureReason reason,
 108       const DataTypeConfigStateMap& config_state_map,
 109       const base::Callback<void(syncer::ModelTypeSet,
 110                                 syncer::ModelTypeSet)>& ready_task,
 111       const base::Callback<void()>& retry_callback) OVERRIDE;
 112   virtual void ActivateDataType(
 113      syncer::ModelType type, syncer::ModelSafeGroup group,
 114      sync_driver::ChangeProcessor* change_processor) OVERRIDE;
 115   virtual void DeactivateDataType(syncer::ModelType type) OVERRIDE;
 116   virtual void EnableEncryptEverything() OVERRIDE;
 117   virtual syncer::UserShare* GetUserShare() const OVERRIDE;
 118   virtual scoped_ptr<syncer::SyncContextProxy> GetSyncContextProxy() OVERRIDE;
 119   virtual Status GetDetailedStatus() OVERRIDE;
 120   virtual syncer::sessions::SyncSessionSnapshot
 121       GetLastSessionSnapshot() const OVERRIDE;
 122   virtual bool HasUnsyncedItems() const OVERRIDE;
 123   virtual bool IsNigoriEnabled() const OVERRIDE;
 124   virtual syncer::PassphraseType GetPassphraseType() const OVERRIDE;
 125   virtual base::Time GetExplicitPassphraseTime() const OVERRIDE;
 126   virtual bool IsCryptographerReady(
 127       const syncer::BaseTransaction* trans) const OVERRIDE;
 128   virtual void GetModelSafeRoutingInfo(
 129       syncer::ModelSafeRoutingInfo* out) const OVERRIDE;
 130   virtual void RequestBufferedProtocolEventsAndEnableForwarding() OVERRIDE;
 131   virtual void DisableProtocolEventForwarding() OVERRIDE;
 132   virtual void EnableDirectoryTypeDebugInfoForwarding() OVERRIDE;
 133   virtual void DisableDirectoryTypeDebugInfoForwarding() OVERRIDE;
 134   virtual void GetAllNodesForTypes(
 135       syncer::ModelTypeSet types,
 136       base::Callback<void(const std::vector<syncer::ModelType>&,
 137                           ScopedVector<base::ListValue>)> type) OVERRIDE;
 138   virtual base::MessageLoop* GetSyncLoopForTesting() OVERRIDE;
 139
 140  protected:
 141   // The types and functions below are protected so that test
 142   // subclasses can use them.
 143
 144   // Allows tests to perform alternate core initialization work.
 145   virtual void InitCore(scoped_ptr<DoInitializeOptions> options);
 146
 147   // Request the syncer to reconfigure with the specfied params.
 148   // Virtual for testing.
 149   virtual void RequestConfigureSyncer(
 150       syncer::ConfigureReason reason,
 151       syncer::ModelTypeSet to_download,
 152       syncer::ModelTypeSet to_purge,
 153       syncer::ModelTypeSet to_journal,
 154       syncer::ModelTypeSet to_unapply,
 155       syncer::ModelTypeSet to_ignore,
 156       const syncer::ModelSafeRoutingInfo& routing_info,
 157       const base::Callback<void(syncer::ModelTypeSet,
 158                                 syncer::ModelTypeSet)>& ready_task,
 159       const base::Closure& retry_callback);
 160
 161   // Called when the syncer has finished performing a configuration.
 162   void FinishConfigureDataTypesOnFrontendLoop(
 163       const syncer::ModelTypeSet enabled_types,
 164       const syncer::ModelTypeSet succeeded_configuration_types,
 165       const syncer::ModelTypeSet failed_configuration_types,
 166       const base::Callback<void(syncer::ModelTypeSet,
 167                                 syncer::ModelTypeSet)>& ready_task);
 168
 169   // Reports backend initialization success.  Includes some objects from sync
 170   // manager initialization to be passed back to the UI thread.
 171   //
 172   // |sync_context_proxy| points to an object owned by the SyncManager.
 173   // Ownership is not transferred, but we can obtain our own copy of the object
 174   // using its Clone() method.
 175   virtual void HandleInitializationSuccessOnFrontendLoop(
 176       const syncer::WeakHandle<syncer::JsBackend> js_backend,
 177       const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>
 178           debug_info_listener,
 179       syncer::SyncContextProxy* sync_context_proxy,
 180       const std::string& cache_guid);
 181
 182   // Downloading of control types failed and will be retried. Invokes the
 183   // frontend's sync configure retry method.
 184   void HandleControlTypesDownloadRetry();
 185
 186   // Forwards a ProtocolEvent to the frontend.  Will not be called unless a
 187   // call to SetForwardProtocolEvents() explicitly requested that we start
 188   // forwarding these events.
 189   void HandleProtocolEventOnFrontendLoop(syncer::ProtocolEvent* event);
 190
 191   // Forwards a directory commit counter update to the frontend loop.  Will not
 192   // be called unless a call to EnableDirectoryTypeDebugInfoForwarding()
 193   // explicitly requested that we start forwarding these events.
 194   void HandleDirectoryCommitCountersUpdatedOnFrontendLoop(
 195       syncer::ModelType type,
 196       const syncer::CommitCounters& counters);
 197
 198   // Forwards a directory update counter update to the frontend loop.  Will not
 199   // be called unless a call to EnableDirectoryTypeDebugInfoForwarding()
 200   // explicitly requested that we start forwarding these events.
 201   void HandleDirectoryUpdateCountersUpdatedOnFrontendLoop(
 202       syncer::ModelType type,
 203       const syncer::UpdateCounters& counters);
 204
 205   // Forwards a directory status counter update to the frontend loop.  Will not
 206   // be called unless a call to EnableDirectoryTypeDebugInfoForwarding()
 207   // explicitly requested that we start forwarding these events.
 208   void HandleDirectoryStatusCountersUpdatedOnFrontendLoop(
 209       syncer::ModelType type,
 210       const syncer::StatusCounters& counters);
 211
 212   sync_driver::SyncFrontend* frontend() { return frontend_; }
 213
 214  private:
 215   friend class SyncBackendHostCore;
 216
 217   // Checks if we have received a notice to turn on experimental datatypes
 218   // (via the nigori node) and informs the frontend if that is the case.
 219   // Note: it is illegal to call this before the backend is initialized.
 220   void AddExperimentalTypes();
 221
 222   // Handles backend initialization failure.
 223   void HandleInitializationFailureOnFrontendLoop();
 224
 225   // Called from Core::OnSyncCycleCompleted to handle updating frontend
 226   // thread components.
 227   void HandleSyncCycleCompletedOnFrontendLoop(
 228       const syncer::sessions::SyncSessionSnapshot& snapshot);
 229
 230   // Called when the syncer failed to perform a configuration and will
 231   // eventually retry. FinishingConfigurationOnFrontendLoop(..) will be called
 232   // on successful completion.
 233   void RetryConfigurationOnFrontendLoop(const base::Closure& retry_callback);
 234
 235   // Helpers to persist a token that can be used to bootstrap sync encryption
 236   // across browser restart to avoid requiring the user to re-enter their
 237   // passphrase.  |token| must be valid UTF-8 as we use the PrefService for
 238   // storage.
 239   void PersistEncryptionBootstrapToken(
 240       const std::string& token,
 241       syncer::BootstrapTokenType token_type);
 242
 243   // For convenience, checks if initialization state is INITIALIZED.
 244   bool initialized() const { return initialized_; }
 245
 246   // Let the front end handle the actionable error event.
 247   void HandleActionableErrorEventOnFrontendLoop(
 248       const syncer::SyncProtocolError& sync_error);
 249
 250   // Handle a migration request.
 251   void HandleMigrationRequestedOnFrontendLoop(const syncer::ModelTypeSet types);
 252
 253   // Checks if |passphrase| can be used to decrypt the cryptographer's pending
 254   // keys that were cached during NotifyPassphraseRequired. Returns true if
 255   // decryption was successful. Returns false otherwise. Must be called with a
 256   // non-empty pending keys cache.
 257   bool CheckPassphraseAgainstCachedPendingKeys(
 258       const std::string& passphrase) const;
 259
 260   // Invoked when a passphrase is required to decrypt a set of Nigori keys,
 261   // or for encrypting. |reason| denotes why the passphrase was required.
 262   // |pending_keys| is a copy of the cryptographer's pending keys, that are
 263   // cached by the frontend. If there are no pending keys, or if the passphrase
 264   // required reason is REASON_ENCRYPTION, an empty EncryptedData object is
 265   // passed.
 266   void NotifyPassphraseRequired(syncer::PassphraseRequiredReason reason,
 267                                 sync_pb::EncryptedData pending_keys);
 268
 269   // Invoked when the passphrase provided by the user has been accepted.
 270   void NotifyPassphraseAccepted();
 271
 272   // Invoked when the set of encrypted types or the encrypt
 273   // everything flag changes.
 274   void NotifyEncryptedTypesChanged(
 275       syncer::ModelTypeSet encrypted_types,
 276       bool encrypt_everything);
 277
 278   // Invoked when sync finishes encrypting new datatypes.
 279   void NotifyEncryptionComplete();
 280
 281   // Invoked when the passphrase state has changed. Caches the passphrase state
 282   // for later use on the UI thread.
 283   // If |type| is FROZEN_IMPLICIT_PASSPHRASE or CUSTOM_PASSPHRASE,
 284   // |explicit_passphrase_time| is the time at which that passphrase was set
 285   // (if available).
 286   void HandlePassphraseTypeChangedOnFrontendLoop(
 287       syncer::PassphraseType type,
 288       base::Time explicit_passphrase_time);
 289
 290   void HandleStopSyncingPermanentlyOnFrontendLoop();
 291
 292   // Dispatched to from OnConnectionStatusChange to handle updating
 293   // frontend UI components.
 294   void HandleConnectionStatusChangeOnFrontendLoop(
 295       syncer::ConnectionStatus status);
 296
 297   // NotificationObserver implementation.
 298   virtual void Observe(
 299     int type,
 300     const content::NotificationSource& source,
 301     const content::NotificationDetails& details) OVERRIDE;
 302
 303   // InvalidationHandler implementation.
 304   virtual void OnInvalidatorStateChange(
 305       syncer::InvalidatorState state) OVERRIDE;
 306   virtual void OnIncomingInvalidation(
 307       const syncer::ObjectIdInvalidationMap& invalidation_map) OVERRIDE;
 308   virtual std::string GetOwnerName() const OVERRIDE;
 309
 310   content::NotificationRegistrar notification_registrar_;
 311
 312   // A reference to the MessageLoop used to construct |this|, so we know how
 313   // to safely talk back to the SyncFrontend.
 314   base::MessageLoop* const frontend_loop_;
 315
 316   Profile* const profile_;
 317
 318   // Name used for debugging (set from profile_->GetDebugName()).
 319   const std::string name_;
 320
 321   // Our core, which communicates directly to the syncapi. Use refptr instead
 322   // of WeakHandle because |core_| is created on UI loop but released on
 323   // sync loop.
 324   scoped_refptr<SyncBackendHostCore> core_;
 325
 326   // A handle referencing the main interface for non-blocking sync types.
 327   scoped_ptr<syncer::SyncContextProxy> sync_context_proxy_;
 328
 329   bool initialized_;
 330
 331   const base::WeakPtr<sync_driver::SyncPrefs> sync_prefs_;
 332
 333   ExtensionsActivityMonitor extensions_activity_monitor_;
 334
 335   scoped_ptr<SyncBackendRegistrar> registrar_;
 336
 337   // The frontend which we serve (and are owned by).
 338   sync_driver::SyncFrontend* frontend_;
 339
 340   // We cache the cryptographer's pending keys whenever NotifyPassphraseRequired
 341   // is called. This way, before the UI calls SetDecryptionPassphrase on the
 342   // syncer, it can avoid the overhead of an asynchronous decryption call and
 343   // give the user immediate feedback about the passphrase entered by first
 344   // trying to decrypt the cached pending keys on the UI thread. Note that
 345   // SetDecryptionPassphrase can still fail after the cached pending keys are
 346   // successfully decrypted if the pending keys have changed since the time they
 347   // were cached.
 348   sync_pb::EncryptedData cached_pending_keys_;
 349
 350   // The state of the passphrase required to decrypt the bag of encryption keys
 351   // in the nigori node. Updated whenever a new nigori node arrives or the user
 352   // manually changes their passphrase state. Cached so we can synchronously
 353   // check it from the UI thread.
 354   syncer::PassphraseType cached_passphrase_type_;
 355
 356   // If an explicit passphrase is in use, the time at which the passphrase was
 357   // first set (if available).
 358   base::Time cached_explicit_passphrase_time_;
 359
 360   // UI-thread cache of the last SyncSessionSnapshot received from syncapi.
 361   syncer::sessions::SyncSessionSnapshot last_snapshot_;
 362
 363   invalidation::InvalidationService* invalidator_;
 364   bool invalidation_handler_registered_;
 365
 366   base::WeakPtrFactory<SyncBackendHostImpl> weak_ptr_factory_;
 367
 368   DISALLOW_COPY_AND_ASSIGN(SyncBackendHostImpl);
 369 };
 370
 371 }  // namespace browser_sync
 372
 373 #endif  // CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_IMPL_H_
 374