[Sync] Split DirectoryChangeListener for thread-safety

chrome/browser/sync/engine/syncapi.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/engine/syncapi.h"
 
 #include <algorithm>
 #include <bitset>
 #include <iomanip>
 #include <list>
@@ skipping 10 matching lines @@
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/observer_list.h"
 #include "base/sha1.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/task.h"
 #include "base/time.h"
+#include "base/tracked.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/sync/engine/all_status.h"
 #include "chrome/browser/sync/engine/change_reorder_buffer.h"
 #include "chrome/browser/sync/engine/model_safe_worker.h"
 #include "chrome/browser/sync/engine/nudge_source.h"
 #include "chrome/browser/sync/engine/net/server_connection_manager.h"
 #include "chrome/browser/sync/engine/net/syncapi_server_connection_manager.h"
 #include "chrome/browser/sync/engine/sync_scheduler.h"
 #include "chrome/browser/sync/engine/syncer.h"
 #include "chrome/browser/sync/engine/http_post_provider_factory.h"
 #include "chrome/browser/sync/js_arg_list.h"
 #include "chrome/browser/sync/js_backend.h"
-#include "chrome/browser/sync/js_directory_change_listener.h"
+#include "chrome/browser/sync/js_transaction_observer.h"
 #include "chrome/browser/sync/js_event_details.h"
 #include "chrome/browser/sync/js_event_router.h"
 #include "chrome/browser/sync/notifier/sync_notifier.h"
 #include "chrome/browser/sync/notifier/sync_notifier_observer.h"
 #include "chrome/browser/sync/protocol/app_specifics.pb.h"
 #include "chrome/browser/sync/protocol/autofill_specifics.pb.h"
 #include "chrome/browser/sync/protocol/bookmark_specifics.pb.h"
 #include "chrome/browser/sync/protocol/extension_specifics.pb.h"
 #include "chrome/browser/sync/protocol/nigori_specifics.pb.h"
 #include "chrome/browser/sync/protocol/preference_specifics.pb.h"
 #include "chrome/browser/sync/protocol/proto_value_conversions.h"
 #include "chrome/browser/sync/protocol/service_constants.h"
 #include "chrome/browser/sync/protocol/session_specifics.pb.h"
 #include "chrome/browser/sync/protocol/sync.pb.h"
 #include "chrome/browser/sync/protocol/theme_specifics.pb.h"
 #include "chrome/browser/sync/protocol/typed_url_specifics.pb.h"
 #include "chrome/browser/sync/sessions/sync_session.h"
 #include "chrome/browser/sync/sessions/sync_session_context.h"
 #include "chrome/browser/sync/syncable/autofill_migration.h"
-#include "chrome/browser/sync/syncable/directory_change_listener.h"
+#include "chrome/browser/sync/syncable/directory_change_delegate.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/browser/sync/syncable/model_type_payload_map.h"
 #include "chrome/browser/sync/syncable/model_type.h"
 #include "chrome/browser/sync/syncable/nigori_util.h"
 #include "chrome/browser/sync/syncable/syncable.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/deprecated/event_sys.h"
 #include "chrome/common/net/gaia/gaia_authenticator.h"
-#include "content/browser/browser_thread.h"
 #include "net/base/network_change_notifier.h"
 
 using base::TimeDelta;
 using browser_sync::AllStatus;
 using browser_sync::Cryptographer;
 using browser_sync::KeyParams;
 using browser_sync::ModelSafeRoutingInfo;
 using browser_sync::ModelSafeWorker;
 using browser_sync::ModelSafeWorkerRegistrar;
 using browser_sync::ServerConnectionEvent;
@@ skipping 877 matching lines @@
       << "SyncAPI InitByTagLookup referencing unusually typed object.";
   return DecryptIfNecessary();
 }
 
 //////////////////////////////////////////////////////////////////////////
 // ReadTransaction member definitions
 ReadTransaction::ReadTransaction(UserShare* share)
     : BaseTransaction(share),
       transaction_(NULL),
       close_transaction_(true) {
-  transaction_ = new syncable::ReadTransaction(GetLookup(), __FILE__, __LINE__);
+  transaction_ = new syncable::ReadTransaction(GetLookup(), FROM_HERE);
 }
 
 ReadTransaction::ReadTransaction(UserShare* share,
                                  syncable::BaseTransaction* trans)
     : BaseTransaction(share),
       transaction_(trans),
       close_transaction_(false) {}
 
 ReadTransaction::~ReadTransaction() {
   if (close_transaction_) {
     delete transaction_;
   }
 }
 
 syncable::BaseTransaction* ReadTransaction::GetWrappedTrans() const {
   return transaction_;
 }
 
 //////////////////////////////////////////////////////////////////////////
 // WriteTransaction member definitions
 WriteTransaction::WriteTransaction(UserShare* share)
     : BaseTransaction(share),
       transaction_(NULL) {
   transaction_ = new syncable::WriteTransaction(GetLookup(), syncable::SYNCAPI,
-                                                __FILE__, __LINE__);
+                                                FROM_HERE);
 }
 
 WriteTransaction::~WriteTransaction() {
   delete transaction_;
 }
 
 syncable::BaseTransaction* WriteTransaction::GetWrappedTrans() const {
   return transaction_;
 }
 
