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

chrome/browser/sync/internal_api/sync_manager.cc

 // 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.
 
 #include "chrome/browser/sync/internal_api/sync_manager.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/command_line.h"
+#include "base/compiler_specific.h"
 #include "base/json/json_writer.h"
+#include "base/memory/ref_counted.h"
+#include "base/observer_list.h"
+#include "base/observer_list_threadsafe.h"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/sync/engine/all_status.h"
 #include "chrome/browser/sync/engine/net/server_connection_manager.h"
 #include "chrome/browser/sync/engine/nigori_util.h"
 #include "chrome/browser/sync/engine/syncapi_internal.h"
 #include "chrome/browser/sync/engine/syncer_types.h"
 #include "chrome/browser/sync/engine/sync_scheduler.h"
 #include "chrome/browser/sync/internal_api/base_node.h"
 #include "chrome/browser/sync/internal_api/change_reorder_buffer.h"
@@ skipping 43 matching lines @@
 using browser_sync::ModelSafeRoutingInfo;
 using browser_sync::ServerConnectionEvent;
 using browser_sync::ServerConnectionEventListener;
 using browser_sync::SyncEngineEvent;
 using browser_sync::SyncEngineEventListener;
 using browser_sync::SyncScheduler;
 using browser_sync::Syncer;
 using browser_sync::WeakHandle;
 using browser_sync::sessions::SyncSessionContext;
 using syncable::DirectoryManager;
-using syncable::EntryKernelMutationMap;
+using syncable::ImmutableWriteTransactionInfo;
 using syncable::ModelType;
 using syncable::ModelTypeBitSet;
 using syncable::SPECIFICS;
 using sync_pb::GetUpdatesCallerInfo;
 
 typedef GoogleServiceAuthError AuthError;
 
 namespace {
 
 static const int kSyncSchedulerDelayMsec = 250;
@@ skipping 32 matching lines @@
       public JsBackend,
       public SyncEngineEventListener,
       public ServerConnectionEventListener,
       public syncable::DirectoryChangeDelegate {
   static const int kDefaultNudgeDelayMilliseconds;
   static const int kPreferencesNudgeDelayMilliseconds;
  public:
   explicit SyncInternal(const std::string& name)
       : name_(name),
         weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+        change_observers_(
+            new ObserverListThreadSafe<SyncManager::ChangeObserver>()),
         registrar_(NULL),
+        change_delegate_(NULL),
         initialized_(false),
         setup_for_test_mode_(false),
         observing_ip_address_changes_(false) {
     // Pre-fill |notification_info_map_|.
     for (int i = syncable::FIRST_REAL_MODEL_TYPE;
          i < syncable::MODEL_TYPE_COUNT; ++i) {
       notification_info_map_.insert(
           std::make_pair(syncable::ModelTypeFromInt(i), NotificationInfo()));
     }
 
@@ skipping 25 matching lines @@
     CHECK(!initialized_);
   }
 
   bool Init(const FilePath& database_location,
             const WeakHandle<JsEventHandler>& event_handler,
             const std::string& sync_server_and_path,
             int port,
             bool use_ssl,
             HttpPostProviderFactory* post_factory,
             ModelSafeWorkerRegistrar* model_safe_worker_registrar,
+            ChangeDelegate* change_delegate,
             const std::string& user_agent,
             const SyncCredentials& credentials,
             sync_notifier::SyncNotifier* sync_notifier,
             const std::string& restored_key_for_bootstrapping,
             bool setup_for_test_mode);
 
   // Sign into sync with given credentials.
   // We do not verify the tokens given. After this call, the tokens are set
   // and the sync DB is open. True if successful, false if something
   // went wrong.
@@ skipping 33 matching lines @@
 
   // Call periodically from a database-safe thread to persist recent changes
   // to the syncapi model.
   void SaveChanges();
 
   // DirectoryChangeDelegate implementation.
   // This listener is called upon completion of a syncable transaction, and
   // builds the list of sync-engine initiated changes that will be forwarded to
   // the SyncManager's Observers.
   virtual void HandleTransactionCompleteChangeEvent(
-      const ModelTypeBitSet& models_with_changes);
+      const ModelTypeBitSet& models_with_changes) OVERRIDE;
   virtual ModelTypeBitSet HandleTransactionEndingChangeEvent(
-      syncable::BaseTransaction* trans);
+      const ImmutableWriteTransactionInfo& write_transaction_info,
+      syncable::BaseTransaction* trans) OVERRIDE;
   virtual void HandleCalculateChangesChangeEventFromSyncApi(
-      const EntryKernelMutationMap& mutations,
-      syncable::BaseTransaction* trans);
+      const ImmutableWriteTransactionInfo& write_transaction_info,
+      syncable::BaseTransaction* trans) OVERRIDE;
   virtual void HandleCalculateChangesChangeEventFromSyncer(
-      const EntryKernelMutationMap& mutations,
-      syncable::BaseTransaction* trans);
+      const ImmutableWriteTransactionInfo& write_transaction_info,
+      syncable::BaseTransaction* trans) OVERRIDE;
 
   // Listens for notifications from the ServerConnectionManager
   void HandleServerConnectionEvent(const ServerConnectionEvent& event);
 
   // Open the directory named with username_for_share
   bool OpenDirectory();
 
   // SyncNotifierObserver implementation.
   virtual void OnNotificationStateChange(
-      bool notifications_enabled);
+      bool notifications_enabled) OVERRIDE;
 
   virtual void OnIncomingNotification(
-      const syncable::ModelTypePayloadMap& type_payloads);
+      const syncable::ModelTypePayloadMap& type_payloads) OVERRIDE;
 
-  virtual void StoreState(const std::string& cookie);
+  virtual void StoreState(const std::string& cookie) OVERRIDE;
 
