Merge 208347 "Revert 208315 "Make use of InvalidationService""

sync/internal_api/test/fake_sync_manager.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 "sync/internal_api/public/test/fake_sync_manager.h"
 
 #include <cstddef>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 43 matching lines @@
   enabled_types_.Clear();
   return enabled_types;
 }
 
 ConfigureReason FakeSyncManager::GetAndResetConfigureReason() {
   ConfigureReason reason = last_configure_reason_;
   last_configure_reason_ = CONFIGURE_REASON_UNKNOWN;
   return reason;
 }
 
+void FakeSyncManager::Invalidate(
+    const ObjectIdInvalidationMap& invalidation_map) {
+  if (!sync_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&FakeSyncManager::InvalidateOnSyncThread,
+                 base::Unretained(this), invalidation_map))) {
+    NOTREACHED();
+  }
+}
+
+void FakeSyncManager::UpdateInvalidatorState(InvalidatorState state) {
+  if (!sync_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&FakeSyncManager::UpdateInvalidatorStateOnSyncThread,
+                 base::Unretained(this), state))) {
+    NOTREACHED();
+  }
+}
+
 void FakeSyncManager::WaitForSyncThread() {
   // Post a task to |sync_task_runner_| and block until it runs.
   base::RunLoop run_loop;
   if (!sync_task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&base::DoNothing),
       run_loop.QuitClosure())) {
     NOTREACHED();
   }
   run_loop.Run();
 }
 
 void FakeSyncManager::Init(
     const base::FilePath& database_location,
     const WeakHandle<JsEventHandler>& event_handler,
     const std::string& sync_server_and_path,
     int sync_server_port,
     bool use_ssl,
     scoped_ptr<HttpPostProviderFactory> post_factory,
     const std::vector<ModelSafeWorker*>& workers,
     ExtensionsActivityMonitor* extensions_activity_monitor,
     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,
     scoped_ptr<InternalComponentsFactory> internal_components_factory,
     Encryptor* encryptor,
     UnrecoverableErrorHandler* unrecoverable_error_handler,
     ReportUnrecoverableErrorFunction
         report_unrecoverable_error_function,
     bool use_oauth2_token) {
   sync_task_runner_ = base::ThreadTaskRunnerHandle::Get();
@@ skipping 37 matching lines @@
   }
   progress_marker_types_.RemoveAll(partial_types);
   cleaned_types_.PutAll(partial_types);
   return true;
 }
 
 void FakeSyncManager::UpdateCredentials(const SyncCredentials& credentials) {
   NOTIMPLEMENTED();
 }
 
+void FakeSyncManager::UpdateEnabledTypes(ModelTypeSet types) {
+  enabled_types_ = types;
+}
+
+void FakeSyncManager::RegisterInvalidationHandler(
+    InvalidationHandler* handler) {
+  registrar_.RegisterHandler(handler);
+}
+
+void FakeSyncManager::UpdateRegisteredInvalidationIds(
+    InvalidationHandler* handler,
+    const ObjectIdSet& ids) {
+  registrar_.UpdateRegisteredIds(handler, ids);
+}
+
+void FakeSyncManager::UnregisterInvalidationHandler(
+    InvalidationHandler* handler) {
+  registrar_.UnregisterHandler(handler);
+}
+
+void FakeSyncManager::AcknowledgeInvalidation(const invalidation::ObjectId& id,
+                                              const AckHandle& ack_handle) {
+  // Do nothing.
+}
+
 void FakeSyncManager::StartSyncingNormally(
       const ModelSafeRoutingInfo& routing_info) {
   // Do nothing.
 }
 
 void FakeSyncManager::ConfigureSyncer(
     ConfigureReason reason,
     ModelTypeSet to_download,
     ModelTypeSet to_purge,
     ModelTypeSet to_journal,
     ModelTypeSet to_unapply,
     const ModelSafeRoutingInfo& new_routing_info,
     const base::Closure& ready_task,
     const base::Closure& retry_task) {
   last_configure_reason_ = reason;
-  enabled_types_ = GetRoutingInfoTypes(new_routing_info);
+  ModelTypeSet enabled_types = GetRoutingInfoTypes(new_routing_info);
   ModelTypeSet success_types = to_download;
   success_types.RemoveAll(configure_fail_types_);
 
   DVLOG(1) << "Faking configuration. Downloading: "
            << ModelTypeSetToString(success_types) << ". Cleaning: "
            << ModelTypeSetToString(to_purge);
 
   // Update our fake directory by clearing and fake-downloading as necessary.
   UserShare* share = GetUserShare();
   share->directory->PurgeEntriesWithTypeIn(to_purge,
@@ skipping 69 matching lines @@
 }
 
 SyncEncryptionHandler* FakeSyncManager::GetEncryptionHandler() {
   return fake_encryption_handler_.get();
 }
 
 void FakeSyncManager::RefreshTypes(ModelTypeSet types) {
   last_refresh_request_types_ = types;
 }
 
-void FakeSyncManager::OnIncomingInvalidation(
-      const ObjectIdInvalidationMap& invalidation_map) {
-  // Do nothing.
+void FakeSyncManager::InvalidateOnSyncThread(
+    const ObjectIdInvalidationMap& invalidation_map) {
+  DCHECK(sync_task_runner_->RunsTasksOnCurrentThread());
+  registrar_.DispatchInvalidationsToHandlers(invalidation_map);
+}
+
+void FakeSyncManager::UpdateInvalidatorStateOnSyncThread(
+    InvalidatorState state) {
+  DCHECK(sync_task_runner_->RunsTasksOnCurrentThread());
+  registrar_.UpdateInvalidatorState(state);
 }
 
 ModelTypeSet FakeSyncManager::GetLastRefreshRequestTypes() {
   return last_refresh_request_types_;
 }
 
-void FakeSyncManager::OnInvalidatorStateChange(InvalidatorState state) {
-  // Do nothing.
-}
-
 }  // namespace syncer