Make use of InvalidationService

chrome/browser/sync/glue/sync_backend_host.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_GLUE_SYNC_BACKEND_HOST_H_
 #define CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread.h"
+#include "chrome/browser/invalidation/invalidation_service.h"
 #include "chrome/browser/sync/glue/backend_data_type_configurer.h"
 #include "chrome/browser/sync/glue/chrome_extensions_activity_monitor.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "googleurl/src/gurl.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/configure_reason.h"
 #include "sync/internal_api/public/engine/model_safe_worker.h"
 #include "sync/internal_api/public/sessions/sync_session_snapshot.h"
 #include "sync/internal_api/public/sync_encryption_handler.h"
 #include "sync/internal_api/public/sync_manager.h"
 #include "sync/internal_api/public/util/report_unrecoverable_error_function.h"
 #include "sync/internal_api/public/util/unrecoverable_error_handler.h"
 #include "sync/internal_api/public/util/weak_handle.h"
 #include "sync/notifier/invalidation_handler.h"
-#include "sync/notifier/invalidator_factory.h"
 #include "sync/protocol/encryption.pb.h"
 #include "sync/protocol/sync_protocol_error.h"
 
 class Profile;
 
 namespace base {
 class MessageLoop;
 }
 
 namespace syncer {
 class SyncManagerFactory;
 }
 
-namespace invalidation {
-class InvalidatorStorage;
-}
-
 namespace browser_sync {
 
-class AndroidInvalidatorBridge;
 class ChangeProcessor;
+class InvalidatorStorage;
 class SyncBackendRegistrar;
 class SyncPrefs;
 class SyncedDeviceTracker;
 struct Experiments;
 
 // 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 syncer::InvalidationHandler {
+class SyncFrontend {
  public:
   SyncFrontend() {}
 
   // The backend has completed initialization and it is now ready to
   // accept and process changes.  If success is false, initialization
   // wasn't able to be completed and should be retried.
   //
   // |js_backend| is what about:sync interacts with; it's different
   // from the 'Backend' in 'OnBackendInitialized' (unfortunately).  It
   // is initialized only if |success| is true.
@@ skipping 70 matching lines @@
  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
 // dispatch of potentially blocking calls to appropriate threads and ensures
 // that the SyncFrontend is only accessed on the UI loop.
 class SyncBackendHost
     : public BackendDataTypeConfigurer,
-      public content::NotificationObserver {
+      public content::NotificationObserver,
+      public syncer::InvalidationHandler {
  public:
   typedef syncer::SyncStatus Status;
 
   // Create a SyncBackendHost with a reference to the |frontend| that
   // it serves and communicates to via the SyncFrontend interface (on
   // the same thread it used to call the constructor).  Must outlive
   // |sync_prefs| and |invalidator_storage|.
   SyncBackendHost(
       const std::string& name,
       Profile* profile,
-      const base::WeakPtr<SyncPrefs>& sync_prefs,
-      // TODO(tim): Temporary, remove when bug 124137 finished.
-      const base::WeakPtr<invalidation::InvalidatorStorage>&
-          invalidator_storage);
+      const base::WeakPtr<SyncPrefs>& sync_prefs);
 
   // For testing.
   // TODO(skrul): Extract an interface so this is not needed.
   explicit SyncBackendHost(Profile* profile);
   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).
   // |report_unrecoverable_error_function| can be NULL.
   // Note: |unrecoverable_error_handler| may be invoked from any thread.
   void Initialize(
       SyncFrontend* frontend,
       const syncer::WeakHandle<syncer::JsEventHandler>& event_handler,
       const GURL& service_url,
       const syncer::SyncCredentials& credentials,
       bool delete_sync_data_folder,
       syncer::SyncManagerFactory* sync_manager_factory,
       syncer::UnrecoverableErrorHandler* unrecoverable_error_handler,
       syncer::ReportUnrecoverableErrorFunction
           report_unrecoverable_error_function);
 
   // Called on |frontend_loop| to update SyncCredentials.
   virtual void UpdateCredentials(const syncer::SyncCredentials& credentials);
 
-  // Registers the underlying frontend for the given IDs to the underlying
-  // notifier.  This lasts until StopSyncingForShutdown() is called.
-  void UpdateRegisteredInvalidationIds(const syncer::ObjectIdSet& ids);
-
-  // Forwards an invalidation acknowledgement to the underlying notifier.
-  void AcknowledgeInvalidation(const invalidation::ObjectId& id,
-                               const syncer::AckHandle& ack_handle);
-
   // This starts the SyncerThread running a Syncer object to communicate with
   // sync servers.  Until this is called, no changes will leave or enter this
   // browser from the cloud / sync servers.
   // Called on |frontend_loop_|.
   virtual void StartSyncingWithServer();
 
   // Called on |frontend_loop_| to asynchronously set a new passphrase for
   // encryption. Note that it is an error to call SetEncryptionPassphrase under
   // the following circumstances:
   // - An explicit passphrase has already been set
@@ skipping 103 matching lines @@
     DoInitializeOptions(
         base::MessageLoop* sync_loop,
         SyncBackendRegistrar* registrar,
         const syncer::ModelSafeRoutingInfo& routing_info,
         const std::vector<syncer::ModelSafeWorker*>& workers,
         syncer::ExtensionsActivityMonitor* extensions_activity_monitor,
         const syncer::WeakHandle<syncer::JsEventHandler>& event_handler,
         const GURL& service_url,
         MakeHttpBridgeFactoryFn make_http_bridge_factory_fn,
         const syncer::SyncCredentials& credentials,
-        AndroidInvalidatorBridge* android_invalidator_bridge,
-        syncer::InvalidatorFactory* invalidator_factory,
+        const std::string& invalidator_client_id,
         syncer::SyncManagerFactory* sync_manager_factory,
         bool delete_sync_data_folder,
         const std::string& restored_key_for_bootstrapping,
         const std::string& restored_keystore_key_for_bootstrapping,
         syncer::InternalComponentsFactory* internal_components_factory,
         syncer::UnrecoverableErrorHandler* unrecoverable_error_handler,
         syncer::ReportUnrecoverableErrorFunction
             report_unrecoverable_error_function,
         bool use_oauth2_token);
     ~DoInitializeOptions();
 
     base::MessageLoop* sync_loop;
     SyncBackendRegistrar* registrar;
     syncer::ModelSafeRoutingInfo routing_info;
     std::vector<syncer::ModelSafeWorker*> workers;
     syncer::ExtensionsActivityMonitor* extensions_activity_monitor;
     syncer::WeakHandle<syncer::JsEventHandler> event_handler;
     GURL service_url;
     // Overridden by tests.
     MakeHttpBridgeFactoryFn make_http_bridge_factory_fn;
     syncer::SyncCredentials credentials;
-    AndroidInvalidatorBridge* const android_invalidator_bridge;
-    syncer::InvalidatorFactory* const invalidator_factory;
+    const std::string invalidator_client_id;
     syncer::SyncManagerFactory* const sync_manager_factory;
     std::string lsid;
     bool delete_sync_data_folder;
     std::string restored_key_for_bootstrapping;
     std::string restored_keystore_key_for_bootstrapping;
     syncer::InternalComponentsFactory* internal_components_factory;
     syncer::UnrecoverableErrorHandler* unrecoverable_error_handler;
     syncer::ReportUnrecoverableErrorFunction
         report_unrecoverable_error_function;
     bool use_oauth2_token;
@@ skipping 10 matching lines @@
       syncer::ModelTypeSet to_journal,
       syncer::ModelTypeSet to_unapply,
       syncer::ModelTypeSet to_ignore,
       const syncer::ModelSafeRoutingInfo& routing_info,
       const base::Callback<void(syncer::ModelTypeSet,
                                 syncer::ModelTypeSet)>& ready_task,
       const base::Closure& retry_callback);
 
   // Called when the syncer has finished performing a configuration.
   void FinishConfigureDataTypesOnFrontendLoop(
+      const syncer::ModelTypeSet enabled_types,
       const syncer::ModelTypeSet succeeded_configuration_types,
       const syncer::ModelTypeSet failed_configuration_types,
       const base::Callback<void(syncer::ModelTypeSet,
                                 syncer::ModelTypeSet)>& ready_task);
 
   // Called when the SyncManager has been constructed and initialized.
   // Stores |js_backend| and |debug_info_listener| on the UI thread for
   // consumption when initialization is complete.
   virtual void HandleSyncManagerInitializationOnFrontendLoop(
       const syncer::WeakHandle<syncer::JsBackend>& js_backend,
@@ skipping 112 matching lines @@
       syncer::InvalidatorState state);
   void HandleIncomingInvalidationOnFrontendLoop(
       const syncer::ObjectIdInvalidationMap& invalidation_map);
 
   // NotificationObserver implementation.
   virtual void Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) OVERRIDE;
 
