Worker changes to prepare for lock-free shutdown.

chrome/browser/sync/glue/sync_backend_registrar.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.
 
 #ifndef CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_REGISTRAR_H_
 #define CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_REGISTRAR_H_
 
 #include <map>
 #include <vector>
 
@@ skipping 16 matching lines @@
 }  // namespace syncer
 
 namespace browser_sync {
 
 class ChangeProcessor;
 class UIModelWorker;
 
 // A class that keep track of the workers, change processors, and
 // routing info for the enabled sync types, and also routes change
 // events to the right processors.
-class SyncBackendRegistrar : public syncer::SyncManager::ChangeDelegate {
+class SyncBackendRegistrar : public syncer::SyncManager::ChangeDelegate,
+                             public syncer::WorkerObserver {

[tim (not reviewing), 2013/05/14 04:14:29]

WorkerDestructionObserver would be a better name for this, particularly since it
is just a relay of MessageLoop::DestructionObserver.

[haitaol1, 2013/05/15 23:39:21]

I think WorkerLoopDesctructionObserver is more accurate.

On 2013/05/14 04:14:29, timsteele wrote:

  public:
   // |name| is used for debugging.  Does not take ownership of |profile| or
   // |sync_loop|.  Must be created on the UI thread.
   SyncBackendRegistrar(const std::string& name,
                        Profile* profile,
                        base::MessageLoop* sync_loop);
 
   // Informs the SyncBackendRegistrar of the currently enabled set of types.
   // These types will be placed in the passive group.  This function should be
   // called exactly once during startup.
@@ skipping 53 matching lines @@
   virtual void OnChangesApplied(
       syncer::ModelType model_type,
       int64 model_version,
       const syncer::BaseTransaction* trans,
       const syncer::ImmutableChangeRecordList& changes) OVERRIDE;
   virtual void OnChangesComplete(syncer::ModelType model_type) OVERRIDE;
 
   void GetWorkers(std::vector<syncer::ModelSafeWorker*>* out);
   void GetModelSafeRoutingInfo(syncer::ModelSafeRoutingInfo* out);
 
+  // syncer::WorkerObserver implementation.
+  virtual void OnWorkerDisabled(syncer::ModelSafeGroup group) OVERRIDE;
+
  private:
   typedef std::map<syncer::ModelSafeGroup,
                    scoped_refptr<syncer::ModelSafeWorker> > WorkerMap;
 
   // Returns the change processor for the given model, or NULL if none
   // exists.  Must be called from |group|'s native thread.
   ChangeProcessor* GetProcessor(syncer::ModelType type) const;
 
   // Must be called with |lock_| held.  Simply returns the change
   // processor for the given type, if it exists.  May be called from
@@ skipping 34 matching lines @@
 
   // The change processors that handle the different data types.
   std::map<syncer::ModelType, ChangeProcessor*> processors_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncBackendRegistrar);
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_REGISTRAR_H_