Remove syncer::IncomingInvalidationSource

Since we separated local and remote invalidations in r179546, we no
longer need to differentiate between the two sources with an enum.  The
IncomingInvalidationSource is always REMOTE_INVALIDATION.

This commit removes the IncomingInvalidationSource enum and the
'source' parameter that was part of the invalidator callback API.  The
callees can now safely assume that all invalidations have a 'remote'
source.

BUG=124143


Review URL: https://chromiumcodereview.appspot.com/12114012

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@180213 0039d316-1c4b-4281-b951-d872f2087c98

24 files changed, 68 insertions, 160 deletions

diff --git a/sync/internal_api/public/test/fake_sync_manager.h b/sync/internal_api/public/test/fake_sync_manager.h
index 70415c9..74aadd7 100644
--- a/sync/internal_api/public/test/fake_sync_manager.h
+++ b/sync/internal_api/public/test/fake_sync_manager.h
@@ -58,8 +58,7 @@ class FakeSyncManager : public SyncManager {
   ModelTypeSet GetLastRefreshRequestTypes();
 
   // Posts a method to invalidate the given IDs on the sync thread.
-  void Invalidate(const ObjectIdInvalidationMap& invalidation_map,
-                  IncomingInvalidationSource source);
+  void Invalidate(const ObjectIdInvalidationMap& invalidation_map);
 
   // Posts a method to update the invalidator state on the sync thread.
   void UpdateInvalidatorState(InvalidatorState state);
@@ -127,8 +126,7 @@ class FakeSyncManager : public SyncManager {
 
  private:
   void InvalidateOnSyncThread(
-      const ObjectIdInvalidationMap& invalidation_map,
-      IncomingInvalidationSource source);
+      const ObjectIdInvalidationMap& invalidation_map);
   void UpdateInvalidatorStateOnSyncThread(InvalidatorState state);
 
   scoped_refptr<base::SequencedTaskRunner> sync_task_runner_;
diff --git a/sync/internal_api/sync_manager_impl.cc b/sync/internal_api/sync_manager_impl.cc
index 65e2a47..b2b9ed5 100644
--- a/sync/internal_api/sync_manager_impl.cc
+++ b/sync/internal_api/sync_manager_impl.cc
@@ -1235,8 +1235,7 @@ void SyncManagerImpl::OnInvalidatorStateChange(InvalidatorState state) {
 }
 
 void SyncManagerImpl::OnIncomingInvalidation(
-    const ObjectIdInvalidationMap& invalidation_map,
-    IncomingInvalidationSource source) {
+    const ObjectIdInvalidationMap& invalidation_map) {
   DCHECK(thread_checker_.CalledOnValidThread());
   const ModelTypeInvalidationMap& type_invalidation_map =
       ObjectIdInvalidationMapToModelTypeInvalidationMap(invalidation_map);
diff --git a/sync/internal_api/sync_manager_impl.h b/sync/internal_api/sync_manager_impl.h
index 32cee99..75bc930 100644
--- a/sync/internal_api/sync_manager_impl.h
+++ b/sync/internal_api/sync_manager_impl.h
@@ -177,8 +177,7 @@ class SYNC_EXPORT_PRIVATE SyncManagerImpl :
   // InvalidationHandler implementation.
   virtual void OnInvalidatorStateChange(InvalidatorState state) OVERRIDE;
   virtual void OnIncomingInvalidation(
-      const ObjectIdInvalidationMap& invalidation_map,
-      IncomingInvalidationSource source) OVERRIDE;
+      const ObjectIdInvalidationMap& invalidation_map) OVERRIDE;
 
   // Handle explicit requests to fetch updates for the given types.
   virtual void RefreshTypes(ModelTypeSet types) OVERRIDE;
diff --git a/sync/internal_api/sync_manager_impl_unittest.cc b/sync/internal_api/sync_manager_impl_unittest.cc
index b796679..3c5e529 100644
--- a/sync/internal_api/sync_manager_impl_unittest.cc
+++ b/sync/internal_api/sync_manager_impl_unittest.cc
@@ -973,8 +973,7 @@ class SyncManagerTest : public testing::Test,
         ModelTypeSetToInvalidationMap(model_types, std::string());
     sync_manager_.OnIncomingInvalidation(
         ModelTypeInvalidationMapToObjectIdInvalidationMap(
-            invalidation_map),
-        REMOTE_INVALIDATION);
+            invalidation_map));
   }
 
   void SetProgressMarkerForType(ModelType type, bool set) {
diff --git a/sync/internal_api/test/fake_sync_manager.cc b/sync/internal_api/test/fake_sync_manager.cc
index 25335fd..74e7b20 100644
--- a/sync/internal_api/test/fake_sync_manager.cc
+++ b/sync/internal_api/test/fake_sync_manager.cc
@@ -55,12 +55,11 @@ ModelTypeSet FakeSyncManager::GetAndResetEnabledTypes() {
 }
 
 void FakeSyncManager::Invalidate(
-    const ObjectIdInvalidationMap& invalidation_map,
-    IncomingInvalidationSource source) {
+    const ObjectIdInvalidationMap& invalidation_map) {
   if (!sync_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&FakeSyncManager::InvalidateOnSyncThread,
-                 base::Unretained(this), invalidation_map, source))) {
+                 base::Unretained(this), invalidation_map))) {
     NOTREACHED();
   }
 }
