Refactor sync-specific parts out of SyncNotifier/SyncNotifierObserver

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 "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 26 matching lines @@
 // 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::ModelTypePayloadMap& expected_payloads,
+      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_->AddObserver(this);
+    // TODO(dcheng): We might want a function to go from ObjectIdPayloadMap ->
+    // ObjectIdSet to avoid this rather long incantation...
+    const syncer::ObjectIdSet& ids = syncer::ModelTypeSetToObjectIdSet(
+        syncer::ModelTypePayloadMapToEnumSet(
+            syncer::ObjectIdPayloadMapToModelTypePayloadMap(
+                expected_payloads)));
+    bridge_->UpdateRegisteredIds(this, ids);
   }
 
   virtual ~FakeSyncNotifierObserver() {
     DCHECK(sync_task_runner_->RunsTasksOnCurrentThread());
-    bridge_->RemoveObserver(this);
+    bridge_->UpdateRegisteredIds(this, syncer::ObjectIdSet());
   }
 
   // SyncNotifierObserver implementation.
   virtual void OnIncomingNotification(
-      const syncer::ModelTypePayloadMap& type_payloads,
+      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";
       received_improper_notification_ = true;
     }
-    if (expected_payloads_ != type_payloads) {
+    if (expected_payloads_ != id_payloads) {
       LOG(ERROR) << "Received wrong payload";
       received_improper_notification_ = true;
     }
   }
   virtual void OnNotificationsEnabled() OVERRIDE {
     NOTREACHED();
   }
   virtual void OnNotificationsDisabled(
       syncer::NotificationsDisabledReason reason) OVERRIDE {
     NOTREACHED();
   }
 
   bool ReceivedProperNotification() const {
     DCHECK(sync_task_runner_->RunsTasksOnCurrentThread());
     return (notification_count_ == 1) && !received_improper_notification_;
   }
 
  private:
   const scoped_refptr<base::SequencedTaskRunner> sync_task_runner_;
   ChromeSyncNotificationBridge* const bridge_;
   bool received_improper_notification_;
   size_t notification_count_;
-  const syncer::ModelTypePayloadMap expected_payloads_;
+  const syncer::ObjectIdPayloadMap expected_payloads_;
   const syncer::IncomingNotificationSource expected_source_;
 };
 
 class ChromeSyncNotificationBridgeTest : public testing::Test {
  public:
   ChromeSyncNotificationBridgeTest()
       : ui_thread_(BrowserThread::UI),
         sync_thread_("Sync thread"),
         sync_observer_(NULL),
         sync_observer_notification_failure_(false),
@@ skipping 21 matching lines @@
   void VerifyAndDestroyObserver() {
     ASSERT_TRUE(sync_thread_.message_loop_proxy()->PostTask(
         FROM_HERE,
         base::Bind(&ChromeSyncNotificationBridgeTest::
                        VerifyAndDestroyObserverOnSyncThread,
                    base::Unretained(this))));
     BlockForSyncThread();
   }
 
   void CreateObserverWithExpectations(
-      syncer::ModelTypePayloadMap expected_payloads,
+      const syncer::ModelTypePayloadMap& expected_payloads,
       syncer::IncomingNotificationSource expected_source) {
+    const syncer::ObjectIdPayloadMap& expected_id_payloads =
+        syncer::ModelTypePayloadMapToObjectIdPayloadMap(expected_payloads);
     ASSERT_TRUE(sync_thread_.message_loop_proxy()->PostTask(
         FROM_HERE,
         base::Bind(
             &ChromeSyncNotificationBridgeTest::CreateObserverOnSyncThread,
             base::Unretained(this),
-            expected_payloads,
+            expected_id_payloads,
             expected_source)));
     BlockForSyncThread();
   }
 
   void UpdateBridgeEnabledTypes(syncer::ModelTypeSet enabled_types) {
     ASSERT_TRUE(sync_thread_.message_loop_proxy()->PostTask(
         FROM_HERE,
         base::Bind(
             &ChromeSyncNotificationBridgeTest::
                 UpdateBridgeEnabledTypesOnSyncThread,
@@ skipping 18 matching lines @@
       sync_observer_notification_failure_ = true;
     } else {
       sync_observer_notification_failure_ =
           !sync_observer_->ReceivedProperNotification();
       delete sync_observer_;
       sync_observer_ = NULL;
     }
   }
 
   void CreateObserverOnSyncThread(
-      syncer::ModelTypePayloadMap expected_payloads,
+      const syncer::ObjectIdPayloadMap& expected_payloads,
       syncer::IncomingNotificationSource expected_source) {
     DCHECK(sync_thread_.message_loop_proxy()->RunsTasksOnCurrentThread());
     sync_observer_ = new FakeSyncNotifierObserver(
         sync_thread_.message_loop_proxy(),
         bridge_.get(),
         expected_payloads,
         expected_source);
   }
 
   void UpdateBridgeEnabledTypesOnSyncThread(
@@ skipping 79 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