Revert 208315 "Make use of InvalidationService"

trunk/src/chrome/browser/sync/profile_sync_service.cc

 // 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.
 
 #include "chrome/browser/sync/profile_sync_service.h"
 
 #include <cstddef>
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 48 matching lines @@
 #include "chrome/common/pref_names.h"
 #include "chrome/common/time_format.h"
 #include "chrome/common/url_constants.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "grit/generated_resources.h"
 #include "net/cookies/cookie_monster.h"
-#include "net/url_request/url_request_context_getter.h"
 #include "sync/api/sync_error.h"
 #include "sync/internal_api/public/configure_reason.h"
 #include "sync/internal_api/public/sync_encryption_handler.h"
 #include "sync/internal_api/public/util/experiments.h"
 #include "sync/internal_api/public/util/sync_string_conversions.h"
 #include "sync/js/js_arg_list.h"
 #include "sync/js/js_event_details.h"
+#include "sync/notifier/invalidator_registrar.h"
+#include "sync/notifier/invalidator_state.h"
 #include "sync/util/cryptographer.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(ENABLE_MANAGED_USERS)
 #include "chrome/browser/managed_mode/managed_user_service.h"
 #endif
 
 #if defined(OS_ANDROID)
 #include "sync/internal_api/public/read_transaction.h"
 #endif
@@ skipping 19 matching lines @@
 const char* ProfileSyncService::kSyncServerUrl =
     "https://clients4.google.com/chrome-sync";
 
 const char* ProfileSyncService::kDevServerUrl =
     "https://clients4.google.com/chrome-sync/dev";
 
 static const int kSyncClearDataTimeoutInSeconds = 60;  // 1 minute.
 
 static const char* kOAuth2Scopes[] = {
   GaiaConstants::kChromeSyncOAuth2Scope,
+  // GoogleTalk scope is needed for notifications.
+  GaiaConstants::kGoogleTalkOAuth2Scope
 };
 
 static const char* kManagedOAuth2Scopes[] = {
   GaiaConstants::kChromeSyncManagedOAuth2Scope
 };
 
 static const char* kSyncUnrecoverableErrorHistogram =
     "Sync.UnrecoverableErrors";
 
 const net::BackoffEntry::Policy kRequestAccessTokenBackoffPolicy = {
@@ skipping 34 matching lines @@
 ProfileSyncService::ProfileSyncService(ProfileSyncComponentsFactory* factory,
                                        Profile* profile,
                                        SigninManagerBase* signin_manager,
                                        StartBehavior start_behavior)
     : last_auth_error_(AuthError::AuthErrorNone()),
       passphrase_required_reason_(syncer::REASON_PASSPHRASE_NOT_REQUIRED),
       factory_(factory),
       profile_(profile),
       // |profile| may be NULL in unit tests.
       sync_prefs_(profile_ ? profile_->GetPrefs() : NULL),
+      invalidator_storage_(profile_ ? profile_->GetPrefs(): NULL),
       sync_service_url_(kDevServerUrl),
       data_type_requested_sync_startup_(false),
       is_first_time_sync_configure_(false),
       backend_initialized_(false),
       sync_disabled_by_admin_(false),
       is_auth_in_progress_(false),
       signin_(signin_manager),
       unrecoverable_error_reason_(ERROR_REASON_UNSET),
       weak_factory_(this),
       expect_sync_configuration_aborted_(false),
       encrypted_types_(syncer::SyncEncryptionHandler::SensitiveTypes()),
       encrypt_everything_(false),
       encryption_pending_(false),
       auto_start_enabled_(start_behavior == AUTO_START),
       configure_status_(DataTypeManager::UNKNOWN),
       setup_in_progress_(false),
+      invalidator_state_(syncer::DEFAULT_INVALIDATION_ERROR),
       request_access_token_backoff_(&kRequestAccessTokenBackoffPolicy) {
   // By default, dev, canary, and unbranded Chromium users will go to the
   // development servers. Development servers have more features than standard
   // sync servers. Users with officially-branded Chrome stable and beta builds
   // will go to the standard sync servers.
   //
   // GetChannel hits the registry on Windows. See http://crbug.com/70380.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
   chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
   if (channel == chrome::VersionInfo::CHANNEL_STABLE ||
@@ skipping 32 matching lines @@
     return token_service->RefreshTokenIsAvailable();
   } else {
     TokenService* token_service = TokenServiceFactory::GetForProfile(profile_);
     if (!token_service)
       return false;
     return token_service->HasTokenForService(GaiaConstants::kSyncService);
   }
 }
 
 void ProfileSyncService::Initialize() {
+  DCHECK(!invalidator_registrar_.get());
+  invalidator_registrar_.reset(new syncer::InvalidatorRegistrar());
+
   InitSettings();
 
   // We clear this here (vs Shutdown) because we want to remember that an error
   // happened on shutdown so we can display details (message, location) about it
   // in about:sync.
   ClearStaleErrors();
 
   sync_prefs_.AddSyncPrefObserver(this);
 
   // For now, the only thing we can do through policy is to turn sync off.
@@ skipping 244 matching lines @@
       credentials,
       delete_stale_data,
       &sync_manager_factory_,
       backend_unrecoverable_error_handler_.get(),
       &browser_sync::ChromeReportUnrecoverableError);
 }
 
 void ProfileSyncService::CreateBackend() {
   backend_.reset(
       new SyncBackendHost(profile_->GetDebugName(),
-                          profile_, sync_prefs_.AsWeakPtr()));
+                          profile_, sync_prefs_.AsWeakPtr(),
+                          invalidator_storage_.AsWeakPtr()));
 }
 
 bool ProfileSyncService::IsEncryptedDatatypeEnabled() const {
   if (encryption_pending())
     return true;
   const syncer::ModelTypeSet preferred_types = GetPreferredDataTypes();
   const syncer::ModelTypeSet encrypted_types = GetEncryptedDataTypes();
   DCHECK(encrypted_types.Has(syncer::PASSWORDS));
   return !Intersection(preferred_types, encrypted_types).Empty();
 }