-  // Thread-safe observers_ accessors.
-  void CopyObservers(ObserverList<SyncManager::Observer>* observers_copy);
-  bool HaveObservers() const;
+  void AddChangeObserver(SyncManager::ChangeObserver* observer);
+  void RemoveChangeObserver(SyncManager::ChangeObserver* observer);
+
   void AddObserver(SyncManager::Observer* observer);
   void RemoveObserver(SyncManager::Observer* observer);
 
   // Accessors for the private members.
   DirectoryManager* dir_manager() { return share_.dir_manager.get(); }
   SyncAPIServerConnectionManager* connection_manager() {
     return connection_manager_.get();
   }
   SyncScheduler* scheduler() { return scheduler_.get(); }
   UserShare* GetUserShare() {
@@ skipping 25 matching lines @@
   // |buffer|'s specifics field to contain the unencrypted data.
   void SetExtraChangeRecordData(int64 id,
                                 syncable::ModelType type,
                                 ChangeReorderBuffer* buffer,
                                 Cryptographer* cryptographer,
                                 const syncable::EntryKernel& original,
                                 bool existed_before,
                                 bool exists_now);
 
   // Called only by our NetworkChangeNotifier.
-  virtual void OnIPAddressChanged();
+  virtual void OnIPAddressChanged() OVERRIDE;
 
   bool InitialSyncEndedForAllEnabledTypes() {
     syncable::ModelTypeSet types;
     ModelSafeRoutingInfo enabled_types;
     registrar_->GetModelSafeRoutingInfo(&enabled_types);
     for (ModelSafeRoutingInfo::const_iterator i = enabled_types.begin();
         i != enabled_types.end(); ++i) {
       types.insert(i->first);
     }
 
     return InitialSyncEndedForTypes(types, &share_);
   }
 
   // SyncEngineEventListener implementation.
-  virtual void OnSyncEngineEvent(const SyncEngineEvent& event);
+  virtual void OnSyncEngineEvent(const SyncEngineEvent& event) OVERRIDE;
 
   // ServerConnectionEventListener implementation.
-  virtual void OnServerConnectionEvent(const ServerConnectionEvent& event);
+  virtual void OnServerConnectionEvent(
+      const ServerConnectionEvent& event) OVERRIDE;
 
   // JsBackend implementation.
   virtual void SetJsEventHandler(
       const WeakHandle<JsEventHandler>& event_handler) OVERRIDE;
   virtual void ProcessJsMessage(
       const std::string& name, const JsArgList& args,
       const WeakHandle<JsReplyHandler>& reply_handler) OVERRIDE;
 
  private:
   struct NotificationInfo {
@@ skipping 148 matching lines @@
   // we'd have another worker class which implements
   // HandleCalculateChangesChangeEventFromSyncApi() and we'd pass it a
   // WeakHandle when we construct it.
   WeakHandle<SyncInternal> weak_handle_this_;
 
   // We couple the DirectoryManager and username together in a UserShare member
   // so we can return a handle to share_ to clients of the API for use when
   // constructing any transaction type.
   UserShare share_;
 
-  // We have to lock around every observers_ access because it can get accessed
-  // from any thread and added to/removed from on the core thread.
-  mutable base::Lock observers_lock_;
+  // Even though observers are always added/removed from the sync
+  // thread, we still need to use a thread-safe observer list as we
+  // can notify from any thread.
+  scoped_refptr<ObserverListThreadSafe<SyncManager::ChangeObserver> >
+      change_observers_;
+
   ObserverList<SyncManager::Observer> observers_;
 
   // The ServerConnectionManager used to abstract communication between the
   // client (the Syncer) and the sync server.
   scoped_ptr<SyncAPIServerConnectionManager> connection_manager_;
 
   // The scheduler that runs the Syncer. Needs to be explicitly
   // Start()ed.
   scoped_ptr<SyncScheduler> scheduler_;
 
   // The SyncNotifier which notifies us when updates need to be downloaded.
   scoped_ptr<sync_notifier::SyncNotifier> sync_notifier_;
 
   // A multi-purpose status watch object that aggregates stats from various
   // sync components.
   AllStatus allstatus_;
 
   // Each element of this array is a store of change records produced by
   // HandleChangeEvent during the CALCULATE_CHANGES step.  The changes are
   // segregated by model type, and are stored here to be processed and
   // forwarded to the observer slightly later, at the TRANSACTION_ENDING
   // step by HandleTransactionEndingChangeEvent. The list is cleared in the
   // TRANSACTION_COMPLETE step by HandleTransactionCompleteChangeEvent.
   ChangeReorderBuffer change_buffers_[syncable::MODEL_TYPE_COUNT];
 
   // The entity that provides us with information about which types to sync.
   // The instance is shared between the SyncManager and the Syncer.
   ModelSafeWorkerRegistrar* registrar_;
 
+  SyncManager::ChangeDelegate* change_delegate_;
+
   // Set to true once Init has been called.
   bool initialized_;
 
   // True if the SyncManager should be running in test mode (no sync
   // scheduler actually communicating with the server).
   bool setup_for_test_mode_;
 
   // Whether we should respond to an IP address change notification.
   bool observing_ip_address_changes_;
 
   // Map used to store the notification info to be displayed in
   // about:sync page.
   NotificationInfoMap notification_info_map_;
 
   // These are for interacting with chrome://sync-internals.
   JsMessageHandlerMap js_message_handlers_;
   WeakHandle<JsEventHandler> js_event_handler_;
   JsSyncManagerObserver js_sync_manager_observer_;
   JsTransactionObserver js_transaction_observer_;
 };
 const int SyncManager::SyncInternal::kDefaultNudgeDelayMilliseconds = 200;
 const int SyncManager::SyncInternal::kPreferencesNudgeDelayMilliseconds = 2000;
 
+SyncManager::ChangeDelegate::~ChangeDelegate() {}
+
+SyncManager::ChangeObserver::~ChangeObserver() {}
+
 SyncManager::Observer::~Observer() {}
 
 SyncManager::SyncManager(const std::string& name)
     : data_(new SyncInternal(name)) {}
 
 SyncManager::Status::Status()
     : summary(INVALID),
       authenticated(false),
       server_up(false),
       server_reachable(false),
@@ skipping 25 matching lines @@
 }
 
 bool SyncManager::Init(
     const FilePath& database_location,
     const WeakHandle<JsEventHandler>& event_handler,
     const std::string& sync_server_and_path,
     int sync_server_port,
     bool use_ssl,
     HttpPostProviderFactory* post_factory,
     ModelSafeWorkerRegistrar* registrar,
+    ChangeDelegate* change_delegate,
     const std::string& user_agent,
     const SyncCredentials& credentials,
     sync_notifier::SyncNotifier* sync_notifier,
     const std::string& restored_key_for_bootstrapping,
     bool setup_for_test_mode) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(post_factory);
   VLOG(1) << "SyncManager starting Init...";
   string server_string(sync_server_and_path);
   return data_->Init(database_location,
                      event_handler,
                      server_string,
                      sync_server_port,
                      use_ssl,
                      post_factory,
                      registrar,
+                     change_delegate,
                      user_agent,
                      credentials,
                      sync_notifier,
                      restored_key_for_bootstrapping,
                      setup_for_test_mode);
 }
 
 void SyncManager::UpdateCredentials(const SyncCredentials& credentials) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   data_->UpdateCredentials(credentials);
 }
 
 void SyncManager::UpdateEnabledTypes() {
+  DCHECK(thread_checker_.CalledOnValidThread());
   data_->UpdateEnabledTypes();
 }
 
 void SyncManager::MaybeSetSyncTabsInNigoriNode(
     const syncable::ModelTypeSet enabled_types) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   data_->MaybeSetSyncTabsInNigoriNode(enabled_types);
 }
 
 bool SyncManager::InitialSyncEndedForAllEnabledTypes() {
   return data_->InitialSyncEndedForAllEnabledTypes();
 }
 
 void SyncManager::StartSyncingNormally() {
+  DCHECK(thread_checker_.CalledOnValidThread());
   data_->StartSyncingNormally();
 }
 
 void SyncManager::SetPassphrase(const std::string& passphrase,
      bool is_explicit) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   data_->SetPassphrase(passphrase, is_explicit);
 }
 
 void SyncManager::EnableEncryptEverything() {
+  DCHECK(thread_checker_.CalledOnValidThread());
   {
     // Update the cryptographer to know we're now encrypting everything.
     WriteTransaction trans(FROM_HERE, GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     // Only set encrypt everything if we know we can encrypt. This allows the
     // user to cancel encryption if they have forgotten their passphrase.
     if (cryptographer->is_ready())
       cryptographer->set_encrypt_everything();
   }
 
   // Call with empty set. Reads from cryptographer so will automatically encrypt
   // all datatypes and update the nigori node as necessary. Will trigger
   // OnPassphraseRequired if necessary.
   data_->EncryptDataTypes(syncable::ModelTypeSet());
 }
 
 bool SyncManager::EncryptEverythingEnabled() const {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   return trans.GetCryptographer()->encrypt_everything();
 }
 
 bool SyncManager::IsUsingExplicitPassphrase() {
   return data_ && data_->IsUsingExplicitPassphrase();
 }
 
 void SyncManager::RequestCleanupDisabledTypes() {
+  DCHECK(thread_checker_.CalledOnValidThread());
   if (data_->scheduler())
     data_->scheduler()->ScheduleCleanupDisabledTypes();
 }
 
 void SyncManager::RequestClearServerData() {
+  DCHECK(thread_checker_.CalledOnValidThread());
   if (data_->scheduler())
     data_->scheduler()->ScheduleClearUserData();
 }
 
 void SyncManager::RequestConfig(const syncable::ModelTypeBitSet& types,
     ConfigureReason reason) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   if (!data_->scheduler()) {
     LOG(INFO)
         << "SyncManager::RequestConfig: bailing out because scheduler is "
         << "null";
     return;
   }
   StartConfigurationMode(NULL);
   data_->scheduler()->ScheduleConfig(types, GetSourceFromReason(reason));
 }
 
 void SyncManager::StartConfigurationMode(ModeChangeCallback* callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   if (!data_->scheduler()) {
     LOG(INFO)
         << "SyncManager::StartConfigurationMode: could not start "
         << "configuration mode because because scheduler is null";
     return;
   }
   data_->scheduler()->Start(
       browser_sync::SyncScheduler::CONFIGURATION_MODE, callback);
 }
 
 const std::string& SyncManager::GetAuthenticatedUsername() {
   DCHECK(data_);
   return data_->username_for_share();
 }
 
 bool SyncManager::SyncInternal::Init(
     const FilePath& database_location,
     const WeakHandle<JsEventHandler>& event_handler,
     const std::string& sync_server_and_path,
     int port,
     bool use_ssl,
     HttpPostProviderFactory* post_factory,
     ModelSafeWorkerRegistrar* model_safe_worker_registrar,
+    ChangeDelegate* change_delegate,
     const std::string& user_agent,
     const SyncCredentials& credentials,
     sync_notifier::SyncNotifier* sync_notifier,
     const std::string& restored_key_for_bootstrapping,
     bool setup_for_test_mode) {
   CHECK(!initialized_);
 
   DCHECK(thread_checker_.CalledOnValidThread());
 
   VLOG(1) << "Starting SyncInternal initialization.";
 
   weak_handle_this_ = MakeWeakHandle(weak_ptr_factory_.GetWeakPtr());
 
   registrar_ = model_safe_worker_registrar;
+  change_delegate_ = change_delegate;
   setup_for_test_mode_ = setup_for_test_mode;
 
   sync_notifier_.reset(sync_notifier);
 
+  AddChangeObserver(&js_sync_manager_observer_);
   AddObserver(&js_sync_manager_observer_);
   SetJsEventHandler(event_handler);
 
   share_.dir_manager.reset(new DirectoryManager(database_location));
 
   connection_manager_.reset(new SyncAPIServerConnectionManager(
       sync_server_and_path, port, use_ssl, user_agent, post_factory));
 
   net::NetworkChangeNotifier::AddIPAddressObserver(this);
   observing_ip_address_changes_ = true;
@@ skipping 33 matching lines @@
 
     // The following calls check that initialized_ is true.
     BootstrapEncryption(restored_key_for_bootstrapping);
   }
 
   // Notify that initialization is complete. Note: This should be the last to
   // execute if |signed_in| is false. Reason being in that case we would
   // post a task to shutdown sync. But if this function posts any other tasks
   // on the UI thread and if shutdown wins then that tasks would execute on
   // a freed pointer. This is because UI thread is not shut down.
