Sync: Add a SyncTypePreferenceProvider interface.

chrome/browser/sync/profile_sync_service.h

 // Copyright (c) 2012 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_PROFILE_SYNC_SERVICE_H_
 #define CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_
 
+#include <set>
 #include <string>
 #include <utility>
-#include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/strings/string16.h"
@@ skipping 29 matching lines @@
 #include "sync/internal_api/public/util/experiments.h"
 #include "sync/internal_api/public/util/unrecoverable_error_handler.h"
 #include "sync/js/sync_js_controller.h"
 #include "url/gurl.h"
 
 class Profile;
 class ProfileOAuth2TokenService;
 class ProfileSyncComponentsFactory;
 class SupervisedUserSigninManagerWrapper;
 class SyncErrorController;
+class SyncTypePreferenceProvider;
 
 namespace base {
 class CommandLine;
 };
 
 namespace browser_sync {
 class BackendMigrator;
 class DeviceInfo;
 class FaviconCache;
 class JsController;
@@ skipping 224 matching lines @@
       ProfileSyncServiceBase::Observer* observer) const OVERRIDE;
 
 
   void AddProtocolEventObserver(browser_sync::ProtocolEventObserver* observer);
   void RemoveProtocolEventObserver(
       browser_sync::ProtocolEventObserver* observer);
 
   void AddTypeDebugInfoObserver(syncer::TypeDebugInfoObserver* observer);
   void RemoveTypeDebugInfoObserver(syncer::TypeDebugInfoObserver* observer);
 
+  // Add a sync type preference provider. Each provider may only be added once.
+  void AddPreferenceProvider(SyncTypePreferenceProvider* provider);
+  // Remove a sync type preference provider. May only be called for providers
+  // that have been added. Providers must not remove themselves while being
+  // called back.
+  void RemovePreferenceProvider(SyncTypePreferenceProvider* provider);
+  // Check whether a given sync type preference provider has been added.
+  bool HasPreferenceProvider(SyncTypePreferenceProvider* provider) const;
+
   // Asynchronously fetches base::Value representations of all sync nodes and
   // returns them to the specified callback on this thread.
   //
   // These requests can live a long time and return when you least expect it.
   // For safety, the callback should be bound to some sort of WeakPtr<> or
   // scoped_refptr<>.
   void GetAllNodes(
       const base::Callback<void(scoped_ptr<base::ListValue>)>& callback);
 
   void RegisterAuthNotifications();
@@ skipping 599 matching lines @@
   void RegisterNewDataType(syncer::ModelType data_type);
 
   // Reconfigures the data type manager with the latest enabled types.
   // Note: Does not initialize the backend if it is not already initialized.
   // This function needs to be called only after sync has been initialized
   // (i.e.,only for reconfigurations). The reason we don't initialize the
   // backend is because if we had encountered an unrecoverable error we don't
   // want to startup once more.
   virtual void ReconfigureDatatypeManager();
 
+  // Collects preferred sync data types from |preference_providers_|.
+  syncer::ModelTypeSet GetDataTypesFromPreferenceProviders();
+
   // Called when the user changes the sync configuration, to update the UMA
   // stats.
   void UpdateSelectedTypesHistogram(
       bool sync_everything,
       const syncer::ModelTypeSet chosen_types) const;
 
 #if defined(OS_CHROMEOS)
   // Refresh spare sync bootstrap token for re-enabling the sync service.
   // Called on successful sign-in notifications.
   void RefreshSpareBootstrapToken(const std::string& passphrase);
@@ skipping 84 matching lines @@
   // Manages the start and stop of the directory data types.
   scoped_ptr<sync_driver::DataTypeManager> directory_data_type_manager_;
 
   // Manager for the non-blocking data types.
   sync_driver::NonBlockingDataTypeManager non_blocking_data_type_manager_;
 
   ObserverList<ProfileSyncServiceBase::Observer> observers_;
   ObserverList<browser_sync::ProtocolEventObserver> protocol_event_observers_;
   ObserverList<syncer::TypeDebugInfoObserver> type_debug_info_observers_;
 
+  std::set<SyncTypePreferenceProvider*> preference_providers_;
+
   syncer::SyncJsController sync_js_controller_;
 
   // This allows us to gracefully handle an ABORTED return code from the
   // DataTypeManager in the event that the server informed us to cease and
   // desist syncing immediately.
   bool expect_sync_configuration_aborted_;
 
   // Sometimes we need to temporarily hold on to a passphrase because we don't
   // yet have a backend to send it to.  This happens during initialization as
   // we don't StartUp until we have a valid token, which happens after valid
@@ skipping 100 matching lines @@
   scoped_ptr<base::Time> last_backup_time_;
 
   DISALLOW_COPY_AND_ASSIGN(ProfileSyncService);
 };
 
 bool ShouldShowActionOnUI(
     const syncer::SyncProtocolError& error);
 
 
 #endif  // CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_