Support for multiple sync ModelSafeWorkers....

chrome/browser/sync/engine/syncapi.cc

 // Copyright (c) 2006-2009 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 "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
@@ skipping 43 matching lines @@
 #include "chrome/common/chrome_switches.h"
 
 #if defined(OS_WIN)
 #pragma comment(lib, "iphlpapi.lib")
 #endif
 
 using browser_sync::AllStatus;
 using browser_sync::AllStatusEvent;
 using browser_sync::AuthWatcher;
 using browser_sync::AuthWatcherEvent;
+using browser_sync::ModelSafeWorker;
+using browser_sync::ModelSafeWorkerRegistrar;
 using browser_sync::Syncer;
 using browser_sync::SyncerEvent;
 using browser_sync::SyncerThread;
 using browser_sync::UserSettings;
 using browser_sync::TalkMediator;
 using browser_sync::TalkMediatorImpl;
 using browser_sync::sessions::SyncSessionContext;
 using std::list;
 using std::hex;
 using std::string;
@@ skipping 104 matching lines @@
 #endif
     LOG(INFO) << "The address watch thread has stopped";
   }
 
  private:
   AddressWatchTaskParams* const params_;
   DISALLOW_COPY_AND_ASSIGN(AddressWatchTask);
 };
 
 namespace sync_api {
-class ModelSafeWorkerBridge;
 
 static const FilePath::CharType kBookmarkSyncUserSettingsDatabase[] =
     FILE_PATH_LITERAL("BookmarkSyncSettings.sqlite3");
 static const char kDefaultNameForNewNodes[] = " ";
 
 // The list of names which are reserved for use by the server.
 static const char* kForbiddenServerNames[] = { "", ".", ".." };
 
 //////////////////////////////////////////////////////////////////////////
 // Static helper functions.
@@ skipping 394 matching lines @@
 }
 
 WriteTransaction::~WriteTransaction() {
   delete transaction_;
 }
 
 syncable::BaseTransaction* WriteTransaction::GetWrappedTrans() const {
   return transaction_;
 }
 
