[Sync] Use fakes for SyncNotifier{,Observer} instead of mocks

An upcoming CL will require more complex functionality, so fakes
are better suited.

BUG=141678

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

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

13 files changed, 421 insertions, 223 deletions

diff --git a/sync/notifier/fake_sync_notifier.cc b/sync/notifier/fake_sync_notifier.cc
new file mode 100644
index 0000000..0ef5ef9
--- /dev/null
+++ b/sync/notifier/fake_sync_notifier.cc
@@ -0,0 +1,74 @@
+// 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 "sync/notifier/fake_sync_notifier.h"
+
+namespace syncer {
+
+FakeSyncNotifier::FakeSyncNotifier() {}
+
+FakeSyncNotifier::~FakeSyncNotifier() {}
+
+bool FakeSyncNotifier::IsHandlerRegistered(
+    SyncNotifierObserver* handler) const {
+  return registrar_.IsHandlerRegisteredForTest(handler);
+}
+
+ObjectIdSet FakeSyncNotifier::GetRegisteredIds(
+    SyncNotifierObserver* handler) const {
+  return registrar_.GetRegisteredIdsForTest(handler);
+}
+
+void FakeSyncNotifier::RegisterHandler(SyncNotifierObserver* handler) {
+  registrar_.RegisterHandler(handler);
+}
+
+const std::string& FakeSyncNotifier::GetUniqueId() const {
+  return unique_id_;
+}
+
+const std::string& FakeSyncNotifier::GetStateDeprecated() const {
+  return state_;
+}
+
+const std::string& FakeSyncNotifier::GetCredentialsEmail() const {
+  return email_;
+}
+
+const std::string& FakeSyncNotifier::GetCredentialsToken() const {
+  return token_;
+}
+
+ModelTypeSet FakeSyncNotifier::GetLastChangedTypes() const {
+  return last_changed_types_;
+}
+
+void FakeSyncNotifier::UpdateRegisteredIds(SyncNotifierObserver* handler,
+                                           const ObjectIdSet& ids) {
+  registrar_.UpdateRegisteredIds(handler, ids);
+}
+
+void FakeSyncNotifier::UnregisterHandler(SyncNotifierObserver* handler) {
+  registrar_.UnregisterHandler(handler);
+}
+
+void FakeSyncNotifier::SetUniqueId(const std::string& unique_id) {
+  unique_id_ = unique_id;
+}
+
+void FakeSyncNotifier::SetStateDeprecated(const std::string& state) {
+  state_ = state;
+}
+
+void FakeSyncNotifier::UpdateCredentials(
+    const std::string& email, const std::string& token) {
+  email_ = email;
+  token_ = token;
+}
+
+void FakeSyncNotifier::SendNotification(ModelTypeSet changed_types) {
+  last_changed_types_ = changed_types;
+}
+
+}  // namespace syncer
diff --git a/sync/notifier/fake_sync_notifier.h b/sync/notifier/fake_sync_notifier.h
new file mode 100644
index 0000000..74cfdf1
--- /dev/null
+++ b/sync/notifier/fake_sync_notifier.h
@@ -0,0 +1,51 @@
+// 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.
+
+#ifndef SYNC_NOTIFIER_FAKE_SYNC_NOTIFIER_H_
+#define SYNC_NOTIFIER_FAKE_SYNC_NOTIFIER_H_
+
+#include <string>
+
+#include "base/compiler_specific.h"
+#include "sync/notifier/invalidation_util.h"
+#include "sync/notifier/sync_notifier.h"
+#include "sync/notifier/sync_notifier_registrar.h"
+
+namespace syncer {
+
+class FakeSyncNotifier : public SyncNotifier {
+ public:
+  FakeSyncNotifier();
+  virtual ~FakeSyncNotifier();
+
+  bool IsHandlerRegistered(SyncNotifierObserver* handler) const;
+  ObjectIdSet GetRegisteredIds(SyncNotifierObserver* handler) const;
+  const std::string& GetUniqueId() const;
+  const std::string& GetStateDeprecated() const;
+  const std::string& GetCredentialsEmail() const;
+  const std::string& GetCredentialsToken() const;
+  ModelTypeSet GetLastChangedTypes() const;
+
+  virtual void RegisterHandler(SyncNotifierObserver* handler) OVERRIDE;
+  virtual void UpdateRegisteredIds(SyncNotifierObserver* handler,
+                                   const ObjectIdSet& ids) OVERRIDE;
+  virtual void UnregisterHandler(SyncNotifierObserver* handler) OVERRIDE;
+  virtual void SetUniqueId(const std::string& unique_id) OVERRIDE;
+  virtual void SetStateDeprecated(const std::string& state) OVERRIDE;
+  virtual void UpdateCredentials(
+      const std::string& email, const std::string& token) OVERRIDE;
+  virtual void SendNotification(ModelTypeSet changed_types) OVERRIDE;
+
+ private:
+  SyncNotifierRegistrar registrar_;
+  std::string unique_id_;
+  std::string state_;
+  std::string email_;
+  std::string token_;
+  ModelTypeSet last_changed_types_;
+};
+
+}  // namespace syncer
+
+#endif  // SYNC_NOTIFIER_FAKE_SYNC_NOTIFIER_H_
diff --git a/sync/notifier/fake_sync_notifier_observer.cc b/sync/notifier/fake_sync_notifier_observer.cc
new file mode 100644
index 0000000..b95f9a9
--- /dev/null
+++ b/sync/notifier/fake_sync_notifier_observer.cc
@@ -0,0 +1,52 @@
+// 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 "sync/notifier/fake_sync_notifier_observer.h"
+
+namespace syncer {
+
+FakeSyncNotifierObserver::FakeSyncNotifierObserver()
+    : reason_(TRANSIENT_NOTIFICATION_ERROR),
+      last_source_(LOCAL_NOTIFICATION),
+      notification_count_(0) {}
+
+FakeSyncNotifierObserver::~FakeSyncNotifierObserver() {}
+
+NotificationsDisabledReason
+FakeSyncNotifierObserver::GetNotificationsDisabledReason() const {
+  return reason_;
+}
+
+const ObjectIdStateMap&
+FakeSyncNotifierObserver::GetLastNotificationIdStateMap() const {
+  return last_id_state_map_;
+}
+
+IncomingNotificationSource
+FakeSyncNotifierObserver::GetLastNotificationSource() const {
+  return last_source_;
+}
+
+int FakeSyncNotifierObserver::GetNotificationCount() const {
+  return notification_count_;
+}
+
+void FakeSyncNotifierObserver::OnNotificationsEnabled() {
+  reason_ = NO_NOTIFICATION_ERROR;
+}
+
+void FakeSyncNotifierObserver::OnNotificationsDisabled(
+    NotificationsDisabledReason reason) {
+  reason_ = reason;
+}
+
+void FakeSyncNotifierObserver::OnIncomingNotification(
+    const ObjectIdStateMap& id_state_map,
+    IncomingNotificationSource source) {
+  last_id_state_map_ = id_state_map;
+  last_source_ = source;
+  ++notification_count_;
+}
+
+}  // namespace syncer
diff --git a/sync/notifier/fake_sync_notifier_observer.h b/sync/notifier/fake_sync_notifier_observer.h
new file mode 100644
index 0000000..e1195d9
--- /dev/null
+++ b/sync/notifier/fake_sync_notifier_observer.h
@@ -0,0 +1,42 @@
+// 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.
+
+#ifndef SYNC_NOTIFIER_FAKE_SYNC_NOTIFIER_OBSERVER_H_
+#define SYNC_NOTIFIER_FAKE_SYNC_NOTIFIER_OBSERVER_H_
+
+#include <string>
+
+#include "base/compiler_specific.h"
+#include "sync/notifier/sync_notifier_observer.h"
+
+namespace syncer {
+
+class FakeSyncNotifierObserver : public SyncNotifierObserver {
+ public:
+  FakeSyncNotifierObserver();
+  virtual ~FakeSyncNotifierObserver();
+
+  NotificationsDisabledReason GetNotificationsDisabledReason() const;
+  const ObjectIdStateMap& GetLastNotificationIdStateMap() const;
+  IncomingNotificationSource GetLastNotificationSource() const;
+  int GetNotificationCount() const;
+
+  // SyncNotifierObserver implementation.
+  virtual void OnNotificationsEnabled() OVERRIDE;
+  virtual void OnNotificationsDisabled(
+      NotificationsDisabledReason reason) OVERRIDE;
+  virtual void OnIncomingNotification(
+      const ObjectIdStateMap& id_state_map,
+      IncomingNotificationSource source) OVERRIDE;
+
+ private:
+  NotificationsDisabledReason reason_;
+  ObjectIdStateMap last_id_state_map_;
+  IncomingNotificationSource last_source_;
+  int notification_count_;
+};
+
+}  // namespace syncer
+
+#endif  // SYNC_NOTIFIER_FAKE_SYNC_NOTIFIER_OBSERVER_H_
diff --git a/sync/notifier/invalidation_notifier_unittest.cc b/sync/notifier/invalidation_notifier_unittest.cc
index bdf88eb..6ced3ef 100644
--- a/sync/notifier/invalidation_notifier_unittest.cc
+++ b/sync/notifier/invalidation_notifier_unittest.cc
@@ -14,8 +14,8 @@
 #include "sync/internal_api/public/base/model_type_state_map.h"
 #include "sync/internal_api/public/util/weak_handle.h"
 #include "sync/notifier/fake_invalidation_state_tracker.h"