@@ skipping 105 matching lines @@
     return;
   }
 
   DCHECK(IsSyncEnabledAndLoggedIn());
   CreateBackend();
 
   // Initialize the backend.  Every time we start up a new SyncBackendHost,
   // we'll want to start from a fresh SyncDB, so delete any old one that might
   // be there.
   InitializeBackend(!HasSyncSetupCompleted());
+
+  // |backend_| may end up being NULL here in tests (in synchronous
+  // initialization mode).
+  //
+  // TODO(akalin): Fix this horribly non-intuitive behavior (see
+  // http://crbug.com/140354).
+  if (backend_) {
+    backend_->UpdateRegisteredInvalidationIds(
+        invalidator_registrar_->GetAllRegisteredIds());
+    for (AckHandleReplayQueue::const_iterator it = ack_replay_queue_.begin();
+         it != ack_replay_queue_.end(); ++it) {
+      backend_->AcknowledgeInvalidation(it->first, it->second);
+    }
+    ack_replay_queue_.clear();
+  }
+}
+
+void ProfileSyncService::RegisterInvalidationHandler(
+    syncer::InvalidationHandler* handler) {
+  invalidator_registrar_->RegisterHandler(handler);
+}
+
+void ProfileSyncService::UpdateRegisteredInvalidationIds(
+    syncer::InvalidationHandler* handler,
+    const syncer::ObjectIdSet& ids) {
+  invalidator_registrar_->UpdateRegisteredIds(handler, ids);
+
+  // If |backend_| is NULL, its registered IDs will be updated when
+  // it's created and initialized.
+  if (backend_) {
+    backend_->UpdateRegisteredInvalidationIds(
+        invalidator_registrar_->GetAllRegisteredIds());
+  }
+}
+
+void ProfileSyncService::UnregisterInvalidationHandler(
+    syncer::InvalidationHandler* handler) {
+  invalidator_registrar_->UnregisterHandler(handler);
+}
+
+void ProfileSyncService::AcknowledgeInvalidation(
+    const invalidation::ObjectId& id,
+    const syncer::AckHandle& ack_handle) {
+  if (backend_) {
+    backend_->AcknowledgeInvalidation(id, ack_handle);
+  } else {
+    // If |backend_| is NULL, save the acknowledgements to replay when
+    // it's created and initialized.
+    ack_replay_queue_.push_back(std::make_pair(id, ack_handle));
+  }
+}
+
+syncer::InvalidatorState ProfileSyncService::GetInvalidatorState() const {
+  return invalidator_registrar_->GetInvalidatorState();
 }
 
 void ProfileSyncService::OnGetTokenSuccess(
     const OAuth2TokenService::Request* request,
     const std::string& access_token,
     const base::Time& expiration_time) {
   DCHECK_EQ(access_token_request_, request);
   access_token_request_.reset();
   // Reset backoff time after successful response.
   request_access_token_backoff_.Reset();
@@ skipping 43 matching lines @@
       }
       // Fallthrough.
     }
     default: {
       // Show error to user.
       UpdateAuthErrorState(error);
     }
   }
 }
 
