Revert 208315 "Make use of InvalidationService"

trunk/src/sync/internal_api/sync_manager_impl.cc

Index: trunk/src/sync/internal_api/sync_manager_impl.cc
===================================================================
--- trunk/src/sync/internal_api/sync_manager_impl.cc	(revision 208346)
+++ trunk/src/sync/internal_api/sync_manager_impl.cc	(working copy)
@@ -349,6 +349,7 @@
     ExtensionsActivityMonitor* extensions_activity_monitor,
     SyncManager::ChangeDelegate* change_delegate,
     const SyncCredentials& credentials,
+    scoped_ptr<Invalidator> invalidator,
     const std::string& invalidator_client_id,
     const std::string& restored_key_for_bootstrapping,
     const std::string& restored_keystore_key_for_bootstrapping,
@@ -368,6 +369,9 @@
 
   change_delegate_ = change_delegate;
 
+  invalidator_ = invalidator.Pass();
+  invalidator_->RegisterHandler(this);
+
   AddObserver(&js_sync_manager_observer_);
   SetJsEventHandler(event_handler);
 
@@ -605,11 +609,49 @@
   if (!connection_manager_->SetAuthToken(credentials.sync_token))
     return;  // Auth token is known to be invalid, so exit early.
 
+  invalidator_->UpdateCredentials(credentials.email, credentials.sync_token);
   scheduler_->OnCredentialsUpdated();
 
   // TODO(zea): pass the credential age to the debug info event listener.
 }
 
+void SyncManagerImpl::UpdateEnabledTypes(ModelTypeSet enabled_types) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(initialized_);
+  invalidator_->UpdateRegisteredIds(
+      this,
+      ModelTypeSetToObjectIdSet(enabled_types));
+}
+
+void SyncManagerImpl::RegisterInvalidationHandler(
+    InvalidationHandler* handler) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(initialized_);
+  invalidator_->RegisterHandler(handler);
+}
+
+void SyncManagerImpl::UpdateRegisteredInvalidationIds(
+    InvalidationHandler* handler,
+    const ObjectIdSet& ids) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(initialized_);
+  invalidator_->UpdateRegisteredIds(handler, ids);
+}
+
+void SyncManagerImpl::UnregisterInvalidationHandler(
+    InvalidationHandler* handler) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(initialized_);
+  invalidator_->UnregisterHandler(handler);
+}
+
+void SyncManagerImpl::AcknowledgeInvalidation(
+    const invalidation::ObjectId& id, const syncer::AckHandle& ack_handle) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(initialized_);
+  invalidator_->Acknowledge(id, ack_handle);
+}
+
 void SyncManagerImpl::AddObserver(SyncManager::Observer* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   observers_.AddObserver(observer);
@@ -648,10 +690,15 @@
 
   RemoveObserver(&debug_info_event_listener_);
 
-  // |connection_manager_| may end up being NULL here in tests (in synchronous
-  // initialization mode).
+  // |invalidator_| and |connection_manager_| may end up being NULL here in
+  // tests (in synchronous initialization mode).
   //
   // TODO(akalin): Fix this behavior.
+
+  if (invalidator_)
+    invalidator_->UnregisterHandler(this);
+  invalidator_.reset();
+
   if (connection_manager_)
     connection_manager_->RemoveListener(this);
   connection_manager_.reset();
@@ -941,6 +988,20 @@
     DVLOG(1) << "Sending OnSyncCycleCompleted";
     FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                       OnSyncCycleCompleted(event.snapshot));
+
+    // This is here for tests, which are still using p2p notifications.
+    bool is_notifiable_commit =
+        (event.snapshot.model_neutral_state().num_successful_commits > 0);
+    if (is_notifiable_commit) {
+      if (invalidator_) {
+        const ObjectIdInvalidationMap& invalidation_map =
+            ModelTypeInvalidationMapToObjectIdInvalidationMap(
+                event.snapshot.source().types);
+        invalidator_->SendInvalidation(invalidation_map);
+      } else {
+        DVLOG(1) << "Not sending invalidation: invalidator_ is NULL";
+      }
+    }
   }
 
   if (event.what_happened == SyncEngineEvent::STOP_SYNCING_PERMANENTLY) {
@@ -1163,8 +1224,6 @@
 }
 
 void SyncManagerImpl::OnInvalidatorStateChange(InvalidatorState state) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
   const std::string& state_str = InvalidatorStateToString(state);
   invalidator_state_ = state;
   DVLOG(1) << "Invalidator state changed to: " << state_str;
@@ -1173,6 +1232,12 @@
   allstatus_.SetNotificationsEnabled(notifications_enabled);
   scheduler_->SetNotificationsEnabled(notifications_enabled);
 
+  if (invalidator_state_ == syncer::INVALIDATION_CREDENTIALS_REJECTED) {
+    // If the invalidator's credentials were rejected, that means that
+    // our sync credentials are also bad, so invalidate those.
+    connection_manager_->OnInvalidationCredentialsRejected();
+  }
+
   if (js_event_handler_.IsInitialized()) {
     base::DictionaryValue details;
     details.SetString("state", state_str);
@@ -1187,6 +1252,15 @@
     const ObjectIdInvalidationMap& invalidation_map) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  // TODO(dcheng): Acknowledge immediately for now. Fix this once the
+  // invalidator doesn't repeatedly ping for unacknowledged invaliations, since
+  // it conflicts with the sync scheduler's internal backoff algorithm.
+  // See http://crbug.com/124149 for more information.
+  for (ObjectIdInvalidationMap::const_iterator it = invalidation_map.begin();
+       it != invalidation_map.end(); ++it) {
+    invalidator_->Acknowledge(it->first, it->second.ack_handle);
+  }
+
   const ModelTypeInvalidationMap& type_invalidation_map =
       ObjectIdInvalidationMapToModelTypeInvalidationMap(invalidation_map);
   if (type_invalidation_map.empty()) {