+#include "sync/notifier/fake_sync_notifier_observer.h"
 #include "sync/notifier/invalidation_state_tracker.h"
-#include "sync/notifier/mock_sync_notifier_observer.h"
 #include "sync/notifier/object_id_state_map_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -35,7 +35,7 @@ class InvalidationNotifierTest : public testing::Test {
   }
 
   // Constructs an InvalidationNotifier, places it in |invalidation_notifier_|,
-  // and registers |mock_observer_| as a handler. This remains in place until
+  // and registers |fake_observer_| as a handler. This remains in place until
   // either TearDown (automatic) or ResetNotifier (manual) is called.
   void CreateNotifier(
       const std::string& initial_invalidation_state) {
@@ -50,11 +50,11 @@ class InvalidationNotifierTest : public testing::Test {
             initial_invalidation_state,
             MakeWeakHandle(fake_tracker_.AsWeakPtr()),
             "fake_client_info"));
-    invalidation_notifier_->RegisterHandler(&mock_observer_);
+    invalidation_notifier_->RegisterHandler(&fake_observer_);
   }
 
   void ResetNotifier() {
-    invalidation_notifier_->UnregisterHandler(&mock_observer_);
+    invalidation_notifier_->UnregisterHandler(&fake_observer_);
     // Stopping the invalidation notifier stops its scheduler, which deletes any
     // pending tasks without running them.  Some tasks "run and delete" another
     // task, so they must be run in order to avoid leaking the inner task.
@@ -76,28 +76,19 @@ class InvalidationNotifierTest : public testing::Test {
  protected:
   scoped_ptr<InvalidationNotifier> invalidation_notifier_;
   FakeInvalidationStateTracker fake_tracker_;
-  StrictMock<MockSyncNotifierObserver> mock_observer_;
+  FakeSyncNotifierObserver fake_observer_;
 };
 
 TEST_F(InvalidationNotifierTest, Basic) {
-  InSequence dummy;
-
   CreateNotifier("fake_state");
 
   const ModelTypeSet models(PREFERENCES, BOOKMARKS, AUTOFILL);
-  const ModelTypeStateMap& type_state_map =
-      ModelTypeSetToStateMap(models, "payload");
-  EXPECT_CALL(mock_observer_, OnNotificationsEnabled());
-  EXPECT_CALL(mock_observer_, OnIncomingNotification(
-      ModelTypeStateMapToObjectIdStateMap(type_state_map),
-      REMOTE_NOTIFICATION));
-  EXPECT_CALL(mock_observer_,
-              OnNotificationsDisabled(TRANSIENT_NOTIFICATION_ERROR));
-  EXPECT_CALL(mock_observer_,
-              OnNotificationsDisabled(NOTIFICATION_CREDENTIALS_REJECTED));
+  const ObjectIdStateMap& id_state_map =
+      ModelTypeStateMapToObjectIdStateMap(
+          ModelTypeSetToStateMap(models, "payload"));
 
   invalidation_notifier_->UpdateRegisteredIds(
-      &mock_observer_, ModelTypeSetToObjectIdSet(models));
+      &fake_observer_, ModelTypeSetToObjectIdSet(models));
 
   // TODO(tim): This call should be a no-op, Remove once bug 124140 and
   // associated issues are fixed.
@@ -109,14 +100,23 @@ TEST_F(InvalidationNotifierTest, Basic) {
   invalidation_notifier_->UpdateCredentials("foo@bar.com", "fake_token");
 
   invalidation_notifier_->OnNotificationsEnabled();
+  EXPECT_EQ(NO_NOTIFICATION_ERROR,
+            fake_observer_.GetNotificationsDisabledReason());
 
-  invalidation_notifier_->OnInvalidate(
-      ModelTypeStateMapToObjectIdStateMap(type_state_map));
+  invalidation_notifier_->OnInvalidate(id_state_map);
+  EXPECT_THAT(id_state_map,
+              Eq(fake_observer_.GetLastNotificationIdStateMap()));
+  EXPECT_EQ(REMOTE_NOTIFICATION, fake_observer_.GetLastNotificationSource());
 
   invalidation_notifier_->OnNotificationsDisabled(
       TRANSIENT_NOTIFICATION_ERROR);
+  EXPECT_EQ(TRANSIENT_NOTIFICATION_ERROR,
+            fake_observer_.GetNotificationsDisabledReason());
+
   invalidation_notifier_->OnNotificationsDisabled(
       NOTIFICATION_CREDENTIALS_REJECTED);
+  EXPECT_EQ(NOTIFICATION_CREDENTIALS_REJECTED,
+            fake_observer_.GetNotificationsDisabledReason());
 }
 
 TEST_F(InvalidationNotifierTest, MigrateState) {
diff --git a/sync/notifier/mock_sync_notifier_observer.cc b/sync/notifier/mock_sync_notifier_observer.cc
deleted file mode 100644
index d8db8f2..0000000
--- a/sync/notifier/mock_sync_notifier_observer.cc
+++ /dev/null
@@ -1,12 +0,0 @@
-// 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 "sync/notifier/mock_sync_notifier_observer.h"
-
-namespace syncer {
-
-MockSyncNotifierObserver::MockSyncNotifierObserver() {}
-MockSyncNotifierObserver::~MockSyncNotifierObserver() {}
-
-}  // namespace syncer
diff --git a/sync/notifier/mock_sync_notifier_observer.h b/sync/notifier/mock_sync_notifier_observer.h
deleted file mode 100644
index 6a50ad4..0000000
--- a/sync/notifier/mock_sync_notifier_observer.h
+++ /dev/null
@@ -1,28 +0,0 @@
-// 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.
-
-#ifndef SYNC_NOTIFIER_MOCK_SYNC_NOTIFIER_OBSERVER_H_
-#define SYNC_NOTIFIER_MOCK_SYNC_NOTIFIER_OBSERVER_H_
-
-#include <string>
-
-#include "sync/notifier/sync_notifier_observer.h"
-#include "testing/gmock/include/gmock/gmock.h"
-
-namespace syncer {
-
-class MockSyncNotifierObserver : public SyncNotifierObserver {
- public:
-  MockSyncNotifierObserver();
-  virtual ~MockSyncNotifierObserver();
-
-  MOCK_METHOD0(OnNotificationsEnabled, void());
-  MOCK_METHOD1(OnNotificationsDisabled, void(NotificationsDisabledReason));
-  MOCK_METHOD2(OnIncomingNotification,
-               void(const ObjectIdStateMap&, IncomingNotificationSource));
-};
-
-}  // namespace syncer
-
-#endif  // SYNC_NOTIFIER_MOCK_SYNC_NOTIFIER_OBSERVER_H_
diff --git a/sync/notifier/non_blocking_invalidation_notifier_unittest.cc b/sync/notifier/non_blocking_invalidation_notifier_unittest.cc
index 1121b4b..a749b64 100644
--- a/sync/notifier/non_blocking_invalidation_notifier_unittest.cc
+++ b/sync/notifier/non_blocking_invalidation_notifier_unittest.cc
@@ -14,8 +14,8 @@
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/base/model_type_state_map.h"
 #include "sync/internal_api/public/util/weak_handle.h"
+#include "sync/notifier/fake_sync_notifier_observer.h"
 #include "sync/notifier/invalidation_state_tracker.h"
-#include "sync/notifier/mock_sync_notifier_observer.h"
 #include "sync/notifier/object_id_state_map_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -47,11 +47,11 @@ class NonBlockingInvalidationNotifierTest : public testing::Test {
             std::string(),  // initial_invalidation_state
             MakeWeakHandle(base::WeakPtr<InvalidationStateTracker>()),
             "fake_client_info"));