-  ObserverList<SyncManager::Observer> temp_obs_list;
-  CopyObservers(&temp_obs_list);
-  FOR_EACH_OBSERVER(SyncManager::Observer, temp_obs_list,
+  FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                     OnInitializationComplete(
                         WeakHandle<JsBackend>(weak_ptr_factory_.GetWeakPtr()),
                         signed_in));
 
   if (!signed_in && !setup_for_test_mode_)
     return false;
 
   sync_notifier_->AddObserver(this);
 
   return signed_in;
@@ skipping 24 matching lines @@
   Cryptographer* cryptographer = trans.GetCryptographer();
 
   WriteNode node(&trans);
   if (!node.InitByTagLookup(kNigoriTag)) {
     NOTREACHED();
     return false;
   }
   sync_pb::NigoriSpecifics nigori(node.GetNigoriSpecifics());
   Cryptographer::UpdateResult result = cryptographer->Update(nigori);
   if (result == Cryptographer::NEEDS_PASSPHRASE) {
-    ObserverList<SyncManager::Observer> temp_obs_list;
-    CopyObservers(&temp_obs_list);
-    FOR_EACH_OBSERVER(SyncManager::Observer, temp_obs_list,
+    FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                       OnPassphraseRequired(sync_api::REASON_DECRYPTION));
   }
 
   // Ensure the nigori node reflects the most recent set of sensitive types
   // and properly sets encrypt_everything. This is a no-op if nothing changes.
   cryptographer->UpdateNigoriFromEncryptedTypes(&nigori);
   node.SetNigoriSpecifics(nigori);
 
   allstatus_.SetCryptographerReady(cryptographer->is_ready());
   allstatus_.SetCryptoHasPendingKeys(cryptographer->has_pending_keys());
