Support for multiple sync ModelSafeWorkers....

chrome/browser/sync/engine/syncapi.h

 // Copyright (c) 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.
 
 // This file defines the "sync API", an interface to the syncer
 // backend that exposes (1) the core functionality of maintaining a consistent
 // local snapshot of a hierarchical object set; (2) a means to transactionally
 // access and modify those objects; (3) a means to control client/server
 // synchronization tasks, namely: pushing local object modifications to a
 // server, pulling nonlocal object modifications from a server to this client,
@@ skipping 34 matching lines @@
 #include "build/build_config.h"
 #include "chrome/browser/google_service_auth_error.h"
 #include "googleurl/src/gurl.h"
 
 // The MSVC compiler for Windows requires that any classes exported by, or
 // imported from, a dynamic library be marked with an appropriate
 // __declspec() decoration. However, we currently use static linkage
 // on all platforms.
 #define SYNC_EXPORT
 
+namespace browser_sync {
+class ModelSafeWorkerRegistrar;
+}
+
 // Forward declarations of internal class types so that sync API objects
 // may have opaque pointers to these types.
 namespace syncable {
 class BaseTransaction;
 class DirectoryManager;
 class Entry;
 class MutableEntry;
 class ReadTransaction;
 class ScopedDirLookup;
 class WriteTransaction;
 }
 
 namespace sync_api {
 
 // Forward declarations of classes to be defined later in this file.
 class BaseTransaction;
 class HttpPostProviderFactory;
-class ModelSafeWorkerInterface;
 class SyncManager;
 class WriteTransaction;
 struct UserShare;
 
 // A valid BaseNode will never have an ID of zero.
 static const int64 kInvalidId = 0;
 
 // BaseNode wraps syncable::Entry, and corresponds to a single object's state.
 // This, like syncable::Entry, is intended for use on the stack.  A valid
 // transaction is necessary to create a BaseNode or any of its children.
@@ skipping 419 matching lines @@
   // As a fallback when no cached auth information is available, try to
   // bootstrap authentication using |lsid|, if it isn't empty.
   bool 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,
+            browser_sync::ModelSafeWorkerRegistrar* registrar,
             bool attempt_last_user_authentication,
             const char* user_agent,
             const char* lsid);
 
   // Returns the username last used for a successful authentication.
   // Returns empty if there is no such username.
   const std::string& GetAuthenticatedUsername();
 
   // Submit credentials to GAIA for verification and start the
   // syncing process on success. On success, both |username| and the obtained
@@ skipping 109 matching lines @@
 
   // When the interface is no longer needed (ready to be cleaned up), clients
   // must call Destroy().
   // This allows actual HttpPostProvider subclass implementations to be
   // reference counted, which is useful if a particular implementation uses
   // multiple threads to serve network requests.
   virtual void Destroy(HttpPostProviderInterface* http) = 0;
   virtual ~HttpPostProviderFactory() { }
 };
 
-// A class syncapi clients should use whenever the underlying model is bound to
-// a particular thread in the embedding application. This exposes an interface
-// by which any model-modifying invocations will be forwarded to the
-// appropriate thread in the embedding application.
-// "model safe" refers to not allowing an embedding application model to fall
-// out of sync with the syncable::Directory due to race conditions.
-class ModelSafeWorkerInterface {
- public:
-  virtual ~ModelSafeWorkerInterface() { }
-  // A Visitor is passed to CallDoWorkFromModelSafeThreadAndWait invocations,
-  // and it's sole purpose is to provide a way for the ModelSafeWorkerInterface
-  // implementation to actually _do_ the work required, by calling the only
-  // method on this class, DoWork().
-  class Visitor {
-   public:
-    virtual ~Visitor() { }
-    // When on a model safe thread, this should be called to have the syncapi
-    // actually perform the work needing to be done.
-    virtual void DoWork() = 0;
-  };
-  // Subclasses should implement to invoke DoWork on |visitor| once on a thread
-  // appropriate for data model modifications.
-  // While it doesn't hurt, the impl does not need to be re-entrant (for now).
-  // Note: |visitor| is owned by caller.
-  virtual void CallDoWorkFromModelSafeThreadAndWait(Visitor* visitor) = 0;
-};
-
 }  // namespace sync_api
 
 #endif  // CHROME_BROWSER_SYNC_ENGINE_SYNCAPI_H_