-    invalidation_notifier_->RegisterHandler(&mock_observer_);
+    invalidation_notifier_->RegisterHandler(&fake_observer_);
   }
 
   virtual void TearDown() {
-    invalidation_notifier_->UnregisterHandler(&mock_observer_);
+    invalidation_notifier_->UnregisterHandler(&fake_observer_);
     invalidation_notifier_.reset();
     request_context_getter_ = NULL;
     io_thread_.Stop();
@@ -62,42 +62,44 @@ class NonBlockingInvalidationNotifierTest : public testing::Test {
   base::Thread io_thread_;
   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
   scoped_ptr<NonBlockingInvalidationNotifier> invalidation_notifier_;
-  StrictMock<MockSyncNotifierObserver> mock_observer_;
+  FakeSyncNotifierObserver fake_observer_;
   notifier::FakeBaseTask fake_base_task_;
 };
 
 // TODO(akalin): Add real unit tests (http://crbug.com/140410).
 
 TEST_F(NonBlockingInvalidationNotifierTest, Basic) {
-  InSequence dummy;
-
   const ModelTypeSet models(PREFERENCES, BOOKMARKS, AUTOFILL);
-  const ModelTypeStateMap& type_state_map =
-      ModelTypeSetToStateMap(models, "payload");
-  EXPECT_CALL(mock_observer_, OnNotificationsEnabled());
-  EXPECT_CALL(mock_observer_, OnIncomingNotification(
-      ModelTypeStateMapToObjectIdStateMap(type_state_map),
-      REMOTE_NOTIFICATION));
-  EXPECT_CALL(mock_observer_,
-              OnNotificationsDisabled(TRANSIENT_NOTIFICATION_ERROR));
-  EXPECT_CALL(mock_observer_,
-              OnNotificationsDisabled(NOTIFICATION_CREDENTIALS_REJECTED));
+  const ObjectIdStateMap& id_state_map =
+      ModelTypeStateMapToObjectIdStateMap(
+          ModelTypeSetToStateMap(models, "payload"));
 
   invalidation_notifier_->UpdateRegisteredIds(
-      &mock_observer_, ModelTypeSetToObjectIdSet(models));
+      &fake_observer_, ModelTypeSetToObjectIdSet(models));
 
   invalidation_notifier_->SetStateDeprecated("fake_state");
   invalidation_notifier_->SetUniqueId("fake_id");
   invalidation_notifier_->UpdateCredentials("foo@bar.com", "fake_token");
 
   invalidation_notifier_->OnNotificationsEnabled();
+  EXPECT_EQ(NO_NOTIFICATION_ERROR,
+            fake_observer_.GetNotificationsDisabledReason());
+
   invalidation_notifier_->OnIncomingNotification(
-      ModelTypeStateMapToObjectIdStateMap(type_state_map),
-      REMOTE_NOTIFICATION);
+      id_state_map, REMOTE_NOTIFICATION);
+  EXPECT_THAT(id_state_map,
+              Eq(fake_observer_.GetLastNotificationIdStateMap()));
+  EXPECT_EQ(REMOTE_NOTIFICATION, fake_observer_.GetLastNotificationSource());
+
   invalidation_notifier_->OnNotificationsDisabled(
       TRANSIENT_NOTIFICATION_ERROR);
