[Sync] Avoid unregistering object IDs on shutdown

chrome/browser/sync/glue/chrome_sync_notification_bridge_unittest.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/glue/chrome_sync_notification_bridge.h"
 
+#include <cstddef>

[msw, 2012/08/03 23:30:46]

nit/question: is it better practice to include this or base/basictypes.h?

[akalin, 2012/08/07 07:25:19]

i don't think basictypes.h makes any particular guarantee about defining NULL,
so I think it's better to include cstddef directly

+
 #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/message_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/test/base/profile_mock.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/test/test_browser_thread.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/base/model_type_payload_map.h"
 #include "sync/notifier/sync_notifier_observer.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace browser_sync {
 namespace {
 
 using ::testing::Mock;
 using ::testing::NiceMock;
 using ::testing::StrictMock;
 using content::BrowserThread;
 
+const char kHandlerName[] = "FakeSyncNotifierObserver";
+
 // Receives a ChromeSyncNotificationBridge to register to, and an expected
 // ModelTypePayloadMap. ReceivedProperNotification() will return true only
 // if the observer has received a notification with the proper source and
 // payload.
 // Note: Because this object lives on the sync thread, we use a fake
 // (vs a mock) so we don't have to worry about possible thread safety
 // issues within GTest/GMock.
 class FakeSyncNotifierObserver : public syncer::SyncNotifierObserver {
  public:
   FakeSyncNotifierObserver(
       const scoped_refptr<base::SequencedTaskRunner>& sync_task_runner,
       ChromeSyncNotificationBridge* bridge,
       const syncer::ObjectIdPayloadMap& expected_payloads,
       syncer::IncomingNotificationSource expected_source)
       : sync_task_runner_(sync_task_runner),
         bridge_(bridge),
         received_improper_notification_(false),
         notification_count_(0),
         expected_payloads_(expected_payloads),
         expected_source_(expected_source) {
     DCHECK(sync_task_runner_->RunsTasksOnCurrentThread());
+    bridge_->SetHandler(kHandlerName, this);
     const syncer::ObjectIdSet& ids =
         syncer::ObjectIdPayloadMapToSet(expected_payloads);
-    bridge_->UpdateRegisteredIds(this, ids);
+    bridge_->UpdateRegisteredIds(kHandlerName, ids);
   }
 
   virtual ~FakeSyncNotifierObserver() {
     DCHECK(sync_task_runner_->RunsTasksOnCurrentThread());
-    bridge_->UpdateRegisteredIds(this, syncer::ObjectIdSet());
+    bridge_->SetHandler(kHandlerName, NULL);
   }
 
   // SyncNotifierObserver implementation.
   virtual void OnIncomingNotification(
       const syncer::ObjectIdPayloadMap& id_payloads,
       syncer::IncomingNotificationSource source) OVERRIDE {
     DCHECK(sync_task_runner_->RunsTasksOnCurrentThread());
     notification_count_++;
     if (source != expected_source_) {
       LOG(ERROR) << "Received notification with wrong source";
@@ skipping 39 matching lines @@
 
  protected:
   virtual void SetUp() OVERRIDE {
     ASSERT_TRUE(sync_thread_.Start());
     bridge_.reset(
         new ChromeSyncNotificationBridge(
             &mock_profile_, sync_thread_.message_loop_proxy()));
   }
 
   virtual void TearDown() OVERRIDE {
+    bridge_->StopForShutdown();
     sync_thread_.Stop();
     // Must be reset only after the sync thread is stopped.
     bridge_.reset();
     EXPECT_EQ(NULL, sync_observer_);
     if (sync_observer_notification_failure_)
       ADD_FAILURE() << "Sync Observer did not receive proper notification.";
   }
 
   void VerifyAndDestroyObserver() {
     ASSERT_TRUE(sync_thread_.message_loop_proxy()->PostTask(
@@ skipping 146 matching lines @@
   CreateObserverWithExpectations(
       enabled_types_payload_map, syncer::REMOTE_NOTIFICATION);
   UpdateBridgeEnabledTypes(enabled_types);
   TriggerRefreshNotification(chrome::NOTIFICATION_SYNC_REFRESH_REMOTE,
                              syncer::ModelTypePayloadMap());
   VerifyAndDestroyObserver();
 }
 
 }  // namespace
 }  // namespace browser_sync