Remove syncer::IncomingInvalidationSource

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/android_invalidator_bridge.h"
 
 #include <cstddef>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 48 matching lines @@
     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) {
+      const syncer::ModelTypeInvalidationMap& expected_invalidations) {
     ASSERT_TRUE(sync_thread_.message_loop_proxy()->PostTask(
         FROM_HERE,
         base::Bind(&AndroidInvalidatorBridgeTest::
                        VerifyAndDestroyObserverOnSyncThread,
                    base::Unretained(this),
-                   expected_invalidations,
-                   expected_source)));
+                   expected_invalidations)));
     BlockForSyncThread();
   }
 
   void CreateObserver() {
     ASSERT_TRUE(sync_thread_.message_loop_proxy()->PostTask(
         FROM_HERE,
         base::Bind(
             &AndroidInvalidatorBridgeTest::CreateObserverOnSyncThread,
             base::Unretained(this))));
     BlockForSyncThread();
@@ skipping 16 matching lines @@
     content::NotificationService::current()->Notify(
         type,
         content::Source<Profile>(&mock_profile_),
         content::Details<const syncer::ModelTypeInvalidationMap>(
             &invalidation_map));
     BlockForSyncThread();
   }
 
  private:
   void VerifyAndDestroyObserverOnSyncThread(
-      const syncer::ModelTypeInvalidationMap& expected_invalidations,
-      syncer::IncomingInvalidationSource expected_source) {
+      const syncer::ModelTypeInvalidationMap& expected_invalidations) {
     DCHECK(sync_thread_.message_loop_proxy()->RunsTasksOnCurrentThread());
     if (sync_handler_.get()) {
       sync_handler_notification_success_ =
           (sync_handler_->GetInvalidationCount() == 1) &&
           ObjectIdInvalidationMapEquals(
               sync_handler_->GetLastInvalidationMap(),
               syncer::ModelTypeInvalidationMapToObjectIdInvalidationMap(
-                  expected_invalidations)) &&
-          (sync_handler_->GetLastInvalidationSource() == expected_source);
+                  expected_invalidations));
       bridge_->UnregisterHandler(sync_handler_.get());
     } else {
       sync_handler_notification_success_ = false;
     }
     sync_handler_.reset();
   }
 
   void CreateObserverOnSyncThread() {
     DCHECK(sync_thread_.message_loop_proxy()->RunsTasksOnCurrentThread());
     sync_handler_.reset(new syncer::FakeInvalidationHandler());
@@ skipping 32 matching lines @@
 // invalidation, and ensures the bridge posts a REMOTE_INVALIDATION
 // with the proper state to it.
 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);
+  VerifyAndDestroyObserver(invalidation_map);
 }
 
 // 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(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);
+  VerifyAndDestroyObserver(enabled_types_invalidation_map);
 }
 
 }  // namespace
 }  // namespace browser_sync