[Sync] Move change-related methods out of SyncManager::Observer

chrome/browser/sync/glue/sync_backend_registrar.h

 // Copyright (c) 2011 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_
 #pragma once
 
 #include <map>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/lock.h"
 #include "chrome/browser/sync/engine/model_safe_worker.h"
+#include "chrome/browser/sync/internal_api/sync_manager.h"
 #include "chrome/browser/sync/syncable/model_type.h"
 
 class MessageLoop;
 class Profile;
 
 namespace sync_api {
 struct UserShare;
 }  // namespace sync_api
 
 namespace browser_sync {
 
 class ChangeProcessor;
 class UIModelWorker;
 
-// A class to keep track of the workers and routing info for the
-// enabled sync types.
-class SyncBackendRegistrar : public ModelSafeWorkerRegistrar {
+// 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 ModelSafeWorkerRegistrar,

[akalin, 2011/09/16 02:20:20]

not sure if SyncBackendRegistrar is the best name for this class, now that it
also implements ChangeDelegate.  WDYT?

+                             public sync_api::SyncManager::ChangeDelegate {
  public:
   // |initial_types| contains the initial set of types to sync
   // (initially put in the passive group).  |name| is used for
   // debugging.  Does not take ownership of |profile| or |sync_loop|.
   // Must be created on the UI thread.
   SyncBackendRegistrar(const syncable::ModelTypeSet& initial_types,
                        const std::string& name,
                        Profile* profile,
                        MessageLoop* sync_loop);
 
@@ skipping 35 matching lines @@
   void ActivateDataType(syncable::ModelType type,
                         ModelSafeGroup group,
                         ChangeProcessor* change_processor,
                         sync_api::UserShare* user_share);
 
   // Deactivates the given type if necessary.  Must be called from the
   // UI thread and not |type|'s native thread.  Yes, this is
   // surprising: see http://crbug.com/92804.
   void DeactivateDataType(syncable::ModelType type);
 
-  // Returns the change processor for the given model, or NULL if none
-  // exists.  Must be called from |group|'s native thread.
-  ChangeProcessor* GetProcessor(syncable::ModelType type);
+  // Returns true only between calls to ActivateDataType(type, ...)
+  // and DeactivateDataType(type).  Used only by tests.
+  bool IsTypeActivatedForTest(syncable::ModelType type) const;
+
+  // SyncManager::ChangeDelegate implementation.  May be called from
+  // any thread.
+  virtual void OnChangesApplied(
+      syncable::ModelType model_type,
+      const sync_api::BaseTransaction* trans,
+      const sync_api::ImmutableChangeRecordList& changes) OVERRIDE;
+  virtual void OnChangesComplete(syncable::ModelType model_type) OVERRIDE;
 
   // ModelSafeWorkerRegistrar implementation.  May be called from any
   // thread.
   virtual void GetWorkers(
       std::vector<ModelSafeWorker*>* out) OVERRIDE;
   virtual void GetModelSafeRoutingInfo(ModelSafeRoutingInfo* out) OVERRIDE;
 
  private:
   typedef std::map<ModelSafeGroup,
                    scoped_refptr<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(syncable::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
   // any thread.
-  ChangeProcessor* GetProcessorUnsafe(syncable::ModelType type);
+  ChangeProcessor* GetProcessorUnsafe(syncable::ModelType type) const;
 
   // Return true if |model_type| lives on the current thread.  Must be
   // called with |lock_| held.  May be called on any thread.
   bool IsCurrentThreadSafeForModel(
       syncable::ModelType model_type) const;
 
   // Name used for debugging.
   const std::string name_;
 
   Profile* const profile_;
@@ skipping 22 matching lines @@
 
   // The change processors that handle the different data types.
   std::map<syncable::ModelType, ChangeProcessor*> processors_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncBackendRegistrar);
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_REGISTRAR_H_