+  // InvalidationHandler implementation.
+  virtual void OnInvalidatorStateChange(
+      syncer::InvalidatorState state) OVERRIDE;
+  virtual void OnIncomingInvalidation(
+      const syncer::ObjectIdInvalidationMap& invalidation_map) OVERRIDE;
+
   // Handles stopping the core's SyncManager, accounting for whether
   // initialization is done yet.
   void StopSyncManagerForShutdown(const base::Closure& closure);
 
   base::WeakPtrFactory<SyncBackendHost> weak_ptr_factory_;
 
   content::NotificationRegistrar notification_registrar_;
 
   // A thread where all the sync operations happen.
   base::Thread sync_thread_;
 
   // A reference to the MessageLoop used to construct |this|, so we know how
   // to safely talk back to the SyncFrontend.
   base::MessageLoop* const frontend_loop_;
 
   Profile* const profile_;
 
   // Name used for debugging (set from profile_->GetDebugName()).
   const std::string name_;
 
   // Our core, which communicates directly to the syncapi.
   scoped_refptr<Core> core_;
 
   InitializationState initialization_state_;
 
   const base::WeakPtr<SyncPrefs> sync_prefs_;
 
-  scoped_ptr<AndroidInvalidatorBridge> android_invalidator_bridge_;
-
-  syncer::InvalidatorFactory invalidator_factory_;
-
   ChromeExtensionsActivityMonitor extensions_activity_monitor_;
 
   scoped_ptr<SyncBackendRegistrar> registrar_;
 
   // The frontend which we serve (and are owned by).
   SyncFrontend* frontend_;
 
   // We cache the cryptographer's pending keys whenever NotifyPassphraseRequired
   // is called. This way, before the UI calls SetDecryptionPassphrase on the
   // syncer, it can avoid the overhead of an asynchronous decryption call and
@@ skipping 17 matching lines @@
   // UI-thread cache of the last SyncSessionSnapshot received from syncapi.
   syncer::sessions::SyncSessionSnapshot last_snapshot_;
 
   // Temporary holder of sync manager's initialization results. Set by
   // HandleSyncManagerInitializationOnFrontendLoop, and consumed when we pass
   // it via OnBackendInitialized in the final state of
   // HandleInitializationCompletedOnFrontendLoop.
   syncer::WeakHandle<syncer::JsBackend> js_backend_;
   syncer::WeakHandle<syncer::DataTypeDebugInfoListener> debug_info_listener_;
 
+  invalidation::InvalidationService* invalidator_;
+
   DISALLOW_COPY_AND_ASSIGN(SyncBackendHost);
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_