+  EXPECT_EQ(TRANSIENT_NOTIFICATION_ERROR,
+            fake_observer_.GetNotificationsDisabledReason());
+
   invalidation_notifier_->OnNotificationsDisabled(
       NOTIFICATION_CREDENTIALS_REJECTED);
+  EXPECT_EQ(NOTIFICATION_CREDENTIALS_REJECTED,
+            fake_observer_.GetNotificationsDisabledReason());
 
   ui_loop_.RunAllPending();
 }
diff --git a/sync/notifier/p2p_notifier_unittest.cc b/sync/notifier/p2p_notifier_unittest.cc
index 9ad6f8a..6a62038b 100644
--- a/sync/notifier/p2p_notifier_unittest.cc
+++ b/sync/notifier/p2p_notifier_unittest.cc
@@ -9,7 +9,7 @@
 #include "jingle/notifier/listener/fake_push_client.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/base/model_type_state_map.h"
-#include "sync/notifier/mock_sync_notifier_observer.h"
+#include "sync/notifier/fake_sync_notifier_observer.h"
 #include "sync/notifier/object_id_state_map_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -17,10 +17,6 @@ namespace syncer {
 
 namespace {
 
-using ::testing::_;
-using ::testing::Mock;
-using ::testing::StrictMock;
-
 class P2PNotifierTest : public testing::Test {
  protected:
   P2PNotifierTest()
@@ -29,11 +25,11 @@ class P2PNotifierTest : public testing::Test {
             scoped_ptr<notifier::PushClient>(fake_push_client_),
             NOTIFY_OTHERS),
         next_sent_notification_to_reflect_(0) {
-    p2p_notifier_.RegisterHandler(&mock_observer_);
+    p2p_notifier_.RegisterHandler(&fake_observer_);
   }
 
   virtual ~P2PNotifierTest() {
-    p2p_notifier_.UnregisterHandler(&mock_observer_);
+    p2p_notifier_.UnregisterHandler(&fake_observer_);
   }
 
   ModelTypeStateMap MakeStateMap(ModelTypeSet types) {
@@ -55,7 +51,7 @@ class P2PNotifierTest : public testing::Test {
   // Owned by |p2p_notifier_|.
   notifier::FakePushClient* fake_push_client_;
   P2PNotifier p2p_notifier_;
-  StrictMock<MockSyncNotifierObserver> mock_observer_;
+  FakeSyncNotifierObserver fake_observer_;
 
  private:
   size_t next_sent_notification_to_reflect_;
@@ -144,13 +140,7 @@ TEST_F(P2PNotifierTest, P2PNotificationDataNonDefault) {
 TEST_F(P2PNotifierTest, NotificationsBasic) {
   const ModelTypeSet enabled_types(BOOKMARKS, PREFERENCES);
 
-  EXPECT_CALL(mock_observer_, OnNotificationsEnabled());
-  EXPECT_CALL(mock_observer_, OnIncomingNotification(
-      ModelTypeStateMapToObjectIdStateMap(MakeStateMap(
-          enabled_types)),
-      REMOTE_NOTIFICATION));
-
-  p2p_notifier_.UpdateRegisteredIds(&mock_observer_,
+  p2p_notifier_.UpdateRegisteredIds(&fake_observer_,
                                     ModelTypeSetToObjectIdSet(enabled_types));
 
   p2p_notifier_.SetUniqueId("sender");
@@ -171,15 +161,25 @@ TEST_F(P2PNotifierTest, NotificationsBasic) {
 
   ReflectSentNotifications();
   fake_push_client_->EnableNotifications();
+  EXPECT_EQ(NO_NOTIFICATION_ERROR,
+            fake_observer_.GetNotificationsDisabledReason());
+
+  ReflectSentNotifications();
+  EXPECT_EQ(1, fake_observer_.GetNotificationCount());
+  EXPECT_THAT(
+      ModelTypeStateMapToObjectIdStateMap(MakeStateMap(enabled_types)),
+      Eq(fake_observer_.GetLastNotificationIdStateMap()));
+  EXPECT_EQ(REMOTE_NOTIFICATION, fake_observer_.GetLastNotificationSource());
 
   // Sent with target NOTIFY_OTHERS so should not be propagated to
-  // |mock_observer_|.
+  // |fake_observer_|.
   {
     ModelTypeSet changed_types(THEMES, APPS);
     p2p_notifier_.SendNotification(changed_types);
   }
 
   ReflectSentNotifications();
+  EXPECT_EQ(1, fake_observer_.GetNotificationCount());
 }
 
 // Set up the P2PNotifier and send out notifications with various
@@ -190,106 +190,97 @@ TEST_F(P2PNotifierTest, SendNotificationData) {
   const ModelTypeSet changed_types(THEMES, APPS);
   const ModelTypeSet expected_types(THEMES);
 
-  EXPECT_CALL(mock_observer_, OnNotificationsEnabled());
-  EXPECT_CALL(mock_observer_,
-              OnIncomingNotification(
-                  ModelTypeStateMapToObjectIdStateMap(
-                      MakeStateMap(enabled_types)),
-                  REMOTE_NOTIFICATION));
-
-  p2p_notifier_.UpdateRegisteredIds(&mock_observer_,
+  p2p_notifier_.UpdateRegisteredIds(&fake_observer_,
                                     ModelTypeSetToObjectIdSet(enabled_types));
 
-  const ModelTypeStateMap& expected_state_map =
-      MakeStateMap(expected_types);
-
   p2p_notifier_.SetUniqueId("sender");
   p2p_notifier_.UpdateCredentials("foo@bar.com", "fake_token");
 
   ReflectSentNotifications();
   fake_push_client_->EnableNotifications();
+  EXPECT_EQ(NO_NOTIFICATION_ERROR,
+            fake_observer_.GetNotificationsDisabledReason());
 
   ReflectSentNotifications();
+  EXPECT_EQ(1, fake_observer_.GetNotificationCount());
+  EXPECT_THAT(
+      ModelTypeStateMapToObjectIdStateMap(MakeStateMap(enabled_types)),
+      Eq(fake_observer_.GetLastNotificationIdStateMap()));
+  EXPECT_EQ(REMOTE_NOTIFICATION, fake_observer_.GetLastNotificationSource());
 
   // Should be dropped.
-  Mock::VerifyAndClearExpectations(&mock_observer_);
   p2p_notifier_.SendNotificationDataForTest(P2PNotificationData());
-
   ReflectSentNotifications();
+  EXPECT_EQ(1, fake_observer_.GetNotificationCount());
+
+  const ObjectIdStateMap& expected_ids =
+      ModelTypeStateMapToObjectIdStateMap(MakeStateMap(expected_types));
 
   // Should be propagated.
-  Mock::VerifyAndClearExpectations(&mock_observer_);
-  EXPECT_CALL(mock_observer_, OnIncomingNotification(
-      ModelTypeStateMapToObjectIdStateMap(expected_state_map),
-      REMOTE_NOTIFICATION));
   p2p_notifier_.SendNotificationDataForTest(
       P2PNotificationData("sender", NOTIFY_SELF, changed_types));
-
   ReflectSentNotifications();
+  EXPECT_EQ(2, fake_observer_.GetNotificationCount());
+  EXPECT_THAT(
+      expected_ids,
+      Eq(fake_observer_.GetLastNotificationIdStateMap()));
 
   // Should be dropped.
-  Mock::VerifyAndClearExpectations(&mock_observer_);
   p2p_notifier_.SendNotificationDataForTest(
       P2PNotificationData("sender2", NOTIFY_SELF, changed_types));
-
   ReflectSentNotifications();
+  EXPECT_EQ(2, fake_observer_.GetNotificationCount());
 
   // Should be dropped.
-  Mock::VerifyAndClearExpectations(&mock_observer_);
   p2p_notifier_.SendNotificationDataForTest(
       P2PNotificationData("sender", NOTIFY_SELF, ModelTypeSet()));
-
   ReflectSentNotifications();
+  EXPECT_EQ(2, fake_observer_.GetNotificationCount());
 
   // Should be dropped.
   p2p_notifier_.SendNotificationDataForTest(
       P2PNotificationData("sender", NOTIFY_OTHERS, changed_types));
-
   ReflectSentNotifications();
+  EXPECT_EQ(2, fake_observer_.GetNotificationCount());
 
   // Should be propagated.
-  Mock::VerifyAndClearExpectations(&mock_observer_);
-  EXPECT_CALL(mock_observer_, OnIncomingNotification(
-      ModelTypeStateMapToObjectIdStateMap(expected_state_map),
-      REMOTE_NOTIFICATION));
   p2p_notifier_.SendNotificationDataForTest(
       P2PNotificationData("sender2", NOTIFY_OTHERS, changed_types));
-
   ReflectSentNotifications();
+  EXPECT_EQ(3, fake_observer_.GetNotificationCount());
+  EXPECT_THAT(
+      expected_ids,
+      Eq(fake_observer_.GetLastNotificationIdStateMap()));
 
   // Should be dropped.
-  Mock::VerifyAndClearExpectations(&mock_observer_);
   p2p_notifier_.SendNotificationDataForTest(
       P2PNotificationData("sender2", NOTIFY_OTHERS, ModelTypeSet()));
-
   ReflectSentNotifications();
+  EXPECT_EQ(3, fake_observer_.GetNotificationCount());
 
   // Should be propagated.
-  Mock::VerifyAndClearExpectations(&mock_observer_);
-  EXPECT_CALL(mock_observer_, OnIncomingNotification(
-      ModelTypeStateMapToObjectIdStateMap(expected_state_map),
-      REMOTE_NOTIFICATION));
   p2p_notifier_.SendNotificationDataForTest(
       P2PNotificationData("sender", NOTIFY_ALL, changed_types));
-
   ReflectSentNotifications();
+  EXPECT_EQ(4, fake_observer_.GetNotificationCount());
+  EXPECT_THAT(
+      expected_ids,
+      Eq(fake_observer_.GetLastNotificationIdStateMap()));
 
   // Should be propagated.
-  Mock::VerifyAndClearExpectations(&mock_observer_);
-  EXPECT_CALL(mock_observer_, OnIncomingNotification(
-      ModelTypeStateMapToObjectIdStateMap(expected_state_map),
-      REMOTE_NOTIFICATION));
   p2p_notifier_.SendNotificationDataForTest(
       P2PNotificationData("sender2", NOTIFY_ALL, changed_types));
-
   ReflectSentNotifications();
+  EXPECT_EQ(5, fake_observer_.GetNotificationCount());
+  EXPECT_THAT(
+      expected_ids,
+      Eq(fake_observer_.GetLastNotificationIdStateMap()));
 
   // Should be dropped.
-  Mock::VerifyAndClearExpectations(&mock_observer_);
   p2p_notifier_.SendNotificationDataForTest(
       P2PNotificationData("sender2", NOTIFY_ALL, ModelTypeSet()));
-
   ReflectSentNotifications();
+  EXPECT_EQ(5, fake_observer_.GetNotificationCount());
 }
 
 }  // namespace
diff --git a/sync/notifier/sync_notifier_factory_unittest.cc b/sync/notifier/sync_notifier_factory_unittest.cc
index 64c802f..6e2bc58 100644
--- a/sync/notifier/sync_notifier_factory_unittest.cc
+++ b/sync/notifier/sync_notifier_factory_unittest.cc
@@ -15,19 +15,14 @@
 #include "jingle/notifier/base/notifier_options.h"
 #include "net/url_request/url_request_test_util.h"
 #include "sync/internal_api/public/base/model_type.h"
+#include "sync/notifier/fake_sync_notifier_observer.h"
 #include "sync/notifier/invalidation_state_tracker.h"
-#include "sync/notifier/mock_sync_notifier_observer.h"
 #include "sync/notifier/sync_notifier.h"
-#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
 namespace {
 
-using ::testing::Mock;
-using ::testing::NiceMock;
-using ::testing::StrictMock;
-
 class SyncNotifierFactoryTest : public testing::Test {
  protected:
 
@@ -37,12 +32,12 @@ class SyncNotifierFactoryTest : public testing::Test {
   }
 
   virtual void TearDown() OVERRIDE {
-    Mock::VerifyAndClearExpectations(&mock_observer_);
     message_loop_.RunAllPending();
+    EXPECT_EQ(0, fake_observer_.GetNotificationCount());
   }
 
   MessageLoop message_loop_;
-  StrictMock<MockSyncNotifierObserver> mock_observer_;
+  FakeSyncNotifierObserver fake_observer_;
   notifier::NotifierOptions notifier_options_;
   scoped_ptr<SyncNotifierFactory> factory_;
 };
@@ -60,9 +55,9 @@ TEST_F(SyncNotifierFactoryTest, Basic) {
 #else
   ASSERT_TRUE(notifier.get());
   ObjectIdSet ids = ModelTypeSetToObjectIdSet(ModelTypeSet(syncer::BOOKMARKS));
-  notifier->RegisterHandler(&mock_observer_);
-  notifier->UpdateRegisteredIds(&mock_observer_, ids);
-  notifier->UnregisterHandler(&mock_observer_);
+  notifier->RegisterHandler(&fake_observer_);
+  notifier->UpdateRegisteredIds(&fake_observer_, ids);
+  notifier->UnregisterHandler(&fake_observer_);
 #endif
 }
 
@@ -79,9 +74,9 @@ TEST_F(SyncNotifierFactoryTest, Basic_P2P) {
 #else
   ASSERT_TRUE(notifier.get());
   ObjectIdSet ids = ModelTypeSetToObjectIdSet(ModelTypeSet(syncer::BOOKMARKS));
-  notifier->RegisterHandler(&mock_observer_);
-  notifier->UpdateRegisteredIds(&mock_observer_, ids);
-  notifier->UnregisterHandler(&mock_observer_);
+  notifier->RegisterHandler(&fake_observer_);
+  notifier->UpdateRegisteredIds(&fake_observer_, ids);
+  notifier->UnregisterHandler(&fake_observer_);
 #endif
 }
 
diff --git a/sync/notifier/sync_notifier_registrar.cc b/sync/notifier/sync_notifier_registrar.cc
index 77c394c..a6960f5 100644
--- a/sync/notifier/sync_notifier_registrar.cc
+++ b/sync/notifier/sync_notifier_registrar.cc
@@ -114,6 +114,25 @@ void SyncNotifierRegistrar::EmitOnNotificationsDisabled(
                     OnNotificationsDisabled(reason));
 }
 
+bool SyncNotifierRegistrar::IsHandlerRegisteredForTest(
+    SyncNotifierObserver* handler) const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return handlers_.HasObserver(handler);
+}
+
+ObjectIdSet SyncNotifierRegistrar::GetRegisteredIdsForTest(
+    SyncNotifierObserver* handler) const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  ObjectIdSet registered_ids;
+  for (IdHandlerMap::const_iterator it = id_to_handler_map_.begin();
+       it != id_to_handler_map_.end(); ++it) {
+    if (it->second == handler) {
+      registered_ids.insert(it->first);
+    }
+  }
+  return registered_ids;
+}
+
 void SyncNotifierRegistrar::DetachFromThreadForTest() {
   DCHECK(thread_checker_.CalledOnValidThread());
   thread_checker_.DetachFromThread();
diff --git a/sync/notifier/sync_notifier_registrar.h b/sync/notifier/sync_notifier_registrar.h
index 4ebdc14..38a81c4 100644
--- a/sync/notifier/sync_notifier_registrar.h
+++ b/sync/notifier/sync_notifier_registrar.h
@@ -60,6 +60,9 @@ class SyncNotifierRegistrar {
   void EmitOnNotificationsEnabled();
   void EmitOnNotificationsDisabled(NotificationsDisabledReason reason);
 
+  bool IsHandlerRegisteredForTest(SyncNotifierObserver* handler) const;
+  ObjectIdSet GetRegisteredIdsForTest(SyncNotifierObserver* handler) const;
+
   // Needed for death tests.
   void DetachFromThreadForTest();
 
diff --git a/sync/notifier/sync_notifier_registrar_unittest.cc b/sync/notifier/sync_notifier_registrar_unittest.cc
index f78ebc9..a9e57c5 100644
--- a/sync/notifier/sync_notifier_registrar_unittest.cc
+++ b/sync/notifier/sync_notifier_registrar_unittest.cc
@@ -3,7 +3,7 @@
 // found in the LICENSE file.
 
 #include "google/cacheinvalidation/types.pb.h"
-#include "sync/notifier/mock_sync_notifier_observer.h"
+#include "sync/notifier/fake_sync_notifier_observer.h"
 #include "sync/notifier/object_id_state_map_test_util.h"
 #include "sync/notifier/sync_notifier_registrar.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -12,10 +12,6 @@ namespace syncer {
 
 namespace {
 
-using testing::InSequence;
-using testing::Mock;
-using testing::StrictMock;
-
 class SyncNotifierRegistrarTest : public testing::Test {
  protected:
   SyncNotifierRegistrarTest()
@@ -35,7 +31,7 @@ class SyncNotifierRegistrarTest : public testing::Test {
 // the handler, dispatching invalidations in between.  The handler should only
 // see invalidations when its registered and its IDs are registered.
 TEST_F(SyncNotifierRegistrarTest, Basic) {
-  StrictMock<MockSyncNotifierObserver> handler;
+  FakeSyncNotifierObserver handler;
 
   SyncNotifierRegistrar registrar;
 
@@ -48,47 +44,44 @@ TEST_F(SyncNotifierRegistrarTest, Basic) {
 
   // Should be ignored since no IDs are registered to |handler|.
   registrar.DispatchInvalidationsToHandlers(states, REMOTE_NOTIFICATION);
-
-  Mock::VerifyAndClearExpectations(&handler);
+  EXPECT_EQ(0, handler.GetNotificationCount());
 
   ObjectIdSet ids;
   ids.insert(kObjectId1);
   ids.insert(kObjectId2);
   registrar.UpdateRegisteredIds(&handler, ids);
 
-  {
-    ObjectIdStateMap expected_states;
-    expected_states[kObjectId1].payload = "1";
-    expected_states[kObjectId2].payload = "2";
-    EXPECT_CALL(handler, OnIncomingNotification(
-        expected_states, REMOTE_NOTIFICATION));
-  }
+  ObjectIdStateMap expected_states;
+  expected_states[kObjectId1].payload = "1";
+  expected_states[kObjectId2].payload = "2";
 
   registrar.DispatchInvalidationsToHandlers(states, REMOTE_NOTIFICATION);
-
-  Mock::VerifyAndClearExpectations(&handler);
+  EXPECT_EQ(1, handler.GetNotificationCount());
+  EXPECT_THAT(
+      expected_states,
+      Eq(handler.GetLastNotificationIdStateMap()));
+  EXPECT_EQ(REMOTE_NOTIFICATION, handler.GetLastNotificationSource());
 
   ids.erase(kObjectId1);
   ids.insert(kObjectId3);
   registrar.UpdateRegisteredIds(&handler, ids);
 
-  {
-    ObjectIdStateMap expected_states;
-    expected_states[kObjectId2].payload = "2";
-    expected_states[kObjectId3].payload = "3";
-    EXPECT_CALL(handler, OnIncomingNotification(
-        expected_states, REMOTE_NOTIFICATION));
-  }
+  expected_states.erase(kObjectId1);
+  expected_states[kObjectId3].payload = "3";
 
   // Removed object IDs should not be notified, newly-added ones should.
   registrar.DispatchInvalidationsToHandlers(states, REMOTE_NOTIFICATION);
-
-  Mock::VerifyAndClearExpectations(&handler);
+  EXPECT_EQ(2, handler.GetNotificationCount());
+  EXPECT_THAT(
+      expected_states,
+      Eq(handler.GetLastNotificationIdStateMap()));
+  EXPECT_EQ(REMOTE_NOTIFICATION, handler.GetLastNotificationSource());
 
   registrar.UnregisterHandler(&handler);
 
   // Should be ignored since |handler| isn't registered anymore.
   registrar.DispatchInvalidationsToHandlers(states, REMOTE_NOTIFICATION);
+  EXPECT_EQ(2, handler.GetNotificationCount());
 }
 
 // Register handlers and some IDs for those handlers, register a handler with
@@ -97,35 +90,10 @@ TEST_F(SyncNotifierRegistrarTest, Basic) {
 // should get notifications, and the ones that have registered IDs should
 // receive invalidations for those IDs.
 TEST_F(SyncNotifierRegistrarTest, MultipleHandlers) {
-  StrictMock<MockSyncNotifierObserver> handler1;
-  EXPECT_CALL(handler1, OnNotificationsEnabled());
-  {
-    ObjectIdStateMap expected_states;
-    expected_states[kObjectId1].payload = "1";
-    expected_states[kObjectId2].payload = "2";
-    EXPECT_CALL(handler1, OnIncomingNotification(
-        expected_states, REMOTE_NOTIFICATION));
-  }
-  EXPECT_CALL(handler1,
-              OnNotificationsDisabled(TRANSIENT_NOTIFICATION_ERROR));
-
-  StrictMock<MockSyncNotifierObserver> handler2;
-  EXPECT_CALL(handler2, OnNotificationsEnabled());
-  {
-    ObjectIdStateMap expected_states;
-    expected_states[kObjectId3].payload = "3";
-    EXPECT_CALL(handler2, OnIncomingNotification(
-        expected_states, REMOTE_NOTIFICATION));
-  }
-  EXPECT_CALL(handler2,
-              OnNotificationsDisabled(TRANSIENT_NOTIFICATION_ERROR));
-
-  StrictMock<MockSyncNotifierObserver> handler3;
-  EXPECT_CALL(handler3, OnNotificationsEnabled());
-  EXPECT_CALL(handler3,
-              OnNotificationsDisabled(TRANSIENT_NOTIFICATION_ERROR));
-
-  StrictMock<MockSyncNotifierObserver> handler4;
+  FakeSyncNotifierObserver handler1;
+  FakeSyncNotifierObserver handler2;
+  FakeSyncNotifierObserver handler3;
+  FakeSyncNotifierObserver handler4;
 
   SyncNotifierRegistrar registrar;
 
@@ -158,6 +126,15 @@ TEST_F(SyncNotifierRegistrarTest, MultipleHandlers) {
   registrar.UnregisterHandler(&handler4);
 
   registrar.EmitOnNotificationsEnabled();
+  EXPECT_EQ(NO_NOTIFICATION_ERROR,
+            handler1.GetNotificationsDisabledReason());
+  EXPECT_EQ(NO_NOTIFICATION_ERROR,
+            handler2.GetNotificationsDisabledReason());
+  EXPECT_EQ(NO_NOTIFICATION_ERROR,
+            handler3.GetNotificationsDisabledReason());
+  EXPECT_EQ(TRANSIENT_NOTIFICATION_ERROR,
+            handler4.GetNotificationsDisabledReason());
+
   {
     ObjectIdStateMap states;
     states[kObjectId1].payload = "1";
@@ -165,8 +142,39 @@ TEST_F(SyncNotifierRegistrarTest, MultipleHandlers) {
     states[kObjectId3].payload = "3";
     states[kObjectId4].payload = "4";
     registrar.DispatchInvalidationsToHandlers(states, REMOTE_NOTIFICATION);
+
+    ObjectIdStateMap expected_states;
+    expected_states[kObjectId1].payload = "1";
+    expected_states[kObjectId2].payload = "2";
+
+    EXPECT_EQ(1, handler1.GetNotificationCount());
+    EXPECT_THAT(
+        expected_states,
+        Eq(handler1.GetLastNotificationIdStateMap()));
+    EXPECT_EQ(REMOTE_NOTIFICATION, handler1.GetLastNotificationSource());
+
+    expected_states.clear();
+    expected_states[kObjectId3].payload = "3";
+
+    EXPECT_EQ(1, handler2.GetNotificationCount());
+    EXPECT_THAT(
+        expected_states,
+        Eq(handler2.GetLastNotificationIdStateMap()));
+    EXPECT_EQ(REMOTE_NOTIFICATION, handler2.GetLastNotificationSource());
+
+    EXPECT_EQ(0, handler3.GetNotificationCount());
+    EXPECT_EQ(0, handler4.GetNotificationCount());
   }
+
   registrar.EmitOnNotificationsDisabled(TRANSIENT_NOTIFICATION_ERROR);
+  EXPECT_EQ(TRANSIENT_NOTIFICATION_ERROR,
+            handler1.GetNotificationsDisabledReason());
+  EXPECT_EQ(TRANSIENT_NOTIFICATION_ERROR,
+            handler2.GetNotificationsDisabledReason());
+  EXPECT_EQ(TRANSIENT_NOTIFICATION_ERROR,
+            handler3.GetNotificationsDisabledReason());
+  EXPECT_EQ(TRANSIENT_NOTIFICATION_ERROR,
+            handler4.GetNotificationsDisabledReason());
 }
 
 // Multiple registrations by different handlers on the same object ID should
@@ -174,10 +182,10 @@ TEST_F(SyncNotifierRegistrarTest, MultipleHandlers) {
 TEST_F(SyncNotifierRegistrarTest, MultipleRegistration) {
   SyncNotifierRegistrar registrar;
 
-  StrictMock<MockSyncNotifierObserver> handler1;
+  FakeSyncNotifierObserver handler1;
   registrar.RegisterHandler(&handler1);
 
-  MockSyncNotifierObserver handler2;
+  FakeSyncNotifierObserver handler2;
   registrar.RegisterHandler(&handler2);
 
   ObjectIdSet ids;
@@ -194,22 +202,10 @@ TEST_F(SyncNotifierRegistrarTest, MultipleRegistration) {
 // Make sure that passing an empty set to UpdateRegisteredIds clears the
 // corresponding entries for the handler.
 TEST_F(SyncNotifierRegistrarTest, EmptySetUnregisters) {
-  StrictMock<MockSyncNotifierObserver> handler1;
-  EXPECT_CALL(handler1, OnNotificationsEnabled());
-  EXPECT_CALL(handler1,
-              OnNotificationsDisabled(TRANSIENT_NOTIFICATION_ERROR));
+  FakeSyncNotifierObserver handler1;
 
   // Control observer.
-  StrictMock<MockSyncNotifierObserver> handler2;
-  EXPECT_CALL(handler2, OnNotificationsEnabled());
-  {
-    ObjectIdStateMap expected_states;
-    expected_states[kObjectId3].payload = "3";
-    EXPECT_CALL(handler2, OnIncomingNotification(
-        expected_states, REMOTE_NOTIFICATION));
-  }
-  EXPECT_CALL(handler2,
-              OnNotificationsDisabled(TRANSIENT_NOTIFICATION_ERROR));
+  FakeSyncNotifierObserver handler2;
 
   SyncNotifierRegistrar registrar;
 
@@ -234,14 +230,27 @@ TEST_F(SyncNotifierRegistrarTest, EmptySetUnregisters) {
   registrar.UpdateRegisteredIds(&handler1, ObjectIdSet());
 
   registrar.EmitOnNotificationsEnabled();
+  EXPECT_EQ(NO_NOTIFICATION_ERROR,
+            handler1.GetNotificationsDisabledReason());
+  EXPECT_EQ(NO_NOTIFICATION_ERROR,
+            handler2.GetNotificationsDisabledReason());
+
   {
     ObjectIdStateMap states;
     states[kObjectId1].payload = "1";
     states[kObjectId2].payload = "2";
     states[kObjectId3].payload = "3";
-    registrar.DispatchInvalidationsToHandlers(states, REMOTE_NOTIFICATION);
+    registrar.DispatchInvalidationsToHandlers(states,
+                                              REMOTE_NOTIFICATION);
+    EXPECT_EQ(0, handler1.GetNotificationCount());
+    EXPECT_EQ(1, handler2.GetNotificationCount());
   }
+
   registrar.EmitOnNotificationsDisabled(TRANSIENT_NOTIFICATION_ERROR);
+  EXPECT_EQ(TRANSIENT_NOTIFICATION_ERROR,
+            handler1.GetNotificationsDisabledReason());
+  EXPECT_EQ(TRANSIENT_NOTIFICATION_ERROR,
+            handler2.GetNotificationsDisabledReason());
 }
 
 }  // namespace