-// An implementation of Visitor that we use to "visit" the
-// ModelSafeWorkerInterface provided by a client of this API. The object we
-// visit is responsible for calling DoWork, which will invoke Run() on it's
-// cached work closure.
-class ModelSafeWorkerVisitor : public ModelSafeWorkerInterface::Visitor {
- public:
-  explicit ModelSafeWorkerVisitor(Closure* work) : work_(work) { }
-  virtual ~ModelSafeWorkerVisitor() { }
-
-  // ModelSafeWorkerInterface::Visitor implementation.
-  virtual void DoWork() {
-    work_->Run();
-  }
-
- private:
-  // The work to be done. We run this on DoWork and it cleans itself up
-  // after it is run.
-  Closure* work_;
-
-  DISALLOW_COPY_AND_ASSIGN(ModelSafeWorkerVisitor);
-};
-
-// This class is declared in the cc file to allow inheritance from sync types.
-// The ModelSafeWorkerBridge is a liason between a syncapi-client defined
-// ModelSafeWorkerInterface and the actual ModelSafeWorker used by the Syncer
-// for the current SyncManager.
-class ModelSafeWorkerBridge : public browser_sync::ModelSafeWorker {
- public:
-  // Takes ownership of |worker|.
-  explicit ModelSafeWorkerBridge(ModelSafeWorkerInterface* worker)
-      : worker_(worker) {
-  }
-  virtual ~ModelSafeWorkerBridge() { }
-
-  // Overriding ModelSafeWorker.
-  virtual void DoWorkAndWaitUntilDone(Closure* work) {
-    // When the syncer has work to be done, we forward it to our worker who
-    // will invoke DoWork on |visitor| when appropriate (from model safe
-    // thread).
-    ModelSafeWorkerVisitor visitor(work);
-    worker_->CallDoWorkFromModelSafeThreadAndWait(&visitor);
-  }
-
- private:
-  // The worker that we can forward work requests to, to ensure the work
-  // is performed on an appropriate model safe thread.
-  scoped_ptr<ModelSafeWorkerInterface> worker_;
-
-  DISALLOW_COPY_AND_ASSIGN(ModelSafeWorkerBridge);
-};
-
 // A GaiaAuthenticator that uses HttpPostProviders instead of CURL.
 class BridgedGaiaAuthenticator : public browser_sync::GaiaAuthenticator {
  public:
   BridgedGaiaAuthenticator(const string& user_agent, const string& service_id,
                            const string& gaia_url,
                            HttpPostProviderFactory* factory)
       : GaiaAuthenticator(user_agent, service_id, gaia_url),
         gaia_source_(user_agent), post_factory_(factory) {
   }
 
@@ skipping 46 matching lines @@
   ~SyncInternal() { }
 
   bool Init(const FilePath& database_location,
             const std::string& sync_server_and_path,
             int port,
             const char* gaia_service_id,
             const char* gaia_source,
             bool use_ssl,
             HttpPostProviderFactory* post_factory,
             HttpPostProviderFactory* auth_post_factory,
-            ModelSafeWorkerInterface* model_safe_worker,
+            ModelSafeWorkerRegistrar* model_safe_worker_registrar,
             bool attempt_last_user_authentication,
             const char* user_agent,
             const std::string& lsid);
 
   // Tell sync engine to submit credentials to GAIA for verification and start
   // the syncing process on success. Successful GAIA authentication will kick
   // off the following chain of events:
   // 1. Cause sync engine to open the syncer database.
   // 2. Trigger the AuthWatcher to create a Syncer for the directory and call
   //    SyncerThread::SyncDirectory; the SyncerThread will block until (4).
@@ skipping 209 matching lines @@
 }
 
 bool SyncManager::Init(const FilePath& database_location,
                        const char* sync_server_and_path,
                        int sync_server_port,
                        const char* gaia_service_id,
                        const char* gaia_source,
                        bool use_ssl,
                        HttpPostProviderFactory* post_factory,
                        HttpPostProviderFactory* auth_post_factory,
-                       ModelSafeWorkerInterface* model_safe_worker,
+                       ModelSafeWorkerRegistrar* registrar,
                        bool attempt_last_user_authentication,
                        const char* user_agent,
                        const char* lsid) {
   DCHECK(post_factory);
 
   string server_string(sync_server_and_path);
   return data_->Init(database_location,
                      server_string,
                      sync_server_port,
                      gaia_service_id,
                      gaia_source,
                      use_ssl,
                      post_factory,
                      auth_post_factory,
-                     model_safe_worker,
+                     registrar,
                      attempt_last_user_authentication,
                      user_agent,
                      lsid);
 }
 
 void SyncManager::Authenticate(const char* username, const char* password,
     const char* captcha) {
   data_->Authenticate(std::string(username), std::string(password),
                       std::string(captcha));
 }
 
 const std::string& SyncManager::GetAuthenticatedUsername() {
   DCHECK(data_);
   return data_->username_for_share();
 }
 
 bool SyncManager::SyncInternal::Init(
     const FilePath& database_location,
     const std::string& sync_server_and_path,
     int port,
     const char* gaia_service_id,
     const char* gaia_source,
     bool use_ssl, HttpPostProviderFactory* post_factory,
     HttpPostProviderFactory* auth_post_factory,
-    ModelSafeWorkerInterface* model_safe_worker,
+    ModelSafeWorkerRegistrar* model_safe_worker_registrar,
     bool attempt_last_user_authentication,
     const char* user_agent,
     const std::string& lsid) {
 
   // Set up UserSettings, creating the db if necessary. We need this to
   // instantiate a URLFactory to give to the Syncer.
   FilePath settings_db_file =
       database_location.Append(FilePath(kBookmarkSyncUserSettingsDatabase));
   user_settings_.reset(new UserSettings());
   if (!user_settings_->Init(settings_db_file))
@@ skipping 51 matching lines @@
                                   user_settings_.get(),
                                   gaia_auth,
                                   talk_mediator());
 
   talk_mediator()->WatchAuthWatcher(auth_watcher());
   allstatus()->WatchAuthWatcher(auth_watcher());
   authwatcher_hookup_.reset(NewEventListenerHookup(auth_watcher_->channel(),
       this, &SyncInternal::HandleAuthWatcherEvent));
 
   // Build a SyncSessionContext and store the worker in it.
-  // We set up both sides of the "bridge" here, with the ModelSafeWorkerBridge
-  // on the Syncer side, and |model_safe_worker| on the API client side.
-  ModelSafeWorkerBridge* worker = new ModelSafeWorkerBridge(model_safe_worker);
   SyncSessionContext* context = new SyncSessionContext(
-      connection_manager_.get(), dir_manager(), worker);
+      connection_manager_.get(), dir_manager(), model_safe_worker_registrar);
 
   // The SyncerThread takes ownership of |context|.
   syncer_thread_ = new SyncerThread(context, &allstatus_);
   syncer_thread()->WatchTalkMediator(talk_mediator());
   allstatus()->WatchSyncerThread(syncer_thread());
 
   syncer_thread()->Start();  // Start the syncer thread. This won't actually
                              // result in any syncing until at least the
                              // DirectoryManager broadcasts the OPENED event,
                              // and a valid server connection is detected.
@@ skipping 521 matching lines @@
 BaseTransaction::~BaseTransaction() {
   delete lookup_;
 }
 
 UserShare* SyncManager::GetUserShare() const {
   DCHECK(data_->initialized()) << "GetUserShare requires initialization!";
   return data_->GetUserShare();
 }
 
 }  // namespace sync_api