@@ -276,10 +275,9 @@ void FakeSyncManager::RefreshTypes(ModelTypeSet types) {
 }
 
 void FakeSyncManager::InvalidateOnSyncThread(
-    const ObjectIdInvalidationMap& invalidation_map,
-    IncomingInvalidationSource source) {
+    const ObjectIdInvalidationMap& invalidation_map) {
   DCHECK(sync_task_runner_->RunsTasksOnCurrentThread());
-  registrar_.DispatchInvalidationsToHandlers(invalidation_map, source);
+  registrar_.DispatchInvalidationsToHandlers(invalidation_map);
 }
 
 void FakeSyncManager::UpdateInvalidatorStateOnSyncThread(
diff --git a/sync/notifier/fake_invalidation_handler.cc b/sync/notifier/fake_invalidation_handler.cc
index e646bd6..30cb2fd 100644
--- a/sync/notifier/fake_invalidation_handler.cc
+++ b/sync/notifier/fake_invalidation_handler.cc
@@ -8,7 +8,6 @@ namespace syncer {
 
 FakeInvalidationHandler::FakeInvalidationHandler()
     : state_(DEFAULT_INVALIDATION_ERROR),
-      last_source_(LOCAL_INVALIDATION),
       invalidation_count_(0) {}
 
 FakeInvalidationHandler::~FakeInvalidationHandler() {}
@@ -22,11 +21,6 @@ FakeInvalidationHandler::GetLastInvalidationMap() const {
   return last_invalidation_map_;
 }
 
-IncomingInvalidationSource
-FakeInvalidationHandler::GetLastInvalidationSource() const {
-  return last_source_;
-}
-
 int FakeInvalidationHandler::GetInvalidationCount() const {
   return invalidation_count_;
 }
@@ -36,10 +30,8 @@ void FakeInvalidationHandler::OnInvalidatorStateChange(InvalidatorState state) {
 }
 
 void FakeInvalidationHandler::OnIncomingInvalidation(
-    const ObjectIdInvalidationMap& invalidation_map,
-    IncomingInvalidationSource source) {
+    const ObjectIdInvalidationMap& invalidation_map) {
   last_invalidation_map_ = invalidation_map;
-  last_source_ = source;
   ++invalidation_count_;
 }
 
diff --git a/sync/notifier/fake_invalidation_handler.h b/sync/notifier/fake_invalidation_handler.h
index 5f2b8e6..7ab89f4 100644
--- a/sync/notifier/fake_invalidation_handler.h
+++ b/sync/notifier/fake_invalidation_handler.h
@@ -20,19 +20,16 @@ class FakeInvalidationHandler : public InvalidationHandler {
 
   InvalidatorState GetInvalidatorState() const;
   const ObjectIdInvalidationMap& GetLastInvalidationMap() const;
-  IncomingInvalidationSource GetLastInvalidationSource() const;
   int GetInvalidationCount() const;
 
   // InvalidationHandler implementation.
   virtual void OnInvalidatorStateChange(InvalidatorState state) OVERRIDE;
   virtual void OnIncomingInvalidation(
-      const ObjectIdInvalidationMap& invalidation_map,
-      IncomingInvalidationSource source) OVERRIDE;
+      const ObjectIdInvalidationMap& invalidation_map) OVERRIDE;
 
  private:
   InvalidatorState state_;
   ObjectIdInvalidationMap last_invalidation_map_;
-  IncomingInvalidationSource last_source_;
   int invalidation_count_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeInvalidationHandler);
diff --git a/sync/notifier/fake_invalidator.cc b/sync/notifier/fake_invalidator.cc
index 52189d3..b7cfd4d 100644
--- a/sync/notifier/fake_invalidator.cc
+++ b/sync/notifier/fake_invalidator.cc
@@ -41,9 +41,8 @@ void FakeInvalidator::EmitOnInvalidatorStateChange(InvalidatorState state) {
 }
 
 void FakeInvalidator::EmitOnIncomingInvalidation(
-    const ObjectIdInvalidationMap& invalidation_map,
-    IncomingInvalidationSource source) {
-  registrar_.DispatchInvalidationsToHandlers(invalidation_map, source);
+    const ObjectIdInvalidationMap& invalidation_map) {
+  registrar_.DispatchInvalidationsToHandlers(invalidation_map);
 }
 
 void FakeInvalidator::RegisterHandler(InvalidationHandler* handler) {
diff --git a/sync/notifier/fake_invalidator.h b/sync/notifier/fake_invalidator.h
index fa566dc..13c65d7 100644
--- a/sync/notifier/fake_invalidator.h
+++ b/sync/notifier/fake_invalidator.h
@@ -28,8 +28,7 @@ class FakeInvalidator : public Invalidator {
 
   void EmitOnInvalidatorStateChange(InvalidatorState state);
   void EmitOnIncomingInvalidation(
-      const ObjectIdInvalidationMap& invalidation_map,
-      IncomingInvalidationSource source);
+      const ObjectIdInvalidationMap& invalidation_map);
 
   virtual void RegisterHandler(InvalidationHandler* handler) OVERRIDE;
   virtual void UpdateRegisteredIds(InvalidationHandler* handler,
diff --git a/sync/notifier/fake_invalidator_unittest.cc b/sync/notifier/fake_invalidator_unittest.cc
index ee7ef41..de1bb71 100644
--- a/sync/notifier/fake_invalidator_unittest.cc
+++ b/sync/notifier/fake_invalidator_unittest.cc
@@ -45,9 +45,8 @@ class FakeInvalidatorTestDelegate {
   }
 
   void TriggerOnIncomingInvalidation(
-      const ObjectIdInvalidationMap& invalidation_map,
-      IncomingInvalidationSource source) {
-    invalidator_->EmitOnIncomingInvalidation(invalidation_map, source);
+      const ObjectIdInvalidationMap& invalidation_map) {
+    invalidator_->EmitOnIncomingInvalidation(invalidation_map);
   }
 
  private:
diff --git a/sync/notifier/invalidation_handler.h b/sync/notifier/invalidation_handler.h
index 057c37b..be85116 100644
--- a/sync/notifier/invalidation_handler.h
+++ b/sync/notifier/invalidation_handler.h
@@ -11,13 +11,6 @@
 
 namespace syncer {
 
-enum IncomingInvalidationSource {
-  // The server is notifying us that one or more objects have stale data.
-  REMOTE_INVALIDATION,
-  // Something locally is requesting an optimistic refresh of its data.
-  LOCAL_INVALIDATION,
-};
-
 class SYNC_EXPORT InvalidationHandler {
  public:
   // Called when the invalidator state changes.
@@ -27,8 +20,7 @@ class SYNC_EXPORT InvalidationHandler {
   // |id_state_map| and the source is in |source|.  Note that this may be
   // called regardless of the current invalidator state.
   virtual void OnIncomingInvalidation(
-      const ObjectIdInvalidationMap& invalidation_map,
-      IncomingInvalidationSource source) = 0;
+      const ObjectIdInvalidationMap& invalidation_map) = 0;
 
  protected:
   virtual ~InvalidationHandler() {}
diff --git a/sync/notifier/invalidation_notifier.cc b/sync/notifier/invalidation_notifier.cc
index bd49426..1b9830b 100644
--- a/sync/notifier/invalidation_notifier.cc
+++ b/sync/notifier/invalidation_notifier.cc
@@ -87,8 +87,7 @@ void InvalidationNotifier::SendInvalidation(
 void InvalidationNotifier::OnInvalidate(
     const ObjectIdInvalidationMap& invalidation_map) {
   DCHECK(CalledOnValidThread());
-  registrar_.DispatchInvalidationsToHandlers(invalidation_map,
-                                             REMOTE_INVALIDATION);
+  registrar_.DispatchInvalidationsToHandlers(invalidation_map);
 }
 
 void InvalidationNotifier::OnInvalidatorStateChange(InvalidatorState state) {
diff --git a/sync/notifier/invalidation_notifier_unittest.cc b/sync/notifier/invalidation_notifier_unittest.cc
index a63a56a..b1856ba 100644
--- a/sync/notifier/invalidation_notifier_unittest.cc
+++ b/sync/notifier/invalidation_notifier_unittest.cc
@@ -69,9 +69,7 @@ class InvalidationNotifierTestDelegate {
   }
 
   void TriggerOnIncomingInvalidation(
-      const ObjectIdInvalidationMap& invalidation_map,
-      IncomingInvalidationSource source) {
-    // None of the tests actually care about |source|.
+      const ObjectIdInvalidationMap& invalidation_map) {
     invalidator_->OnInvalidate(invalidation_map);
   }
 
diff --git a/sync/notifier/invalidator_registrar.cc b/sync/notifier/invalidator_registrar.cc
index 7243e9d..75db11fc 100644
--- a/sync/notifier/invalidator_registrar.cc
+++ b/sync/notifier/invalidator_registrar.cc
@@ -90,8 +90,7 @@ ObjectIdSet InvalidatorRegistrar::GetAllRegisteredIds() const {
 }
 
 void InvalidatorRegistrar::DispatchInvalidationsToHandlers(
-    const ObjectIdInvalidationMap& invalidation_map,
-    IncomingInvalidationSource source) {
+    const ObjectIdInvalidationMap& invalidation_map) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // If we have no handlers, there's nothing to do.
   if (!handlers_.might_have_observers()) {
@@ -114,7 +113,7 @@ void InvalidatorRegistrar::DispatchInvalidationsToHandlers(
   while ((handler = it.GetNext()) != NULL) {
     DispatchMap::const_iterator dispatch_it = dispatch_map.find(handler);
     if (dispatch_it != dispatch_map.end())
-      handler->OnIncomingInvalidation(dispatch_it->second, source);
+      handler->OnIncomingInvalidation(dispatch_it->second);
   }
 }
 
diff --git a/sync/notifier/invalidator_registrar.h b/sync/notifier/invalidator_registrar.h
index ce227db..f2a3c63 100644
--- a/sync/notifier/invalidator_registrar.h
+++ b/sync/notifier/invalidator_registrar.h
@@ -58,8 +58,7 @@ class SYNC_EXPORT InvalidatorRegistrar {
   // Invalidations for IDs with no corresponding handler are dropped, as are
   // invalidations for handlers that are not added.
   void DispatchInvalidationsToHandlers(
-      const ObjectIdInvalidationMap& invalidation_map,
-      IncomingInvalidationSource source);
+      const ObjectIdInvalidationMap& invalidation_map);
 
   // Updates the invalidator state to the given one and then notifies
   // all handlers.  Note that the order is important; handlers that
diff --git a/sync/notifier/invalidator_registrar_unittest.cc b/sync/notifier/invalidator_registrar_unittest.cc
index a69beae..f833940 100644
--- a/sync/notifier/invalidator_registrar_unittest.cc
+++ b/sync/notifier/invalidator_registrar_unittest.cc
@@ -100,10 +100,9 @@ class RegistrarInvalidatorTestDelegate {
   }
 
   void TriggerOnIncomingInvalidation(
-      const ObjectIdInvalidationMap& invalidation_map,
-      IncomingInvalidationSource source) {
+      const ObjectIdInvalidationMap& invalidation_map) {
     invalidator_->GetRegistrar()->DispatchInvalidationsToHandlers(
-        invalidation_map, source);
+        invalidation_map);
   }
 
  private:
diff --git a/sync/notifier/invalidator_test_template.h b/sync/notifier/invalidator_test_template.h
index 44a288d..72d8c63 100644
--- a/sync/notifier/invalidator_test_template.h
+++ b/sync/notifier/invalidator_test_template.h
@@ -57,8 +57,7 @@
 //     // observers of the Invalidator implementation with the given
 //     // parameters.
 //     void TriggerOnIncomingInvalidation(
-//         const ObjectIdInvalidationMap& invalidation_map,
-//         IncomingInvalidationSource source) {
+//         const ObjectIdInvalidationMap& invalidation_map) {
 //       ...
 //     }
 //   };
@@ -142,7 +141,7 @@ TYPED_TEST_P(InvalidatorTest, Basic) {
   states[this->id3].payload = "3";
 
   // Should be ignored since no IDs are registered to |handler|.
-  this->delegate_.TriggerOnIncomingInvalidation(states, REMOTE_INVALIDATION);
+  this->delegate_.TriggerOnIncomingInvalidation(states);
   EXPECT_EQ(0, handler.GetInvalidationCount());
 
   ObjectIdSet ids;
@@ -157,10 +156,9 @@ TYPED_TEST_P(InvalidatorTest, Basic) {
   expected_states[this->id1].payload = "1";
   expected_states[this->id2].payload = "2";
 
-  this->delegate_.TriggerOnIncomingInvalidation(states, REMOTE_INVALIDATION);
+  this->delegate_.TriggerOnIncomingInvalidation(states);
   EXPECT_EQ(1, handler.GetInvalidationCount());
   EXPECT_THAT(expected_states, Eq(handler.GetLastInvalidationMap()));
-  EXPECT_EQ(REMOTE_INVALIDATION, handler.GetLastInvalidationSource());
 
   ids.erase(this->id1);
   ids.insert(this->id3);
@@ -170,10 +168,9 @@ TYPED_TEST_P(InvalidatorTest, Basic) {
   expected_states[this->id3].payload = "3";
 
   // Removed object IDs should not be notified, newly-added ones should.
-  this->delegate_.TriggerOnIncomingInvalidation(states, REMOTE_INVALIDATION);
+  this->delegate_.TriggerOnIncomingInvalidation(states);
   EXPECT_EQ(2, handler.GetInvalidationCount());
   EXPECT_THAT(expected_states, Eq(handler.GetLastInvalidationMap()));
-  EXPECT_EQ(REMOTE_INVALIDATION, handler.GetLastInvalidationSource());
 
   this->delegate_.TriggerOnInvalidatorStateChange(TRANSIENT_INVALIDATION_ERROR);
   EXPECT_EQ(TRANSIENT_INVALIDATION_ERROR,
@@ -187,7 +184,7 @@ TYPED_TEST_P(InvalidatorTest, Basic) {
   invalidator->UnregisterHandler(&handler);
 
   // Should be ignored since |handler| isn't registered anymore.
-  this->delegate_.TriggerOnIncomingInvalidation(states, REMOTE_INVALIDATION);
+  this->delegate_.TriggerOnIncomingInvalidation(states);
   EXPECT_EQ(2, handler.GetInvalidationCount());
 }
 
@@ -244,7 +241,7 @@ TYPED_TEST_P(InvalidatorTest, MultipleHandlers) {
     states[this->id2].payload = "2";
     states[this->id3].payload = "3";
     states[this->id4].payload = "4";
-    this->delegate_.TriggerOnIncomingInvalidation(states, REMOTE_INVALIDATION);
+    this->delegate_.TriggerOnIncomingInvalidation(states);
 
     ObjectIdInvalidationMap expected_states;
     expected_states[this->id1].payload = "1";
@@ -252,14 +249,12 @@ TYPED_TEST_P(InvalidatorTest, MultipleHandlers) {
 
     EXPECT_EQ(1, handler1.GetInvalidationCount());
     EXPECT_THAT(expected_states, Eq(handler1.GetLastInvalidationMap()));
-    EXPECT_EQ(REMOTE_INVALIDATION, handler1.GetLastInvalidationSource());
 
     expected_states.clear();
     expected_states[this->id3].payload = "3";
 
     EXPECT_EQ(1, handler2.GetInvalidationCount());
     EXPECT_THAT(expected_states, Eq(handler2.GetLastInvalidationMap()));
-    EXPECT_EQ(REMOTE_INVALIDATION, handler2.GetLastInvalidationSource());
 
     EXPECT_EQ(0, handler3.GetInvalidationCount());
     EXPECT_EQ(0, handler4.GetInvalidationCount());
@@ -315,7 +310,7 @@ TYPED_TEST_P(InvalidatorTest, EmptySetUnregisters) {
     states[this->id1].payload = "1";
     states[this->id2].payload = "2";
     states[this->id3].payload = "3";
-    this->delegate_.TriggerOnIncomingInvalidation(states, REMOTE_INVALIDATION);
+    this->delegate_.TriggerOnIncomingInvalidation(states);
     EXPECT_EQ(0, handler1.GetInvalidationCount());
     EXPECT_EQ(1, handler2.GetInvalidationCount());
   }
diff --git a/sync/notifier/non_blocking_invalidator.cc b/sync/notifier/non_blocking_invalidator.cc
index 5ff8dfa..b197e72 100644
--- a/sync/notifier/non_blocking_invalidator.cc
+++ b/sync/notifier/non_blocking_invalidator.cc
@@ -43,8 +43,7 @@ class NonBlockingInvalidator::Core
   // InvalidationNotifier).
   virtual void OnInvalidatorStateChange(InvalidatorState reason) OVERRIDE;
   virtual void OnIncomingInvalidation(
-      const ObjectIdInvalidationMap& invalidation_map,
-      IncomingInvalidationSource source) OVERRIDE;
+      const ObjectIdInvalidationMap& invalidation_map) OVERRIDE;
 
  private:
   friend class
@@ -122,13 +121,11 @@ void NonBlockingInvalidator::Core::OnInvalidatorStateChange(
 }
 
 void NonBlockingInvalidator::Core::OnIncomingInvalidation(
-    const ObjectIdInvalidationMap& invalidation_map,
-    IncomingInvalidationSource source) {
+    const ObjectIdInvalidationMap& invalidation_map) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   delegate_observer_.Call(FROM_HERE,
                           &InvalidationHandler::OnIncomingInvalidation,
-                          invalidation_map,
-                          source);
+                          invalidation_map);
 }
 
 NonBlockingInvalidator::NonBlockingInvalidator(
@@ -232,10 +229,9 @@ void NonBlockingInvalidator::OnInvalidatorStateChange(InvalidatorState state) {
 }
 
 void NonBlockingInvalidator::OnIncomingInvalidation(
-        const ObjectIdInvalidationMap& invalidation_map,
-        IncomingInvalidationSource source) {
+        const ObjectIdInvalidationMap& invalidation_map) {
   DCHECK(parent_task_runner_->BelongsToCurrentThread());
-  registrar_.DispatchInvalidationsToHandlers(invalidation_map, source);
+  registrar_.DispatchInvalidationsToHandlers(invalidation_map);
 }
 
 }  // namespace syncer
diff --git a/sync/notifier/non_blocking_invalidator.h b/sync/notifier/non_blocking_invalidator.h
index a35b42a..0908b48 100644
--- a/sync/notifier/non_blocking_invalidator.h
+++ b/sync/notifier/non_blocking_invalidator.h
@@ -61,8 +61,7 @@ class SYNC_EXPORT_PRIVATE NonBlockingInvalidator
   // InvalidationHandler implementation.
   virtual void OnInvalidatorStateChange(InvalidatorState state) OVERRIDE;
   virtual void OnIncomingInvalidation(
-      const ObjectIdInvalidationMap& invalidation_map,
-      IncomingInvalidationSource source) OVERRIDE;
+      const ObjectIdInvalidationMap& invalidation_map) OVERRIDE;
 
  private:
   class Core;
diff --git a/sync/notifier/non_blocking_invalidator_unittest.cc b/sync/notifier/non_blocking_invalidator_unittest.cc
index c6ddf0f..0a38fb3 100644
--- a/sync/notifier/non_blocking_invalidator_unittest.cc
+++ b/sync/notifier/non_blocking_invalidator_unittest.cc
@@ -79,9 +79,8 @@ class NonBlockingInvalidatorTestDelegate {
   }
 
   void TriggerOnIncomingInvalidation(
-      const ObjectIdInvalidationMap& invalidation_map,
-      IncomingInvalidationSource source) {
-    invalidator_->OnIncomingInvalidation(invalidation_map, source);
+      const ObjectIdInvalidationMap& invalidation_map) {
+    invalidator_->OnIncomingInvalidation(invalidation_map);
   }
 
  private:
diff --git a/sync/notifier/p2p_invalidator.cc b/sync/notifier/p2p_invalidator.cc
index d04a191..5894391 100644
--- a/sync/notifier/p2p_invalidator.cc
+++ b/sync/notifier/p2p_invalidator.cc
@@ -27,7 +27,6 @@ const char kNotifyAll[] = "notifyAll";
 const char kSenderIdKey[] = "senderId";
 const char kNotificationTypeKey[] = "notificationType";
 const char kIdInvalidationMapKey[] = "idInvalidationMap";
-const char kSourceKey[] = "source";
 
 }  // namespace
 
@@ -60,25 +59,16 @@ P2PNotificationTarget P2PNotificationTargetFromString(
   return NOTIFY_SELF;
 }
 
-IncomingInvalidationSource P2PNotificationSourceFromInteger(int source_num) {
-  if (source_num == LOCAL_INVALIDATION) {
-    return LOCAL_INVALIDATION;
-  }
-  return REMOTE_INVALIDATION;
-}
-
 P2PNotificationData::P2PNotificationData()
-    : target_(NOTIFY_SELF), source_(REMOTE_INVALIDATION) {}
+    : target_(NOTIFY_SELF) {}
 
 P2PNotificationData::P2PNotificationData(
     const std::string& sender_id,
     P2PNotificationTarget target,
-    const ObjectIdInvalidationMap& invalidation_map,
-    IncomingInvalidationSource source)
+    const ObjectIdInvalidationMap& invalidation_map)
     : sender_id_(sender_id),
       target_(target),
-      invalidation_map_(invalidation_map),
-      source_(source) {}
+      invalidation_map_(invalidation_map) {}
 
 P2PNotificationData::~P2PNotificationData() {}
 
@@ -101,17 +91,12 @@ P2PNotificationData::GetIdInvalidationMap() const {
   return invalidation_map_;
 }
 
-IncomingInvalidationSource P2PNotificationData::GetSource() const {
-  return source_;
-}
-
 bool P2PNotificationData::Equals(const P2PNotificationData& other) const {
   return
       (sender_id_ == other.sender_id_) &&
       (target_ == other.target_) &&
       ObjectIdInvalidationMapEquals(invalidation_map_,
-                                    other.invalidation_map_) &&
-      (source_ == other.source_);
+                                    other.invalidation_map_);
 }
 
 std::string P2PNotificationData::ToString() const {
@@ -121,7 +106,6 @@ std::string P2PNotificationData::ToString() const {
                   P2PNotificationTargetToString(target_));
   dict->Set(kIdInvalidationMapKey,
             ObjectIdInvalidationMapToValue(invalidation_map_).release());
-  dict->SetInteger(kSourceKey, source_);
   std::string json;
   base::JSONWriter::Write(dict.get(), &json);
   return json;
@@ -149,11 +133,6 @@ bool P2PNotificationData::ResetFromString(const std::string& str) {
                                         &invalidation_map_)) {
     LOG(WARNING) << "Could not parse " << kIdInvalidationMapKey;
   }
-  int source_num = 0;
-  if (!data_dict->GetInteger(kSourceKey, &source_num)) {
-    LOG(WARNING) << "Could not find integer value for " << kSourceKey;
-  }
-  source_ = P2PNotificationSourceFromInteger(source_num);
   return true;
 }
 
@@ -190,8 +169,7 @@ void P2PInvalidator::UpdateRegisteredIds(InvalidationHandler* handler,
                       ObjectIdLessThan());
   registrar_.UpdateRegisteredIds(handler, ids);
   const P2PNotificationData notification_data(
-      unique_id_, NOTIFY_SELF, ObjectIdSetToInvalidationMap(new_ids, ""),
-      REMOTE_INVALIDATION);
+      unique_id_, NOTIFY_SELF, ObjectIdSetToInvalidationMap(new_ids, ""));
   SendNotificationData(notification_data);
 }
 
@@ -231,8 +209,7 @@ void P2PInvalidator::SendInvalidation(
     const ObjectIdInvalidationMap& invalidation_map) {
   DCHECK(thread_checker_.CalledOnValidThread());
   const P2PNotificationData notification_data(
-      unique_id_, send_notification_target_, invalidation_map,
-      REMOTE_INVALIDATION);
+      unique_id_, send_notification_target_, invalidation_map);
   SendNotificationData(notification_data);
 }
 
@@ -244,8 +221,7 @@ void P2PInvalidator::OnNotificationsEnabled() {
   if (just_turned_on) {
     const P2PNotificationData notification_data(
         unique_id_, NOTIFY_SELF,
-        ObjectIdSetToInvalidationMap(registrar_.GetAllRegisteredIds(), ""),
-        REMOTE_INVALIDATION);
+        ObjectIdSetToInvalidationMap(registrar_.GetAllRegisteredIds(), ""));
     SendNotificationData(notification_data);
   }
 }
@@ -279,8 +255,7 @@ void P2PInvalidator::OnIncomingNotification(
     notification_data =
         P2PNotificationData(
             unique_id_, NOTIFY_ALL,
-            ObjectIdSetToInvalidationMap(registrar_.GetAllRegisteredIds(), ""),
-            REMOTE_INVALIDATION);
+            ObjectIdSetToInvalidationMap(registrar_.GetAllRegisteredIds(), ""));
   }
   if (!notification_data.IsTargeted(unique_id_)) {
     DVLOG(1) << "Not a target of the notification -- "
@@ -288,8 +263,7 @@ void P2PInvalidator::OnIncomingNotification(
     return;
   }
   registrar_.DispatchInvalidationsToHandlers(
-      notification_data.GetIdInvalidationMap(),
-      REMOTE_INVALIDATION);
+      notification_data.GetIdInvalidationMap());
 }
 
 void P2PInvalidator::SendNotificationDataForTest(
diff --git a/sync/notifier/p2p_invalidator.h b/sync/notifier/p2p_invalidator.h
index d3faa66..cfb9644 100644
--- a/sync/notifier/p2p_invalidator.h
+++ b/sync/notifier/p2p_invalidator.h
@@ -57,8 +57,7 @@ class SYNC_EXPORT_PRIVATE P2PNotificationData {
   P2PNotificationData();
   P2PNotificationData(const std::string& sender_id,
                       P2PNotificationTarget target,
-                      const ObjectIdInvalidationMap& invalidation_map,
-                      IncomingInvalidationSource source);
+                      const ObjectIdInvalidationMap& invalidation_map);
 
   ~P2PNotificationData();
 
@@ -67,8 +66,6 @@ class SYNC_EXPORT_PRIVATE P2PNotificationData {
 
   const ObjectIdInvalidationMap& GetIdInvalidationMap() const;
 
-  IncomingInvalidationSource GetSource() const;
-
   bool Equals(const P2PNotificationData& other) const;
 
   std::string ToString() const;
@@ -84,8 +81,6 @@ class SYNC_EXPORT_PRIVATE P2PNotificationData {
   P2PNotificationTarget target_;
   // The invalidation map for the notification.
   ObjectIdInvalidationMap invalidation_map_;
-  // The source of the invalidation.
-  IncomingInvalidationSource source_;
 };
 
 class SYNC_EXPORT_PRIVATE P2PInvalidator
diff --git a/sync/notifier/p2p_invalidator_unittest.cc b/sync/notifier/p2p_invalidator_unittest.cc
index 577630f..31a180e0 100644
--- a/sync/notifier/p2p_invalidator_unittest.cc
+++ b/sync/notifier/p2p_invalidator_unittest.cc
@@ -65,10 +65,9 @@ class P2PInvalidatorTestDelegate {
   }
 
   void TriggerOnIncomingInvalidation(
-      const ObjectIdInvalidationMap& invalidation_map,
-      IncomingInvalidationSource source) {
+      const ObjectIdInvalidationMap& invalidation_map) {
     const P2PNotificationData notification_data(
-        "", NOTIFY_ALL, invalidation_map, source);
+        "", NOTIFY_ALL, invalidation_map);
     notifier::Notification notification;
     notification.channel = kSyncP2PNotificationChannel;
     notification.data = notification_data.ToString();
@@ -133,22 +132,21 @@ TEST_F(P2PInvalidatorTest, P2PNotificationTarget) {
 TEST_F(P2PInvalidatorTest, P2PNotificationDataIsTargeted) {
   {
     const P2PNotificationData notification_data(
-        "sender", NOTIFY_SELF, ObjectIdInvalidationMap(), REMOTE_INVALIDATION);
+        "sender", NOTIFY_SELF, ObjectIdInvalidationMap());
     EXPECT_TRUE(notification_data.IsTargeted("sender"));
     EXPECT_FALSE(notification_data.IsTargeted("other1"));
     EXPECT_FALSE(notification_data.IsTargeted("other2"));
   }
   {
     const P2PNotificationData notification_data(
-        "sender", NOTIFY_OTHERS, ObjectIdInvalidationMap(),
-        REMOTE_INVALIDATION);
+        "sender", NOTIFY_OTHERS, ObjectIdInvalidationMap());
     EXPECT_FALSE(notification_data.IsTargeted("sender"));
     EXPECT_TRUE(notification_data.IsTargeted("other1"));
     EXPECT_TRUE(notification_data.IsTargeted("other2"));
   }
   {
     const P2PNotificationData notification_data(
-        "sender", NOTIFY_ALL, ObjectIdInvalidationMap(), REMOTE_INVALIDATION);
+        "sender", NOTIFY_ALL, ObjectIdInvalidationMap());
     EXPECT_TRUE(notification_data.IsTargeted("sender"));
     EXPECT_TRUE(notification_data.IsTargeted("other1"));
     EXPECT_TRUE(notification_data.IsTargeted("other2"));
@@ -166,7 +164,7 @@ TEST_F(P2PInvalidatorTest, P2PNotificationDataDefault) {
   const std::string& notification_data_str = notification_data.ToString();
   EXPECT_EQ(
       "{\"idInvalidationMap\":[],\"notificationType\":\"notifySelf\","
-      "\"senderId\":\"\",\"source\":0}", notification_data_str);
+      "\"senderId\":\"\"}", notification_data_str);
 
   P2PNotificationData notification_data_parsed;
   EXPECT_TRUE(notification_data_parsed.ResetFromString(notification_data_str));
@@ -180,7 +178,7 @@ TEST_F(P2PInvalidatorTest, P2PNotificationDataNonDefault) {
       ObjectIdSetToInvalidationMap(
           ModelTypeSetToObjectIdSet(ModelTypeSet(BOOKMARKS, THEMES)), "");
   const P2PNotificationData notification_data(
-      "sender", NOTIFY_ALL, invalidation_map, LOCAL_INVALIDATION);
+      "sender", NOTIFY_ALL, invalidation_map);
   EXPECT_TRUE(notification_data.IsTargeted("sender"));
   EXPECT_TRUE(notification_data.IsTargeted("other1"));
   EXPECT_TRUE(notification_data.IsTargeted("other2"));
@@ -196,7 +194,7 @@ TEST_F(P2PInvalidatorTest, P2PNotificationDataNonDefault) {
       "\"state\":{\"ackHandle\":{\"state\":\"\",\"timestamp\":\"0\"},"
       "\"payload\":\"\"}}"
       "],\"notificationType\":\"notifyAll\","
-      "\"senderId\":\"sender\",\"source\":1}", notification_data_str);
+      "\"senderId\":\"sender\"}", notification_data_str);
 
   P2PNotificationData notification_data_parsed;
   EXPECT_TRUE(notification_data_parsed.ResetFromString(notification_data_str));
@@ -242,7 +240,6 @@ TEST_F(P2PInvalidatorTest, NotificationsBasic) {
       ModelTypeInvalidationMapToObjectIdInvalidationMap(
           MakeInvalidationMap(enabled_types)),
       Eq(fake_handler_.GetLastInvalidationMap()));
-  EXPECT_EQ(REMOTE_INVALIDATION, fake_handler_.GetLastInvalidationSource());
 
   // Sent with target NOTIFY_OTHERS so should not be propagated to
   // |fake_handler_|.
@@ -288,7 +285,6 @@ TEST_F(P2PInvalidatorTest, SendNotificationData) {
       ModelTypeInvalidationMapToObjectIdInvalidationMap(
           MakeInvalidationMap(enabled_types)),
       Eq(fake_handler_.GetLastInvalidationMap()));
-  EXPECT_EQ(REMOTE_INVALIDATION, fake_handler_.GetLastInvalidationSource());
 
   // Should be dropped.
   invalidator->SendNotificationDataForTest(P2PNotificationData());
@@ -301,68 +297,59 @@ TEST_F(P2PInvalidatorTest, SendNotificationData) {
 
   // Should be propagated.
   invalidator->SendNotificationDataForTest(
-      P2PNotificationData("sender", NOTIFY_SELF,
-                          invalidation_map, REMOTE_INVALIDATION));
+      P2PNotificationData("sender", NOTIFY_SELF, invalidation_map));
   ReflectSentNotifications();
   EXPECT_EQ(2, fake_handler_.GetInvalidationCount());
   EXPECT_THAT(expected_ids, Eq(fake_handler_.GetLastInvalidationMap()));
 
   // Should be dropped.
   invalidator->SendNotificationDataForTest(
-      P2PNotificationData("sender2", NOTIFY_SELF,
-                          invalidation_map, REMOTE_INVALIDATION));
+      P2PNotificationData("sender2", NOTIFY_SELF, invalidation_map));
   ReflectSentNotifications();
   EXPECT_EQ(2, fake_handler_.GetInvalidationCount());
 
   // Should be dropped.
   invalidator->SendNotificationDataForTest(
-      P2PNotificationData("sender", NOTIFY_SELF,
-                          ObjectIdInvalidationMap(), REMOTE_INVALIDATION));
+      P2PNotificationData("sender", NOTIFY_SELF, ObjectIdInvalidationMap()));
   ReflectSentNotifications();
   EXPECT_EQ(2, fake_handler_.GetInvalidationCount());
 
   // Should be dropped.
   invalidator->SendNotificationDataForTest(
-      P2PNotificationData("sender", NOTIFY_OTHERS,
-                          invalidation_map, REMOTE_INVALIDATION));
+      P2PNotificationData("sender", NOTIFY_OTHERS, invalidation_map));
   ReflectSentNotifications();
   EXPECT_EQ(2, fake_handler_.GetInvalidationCount());
 
   // Should be propagated.
   invalidator->SendNotificationDataForTest(
-      P2PNotificationData("sender2", NOTIFY_OTHERS,
-                          invalidation_map, REMOTE_INVALIDATION));
+      P2PNotificationData("sender2", NOTIFY_OTHERS, invalidation_map));
   ReflectSentNotifications();
   EXPECT_EQ(3, fake_handler_.GetInvalidationCount());
   EXPECT_THAT(expected_ids, Eq(fake_handler_.GetLastInvalidationMap()));
 
   // Should be dropped.
   invalidator->SendNotificationDataForTest(
-      P2PNotificationData("sender2", NOTIFY_OTHERS,
-                          ObjectIdInvalidationMap(), REMOTE_INVALIDATION));
+      P2PNotificationData("sender2", NOTIFY_OTHERS, ObjectIdInvalidationMap()));
   ReflectSentNotifications();
   EXPECT_EQ(3, fake_handler_.GetInvalidationCount());
 
   // Should be propagated.
   invalidator->SendNotificationDataForTest(
-      P2PNotificationData("sender", NOTIFY_ALL,
-                          invalidation_map, REMOTE_INVALIDATION));
+      P2PNotificationData("sender", NOTIFY_ALL, invalidation_map));
   ReflectSentNotifications();
   EXPECT_EQ(4, fake_handler_.GetInvalidationCount());
   EXPECT_THAT(expected_ids, Eq(fake_handler_.GetLastInvalidationMap()));
 
   // Should be propagated.
   invalidator->SendNotificationDataForTest(
-      P2PNotificationData("sender2", NOTIFY_ALL,
-                          invalidation_map, REMOTE_INVALIDATION));
+      P2PNotificationData("sender2", NOTIFY_ALL, invalidation_map));
   ReflectSentNotifications();
   EXPECT_EQ(5, fake_handler_.GetInvalidationCount());
   EXPECT_THAT(expected_ids, Eq(fake_handler_.GetLastInvalidationMap()));
 
   // Should be dropped.
   invalidator->SendNotificationDataForTest(
-  P2PNotificationData("sender2", NOTIFY_ALL,
-                      ObjectIdInvalidationMap(), REMOTE_INVALIDATION));
+  P2PNotificationData("sender2", NOTIFY_ALL, ObjectIdInvalidationMap()));
   ReflectSentNotifications();
   EXPECT_EQ(5, fake_handler_.GetInvalidationCount());
 }
diff --git a/sync/tools/sync_listen_notifications.cc b/sync/tools/sync_listen_notifications.cc
index ce901a4..9e958ca 100644
--- a/sync/tools/sync_listen_notifications.cc
+++ b/sync/tools/sync_listen_notifications.cc
@@ -59,15 +59,13 @@ class NotificationPrinter : public InvalidationHandler {
   }
 
   virtual void OnIncomingInvalidation(
-      const ObjectIdInvalidationMap& invalidation_map,
-      IncomingInvalidationSource source) OVERRIDE {
+      const ObjectIdInvalidationMap& invalidation_map) OVERRIDE {
     const ModelTypeInvalidationMap& type_invalidation_map =
         ObjectIdInvalidationMapToModelTypeInvalidationMap(invalidation_map);
     for (ModelTypeInvalidationMap::const_iterator it =
              type_invalidation_map.begin(); it != type_invalidation_map.end();
          ++it) {
-      LOG(INFO) << (source == REMOTE_INVALIDATION ? "Remote" : "Local")
-                << " Invalidation: type = "
+      LOG(INFO) << "Remote invalidation: type = "
                 << ModelTypeToString(it->first)
                 << ", payload = " << it->second.payload;
     }