[Sync] Enable adding notifier observers from ProfileSyncService

chrome/browser/sync/profile_sync_service_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 "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/values.h"
 #include "chrome/browser/signin/signin_manager.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/signin/token_service.h"
 #include "chrome/browser/signin/token_service_factory.h"
 #include "chrome/browser/sync/glue/bookmark_data_type_controller.h"
 #include "chrome/browser/sync/glue/data_type_controller.h"
 #include "chrome/browser/sync/profile_sync_components_factory_mock.h"
 #include "chrome/browser/sync/test_profile_sync_service.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/net/gaia/gaia_constants.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_pref_service.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/common/content_client.h"
 #include "content/public/test/test_browser_thread.h"
+#include "google/cacheinvalidation/include/types.h"
 #include "sync/js/js_arg_list.h"
 #include "sync/js/js_event_details.h"
 #include "sync/js/js_test_util.h"
+#include "sync/notifier/mock_sync_notifier_observer.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/glue/webkit_glue.h"
 
 // TODO(akalin): Add tests here that exercise the whole
 // ProfileSyncService/SyncBackendHost stack while mocking out as
 // little as possible.
 
 namespace browser_sync {
 
 namespace {
 
 using content::BrowserThread;
 using testing::_;
 using testing::AtLeast;
 using testing::AtMost;
+using testing::Mock;
 using testing::Return;
 using testing::StrictMock;
 
 class ProfileSyncServiceTest : public testing::Test {
  protected:
   ProfileSyncServiceTest()
       : ui_thread_(BrowserThread::UI, &ui_loop_),
         db_thread_(BrowserThread::DB),
         file_thread_(BrowserThread::FILE),
         io_thread_(BrowserThread::IO) {}
@@ skipping 22 matching lines @@
     io_thread_.Stop();
     file_thread_.Stop();
     // Ensure that the sync objects destruct to avoid memory leaks.
     ui_loop_.RunAllPending();
   }
 
   // TODO(akalin): Refactor the StartSyncService*() functions below.
 
   void StartSyncService() {
     StartSyncServiceAndSetInitialSyncEnded(
-        true, true, false, true, true, syncer::STORAGE_IN_MEMORY);
+        true, true, false, true, 1, syncer::STORAGE_IN_MEMORY);
   }
 
   void StartSyncServiceAndSetInitialSyncEnded(
       bool set_initial_sync_ended,
       bool issue_auth_token,
       bool synchronous_sync_configuration,
       bool sync_setup_completed,
-      bool expect_create_dtm,
+      int expected_create_dtm_calls,

[tim (not reviewing), 2012/08/02 17:43:23]

Oh boy. 1 and 0 :| An enum CREATE_DTM, DONT_CREATE_DTM would be far more clear,
but frankly, we probably don't care much beyond the fact that the DTM is created
if needed (it's arguably brittle to expect more, imo?). 

Instead of the WillOnce / Times(0) call, I think we should mimic what a "fake"
would do, and say 

   ON_CALL(*factory, CreateDataTypeManager()).
        WillByDefault(ReturnNewDataTypeManager());

... and, wait for it, remove the param to Start...!!!

[akalin, 2012/08/02 22:06:00]

Done.

       syncer::StorageOption storage_option) {
     if (!service_.get()) {
       SigninManager* signin =
           SigninManagerFactory::GetForProfile(profile_.get());
       signin->SetAuthenticatedUsername("test");
       ProfileSyncComponentsFactoryMock* factory =
           new ProfileSyncComponentsFactoryMock();
       service_.reset(new TestProfileSyncService(
           factory,
           profile_.get(),
           signin,
           ProfileSyncService::AUTO_START,
           true,
           base::Closure()));
       if (!set_initial_sync_ended)
         service_->dont_set_initial_sync_ended_on_init();
       if (synchronous_sync_configuration)
         service_->set_synchronous_sync_configuration();
       service_->set_storage_option(storage_option);
       if (!sync_setup_completed)
         profile_->GetPrefs()->SetBoolean(prefs::kSyncHasSetupCompleted, false);
 
-      if (expect_create_dtm) {
-        // Register the bookmark data type.
-        EXPECT_CALL(*factory, CreateDataTypeManager(_, _)).
-            WillOnce(ReturnNewDataTypeManager());
-      } else {
-        EXPECT_CALL(*factory, CreateDataTypeManager(_, _)).
-            Times(0);
-      }
+      // Register the bookmark data type.
+      EXPECT_CALL(*factory, CreateDataTypeManager(_, _)).
+          Times(expected_create_dtm_calls).
+          WillRepeatedly(ReturnNewDataTypeManager());
 
       if (issue_auth_token) {
         IssueTestTokens();
       }
       service_->Initialize();
     }
   }
 
   void IssueTestTokens() {
     TokenService* token_service =
@@ skipping 111 matching lines @@
   EXPECT_TRUE(service_->GetBackendForTest() != NULL);
 
   syncer::JsController* js_controller = service_->GetJsController();
   StrictMock<syncer::MockJsEventHandler> event_handler;
   js_controller->AddJsEventHandler(&event_handler);
   js_controller->RemoveJsEventHandler(&event_handler);
 }
 
 TEST_F(ProfileSyncServiceTest,
        JsControllerHandlersDelayedBackendInitialization) {
-  StartSyncServiceAndSetInitialSyncEnded(true, false, false, true, true,
+  StartSyncServiceAndSetInitialSyncEnded(true, false, false, true, 1,
                                          syncer::STORAGE_IN_MEMORY);
 
   StrictMock<syncer::MockJsEventHandler> event_handler;
   EXPECT_CALL(event_handler, HandleJsEvent(_, _)).Times(AtLeast(1));
 
   EXPECT_EQ(NULL, service_->GetBackendForTest());
   EXPECT_FALSE(service_->sync_initialized());
 
   syncer::JsController* js_controller = service_->GetJsController();
   js_controller->AddJsEventHandler(&event_handler);
@@ skipping 21 matching lines @@
                                     reply_handler.AsWeakHandle());
   }
 
   // This forces the sync thread to process the message and reply.
   service_.reset();
   ui_loop_.RunAllPending();
 }
 
 TEST_F(ProfileSyncServiceTest,
        JsControllerProcessJsMessageBasicDelayedBackendInitialization) {
-  StartSyncServiceAndSetInitialSyncEnded(true, false, false, true, true,
+  StartSyncServiceAndSetInitialSyncEnded(true, false, false, true, 1,
                                          syncer::STORAGE_IN_MEMORY);
 
   StrictMock<syncer::MockJsReplyHandler> reply_handler;
 
   ListValue arg_list1;
   arg_list1.Append(Value::CreateBooleanValue(false));
   syncer::JsArgList args1(&arg_list1);
   EXPECT_CALL(reply_handler,
               HandleJsReply("getNotificationState", HasArgs(args1)));
 
@@ skipping 22 matching lines @@
   FilePath sync_file2 = temp_directory.AppendASCII("SyncData.sqlite3");
   FilePath sync_file3 = temp_directory.AppendASCII("nonsense_file");
   ASSERT_TRUE(file_util::CreateDirectory(temp_directory));
   ASSERT_NE(-1,
             file_util::WriteFile(sync_file1, nonsense1, strlen(nonsense1)));
   ASSERT_NE(-1,
             file_util::WriteFile(sync_file2, nonsense2, strlen(nonsense2)));
   ASSERT_NE(-1,
             file_util::WriteFile(sync_file3, nonsense3, strlen(nonsense3)));
 
-  StartSyncServiceAndSetInitialSyncEnded(false, false, true, false, true,
+  StartSyncServiceAndSetInitialSyncEnded(false, false, true, false, 1,
                                          syncer::STORAGE_ON_DISK);
   EXPECT_FALSE(service_->HasSyncSetupCompleted());
   EXPECT_FALSE(service_->sync_initialized());
 
   // Since we're doing synchronous initialization, backend should be
   // initialized by this call.
   IssueTestTokens();
 
   // Stop the service so we can read the new Sync Data files that were
   // created.
   service_.reset();
 
   // This file should have been deleted when the whole directory was nuked.
   ASSERT_FALSE(file_util::PathExists(sync_file3));
   ASSERT_FALSE(file_util::PathExists(sync_file1));
 
   // This will still exist, but the text should have changed.
   ASSERT_TRUE(file_util::PathExists(sync_file2));
   std::string file2text;
   ASSERT_TRUE(file_util::ReadFileToString(sync_file2, &file2text));
   ASSERT_NE(file2text.compare(nonsense2), 0);
 }
 
 // Simulates a scenario where a database is corrupted and it is impossible to
 // recreate it.  This test is useful mainly when it is run under valgrind.  Its
 // expectations are not very interesting.
 TEST_F(ProfileSyncServiceTest, FailToOpenDatabase) {
-  StartSyncServiceAndSetInitialSyncEnded(false, true, true, true, false,
+  StartSyncServiceAndSetInitialSyncEnded(false, true, true, true, 0,
                                          syncer::STORAGE_INVALID);
 
   // The backend is not ready.  Ensure the PSS knows this.
   EXPECT_FALSE(service_->sync_initialized());
 }
 
+// Register for some IDs with the ProfileSyncService and trigger some
+// invalidation messages.  They should be received by the observer.
+// Then unregister and trigger the invalidation messages again.  Those
+// shouldn't be received by the observer.
+TEST_F(ProfileSyncServiceTest, UpdateRegisteredInvalidationIds) {
+  StartSyncService();
+
+  syncer::ObjectIdSet ids;
+  ids.insert(invalidation::ObjectId(1, "id1"));
+  ids.insert(invalidation::ObjectId(2, "id2"));
+  const syncer::ObjectIdPayloadMap& payloads =
+      syncer::ObjectIdSetToPayloadMap(ids, "payload");
+
+  StrictMock<syncer::MockSyncNotifierObserver> observer;
+  EXPECT_CALL(observer, OnNotificationsEnabled());
+  EXPECT_CALL(observer, OnNotificationsDisabled(
+      syncer::TRANSIENT_NOTIFICATION_ERROR));
+  EXPECT_CALL(observer, OnIncomingNotification(
+      payloads, syncer::REMOTE_NOTIFICATION));
+
+  service_->UpdateRegisteredInvalidationIds(&observer, ids);
+
+  SyncBackendHostForProfileSyncTest* const backend =
+      service_->GetBackendForTest();
+
+  backend->EmitOnNotificationsEnabled();
+  backend->EmitOnNotificationsDisabled(syncer::TRANSIENT_NOTIFICATION_ERROR);
+  backend->EmitOnIncomingNotification(payloads, syncer::REMOTE_NOTIFICATION);
+
+  Mock::VerifyAndClearExpectations(&observer);
+
+  service_->UpdateRegisteredInvalidationIds(&observer, syncer::ObjectIdSet());
+
+  backend->EmitOnNotificationsEnabled();
+  backend->EmitOnNotificationsDisabled(syncer::TRANSIENT_NOTIFICATION_ERROR);
+  backend->EmitOnIncomingNotification(payloads, syncer::REMOTE_NOTIFICATION);
+}
+
+// Register for some IDs with the ProfileSyncService, restart sync,
+// and trigger some invalidation messages.  They should still be
+// received by the observer.
+TEST_F(ProfileSyncServiceTest, UpdateRegisteredInvalidationIdsPersistence) {
+  StartSyncServiceAndSetInitialSyncEnded(true, true, false, true, 2,
+                                         syncer::STORAGE_IN_MEMORY);
+
+  StrictMock<syncer::MockSyncNotifierObserver> observer;
+  EXPECT_CALL(observer, OnNotificationsEnabled());
+
+  syncer::ObjectIdSet ids;
+  ids.insert(invalidation::ObjectId(3, "id3"));
+  service_->UpdateRegisteredInvalidationIds(&observer, ids);
+
+  service_->StopAndSuppress();
+  service_->UnsuppressAndStart();
+
+  service_->GetBackendForTest()->EmitOnNotificationsEnabled();
+}
+
 }  // namespace
 }  // namespace browser_sync