chrome/browser/sync/glue/sync_backend_registrar.h

   1 // Copyright (c) 2012 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_REGISTRAR_H_
   6 #define CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_REGISTRAR_H_
   7
   8 #include <map>
   9 #include <vector>
  10
  11 #include "base/basictypes.h"
  12 #include "base/compiler_specific.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "base/synchronization/lock.h"
  15 #include "base/threading/thread.h"
  16 #include "sync/internal_api/public/base/model_type.h"
  17 #include "sync/internal_api/public/engine/model_safe_worker.h"
  18 #include "sync/internal_api/public/sync_manager.h"
  19
  20 class Profile;
  21
  22 namespace base {
  23 class MessageLoop;
  24 }
  25
  26 namespace syncer {
  27 struct UserShare;
  28 }  // namespace syncer
  29
  30 namespace browser_sync {
  31
  32 class ChangeProcessor;
  33 class UIModelWorker;
  34
  35 // A class that keep track of the workers, change processors, and
  36 // routing info for the enabled sync types, and also routes change
  37 // events to the right processors.
  38 class SyncBackendRegistrar : public syncer::SyncManager::ChangeDelegate,
  39                              public syncer::WorkerLoopDestructionObserver {
  40  public:
  41   // |name| is used for debugging.  Does not take ownership of |profile| or
  42   // |sync_loop|.  Must be created on the UI thread.
  43   SyncBackendRegistrar(const std::string& name,
  44                        Profile* profile,
  45                        scoped_ptr<base::Thread> sync_thread);
  46
  47   // SyncBackendRegistrar must be destroyed as follows:
  48   //
  49   //   1) On the UI thread, call RequestWorkerStopOnUIThread().
  50   //   2) UI posts task to shut down syncer on sync thread.
  51   //   3) If sync is disabled, call ReleaseSyncThread() on the UI thread.
  52   //   3) UI posts SyncBackendRegistrar::ShutDown() on sync thread to
  53   //      unregister workers from observing destruction of their working loops.
  54   //   4) Workers notify registrar when unregistration finishes or working
  55   //      loops are destroyed. Registrar destroys itself on last worker
  56   //      notification. Sync thread will be stopped if ownership was not
  57   //      released.
  58   virtual ~SyncBackendRegistrar();
  59
  60   // Informs the SyncBackendRegistrar of the currently enabled set of types.
  61   // These types will be placed in the passive group.  This function should be
  62   // called exactly once during startup.
  63   void SetInitialTypes(syncer::ModelTypeSet initial_types);
  64
  65   // Returns whether or not we are currently syncing encryption keys.
  66   // Must be called on the UI thread.
  67   bool IsNigoriEnabled() const;
  68
  69   // Removes all types in |types_to_remove| from the routing info and
  70   // adds all the types in |types_to_add| to the routing info that are
  71   // not already there (initially put in the passive group).
  72   // |types_to_remove| and |types_to_add| must be disjoint.  Returns
  73   // the set of newly-added types.  Must be called on the UI thread.
  74   syncer::ModelTypeSet ConfigureDataTypes(
  75       syncer::ModelTypeSet types_to_add,
  76       syncer::ModelTypeSet types_to_remove);
  77
  78   // Returns the set of enabled types as of the last configuration. Note that
  79   // this might be different from the current types in the routing info due
  80   // to DeactiveDataType being called separately from ConfigureDataTypes.
  81   syncer::ModelTypeSet GetLastConfiguredTypes() const;
  82
  83   // Must be called from the UI thread. (See destructor comment.)
  84   void RequestWorkerStopOnUIThread();
  85
  86   // Activates the given data type (which should belong to the given
  87   // group) and starts the given change processor.  Must be called
  88   // from |group|'s native thread.
  89   void ActivateDataType(syncer::ModelType type,
  90                         syncer::ModelSafeGroup group,
  91                         ChangeProcessor* change_processor,
  92                         syncer::UserShare* user_share);
  93
  94   // Deactivates the given type if necessary.  Must be called from the
  95   // UI thread and not |type|'s native thread.  Yes, this is
  96   // surprising: see http://crbug.com/92804.
  97   void DeactivateDataType(syncer::ModelType type);
  98
  99   // Returns true only between calls to ActivateDataType(type, ...)
 100   // and DeactivateDataType(type).  Used only by tests.
 101   bool IsTypeActivatedForTest(syncer::ModelType type) const;
 102
 103   // SyncManager::ChangeDelegate implementation.  May be called from
 104   // any thread.
 105   virtual void OnChangesApplied(
 106       syncer::ModelType model_type,
 107       int64 model_version,
 108       const syncer::BaseTransaction* trans,
 109       const syncer::ImmutableChangeRecordList& changes) OVERRIDE;
 110   virtual void OnChangesComplete(syncer::ModelType model_type) OVERRIDE;
 111
 112   void GetWorkers(std::vector<scoped_refptr<syncer::ModelSafeWorker> >* out);
 113   void GetModelSafeRoutingInfo(syncer::ModelSafeRoutingInfo* out);
 114
 115   // syncer::WorkerLoopDestructionObserver implementation.
 116   virtual void OnWorkerLoopDestroyed(syncer::ModelSafeGroup group) OVERRIDE;
 117
 118   // Release ownership of |sync_thread_|. Called when sync is disabled.
 119   scoped_ptr<base::Thread> ReleaseSyncThread();
 120
 121   // Unregister workers from loop destruction observation.
 122   void Shutdown();
 123
 124   base::Thread* sync_thread();
 125
 126  private:
 127   typedef std::map<syncer::ModelSafeGroup,
 128       scoped_refptr<syncer::ModelSafeWorker> > WorkerMap;
 129   typedef std::map<syncer::ModelType, ChangeProcessor*>
 130       ProcessorMap;
 131
 132   // Callback after workers unregister from observing destruction of their
 133   // working loops.
 134   void OnWorkerUnregistrationDone(syncer::ModelSafeGroup group);
 135
 136   void RemoveWorker(syncer::ModelSafeGroup group);
 137
 138   // Returns the change processor for the given model, or NULL if none
 139   // exists.  Must be called from |group|'s native thread.
 140   ChangeProcessor* GetProcessor(syncer::ModelType type) const;
 141
 142   // Must be called with |lock_| held.  Simply returns the change
 143   // processor for the given type, if it exists.  May be called from
 144   // any thread.
 145   ChangeProcessor* GetProcessorUnsafe(syncer::ModelType type) const;
 146
 147   // Return true if |model_type| lives on the current thread.  Must be
 148   // called with |lock_| held.  May be called on any thread.
 149   bool IsCurrentThreadSafeForModel(
 150       syncer::ModelType model_type) const;
 151
 152   // Name used for debugging.
 153   const std::string name_;
 154
 155   Profile* const profile_;
 156
 157   // Protects all variables below.
 158   mutable base::Lock lock_;
 159
 160   // We maintain ownership of all workers.  In some cases, we need to
 161   // ensure shutdown occurs in an expected sequence by Stop()ing
 162   // certain workers.  They are guaranteed to be valid because we only
 163   // destroy elements of |workers_| after the syncapi has been
 164   // destroyed.  Unless a worker is no longer needed because all types
 165   // that get routed to it have been disabled (from syncing). In that
 166   // case, we'll destroy on demand *after* routing any dependent types
 167   // to syncer::GROUP_PASSIVE, so that the syncapi doesn't call into garbage.
 168   // If a key is present, it means at least one ModelType that routes
 169   // to that model safe group is being synced.
 170   WorkerMap workers_;
 171   syncer::ModelSafeRoutingInfo routing_info_;
 172
 173   // The change processors that handle the different data types.
 174   ProcessorMap processors_;
 175
 176   // The types that were enabled as of the last configuration. Updated on each
 177   // call to ConfigureDataTypes as well as SetInitialTypes.
 178   syncer::ModelTypeSet last_configured_types_;
 179
 180   // Parks stopped workers because they may still be referenced by syncer.
 181   std::vector<scoped_refptr<syncer::ModelSafeWorker> > stopped_workers_;
 182
 183   // Declare |sync_thread_| at the end so that it will be destroyed before
 184   // objects above because tasks on sync thread depend on those objects,
 185   // e.g. Shutdown() depends on |lock_|, SyncManager::Init() depends on
 186   // workers, etc.
 187   scoped_ptr<base::Thread> sync_thread_;
 188
 189   DISALLOW_COPY_AND_ASSIGN(SyncBackendRegistrar);
 190 };
 191
 192 }  // namespace browser_sync
 193
 194 #endif  // CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_REGISTRAR_H_