@@ skipping 116 matching lines @@
       return;
     }
 
     sync_pb::NigoriSpecifics specifics(node.GetNigoriSpecifics());
     specifics.set_sync_tabs(true);
     node.SetNigoriSpecifics(specifics);
   }
 }
 
 void SyncManager::SyncInternal::RaiseAuthNeededEvent() {
-  ObserverList<SyncManager::Observer> temp_obs_list;
-  CopyObservers(&temp_obs_list);
-  FOR_EACH_OBSERVER(SyncManager::Observer, temp_obs_list,
+  FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
       OnAuthError(AuthError(AuthError::INVALID_GAIA_CREDENTIALS)));
 }
 
 void SyncManager::SyncInternal::SetPassphrase(
     const std::string& passphrase, bool is_explicit) {
   // We do not accept empty passphrases.
   if (passphrase.empty()) {
     VLOG(1) << "Rejecting empty passphrase.";
-    ObserverList<SyncManager::Observer> temp_obs_list;
-    CopyObservers(&temp_obs_list);
-    FOR_EACH_OBSERVER(SyncManager::Observer, temp_obs_list,
+    FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
         OnPassphraseRequired(sync_api::REASON_SET_PASSPHRASE_FAILED));
     return;
   }
 
   // All accesses to the cryptographer are protected by a transaction.
   WriteTransaction trans(FROM_HERE, GetUserShare());
   Cryptographer* cryptographer = trans.GetCryptographer();
   KeyParams params = {"localhost", "dummy", passphrase};
 
   WriteNode node(&trans);
@@ skipping 16 matching lines @@
       } else {
         VLOG(1) << "Passphrase failed to decrypt pending keys.";
       }
     } else {
       VLOG(1) << "Not trying the passphrase because the explicit flags dont "
               << "match. Nigori node's explicit flag is "
               << node.GetNigoriSpecifics().using_explicit_passphrase();
     }
 
     if (!succeeded) {
-      ObserverList<SyncManager::Observer> temp_obs_list;
-      CopyObservers(&temp_obs_list);
-      FOR_EACH_OBSERVER(SyncManager::Observer, temp_obs_list,
+      FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
           OnPassphraseRequired(sync_api::REASON_SET_PASSPHRASE_FAILED));
       return;
     }
 
     // Nudge the syncer so that encrypted datatype updates that were waiting for
     // this passphrase get applied as soon as possible.
     RequestNudge(FROM_HERE);
   } else {
     VLOG(1) << "No pending keys, adding provided passphrase.";
 
@@ skipping 15 matching lines @@
     node.SetNigoriSpecifics(specifics);
   }
 
   // Does nothing if everything is already encrypted or the cryptographer has
   // pending keys.
   ReEncryptEverything(&trans);
 
   VLOG(1) << "Passphrase accepted, bootstrapping encryption.";
   std::string bootstrap_token;
   cryptographer->GetBootstrapToken(&bootstrap_token);