@@ skipping 110 matching lines @@
 
 //////////////////////////////////////////////////////////////////////////
 // SyncManager's implementation: SyncManager::SyncInternal
 class SyncManager::SyncInternal
     : public net::NetworkChangeNotifier::IPAddressObserver,
       public sync_notifier::SyncNotifierObserver,
       public browser_sync::JsBackend,
       public browser_sync::JsEventRouter,
       public SyncEngineEventListener,
       public ServerConnectionEventListener,
-      public syncable::DirectoryChangeListener {
+      public syncable::DirectoryChangeDelegate {
   static const int kDefaultNudgeDelayMilliseconds;
   static const int kPreferencesNudgeDelayMilliseconds;
  public:
   SyncInternal(const std::string& name, SyncManager* sync_manager)
       : name_(name),
         sync_loop_(NULL),
         parent_router_(NULL),
         sync_manager_(sync_manager),
         registrar_(NULL),
         initialized_(false),
         method_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
-        js_directory_change_listener_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+        js_transaction_observer_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
     // 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()));
     }
 
     // Bind message handlers.
     BindJsMessageHandler(
         "getNotificationState",
@@ skipping 13 matching lines @@
     BindJsMessageHandler(
         "getChildNodeIds",
         &SyncManager::SyncInternal::GetChildNodeIds);
     BindJsMessageHandler(
         "findNodesContainingString",
         &SyncManager::SyncInternal::FindNodesContainingString);
   }
 
   virtual ~SyncInternal() {
     CHECK(!sync_loop_);
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   }
 
   bool Init(const FilePath& database_location,
             const std::string& sync_server_and_path,
             int port,
             bool use_ssl,
             HttpPostProviderFactory* post_factory,
             ModelSafeWorkerRegistrar* model_safe_worker_registrar,
             const char* user_agent,
             const SyncCredentials& credentials,
@@ skipping 32 matching lines @@
 
   // Try to set the current passphrase to |passphrase|, and record whether
   // it is an explicit passphrase or implicitly using gaia in the Nigori
   // node.
   void SetPassphrase(const std::string& passphrase, bool is_explicit);
 
   // Call periodically from a database-safe thread to persist recent changes
   // to the syncapi model.
   void SaveChanges();
 
-  // DirectoryChangeListener implementation.
+  // 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);
   virtual ModelTypeBitSet HandleTransactionEndingChangeEvent(
       syncable::BaseTransaction* trans);
   virtual void HandleCalculateChangesChangeEventFromSyncApi(
       const OriginalEntries& originals,
-      const WriterTag& writer,
       syncable::BaseTransaction* trans);
   virtual void HandleCalculateChangesChangeEventFromSyncer(
       const OriginalEntries& originals,
-      const WriterTag& writer,
       syncable::BaseTransaction* trans);
 
   // 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(
@@ skipping 334 matching lines @@
   // True if the SyncManager should be running in test mode (no sync
   // scheduler actually communicating with the server).
   bool setup_for_test_mode_;
 
   ScopedRunnableMethodFactory<SyncManager::SyncInternal> method_factory_;
 
   // Map used to store the notification info to be displayed in
   // about:sync page.
   NotificationInfoMap notification_info_map_;
 
-  browser_sync::JsDirectoryChangeListener js_directory_change_listener_;
+  browser_sync::JsTransactionObserver js_transaction_observer_;
 
   JsMessageHandlerMap js_message_handlers_;
 };
 const int SyncManager::SyncInternal::kDefaultNudgeDelayMilliseconds = 200;
 const int SyncManager::SyncInternal::kPreferencesNudgeDelayMilliseconds = 2000;
 
 SyncManager::Observer::~Observer() {}
 
 SyncManager::SyncManager(const std::string& name)
     : data_(new SyncInternal(name, ALLOW_THIS_IN_INITIALIZER_LIST(this))) {}
@@ skipping 237 matching lines @@
   // Start the sync scheduler. This won't actually result in any
   // syncing until at least the DirectoryManager broadcasts the OPENED
   // event, and a valid server connection is detected.
   if (scheduler())  // NULL during certain unittests.
     scheduler()->Start(SyncScheduler::NORMAL_MODE, NULL);
 }
 
 bool SyncManager::SyncInternal::OpenDirectory() {
   DCHECK(!initialized_) << "Should only happen once";
 
-  bool share_opened = dir_manager()->Open(username_for_share());
+  bool share_opened = dir_manager()->Open(username_for_share(), this);
   DCHECK(share_opened);
   if (!share_opened) {
     ObserverList<SyncManager::Observer> temp_obs_list;
     CopyObservers(&temp_obs_list);
     FOR_EACH_OBSERVER(SyncManager::Observer, temp_obs_list,
                       OnStopSyncingPermanently());
 
     LOG(ERROR) << "Could not open share for:" << username_for_share();
     return false;
   }
 
   // Database has to be initialized for the guid to be available.
   syncable::ScopedDirLookup lookup(dir_manager(), username_for_share());
   if (!lookup.good()) {
     NOTREACHED();
     return false;
   }
 
   connection_manager()->set_client_id(lookup->cache_guid());
 
-  // Since we own |share_|, it's okay that we don't ever remove
-  // ourselves as a listener.
-  lookup->AddChangeListener(this);
-
   if (parent_router_) {
-    // Make sure we add the listener at most once.
-    lookup->RemoveChangeListener(&js_directory_change_listener_);
-    lookup->AddChangeListener(&js_directory_change_listener_);
+    // Make sure we add the observer at most once.
+    lookup->RemoveTransactionObserver(&js_transaction_observer_);
+    lookup->AddTransactionObserver(&js_transaction_observer_);
   }
   return true;
 }
 
 bool SyncManager::SyncInternal::SignIn(const SyncCredentials& credentials) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   DCHECK(share_.name.empty());
   share_.name = credentials.email;
 
   VLOG(1) << "Signing in user: " << username_for_share();