+void ProfileSyncService::EmitInvalidationForTest(
+    const invalidation::ObjectId& id,
+    const std::string& payload) {
+  syncer::ObjectIdSet notify_ids;
+  notify_ids.insert(id);
+
+  const syncer::ObjectIdInvalidationMap& invalidation_map =
+      ObjectIdSetToInvalidationMap(notify_ids, payload);
+  OnIncomingInvalidation(invalidation_map);
+}
+
 void ProfileSyncService::Shutdown() {
+  DCHECK(invalidator_registrar_.get());
+  // Reset |invalidator_registrar_| first so that ShutdownImpl cannot
+  // use it.
+  invalidator_registrar_.reset();
+
   if (signin_)
     signin_->signin_global_error()->RemoveProvider(this);
 
   ShutdownImpl(false);
 }
 
 void ProfileSyncService::ShutdownImpl(bool sync_disabled) {
   // First, we spin down the backend and wait for it to stop syncing completely
   // before we Stop the data type manager.  This is to avoid a late sync cycle
   // applying changes to the sync db that wouldn't get applied via
@@ skipping 34 matching lines @@
   base::TimeDelta shutdown_time = base::Time::Now() - shutdown_start_time;
   UMA_HISTOGRAM_TIMES("Sync.Shutdown.BackendDestroyedTime", shutdown_time);
 
   weak_factory_.InvalidateWeakPtrs();
 
   // Clear various flags.
   start_up_time_ = base::Time();
   expect_sync_configuration_aborted_ = false;
   is_auth_in_progress_ = false;
   backend_initialized_ = false;
+  // NULL if we're called from Shutdown().
+  if (invalidator_registrar_)
+    UpdateInvalidatorRegistrarState();
   cached_passphrase_.clear();
   encryption_pending_ = false;
   encrypt_everything_ = false;
   encrypted_types_ = syncer::SyncEncryptionHandler::SensitiveTypes();
   passphrase_required_reason_ = syncer::REASON_PASSPHRASE_NOT_REQUIRED;
   request_access_token_retry_timer_.Stop();
   // Revert to "no auth error".
   if (last_auth_error_.state() != GoogleServiceAuthError::NONE)
     UpdateAuthErrorState(GoogleServiceAuthError::AuthErrorNone());
 
   if (sync_global_error_) {
     GlobalErrorServiceFactory::GetForProfile(profile_)->RemoveGlobalError(
         sync_global_error_.get());
     RemoveObserver(sync_global_error_.get());
     sync_global_error_.reset(NULL);
   }
 
   NotifyObservers();
 }
 
 void ProfileSyncService::DisableForUser() {
   // Clear prefs (including SyncSetupHasCompleted) before shutting down so
   // PSS clients don't think we're set up while we're shutting down.
   sync_prefs_.ClearPreferences();
+  invalidator_storage_.Clear();
   ClearUnrecoverableError();
   ShutdownImpl(true);
 }
 
 bool ProfileSyncService::HasSyncSetupCompleted() const {
   return sync_prefs_.HasSyncSetupCompleted();
 }
 
 void ProfileSyncService::SetSyncSetupCompleted() {
   sync_prefs_.SetSyncSetupCompleted();
 }
 
 void ProfileSyncService::UpdateLastSyncedTime() {
   last_synced_time_ = base::Time::Now();
   sync_prefs_.SetLastSyncedTime(last_synced_time_);
 }
 
 void ProfileSyncService::NotifyObservers() {
   FOR_EACH_OBSERVER(Observer, observers_, OnStateChanged());
   // TODO(akalin): Make an Observer subclass that listens and does the
   // event routing.
-  sync_js_controller_.HandleJsEvent("onServiceStateChanged", JsEventDetails());
-}
-
-void ProfileSyncService::NotifySyncCycleCompleted() {
-  FOR_EACH_OBSERVER(Observer, observers_, OnSyncCycleCompleted());
   sync_js_controller_.HandleJsEvent(
       "onServiceStateChanged", JsEventDetails());
 }
 
 void ProfileSyncService::ClearStaleErrors() {
   ClearUnrecoverableError();
   last_actionable_error_ = SyncProtocolError();
   // Clear the data type errors as well.
   failed_data_types_handler_.Reset();
 }
@@ skipping 63 matching lines @@
   // the task that we are going to post, this type would still be disabled.
   failed_data_types_handler_.UpdateFailedDataTypes(
       errors,
       FailedDataTypesHandler::RUNTIME);
 
   base::MessageLoop::current()->PostTask(FROM_HERE,
       base::Bind(&ProfileSyncService::ReconfigureDatatypeManager,
                  weak_factory_.GetWeakPtr()));
 }
 
