[Sync] Pass the correct set of enabled types to the sync notifier

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 108 matching lines @@
 
   virtual void TearDown() OVERRIDE {
     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(
+        FROM_HERE,
+        base::Bind(&ChromeSyncNotificationBridgeTest::
+                       VerifyAndDestroyObserverOnSyncThread,
+                   base::Unretained(this))));
+    BlockForSyncThread();
+  }
+
+  void CreateObserverWithExpectations(
+      syncer::ModelTypePayloadMap expected_payloads,
+      syncer::IncomingNotificationSource expected_source) {
+    ASSERT_TRUE(sync_thread_.message_loop_proxy()->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &ChromeSyncNotificationBridgeTest::CreateObserverOnSyncThread,
+            base::Unretained(this),
+            expected_payloads,
+            expected_source)));
+    BlockForSyncThread();
+  }
+
+  void UpdateBridgeEnabledTypes(syncer::ModelTypeSet enabled_types) {
+    ASSERT_TRUE(sync_thread_.message_loop_proxy()->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &ChromeSyncNotificationBridgeTest::
+                UpdateBridgeEnabledTypesOnSyncThread,
+            base::Unretained(this),
+            enabled_types)));
+    BlockForSyncThread();
+  }
+
+  void TriggerRefreshNotification(
+      int type,
+      const syncer::ModelTypePayloadMap& payload_map) {
+    content::NotificationService::current()->Notify(
+        type,
+        content::Source<Profile>(&mock_profile_),
+        content::Details<const syncer::ModelTypePayloadMap>(&payload_map));
+  }
+
+ private:
   void VerifyAndDestroyObserverOnSyncThread() {
     DCHECK(sync_thread_.message_loop_proxy()->RunsTasksOnCurrentThread());
     if (!sync_observer_) {
       sync_observer_notification_failure_ = true;
     } else {
       sync_observer_notification_failure_ =
           !sync_observer_->ReceivedProperNotification();
       delete sync_observer_;
       sync_observer_ = NULL;
     }
   }
 
-  void VerifyAndDestroyObserver() {
-    ASSERT_TRUE(sync_thread_.message_loop_proxy()->PostTask(
-        FROM_HERE,
-        base::Bind(&ChromeSyncNotificationBridgeTest::
-                       VerifyAndDestroyObserverOnSyncThread,
-                   base::Unretained(this))));
-    BlockForSyncThread();
-  }
-
   void CreateObserverOnSyncThread(
       syncer::ModelTypePayloadMap 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 CreateObserverWithExpectations(
-      syncer::ModelTypePayloadMap expected_payloads,
-      syncer::IncomingNotificationSource expected_source) {
-    ASSERT_TRUE(sync_thread_.message_loop_proxy()->PostTask(
-        FROM_HERE,
-        base::Bind(
-            &ChromeSyncNotificationBridgeTest::CreateObserverOnSyncThread,
-            base::Unretained(this),
-            expected_payloads,
-            expected_source)));
-    BlockForSyncThread();
+  void UpdateBridgeEnabledTypesOnSyncThread(
+      syncer::ModelTypeSet enabled_types) {
+    DCHECK(sync_thread_.message_loop_proxy()->RunsTasksOnCurrentThread());
+    bridge_->UpdateEnabledTypes(enabled_types);
   }
 
   void SignalOnSyncThread() {
     DCHECK(sync_thread_.message_loop_proxy()->RunsTasksOnCurrentThread());
     done_.Signal();
   }
 
   void BlockForSyncThread() {
     done_.Reset();
     ASSERT_TRUE(sync_thread_.message_loop_proxy()->PostTask(
         FROM_HERE,
         base::Bind(&ChromeSyncNotificationBridgeTest::SignalOnSyncThread,
                    base::Unretained(this))));
     done_.TimedWait(TestTimeouts::action_timeout());
     if (!done_.IsSignaled())
-      ADD_FAILURE() << "Timed out waiting for IO thread.";
+      ADD_FAILURE() << "Timed out waiting for sync thread.";
   }
 
-  void TriggerRefreshNotification(
-      int type,
-      const syncer::ModelTypePayloadMap& payload_map) {
-    content::NotificationService::current()->Notify(
-        type,
-        content::Source<Profile>(&mock_profile_),
-        content::Details<const syncer::ModelTypePayloadMap>(&payload_map));
-  }
-
- private:
   content::TestBrowserThread ui_thread_;
   base::Thread sync_thread_;
   NiceMock<ProfileMock> mock_profile_;
   // Created/used/destroyed on sync thread.
   FakeSyncNotifierObserver* sync_observer_;
   bool sync_observer_notification_failure_;
   scoped_ptr<ChromeSyncNotificationBridge> bridge_;
   base::WaitableEvent done_;
 };
 
@@ skipping 24 matching lines @@
 // Adds an observer on the sync thread, triggers a local refresh
 // notification with empty payload map and ensures the bridge posts a
 // LOCAL_NOTIFICATION with the proper payload to it.
 TEST_F(ChromeSyncNotificationBridgeTest, LocalNotificationEmptyPayloadMap) {
   const syncer::ModelTypeSet enabled_types(
       syncer::BOOKMARKS, syncer::PASSWORDS);
   const syncer::ModelTypePayloadMap enabled_types_payload_map =
       syncer::ModelTypePayloadMapFromEnumSet(enabled_types, std::string());
   CreateObserverWithExpectations(
       enabled_types_payload_map, syncer::LOCAL_NOTIFICATION);
+  UpdateBridgeEnabledTypes(enabled_types);
   TriggerRefreshNotification(chrome::NOTIFICATION_SYNC_REFRESH_LOCAL,
-                             enabled_types_payload_map);
+                             syncer::ModelTypePayloadMap());
   VerifyAndDestroyObserver();
 }
 
 // Adds an observer on the sync thread, triggers a remote refresh
 // notification with empty payload map and ensures the bridge posts a
 // REMOTE_NOTIFICATION with the proper payload to it.
 TEST_F(ChromeSyncNotificationBridgeTest, RemoteNotificationEmptyPayloadMap) {
   const syncer::ModelTypeSet enabled_types(
       syncer::BOOKMARKS, syncer::TYPED_URLS);
   const syncer::ModelTypePayloadMap enabled_types_payload_map =
       syncer::ModelTypePayloadMapFromEnumSet(enabled_types, std::string());
   CreateObserverWithExpectations(
       enabled_types_payload_map, syncer::REMOTE_NOTIFICATION);
+  UpdateBridgeEnabledTypes(enabled_types);
   TriggerRefreshNotification(chrome::NOTIFICATION_SYNC_REFRESH_REMOTE,
-                             enabled_types_payload_map);
+                             syncer::ModelTypePayloadMap());
   VerifyAndDestroyObserver();
 }
 
 }  // namespace
 }  // namespace browser_sync