-  ObserverList<SyncManager::Observer> temp_obs_list;
-  CopyObservers(&temp_obs_list);
-  FOR_EACH_OBSERVER(SyncManager::Observer, temp_obs_list,
+  FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                     OnPassphraseAccepted(bootstrap_token));
 }
 
 bool SyncManager::SyncInternal::IsUsingExplicitPassphrase() {
   ReadTransaction trans(FROM_HERE, &share_);
   ReadNode node(&trans);
   if (!node.InitByTagLookup(kNigoriTag)) {
     // TODO(albertb): Plumb an UnrecoverableError all the way back to the PSS.
     NOTREACHED();
     return false;
@@ skipping 14 matching lines @@
     NOTREACHED() << "Unable to set encrypted datatypes because Nigori node not "
                  << "found.";
     return;
   }
 
   Cryptographer* cryptographer = trans.GetCryptographer();
 
   if (!cryptographer->is_ready()) {
     VLOG(1) << "Attempting to encrypt datatypes when cryptographer not "
             << "initialized, prompting for passphrase.";
-    ObserverList<SyncManager::Observer> temp_obs_list;
-    CopyObservers(&temp_obs_list);
     // TODO(zea): this isn't really decryption, but that's the only way we have
     // to prompt the user for a passsphrase. See http://crbug.com/91379.
-    FOR_EACH_OBSERVER(SyncManager::Observer, temp_obs_list,
+    FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                       OnPassphraseRequired(sync_api::REASON_DECRYPTION));
     return;
   }
 
   // Update the Nigori node's set of encrypted datatypes.
   // Note, we merge the current encrypted types with those requested. Once a
   // datatypes is marked as needing encryption, it is never unmarked.
   cryptographer->SetEncryptedTypes(encrypted_types);
   sync_pb::NigoriSpecifics nigori;
   nigori.CopyFrom(node.GetNigoriSpecifics());
@@ skipping 71 matching lines @@
         if (!child.InitByIdLookup(child_id)) {
           NOTREACHED();
           return;
         }
         child.SetPasswordSpecifics(child.GetPasswordSpecifics());
         child_id = child.GetSuccessorId();
       }
     }
   }
 
-  ObserverList<SyncManager::Observer> temp_obs_list;
-  CopyObservers(&temp_obs_list);
-  FOR_EACH_OBSERVER(SyncManager::Observer, temp_obs_list,
+  FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                     OnEncryptionComplete(encrypted_types));
 }
 
 SyncManager::~SyncManager() {
+  DCHECK(thread_checker_.CalledOnValidThread());
   delete data_;
 }
 
+void SyncManager::AddChangeObserver(ChangeObserver* observer) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  data_->AddChangeObserver(observer);
+}
+
+void SyncManager::RemoveChangeObserver(ChangeObserver* observer) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  data_->RemoveChangeObserver(observer);
+}
+
 void SyncManager::AddObserver(Observer* observer) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   data_->AddObserver(observer);
 }
 
 void SyncManager::RemoveObserver(Observer* observer) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   data_->RemoveObserver(observer);
 }
 
 void SyncManager::RequestEarlyExit() {
   data_->RequestEarlyExit();
 }
 
 void SyncManager::SyncInternal::RequestEarlyExit() {
   if (scheduler()) {
     scheduler()->RequestEarlyExit();
   }
 
   if (connection_manager_.get()) {
     connection_manager_->TerminateAllIO();
   }
 }
 
 void SyncManager::Shutdown() {
+  DCHECK(thread_checker_.CalledOnValidThread());
   data_->Shutdown();
 }
 
 void SyncManager::SyncInternal::Shutdown() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Prevent any in-flight method calls from running.  Also
   // invalidates |weak_handle_this_|.
   weak_ptr_factory_.InvalidateWeakPtrs();
 
   // Automatically stops the scheduler.
   scheduler_.reset();
 
   SetJsEventHandler(WeakHandle<JsEventHandler>());
+  RemoveChangeObserver(&js_sync_manager_observer_);
   RemoveObserver(&js_sync_manager_observer_);
 
   if (sync_notifier_.get()) {
     sync_notifier_->RemoveObserver(this);
   }
   sync_notifier_.reset();
 
   if (connection_manager_.get()) {
     connection_manager_->RemoveListener(this);
   }
@@ skipping 11 matching lines @@
     }
     dir_manager()->FinalSaveChangesForAll();
     dir_manager()->Close(username_for_share());
   }
 
   // Reset the DirectoryManager and UserSettings so they relinquish sqlite
   // handles to backing files.
   share_.dir_manager.reset();
 
   setup_for_test_mode_ = false;
