[Sync] Add support for enabling session sync remotely.

chrome/browser/sync/glue/sync_backend_host.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_HOST_H_
 #define CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_
 #pragma once
 
 #include <map>
 #include <string>
@@ skipping 16 matching lines @@
 #include "chrome/browser/sync/js/js_backend.h"
 #include "chrome/browser/sync/notifier/sync_notifier_factory.h"
 #include "chrome/browser/sync/syncable/model_type.h"
 #include "chrome/browser/sync/weak_handle.h"
 #include "chrome/common/net/gaia/google_service_auth_error.h"
 #include "googleurl/src/gurl.h"
 #include "net/url_request/url_request_context_getter.h"
 
 class CancelableTask;
 class Profile;
+class ProfileSyncFactory;
 
 namespace net {
 class URLRequestContextGetter;
 }
 
 namespace browser_sync {
 
 namespace sessions {
 struct SyncSessionSnapshot;
 }
 
 class ChangeProcessor;
+class DataTypeController;
 class JsEventHandler;
 
 // SyncFrontend is the interface used by SyncBackendHost to communicate with
 // the entity that created it and, presumably, is interested in sync-related
 // activity.
 // NOTE: All methods will be invoked by a SyncBackendHost on the same thread
 // used to create that SyncBackendHost.
 class SyncFrontend {
  public:
   SyncFrontend() {}
@@ skipping 35 matching lines @@
   // encrypted using the accepted passphrase.
   virtual void OnPassphraseAccepted() = 0;
 
   virtual void OnEncryptionComplete(
       const syncable::ModelTypeSet& encrypted_types) = 0;
 
   // Called to perform migration of |types|.
   virtual void OnMigrationNeededForTypes(
       const syncable::ModelTypeSet& types) = 0;
 
+  // Get the list of types that can be enabled.
+  virtual void GetRegisteredDataTypes(syncable::ModelTypeSet* types) const = 0;
+
+  // Get the list of types that are enabled.
+  virtual void GetPreferredDataTypes(syncable::ModelTypeSet* types) const = 0;
+
+  // Register a DataTypeController.
+  virtual void RegisterDataTypeController(
+      browser_sync::DataTypeController* data_type_controller) = 0;
+
  protected:
   // Don't delete through SyncFrontend interface.
   virtual ~SyncFrontend() {
   }
  private:
   DISALLOW_COPY_AND_ASSIGN(SyncFrontend);
 };
 
 // A UI-thread safe API into the sync backend that "hosts" the top-level
 // syncapi element, the SyncManager, on its own thread. This class handles
@@ skipping 13 matching lines @@
   // For testing.
   // TODO(skrul): Extract an interface so this is not needed.
   SyncBackendHost();
   virtual ~SyncBackendHost();
 
   // Called on |frontend_loop_| to kick off asynchronous initialization.
   // As a fallback when no cached auth information is available, try to
   // bootstrap authentication using |lsid|, if it isn't empty.
   // Optionally delete the Sync Data folder (if it's corrupt).
   void Initialize(SyncFrontend* frontend,
+                  ProfileSyncFactory* factory,
                   const WeakHandle<JsEventHandler>& event_handler,
                   const GURL& service_url,
                   const syncable::ModelTypeSet& initial_types,
                   const sync_api::SyncCredentials& credentials,
                   bool delete_sync_data_folder);
 
   // Called from |frontend_loop| to update SyncCredentials.
   void UpdateCredentials(const sync_api::SyncCredentials& credentials);
 
   // This starts the SyncerThread running a Syncer object to communicate with
@@ skipping 444 matching lines @@
   // SyncBackendHost may read (on the UI thread or sync thread) from registrar_
   // without acquiring the lock (which is typically "read ModelSafeWorker
   // pointer value", and then invoke methods), because lifetimes are managed on
   // the UI thread.  Of course, this comment only applies to ModelSafeWorker
   // impls that are themselves thread-safe, such as UIModelWorker.
   mutable base::Lock registrar_lock_;
 
   // The frontend which we serve (and are owned by).
   SyncFrontend* frontend_;
 
+  // The factory for creating DataTypeControllers.
+  ProfileSyncFactory* profile_sync_factory_;
+
   // The change processors that handle the different data types.
   std::map<syncable::ModelType, ChangeProcessor*> processors_;
 
   // Path of the folder that stores the sync data files.
   FilePath sync_data_folder_path_;
 
   scoped_ptr<PendingConfigureDataTypesState> pending_download_state_;
   scoped_ptr<PendingConfigureDataTypesState> pending_config_mode_state_;
 
   // UI-thread cache of the last AuthErrorState received from syncapi.
   GoogleServiceAuthError last_auth_error_;
 
   // UI-thread cache of the last SyncSessionSnapshot received from syncapi.
   scoped_ptr<sessions::SyncSessionSnapshot> last_snapshot_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncBackendHost);
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_