Separate local and remote sync invalidations

chrome/browser/sync/glue/android_invalidator_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 "chrome/browser/sync/glue/android_invalidator_bridge.h"
 
 #include <cstddef>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
@@ skipping 15 matching lines @@
 
 namespace browser_sync {
 namespace {
 
 using ::testing::NiceMock;
 
 // Since all the interesting stuff happens on the sync thread, we have
 // to be careful to use GTest/GMock only on the main thread since they
 // are not thread-safe.
 
-class ChromeSyncNotificationBridgeTest : public testing::Test {
+class AndroidInvalidatorBridgeTest : public testing::Test {
  public:
-  ChromeSyncNotificationBridgeTest()
+  AndroidInvalidatorBridgeTest()
       : ui_thread_(content::BrowserThread::UI, &ui_loop_),
         sync_thread_("Sync thread"),
         sync_handler_notification_success_(false) {}
 
-  virtual ~ChromeSyncNotificationBridgeTest() {}
+  virtual ~AndroidInvalidatorBridgeTest() {}
 
  protected:
   virtual void SetUp() OVERRIDE {
     ASSERT_TRUE(sync_thread_.Start());
     bridge_.reset(
-        new ChromeSyncNotificationBridge(
+        new AndroidInvalidatorBridge(
             &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_handler_.get());
     if (!sync_handler_notification_success_)
       ADD_FAILURE() << "Sync handler did not receive proper notification.";
   }
 
   void VerifyAndDestroyObserver(
       const syncer::ModelTypeInvalidationMap& expected_invalidations,
       syncer::IncomingInvalidationSource expected_source) {
     ASSERT_TRUE(sync_thread_.message_loop_proxy()->PostTask(
         FROM_HERE,
-        base::Bind(&ChromeSyncNotificationBridgeTest::
+        base::Bind(&AndroidInvalidatorBridgeTest::
                        VerifyAndDestroyObserverOnSyncThread,
                    base::Unretained(this),
                    expected_invalidations,
                    expected_source)));
     BlockForSyncThread();
   }
 
   void CreateObserver() {
     ASSERT_TRUE(sync_thread_.message_loop_proxy()->PostTask(
         FROM_HERE,
         base::Bind(
-            &ChromeSyncNotificationBridgeTest::CreateObserverOnSyncThread,
+            &AndroidInvalidatorBridgeTest::CreateObserverOnSyncThread,
             base::Unretained(this))));
     BlockForSyncThread();
   }
 
   void UpdateEnabledTypes(syncer::ModelTypeSet enabled_types) {
     ASSERT_TRUE(sync_thread_.message_loop_proxy()->PostTask(
         FROM_HERE,
         base::Bind(
-            &ChromeSyncNotificationBridgeTest::
+            &AndroidInvalidatorBridgeTest::
                 UpdateEnabledTypesOnSyncThread,
             base::Unretained(this),
             enabled_types)));
     BlockForSyncThread();
   }
 
   void TriggerRefreshNotification(
       int type,
       const syncer::ModelTypeInvalidationMap& invalidation_map) {
     content::NotificationService::current()->Notify(
@@ skipping 48 matching lines @@
     run_loop.Run();
   }
 
   MessageLoop ui_loop_;
   content::TestBrowserThread ui_thread_;
   base::Thread sync_thread_;
   NiceMock<ProfileMock> mock_profile_;
   // Created/used/destroyed on sync thread.
   scoped_ptr<syncer::FakeInvalidationHandler> sync_handler_;
   bool sync_handler_notification_success_;
-  scoped_ptr<ChromeSyncNotificationBridge> bridge_;
+  scoped_ptr<AndroidInvalidatorBridge> bridge_;
 };
 
-// Adds an observer on the sync thread, triggers a local refresh
-// invalidation, and ensures the bridge posts a LOCAL_INVALIDATION
-// with the proper state to it.
-TEST_F(ChromeSyncNotificationBridgeTest, LocalNotification) {
-  const syncer::ModelTypeSet types(syncer::SESSIONS);
-  const syncer::ModelTypeInvalidationMap& invalidation_map =
-      ModelTypeSetToInvalidationMap(types, std::string());
-  CreateObserver();
-  UpdateEnabledTypes(syncer::ModelTypeSet(syncer::SESSIONS));
-  TriggerRefreshNotification(chrome::NOTIFICATION_SYNC_REFRESH_LOCAL,
-                             invalidation_map);
-  VerifyAndDestroyObserver(invalidation_map, syncer::LOCAL_INVALIDATION);
-}
-
 // Adds an observer on the sync thread, triggers a remote refresh
 // invalidation, and ensures the bridge posts a REMOTE_INVALIDATION
 // with the proper state to it.
-TEST_F(ChromeSyncNotificationBridgeTest, RemoteNotification) {
+TEST_F(AndroidInvalidatorBridgeTest, RemoteNotification) {
   const syncer::ModelTypeSet types(syncer::SESSIONS);
   const syncer::ModelTypeInvalidationMap& invalidation_map =
       ModelTypeSetToInvalidationMap(types, std::string());
   CreateObserver();
   UpdateEnabledTypes(syncer::ModelTypeSet(syncer::SESSIONS));
   TriggerRefreshNotification(chrome::NOTIFICATION_SYNC_REFRESH_REMOTE,
                              invalidation_map);
   VerifyAndDestroyObserver(invalidation_map, syncer::REMOTE_INVALIDATION);
 }
 
-// Adds an observer on the sync thread, triggers a local refresh
-// notification with empty state map and ensures the bridge posts a
-// LOCAL_INVALIDATION with the proper state to it.
-TEST_F(ChromeSyncNotificationBridgeTest, LocalNotificationEmptyPayloadMap) {
-  const syncer::ModelTypeSet enabled_types(
-      syncer::BOOKMARKS, syncer::PASSWORDS);
-  const syncer::ModelTypeInvalidationMap enabled_types_invalidation_map =
-      syncer::ModelTypeSetToInvalidationMap(enabled_types, std::string());
-  CreateObserver();
-  UpdateEnabledTypes(enabled_types);
-  TriggerRefreshNotification(chrome::NOTIFICATION_SYNC_REFRESH_LOCAL,
-                             syncer::ModelTypeInvalidationMap());
-  VerifyAndDestroyObserver(
-      enabled_types_invalidation_map, syncer::LOCAL_INVALIDATION);
-}
-
 // Adds an observer on the sync thread, triggers a remote refresh
 // notification with empty state map and ensures the bridge posts a
 // REMOTE_INVALIDATION with the proper state to it.
-TEST_F(ChromeSyncNotificationBridgeTest, RemoteNotificationEmptyPayloadMap) {
+TEST_F(AndroidInvalidatorBridgeTest, RemoteNotificationEmptyPayloadMap) {
   const syncer::ModelTypeSet enabled_types(
       syncer::BOOKMARKS, syncer::TYPED_URLS);
   const syncer::ModelTypeInvalidationMap enabled_types_invalidation_map =
       syncer::ModelTypeSetToInvalidationMap(enabled_types, std::string());
   CreateObserver();
   UpdateEnabledTypes(enabled_types);
   TriggerRefreshNotification(chrome::NOTIFICATION_SYNC_REFRESH_REMOTE,
                              syncer::ModelTypeInvalidationMap());
   VerifyAndDestroyObserver(
       enabled_types_invalidation_map, syncer::REMOTE_INVALIDATION);
 }
 
 }  // namespace
 }  // namespace browser_sync