+  change_delegate_ = NULL;
   registrar_ = NULL;
 
   initialized_ = false;
 
   // We reset this here, since only now we know it will not be
   // accessed from other threads (since we shut down everything).
   weak_handle_this_.Reset();
 }
 
 void SyncManager::SyncInternal::OnIPAddressChanged() {
@@ skipping 21 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   CheckServerReachable();
 }
 
 void SyncManager::SyncInternal::OnServerConnectionEvent(
     const ServerConnectionEvent& event) {
   DCHECK(thread_checker_.CalledOnValidThread());
   allstatus_.HandleServerConnectionEvent(event);
   if (event.connection_code ==
       browser_sync::HttpResponse::SERVER_CONNECTION_OK) {
-    ObserverList<SyncManager::Observer> temp_obs_list;
-    CopyObservers(&temp_obs_list);
-    FOR_EACH_OBSERVER(SyncManager::Observer, temp_obs_list,
+    FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                       OnAuthError(AuthError::None()));
   }
 
   if (event.connection_code == browser_sync::HttpResponse::SYNC_AUTH_ERROR) {
     observing_ip_address_changes_ = false;
-    ObserverList<SyncManager::Observer> temp_obs_list;
-    CopyObservers(&temp_obs_list);
-    FOR_EACH_OBSERVER(SyncManager::Observer, temp_obs_list,
+    FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
         OnAuthError(AuthError(AuthError::INVALID_GAIA_CREDENTIALS)));
   }
 
   if (event.connection_code ==
       browser_sync::HttpResponse::SYNC_SERVER_ERROR) {
-    ObserverList<SyncManager::Observer> temp_obs_list;
-    CopyObservers(&temp_obs_list);
-    FOR_EACH_OBSERVER(SyncManager::Observer, temp_obs_list,
+    FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
         OnAuthError(AuthError(AuthError::CONNECTION_FAILED)));
   }
 }
 
 void SyncManager::SyncInternal::HandleTransactionCompleteChangeEvent(
     const syncable::ModelTypeBitSet& models_with_changes) {
   // This notification happens immediately after the transaction mutex is
   // released. This allows work to be performed without blocking other threads
   // from acquiring a transaction.
-  if (!HaveObservers())
+  if (!change_delegate_)
     return;
 
   // Call commit.
   for (int i = 0; i < syncable::MODEL_TYPE_COUNT; ++i) {
-    if (models_with_changes.test(i)) {
-      ObserverList<SyncManager::Observer> temp_obs_list;
-      CopyObservers(&temp_obs_list);
-      FOR_EACH_OBSERVER(SyncManager::Observer, temp_obs_list,
-                        OnChangesComplete(syncable::ModelTypeFromInt(i)));
+    const syncable::ModelType type = syncable::ModelTypeFromInt(i);
+    if (models_with_changes.test(type)) {
+      change_delegate_->OnChangesComplete(type);
+      change_observers_->Notify(
+          &SyncManager::ChangeObserver::OnChangesComplete, type);
     }
   }
 }
 
 ModelTypeBitSet SyncManager::SyncInternal::HandleTransactionEndingChangeEvent(
+    const ImmutableWriteTransactionInfo& write_transaction_info,
     syncable::BaseTransaction* trans) {
   // This notification happens immediately before a syncable WriteTransaction
   // falls out of scope. It happens while the channel mutex is still held,
   // and while the transaction mutex is held, so it cannot be re-entrant.
-  if (!HaveObservers() || ChangeBuffersAreEmpty())
+  if (!change_delegate_ || ChangeBuffersAreEmpty())
     return ModelTypeBitSet();
 
   // This will continue the WriteTransaction using a read only wrapper.
   // This is the last chance for read to occur in the WriteTransaction
   // that's closing. This special ReadTransaction will not close the
   // underlying transaction.
   ReadTransaction read_trans(GetUserShare(), trans);
 
   syncable::ModelTypeBitSet models_with_changes;
-  for (int i = 0; i < syncable::MODEL_TYPE_COUNT; ++i) {
-    if (change_buffers_[i].IsEmpty())
+  for (int i = syncable::FIRST_REAL_MODEL_TYPE;
+       i < syncable::MODEL_TYPE_COUNT; ++i) {
+    const syncable::ModelType type = syncable::ModelTypeFromInt(i);
+    if (change_buffers_[type].IsEmpty())
       continue;
 
     ImmutableChangeRecordList ordered_changes =
-        change_buffers_[i].GetAllChangesInTreeOrder(&read_trans);
+        change_buffers_[type].GetAllChangesInTreeOrder(&read_trans);
     if (!ordered_changes.Get().empty()) {
-      ObserverList<SyncManager::Observer> temp_obs_list;
-      CopyObservers(&temp_obs_list);
-      FOR_EACH_OBSERVER(SyncManager::Observer, temp_obs_list,
-                        OnChangesApplied(syncable::ModelTypeFromInt(i),
-                                         &read_trans, ordered_changes));
+      change_delegate_->
+          OnChangesApplied(type, &read_trans, ordered_changes);
+      change_observers_->Notify(
+          &SyncManager::ChangeObserver::OnChangesApplied,
+          type, write_transaction_info.Get().id, ordered_changes);
       models_with_changes.set(i, true);
     }
     change_buffers_[i].Clear();
   }
   return models_with_changes;
 }
 
 void SyncManager::SyncInternal::HandleCalculateChangesChangeEventFromSyncApi(
-    const EntryKernelMutationMap& mutations,
+    const ImmutableWriteTransactionInfo& write_transaction_info,
     syncable::BaseTransaction* trans) {
   if (!scheduler()) {
     return;
   }
 
   // We have been notified about a user action changing a sync model.
   LOG_IF(WARNING, !ChangeBuffersAreEmpty()) <<
       "CALCULATE_CHANGES called with unapplied old changes.";
 
   // The mutated model type, or UNSPECIFIED if nothing was mutated.
   syncable::ModelType mutated_model_type = syncable::UNSPECIFIED;
 
   // Find the first real mutation.  We assume that only a single model
   // type is mutated per transaction.
+  const syncable::ImmutableEntryKernelMutationMap& mutations =
+      write_transaction_info.Get().mutations;
   for (syncable::EntryKernelMutationMap::const_iterator it =
-           mutations.begin(); it != mutations.end(); ++it) {
+           mutations.Get().begin(); it != mutations.Get().end(); ++it) {
     if (!it->second.mutated.ref(syncable::IS_UNSYNCED)) {
       continue;
     }
 
     syncable::ModelType model_type =
         syncable::GetModelTypeFromSpecifics(
             it->second.mutated.ref(SPECIFICS));
     if (model_type < syncable::FIRST_REAL_MODEL_TYPE) {
       NOTREACHED() << "Permanent or underspecified item changed via syncapi.";
       continue;
@@ skipping 43 matching lines @@
       if (!cryptographer->Decrypt(encrypted, &original_specifics)) {
         NOTREACHED();
         return;
       }
     }
     buffer->SetSpecificsForId(id, original_specifics);
   }
 }
 
 void SyncManager::SyncInternal::HandleCalculateChangesChangeEventFromSyncer(
-    const EntryKernelMutationMap& mutations,
+    const ImmutableWriteTransactionInfo& write_transaction_info,
     syncable::BaseTransaction* trans) {
   // We only expect one notification per sync step, so change_buffers_ should
   // contain no pending entries.
   LOG_IF(WARNING, !ChangeBuffersAreEmpty()) <<
       "CALCULATE_CHANGES called with unapplied old changes.";
 
   Cryptographer* crypto = dir_manager()->GetCryptographer(trans);
+  const syncable::ImmutableEntryKernelMutationMap& mutations =
+      write_transaction_info.Get().mutations;
   for (syncable::EntryKernelMutationMap::const_iterator it =
-           mutations.begin(); it != mutations.end(); ++it) {
+           mutations.Get().begin(); it != mutations.Get().end(); ++it) {
     bool existed_before = !it->second.original.ref(syncable::IS_DEL);
     bool exists_now = !it->second.mutated.ref(syncable::IS_DEL);
 
     // Omit items that aren't associated with a model.
     syncable::ModelType type =
         syncable::GetModelTypeFromSpecifics(
             it->second.mutated.ref(SPECIFICS));
     if (type < syncable::FIRST_REAL_MODEL_TYPE)
       continue;
 
@@ skipping 50 matching lines @@
   types.set(type);
   scheduler()->ScheduleNudge(nudge_delay,
                              browser_sync::NUDGE_SOURCE_LOCAL,
                              types,
                              nudge_location);
 }
 
 void SyncManager::SyncInternal::OnSyncEngineEvent(
     const SyncEngineEvent& event) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (!HaveObservers()) {
-    LOG(INFO)
-        << "OnSyncEngineEvent returning because observers_.size() is zero";
-    return;
-  }
-
   // Only send an event if this is due to a cycle ending and this cycle
   // concludes a canonical "sync" process; that is, based on what is known
   // locally we are "all happy" and up-to-date.  There may be new changes on
   // the server, but we'll get them on a subsequent sync.
   //
   // Notifications are sent at the end of every sync cycle, regardless of
   // whether we should sync again.
   if (event.what_happened == SyncEngineEvent::SYNC_CYCLE_ENDED) {
     ModelSafeRoutingInfo enabled_types;
     registrar_->GetModelSafeRoutingInfo(&enabled_types);
     {
       // Check to see if we need to notify the frontend that we have newly
       // encrypted types or that we require a passphrase.
       sync_api::ReadTransaction trans(FROM_HERE, GetUserShare());
       Cryptographer* cryptographer = trans.GetCryptographer();
       // If we've completed a sync cycle and the cryptographer isn't ready
       // yet, prompt the user for a passphrase.
       if (cryptographer->has_pending_keys()) {
         VLOG(1) << "OnPassPhraseRequired Sent";
-        ObserverList<SyncManager::Observer> temp_obs_list;
-        CopyObservers(&temp_obs_list);
-        FOR_EACH_OBSERVER(SyncManager::Observer, temp_obs_list,
+        FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                           OnPassphraseRequired(sync_api::REASON_DECRYPTION));
       } else if (!cryptographer->is_ready() &&
                  event.snapshot->initial_sync_ended.test(syncable::NIGORI)) {
         VLOG(1) << "OnPassphraseRequired sent because cryptographer is not "
                 << "ready";
-        ObserverList<SyncManager::Observer> temp_obs_list;
-        CopyObservers(&temp_obs_list);
-        FOR_EACH_OBSERVER(SyncManager::Observer, temp_obs_list,
+        FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                           OnPassphraseRequired(sync_api::REASON_ENCRYPTION));
       }
 
       allstatus_.SetCryptographerReady(cryptographer->is_ready());
       allstatus_.SetCryptoHasPendingKeys(cryptographer->has_pending_keys());
       allstatus_.SetEncryptedTypes(cryptographer->GetEncryptedTypes());
 
       // If everything is in order(we have the passphrase) then there is no
       // need to inform the listeners. They will just wait for sync
       // completion event and if no errors have been raised it means
       // encryption was succesful.
     }
 
     if (!initialized_) {
       LOG(INFO) << "OnSyncCycleCompleted not sent because sync api is not "
                 << "initialized";
       return;
     }
 
     if (!event.snapshot->has_more_to_sync) {
       VLOG(1) << "OnSyncCycleCompleted sent";
-      ObserverList<SyncManager::Observer> temp_obs_list;
-      CopyObservers(&temp_obs_list);
-      FOR_EACH_OBSERVER(SyncManager::Observer, temp_obs_list,
+      FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                         OnSyncCycleCompleted(event.snapshot));
     }
 
     // This is here for tests, which are still using p2p notifications.
     //
     // TODO(chron): Consider changing this back to track has_more_to_sync
     // only notify peers if a successful commit has occurred.
     bool is_notifiable_commit =
         (event.snapshot->syncer_status.num_successful_commits > 0);
     if (is_notifiable_commit) {
       allstatus_.IncrementNotifiableCommits();
       if (sync_notifier_.get()) {
         const syncable::ModelTypeSet& changed_types =
             syncable::ModelTypePayloadMapToSet(event.snapshot->source.types);
         sync_notifier_->SendNotification(changed_types);
       } else {
         VLOG(1) << "Not sending notification: sync_notifier_ is NULL";
       }
     }
   }
 
   if (event.what_happened == SyncEngineEvent::STOP_SYNCING_PERMANENTLY) {
-    ObserverList<SyncManager::Observer> temp_obs_list;
-    CopyObservers(&temp_obs_list);
-    FOR_EACH_OBSERVER(SyncManager::Observer, temp_obs_list,
+    FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                       OnStopSyncingPermanently());
     return;
   }
 
   if (event.what_happened == SyncEngineEvent::CLEAR_SERVER_DATA_SUCCEEDED) {
-    ObserverList<SyncManager::Observer> temp_obs_list;
-    CopyObservers(&temp_obs_list);
-    FOR_EACH_OBSERVER(SyncManager::Observer, temp_obs_list,
+    FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                       OnClearServerDataSucceeded());
     return;
   }
 
   if (event.what_happened == SyncEngineEvent::CLEAR_SERVER_DATA_FAILED) {
-    ObserverList<SyncManager::Observer> temp_obs_list;
-    CopyObservers(&temp_obs_list);
-    FOR_EACH_OBSERVER(SyncManager::Observer, temp_obs_list,
+    FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                       OnClearServerDataFailed());
     return;
   }
 
   if (event.what_happened == SyncEngineEvent::UPDATED_TOKEN) {
-    ObserverList<SyncManager::Observer> temp_obs_list;
-    CopyObservers(&temp_obs_list);
-    FOR_EACH_OBSERVER(SyncManager::Observer, temp_obs_list,
+    FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                       OnUpdatedToken(event.updated_token));
     return;
   }
 
   if (event.what_happened == SyncEngineEvent::ACTIONABLE_ERROR) {
-    ObserverList<SyncManager::Observer> temp_obs_list;
-    CopyObservers(&temp_obs_list);
-    FOR_EACH_OBSERVER(SyncManager::Observer, temp_obs_list,
+    FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                       OnActionableError(
                           event.snapshot->errors.sync_protocol_error));
     return;
   }
 
 }
 
 void SyncManager::SyncInternal::SetJsEventHandler(
     const WeakHandle<JsEventHandler>& event_handler) {
   js_event_handler_ = event_handler;
@@ skipping 250 matching lines @@
   }
   if (VLOG_IS_ON(1)) {
     std::string encoded_state;
     base::Base64Encode(state, &encoded_state);
     VLOG(1) << "Writing notification state: " << encoded_state;
   }
   lookup->SetNotificationState(state);
   lookup->SaveChanges();
 }
 
-// Note: it is possible that an observer will remove itself after we have made
-// a copy, but before the copy is consumed. This could theoretically result
-// in accessing a garbage pointer, but can only occur when an about:sync window
-// is closed in the middle of a notification.
-// See crbug.com/85481.
-void SyncManager::SyncInternal::CopyObservers(
-    ObserverList<SyncManager::Observer>* observers_copy) {
-  DCHECK_EQ(0U, observers_copy->size());
-  base::AutoLock lock(observers_lock_);
-  if (observers_.size() == 0)
-    return;
-  ObserverListBase<SyncManager::Observer>::Iterator it(observers_);
-  SyncManager::Observer* obs;
-  while ((obs = it.GetNext()) != NULL)
-    observers_copy->AddObserver(obs);
+void SyncManager::SyncInternal::AddChangeObserver(
+    SyncManager::ChangeObserver* observer) {
+  change_observers_->AddObserver(observer);
 }
 
-bool SyncManager::SyncInternal::HaveObservers() const {
-  base::AutoLock lock(observers_lock_);
-  return observers_.size() > 0;
+void SyncManager::SyncInternal::RemoveChangeObserver(
+    SyncManager::ChangeObserver* observer) {
+  change_observers_->RemoveObserver(observer);
 }
 
 void SyncManager::SyncInternal::AddObserver(
     SyncManager::Observer* observer) {
-  base::AutoLock lock(observers_lock_);
   observers_.AddObserver(observer);
 }
 
 void SyncManager::SyncInternal::RemoveObserver(
     SyncManager::Observer* observer) {
-  base::AutoLock lock(observers_lock_);
   observers_.RemoveObserver(observer);
 }
 
 SyncManager::Status::Summary SyncManager::GetStatusSummary() const {
   return data_->GetStatus().summary;
 }
 
 SyncManager::Status SyncManager::GetDetailedStatus() const {
   return data_->GetStatus();
 }
 
-SyncManager::SyncInternal* SyncManager::GetImpl() const { return data_; }
-
 void SyncManager::SaveChanges() {
+  DCHECK(thread_checker_.CalledOnValidThread());
   data_->SaveChanges();
 }
 
 void SyncManager::SyncInternal::SaveChanges() {
   syncable::ScopedDirLookup lookup(dir_manager(), username_for_share());
   if (!lookup.good()) {
     DCHECK(false) << "ScopedDirLookup creation failed; Unable to SaveChanges";
     return;
   }
   lookup->SaveChanges();
 }
 
 UserShare* SyncManager::GetUserShare() const {
   return data_->GetUserShare();
 }
 
 void SyncManager::RefreshEncryption() {
+  DCHECK(thread_checker_.CalledOnValidThread());
   if (data_->UpdateCryptographerFromNigori())
     data_->EncryptDataTypes(syncable::ModelTypeSet());
 }
 
 syncable::ModelTypeSet SyncManager::GetEncryptedDataTypes() const {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   return GetEncryptedTypes(&trans);
 }
 
 bool SyncManager::ReceivedExperimentalTypes(syncable::ModelTypeSet* to_add)
     const {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   ReadNode node(&trans);
   if (!node.InitByTagLookup(kNigoriTag)) {
     VLOG(1) << "Couldn't find Nigori node.";
     return false;
   }
   if (node.GetNigoriSpecifics().sync_tabs()) {
     to_add->insert(syncable::SESSIONS);
     return true;
   }
   return false;
 }
 
 bool SyncManager::HasUnsyncedItems() const {
   sync_api::ReadTransaction trans(FROM_HERE, GetUserShare());
   return (trans.GetWrappedTrans()->directory()->unsynced_entity_count() != 0);
 }
 
-void SyncManager::LogUnsyncedItems(int level) const {
-  std::vector<int64> unsynced_handles;
-  sync_api::ReadTransaction trans(FROM_HERE, GetUserShare());
-  trans.GetWrappedTrans()->directory()->GetUnsyncedMetaHandles(
-      trans.GetWrappedTrans(), &unsynced_handles);
-
-  for (std::vector<int64>::const_iterator it = unsynced_handles.begin();
-       it != unsynced_handles.end(); ++it) {
-    ReadNode node(&trans);
-    if (node.InitByIdLookup(*it)) {
-      scoped_ptr<DictionaryValue> value(node.GetDetailsAsValue());
-      std::string info;
-      base::JSONWriter::Write(value.get(), true, &info);
-      VLOG(level) << info;
-    }
-  }
-}
-
 void SyncManager::TriggerOnNotificationStateChangeForTest(
     bool notifications_enabled) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   data_->OnNotificationStateChange(notifications_enabled);
 }
 
 void SyncManager::TriggerOnIncomingNotificationForTest(
     const syncable::ModelTypeBitSet& model_types) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   syncable::ModelTypePayloadMap model_types_with_payloads =
       syncable::ModelTypePayloadMapFromBitSet(model_types,
           std::string());
 
   data_->OnIncomingNotification(model_types_with_payloads);
 }
 
 // Helper function that converts a PassphraseRequiredReason value to a string.
 std::string PassphraseRequiredReasonToString(
     PassphraseRequiredReason reason) {
@@ skipping 24 matching lines @@
 
   for (syncable::ModelTypeSet::const_iterator i = types.begin();
        i != types.end(); ++i) {
     if (!lookup->initial_sync_ended_for_type(*i))
       return false;
   }
   return true;
 }
 
 }  // namespace sync_api