+void ProfileSyncService::OnInvalidatorStateChange(
+    syncer::InvalidatorState state) {
+  invalidator_state_ = state;
+  UpdateInvalidatorRegistrarState();
+}
+
+void ProfileSyncService::OnIncomingInvalidation(
+    const syncer::ObjectIdInvalidationMap& invalidation_map) {
+  invalidator_registrar_->DispatchInvalidationsToHandlers(invalidation_map);
+}
+
 void ProfileSyncService::OnBackendInitialized(
     const syncer::WeakHandle<syncer::JsBackend>& js_backend,
     const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
         debug_info_listener,
     bool success) {
   is_first_time_sync_configure_ = !HasSyncSetupCompleted();
 
   if (is_first_time_sync_configure_) {
     UMA_HISTOGRAM_BOOLEAN("Sync.BackendInitializeFirstTimeSuccess", success);
   } else {
@@ skipping 23 matching lines @@
     // we get here, we will have already tried and failed to delete the
     // directory.  It would be no big deal if we tried to delete it again.
     OnInternalUnrecoverableError(FROM_HERE,
                                  "BackendInitialize failure",
                                  false,
                                  ERROR_REASON_BACKEND_INIT_FAILURE);
     return;
   }
 
   backend_initialized_ = true;
+  UpdateInvalidatorRegistrarState();
 
   sync_js_controller_.AttachJsBackend(js_backend);
   debug_info_listener_ = debug_info_listener;
 
   // If we have a cached passphrase use it to decrypt/encrypt data now that the
   // backend is initialized. We want to call this before notifying observers in
   // case this operation affects the "passphrase required" status.
   ConsumeCachedPassphraseIfPossible();
 
   // The very first time the backend initializes is effectively the first time
@@ skipping 28 matching lines @@
     // Trigger garbage collection of old sessions now that we've downloaded
     // any new session data. TODO(zea): Have this be a notification the session
     // model associator listens too. Also consider somehow plumbing the current
     // server time as last reported by CheckServerReachable, so we don't have to
     // rely on the local clock, which may be off significantly.
     base::MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(&browser_sync::SessionModelAssociator::DeleteStaleSessions,
                    GetSessionModelAssociator()->AsWeakPtr()));
   }
   DVLOG(2) << "Notifying observers sync cycle completed";
-  NotifySyncCycleCompleted();
+  NotifyObservers();
 }
 
 void ProfileSyncService::OnExperimentsChanged(
     const syncer::Experiments& experiments) {
   if (current_experiments_.Matches(experiments))
     return;
 
   // If this is a first time sync for a client, this will be called before
   // OnBackendInitialized() to ensure the new datatypes are available at sync
   // setup. As a result, the migrator won't exist yet. This is fine because for
@@ skipping 75 matching lines @@
       NOTREACHED();
       return AuthError(AuthError::CONNECTION_FAILED);
   }
 }
 
 }  // namespace
 
 void ProfileSyncService::OnConnectionStatusChange(
     syncer::ConnectionStatus status) {
   if (use_oauth2_token_ && status == syncer::CONNECTION_AUTH_ERROR) {
-    // Sync server returned error indicating that access token is invalid. It
-    // could be either expired or access is revoked. Let's request another
-    // access token and if access is revoked then request for token will fail
-    // with corresponding error.
+    // Sync or Tango server returned error indicating that access token is
+    // invalid. It could be either expired or access is revoked. Let's request
+    // another access token and if access is revoked then request for token will
+    // fail with corresponding error.
     RequestAccessToken();
   } else {
     const GoogleServiceAuthError auth_error =
         ConnectionStatusToAuthError(status);
     DVLOG(1) << "Connection status change: " << auth_error.ToString();
     UpdateAuthErrorState(auth_error);
   }
 }
 
 void ProfileSyncService::OnStopSyncingPermanently() {
@@ skipping 1004 matching lines @@
 void ProfileSyncService::OnInternalUnrecoverableError(
     const tracked_objects::Location& from_here,
     const std::string& message,
     bool delete_sync_database,
     UnrecoverableErrorReason reason) {
   DCHECK(!HasUnrecoverableError());
   unrecoverable_error_reason_ = reason;
   OnUnrecoverableErrorImpl(from_here, message, delete_sync_database);
 }
 
+void ProfileSyncService::UpdateInvalidatorRegistrarState() {
+  const syncer::InvalidatorState effective_state =
+      backend_initialized_ ?
+      invalidator_state_ : syncer::TRANSIENT_INVALIDATION_ERROR;
+  DVLOG(1) << "New invalidator state: "
+           << syncer::InvalidatorStateToString(invalidator_state_)
+           << ", effective state: "
+           << syncer::InvalidatorStateToString(effective_state);
+  invalidator_registrar_->UpdateInvalidatorState(effective_state);
+}
+
 std::string ProfileSyncService::GetEffectiveUsername() {
 #if defined(ENABLE_MANAGED_USERS)
   if (ManagedUserService::ProfileIsManaged(profile_)) {
     DCHECK_EQ(std::string(), signin_->GetAuthenticatedUsername());
     return ManagedUserService::GetManagedUserPseudoEmail();
   }
 #endif
 
   return signin_->GetAuthenticatedUsername();
 }