[Sync] Avoid unregistering object IDs on shutdown

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/location.h"
 #include "base/logging.h"
+#include "base/run_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "sync/internal_api/public/http_post_provider_factory.h"
 #include "sync/internal_api/public/internal_components_factory.h"
 #include "sync/internal_api/public/util/weak_handle.h"
 #include "sync/notifier/notifications_disabled_reason.h"
 #include "sync/notifier/object_id_payload_map.h"
 #include "sync/notifier/sync_notifier.h"
 
 namespace syncer {
 
-FakeSyncManager::FakeSyncManager() {}
+FakeSyncManager::FakeSyncManager(ModelTypeSet initial_sync_ended_types,
+                                 ModelTypeSet progress_marker_types,
+                                 ModelTypeSet configure_fail_types) :
+    initial_sync_ended_types_(initial_sync_ended_types),
+    progress_marker_types_(progress_marker_types),
+    configure_fail_types_(configure_fail_types) {}
 
 FakeSyncManager::~FakeSyncManager() {}
 
-void FakeSyncManager::set_initial_sync_ended_types(ModelTypeSet types) {
-  initial_sync_ended_types_ = types;
-}
-
-void FakeSyncManager::set_progress_marker_types(ModelTypeSet types) {
-  progress_marker_types_ = types;
-}
-
-void FakeSyncManager::set_configure_fail_types(ModelTypeSet types) {
-  configure_fail_types_ = types;
-}
-
 ModelTypeSet FakeSyncManager::GetAndResetCleanedTypes() {
   ModelTypeSet cleaned_types = cleaned_types_;
   cleaned_types_.Clear();
   return cleaned_types;
 }
 
 ModelTypeSet FakeSyncManager::GetAndResetDownloadedTypes() {
   ModelTypeSet downloaded_types = downloaded_types_;
   downloaded_types_.Clear();
   return downloaded_types;
@@ skipping 27 matching lines @@
 void FakeSyncManager::DisableNotifications(
     NotificationsDisabledReason reason) {
   if (!sync_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&FakeSyncManager::DisableNotificationsOnSyncThread,
                  base::Unretained(this), reason))) {
     NOTREACHED();
   }
 }
 
+namespace {
+
+void DoNothing() {}
+
+}  // namespace
+
+void FakeSyncManager::WaitForSyncThread() {

[msw, 2012/08/07 20:09:30]

This pattern seems odd, is there precedent for it elsewhere?
Can you use MessageLoop::RunAllPending or similar instead?

[akalin, 2012/08/07 23:38:05]

I don't think there's a precedent.  An alternate way to do it would be to post a
task to the sync thread that posts a quit task back to the main thread, and then
call Run().  But I think this is simpler.

RunAllPending won't work since you can't guarantee that the reply task will be
posted while you're running current pending tasks.  So you have to use Run() and
have the reply task be a quit.  But MessageLoop::QuitClosure() is deprecated in
favor of RunLoop::QuitClosure() (to avoid run nesting).

[msw, 2012/08/08 00:55:23]

Sorry, I don't fully understand what you're doing, but that's okay, because I
assume the other reviewers do :)

+  // 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(&DoNothing),
+      run_loop.QuitClosure())) {
+    NOTREACHED();
+  }
+  run_loop.Run();
+}
+
 bool FakeSyncManager::Init(
     const FilePath& database_location,
     const WeakHandle<JsEventHandler>& event_handler,
     const std::string& sync_server_and_path,
     int sync_server_port,
     bool use_ssl,
     const scoped_refptr<base::TaskRunner>& blocking_task_runner,
     scoped_ptr<HttpPostProviderFactory> post_factory,
     const std::vector<ModelSafeWorker*>& workers,
     ExtensionsActivityMonitor* extensions_activity_monitor,
@@ skipping 45 matching lines @@
 }
 
 void FakeSyncManager::UpdateCredentials(const SyncCredentials& credentials) {
   NOTIMPLEMENTED();
 }
 
 void FakeSyncManager::UpdateEnabledTypes(const ModelTypeSet& types) {
   enabled_types_ = types;
 }
 
+void FakeSyncManager::SetInvalidationHandler(
+    const std::string& handler_name,
+    SyncNotifierObserver* handler) {
+  notifier_helper_.SetHandler(handler_name, handler);
+}
+
 void FakeSyncManager::UpdateRegisteredInvalidationIds(
-    SyncNotifierObserver* handler,
+    const std::string& handler_name,
     const ObjectIdSet& ids) {
-  notifier_helper_.UpdateRegisteredIds(handler, ids);
+  notifier_helper_.UpdateRegisteredIds(handler_name, ids);
 }
 
 void FakeSyncManager::StartSyncingNormally(
       const ModelSafeRoutingInfo& routing_info) {
   // Do nothing.
 }
 
 void FakeSyncManager::SetEncryptionPassphrase(const std::string& passphrase,
                                               bool is_explicit) {
   NOTIMPLEMENTED();
@@ skipping 107 matching lines @@
   notifier_helper_.EmitOnNotificationsEnabled();
 }
 
 void FakeSyncManager::DisableNotificationsOnSyncThread(
     NotificationsDisabledReason reason) {
   DCHECK(sync_task_runner_->RunsTasksOnCurrentThread());
   notifier_helper_.EmitOnNotificationsDisabled(reason);
 }
 
 }  // namespace syncer