Refactor sync-specific parts out of SyncNotifier/SyncNotifierObserver

sync/internal_api/syncapi_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.
 
 // Unit tests for the SyncApi. Note that a lot of the underlying
 // functionality is provided by the Syncable layer, which has its own
 // unit tests. We'll test SyncApi specific things in this harness.
 
 #include <cstddef>
 #include <map>
@@ skipping 676 matching lines @@
   MOCK_METHOD1(OnUpdatedToken, void(const std::string&));  // NOLINT
   MOCK_METHOD2(OnEncryptedTypesChanged,
                void(ModelTypeSet, bool));  // NOLINT
   MOCK_METHOD0(OnEncryptionComplete, void());  // NOLINT
   MOCK_METHOD1(OnActionableError,
                void(const syncer::SyncProtocolError&));  // NOLINT
 };
 
 class SyncNotifierMock : public syncer::SyncNotifier {
  public:
-  MOCK_METHOD1(AddObserver, void(syncer::SyncNotifierObserver*));
-  MOCK_METHOD1(RemoveObserver, void(syncer::SyncNotifierObserver*));
+  MOCK_METHOD2(UpdateRegisteredIds, void(SyncNotifierObserver*,
+                                         const ObjectIdSet&));
   MOCK_METHOD1(SetUniqueId, void(const std::string&));
   MOCK_METHOD1(SetStateDeprecated, void(const std::string&));
   MOCK_METHOD2(UpdateCredentials,
                void(const std::string&, const std::string&));
-  MOCK_METHOD1(UpdateEnabledTypes,
-               void(syncer::ModelTypeSet));
   MOCK_METHOD1(SendNotification, void(syncer::ModelTypeSet));
 };
 
 }  // namespace
 
 class SyncManagerTest : public testing::Test,
                         public SyncManager::ChangeDelegate {
  protected:
   enum NigoriStatus {
     DONT_WRITE_NIGORI,
     WRITE_TO_NIGORI
   };
 
   enum EncryptionStatus {
     UNINITIALIZED,
     DEFAULT_ENCRYPTION,
     FULL_ENCRYPTION
   };
 
   SyncManagerTest()
       : sync_notifier_mock_(NULL),
-        sync_manager_("Test sync manager"),
-        sync_notifier_observer_(NULL),
-        update_enabled_types_call_count_(0) {}
+        sync_manager_("Test sync manager") {}
 
   virtual ~SyncManagerTest() {
     EXPECT_FALSE(sync_notifier_mock_);
   }
 
   // Test implementation.
   void SetUp() {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 
     SyncCredentials credentials;
     credentials.email = "foo@bar.com";
     credentials.sync_token = "sometoken";
 
     sync_notifier_mock_ = new StrictMock<SyncNotifierMock>();
-    EXPECT_CALL(*sync_notifier_mock_, AddObserver(_)).
-        WillOnce(Invoke(this, &SyncManagerTest::SyncNotifierAddObserver));
     EXPECT_CALL(*sync_notifier_mock_, SetUniqueId(_));
     EXPECT_CALL(*sync_notifier_mock_, SetStateDeprecated(""));
     EXPECT_CALL(*sync_notifier_mock_,
                 UpdateCredentials(credentials.email, credentials.sync_token));
-    EXPECT_CALL(*sync_notifier_mock_, UpdateEnabledTypes(_)).
-            WillRepeatedly(
-                Invoke(this, &SyncManagerTest::SyncNotifierUpdateEnabledTypes));
-    EXPECT_CALL(*sync_notifier_mock_, RemoveObserver(_)).
-        WillOnce(Invoke(this, &SyncManagerTest::SyncNotifierRemoveObserver));
 
     sync_manager_.AddObserver(&observer_);
     EXPECT_CALL(observer_, OnInitializationComplete(_, _)).
         WillOnce(SaveArg<0>(&js_backend_));
 
-    EXPECT_FALSE(sync_notifier_observer_);
     EXPECT_FALSE(js_backend_.IsInitialized());
 
     std::vector<ModelSafeWorker*> workers;
     ModelSafeRoutingInfo routing_info;
     GetModelSafeRoutingInfo(&routing_info);
 
     // Takes ownership of |sync_notifier_mock_|.
     sync_manager_.Init(temp_dir_.path(),
                        WeakHandle<JsEventHandler>(),
                        "bogus", 0, false,
                        base::MessageLoopProxy::current(),
                        scoped_ptr<HttpPostProviderFactory>(
                            new TestHttpPostProviderFactory()),
                        routing_info, workers,
                        &extensions_activity_monitor_, this,
                        credentials,
                        scoped_ptr<SyncNotifier>(sync_notifier_mock_),
                        "",
                        syncer::SyncManager::TEST_IN_MEMORY,
                        &encryptor_,
                        &handler_,
                        NULL);
 
-    EXPECT_TRUE(sync_notifier_observer_);
     EXPECT_TRUE(js_backend_.IsInitialized());
 
-    EXPECT_EQ(0, update_enabled_types_call_count_);
-
     for (ModelSafeRoutingInfo::iterator i = routing_info.begin();
          i != routing_info.end(); ++i) {
       type_roots_[i->first] = MakeServerNodeForType(
           sync_manager_.GetUserShare(), i->first);
     }
     PumpLoop();
   }
 
   void TearDown() {
     sync_manager_.RemoveObserver(&observer_);
+    EXPECT_CALL(*sync_notifier_mock_,
+                UpdateRegisteredIds(_, ObjectIdSet()));
     sync_manager_.ShutdownOnSyncThread();
     sync_notifier_mock_ = NULL;
-    EXPECT_FALSE(sync_notifier_observer_);
     PumpLoop();
   }
 
   void GetModelSafeRoutingInfo(ModelSafeRoutingInfo* out) {
     (*out)[syncer::NIGORI] = syncer::GROUP_PASSIVE;
     (*out)[syncer::BOOKMARKS] = syncer::GROUP_PASSIVE;
     (*out)[syncer::THEMES] = syncer::GROUP_PASSIVE;
     (*out)[syncer::SESSIONS] = syncer::GROUP_PASSIVE;
     (*out)[syncer::PASSWORDS] = syncer::GROUP_PASSIVE;
     (*out)[syncer::PREFERENCES] = syncer::GROUP_PASSIVE;
@@ skipping 40 matching lines @@
     }
     return cryptographer->is_ready();
   }
 
   int64 GetIdForDataType(ModelType type) {
     if (type_roots_.count(type) == 0)
       return 0;
     return type_roots_[type];
   }
 