@@ skipping 430 matching lines @@
                            &ordered_changes[0], ordered_changes.size()));
       models_with_changes.set(i, true);
     }
     change_buffers_[i].Clear();
   }
   return models_with_changes;
 }
 
 void SyncManager::SyncInternal::HandleCalculateChangesChangeEventFromSyncApi(
     const OriginalEntries& originals,
-    const WriterTag& writer,
     syncable::BaseTransaction* trans) {
   // We have been notified about a user action changing a sync model.
-  DCHECK(writer == syncable::SYNCAPI ||
-         writer == syncable::UNITTEST);
   LOG_IF(WARNING, !ChangeBuffersAreEmpty()) <<
       "CALCULATE_CHANGES called with unapplied old changes.";
 
   bool exists_unsynced_items = false;
   bool only_preference_changes = true;
   syncable::ModelTypeBitSet model_types;
   for (syncable::OriginalEntries::const_iterator i = originals.begin();
        i != originals.end() && !exists_unsynced_items;
        ++i) {
     int64 id = i->ref(syncable::META_HANDLE);
@@ skipping 53 matching lines @@
         NOTREACHED();
         return;
       }
     }
     buffer->SetSpecificsForId(id, original_specifics);
   }
 }
 
 void SyncManager::SyncInternal::HandleCalculateChangesChangeEventFromSyncer(
     const OriginalEntries& originals,
-    const WriterTag& writer,
     syncable::BaseTransaction* trans) {
   // We only expect one notification per sync step, so change_buffers_ should
   // contain no pending entries.
-  DCHECK(writer == syncable::SYNCER ||
-         writer == syncable::UNITTEST);
   LOG_IF(WARNING, !ChangeBuffersAreEmpty()) <<
       "CALCULATE_CHANGES called with unapplied old changes.";
 
   Cryptographer* crypto = dir_manager()->GetCryptographer(trans);
   for (syncable::OriginalEntries::const_iterator i = originals.begin();
        i != originals.end(); ++i) {
     int64 id = i->ref(syncable::META_HANDLE);
     syncable::Entry e(trans, syncable::GET_BY_HANDLE, id);
     bool existed_before = !i->ref(syncable::IS_DEL);
     bool exists_now = e.good() && !e.Get(syncable::IS_DEL);
@@ skipping 179 matching lines @@
 
   // We might be called before OpenDirectory() or after shutdown.
   if (!dir_manager()) {
     return;
   }
   syncable::ScopedDirLookup lookup(dir_manager(), username_for_share());
   if (!lookup.good()) {
     return;
   }
 
-  // Make sure we add the listener at most once.
-  lookup->RemoveChangeListener(&js_directory_change_listener_);
-  lookup->AddChangeListener(&js_directory_change_listener_);
+  // Make sure we add the observer at most once.
+  lookup->RemoveTransactionObserver(&js_transaction_observer_);
+  lookup->AddTransactionObserver(&js_transaction_observer_);
 }
 
 void SyncManager::SyncInternal::RemoveParentJsEventRouter() {
   parent_router_ = NULL;
 
   // We might be called before OpenDirectory() or after shutdown.
   if (!dir_manager()) {
     return;
   }
   syncable::ScopedDirLookup lookup(dir_manager(), username_for_share());
   if (!lookup.good()) {
     return;
   }
 
-  lookup->RemoveChangeListener(&js_directory_change_listener_);
+  lookup->RemoveTransactionObserver(&js_transaction_observer_);
 }
 
 const browser_sync::JsEventRouter*
     SyncManager::SyncInternal::GetParentJsEventRouter() const {
   return parent_router_;
 }
 
 void SyncManager::SyncInternal::ProcessMessage(
     const std::string& name, const browser_sync::JsArgList& args,
     const browser_sync::JsEventHandler* sender) {
@@ skipping 372 matching lines @@
 void SyncManager::TriggerOnIncomingNotificationForTest(
     const syncable::ModelTypeBitSet& model_types) {
   syncable::ModelTypePayloadMap model_types_with_payloads =
       syncable::ModelTypePayloadMapFromBitSet(model_types,
           std::string());
 
   data_->OnIncomingNotification(model_types_with_payloads);
 }
 
 }  // namespace sync_api