-  void SyncNotifierAddObserver(
-      syncer::SyncNotifierObserver* sync_notifier_observer) {
-    EXPECT_EQ(NULL, sync_notifier_observer_);
-    sync_notifier_observer_ = sync_notifier_observer;
-  }
-
-  void SyncNotifierRemoveObserver(
-      syncer::SyncNotifierObserver* sync_notifier_observer) {
-    EXPECT_EQ(sync_notifier_observer_, sync_notifier_observer);
-    sync_notifier_observer_ = NULL;
-  }
-
-  void SyncNotifierUpdateEnabledTypes(syncer::ModelTypeSet types) {
-    ModelSafeRoutingInfo routes;
-    GetModelSafeRoutingInfo(&routes);
-    const syncer::ModelTypeSet expected_types = GetRoutingInfoTypes(routes);
-    EXPECT_TRUE(types.Equals(expected_types));
-    ++update_enabled_types_call_count_;
-  }
-
   void PumpLoop() {
     message_loop_.RunAllPending();
   }
 
   void SendJsMessage(const std::string& name, const JsArgList& args,
                      const WeakHandle<JsReplyHandler>& reply_handler) {
     js_backend_.Call(FROM_HERE, &JsBackend::ProcessJsMessage,
                      name, args, reply_handler);
     PumpLoop();
   }
@@ skipping 27 matching lines @@
   }
 
  private:
   // Needed by |sync_manager_|.
   MessageLoop message_loop_;
   // Needed by |sync_manager_|.
   ScopedTempDir temp_dir_;
   // Sync Id's for the roots of the enabled datatypes.
   std::map<ModelType, int64> type_roots_;
   FakeExtensionsActivityMonitor extensions_activity_monitor_;
-  StrictMock<SyncNotifierMock>* sync_notifier_mock_;
 
  protected:
   FakeEncryptor encryptor_;
   TestUnrecoverableErrorHandler handler_;
+  StrictMock<SyncNotifierMock>* sync_notifier_mock_;
   SyncManagerImpl sync_manager_;
   WeakHandle<JsBackend> js_backend_;
   StrictMock<SyncManagerObserverMock> observer_;
-  syncer::SyncNotifierObserver* sync_notifier_observer_;
-  int update_enabled_types_call_count_;
 };
 
 TEST_F(SyncManagerTest, UpdateEnabledTypes) {
-  EXPECT_EQ(0, update_enabled_types_call_count_);
-
   ModelSafeRoutingInfo routes;
   GetModelSafeRoutingInfo(&routes);
   const syncer::ModelTypeSet enabled_types = GetRoutingInfoTypes(routes);
 
+  EXPECT_CALL(*sync_notifier_mock_,
+              UpdateRegisteredIds(_, ModelTypeSetToObjectIdSet(enabled_types)));
   sync_manager_.UpdateEnabledTypes(enabled_types);
-  EXPECT_EQ(1, update_enabled_types_call_count_);
 }
 
 TEST_F(SyncManagerTest, ProcessJsMessage) {
   const JsArgList kNoArgs;
 
   StrictMock<MockJsReplyHandler> reply_handler;
 
   ListValue false_args;
   false_args.Append(Value::CreateBooleanValue(false));
 
@@ skipping 1647 matching lines @@
   // Ensure only bookmarks and nigori lost their progress marker. Preferences
   // should still have it.
   partial_types =
       sync_manager_.GetTypesWithEmptyProgressMarkerToken(ModelTypeSet::All());
   EXPECT_TRUE(partial_types.Has(NIGORI));
   EXPECT_TRUE(partial_types.Has(BOOKMARKS));
   EXPECT_FALSE(partial_types.Has(PREFERENCES));
 }
 
 }  // namespace