[Sync] Replace ClearServerDataCallback with Closure.

components/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 "components/browser_sync/profile_sync_service.h"
 
 #include <utility>
 
 #include "base/callback.h"
 #include "base/command_line.h"
@@ skipping 110 matching lines @@
   }
 
  private:
   std::vector<bool>* delete_dir_param_;
 };
 
 // FakeSyncEngine that calls an external callback when ClearServerData is
 // called.
 class SyncEngineCaptureClearServerData : public FakeSyncEngine {
  public:
-  using ClearServerDataCalled =
-      base::Callback<void(const syncer::SyncManager::ClearServerDataCallback&)>;
+  using ClearServerDataCalled = base::Callback<void(const base::Closure&)>;
   explicit SyncEngineCaptureClearServerData(
       const ClearServerDataCalled& clear_server_data_called)
       : clear_server_data_called_(clear_server_data_called) {}
 
-  void ClearServerData(
-      const syncer::SyncManager::ClearServerDataCallback& callback) override {
+  void ClearServerData(const base::Closure& callback) override {
     clear_server_data_called_.Run(callback);
   }
 
  private:
   ClearServerDataCalled clear_server_data_called_;
 };
 
 ACTION(ReturnNewFakeSyncEngine) {
   return new FakeSyncEngine();
 }
 
 ACTION(ReturnNewSyncEngineNoReturn) {
   return new SyncEngineNoReturn();
 }
 
 ACTION_P(ReturnNewMockHostCollectDeleteDirParam, delete_dir_param) {
   return new FakeSyncEngineCollectDeleteDirParam(delete_dir_param);
 }
 
-void OnClearServerDataCalled(
-    syncer::SyncManager::ClearServerDataCallback* captured_callback,
-    const syncer::SyncManager::ClearServerDataCallback& callback) {
+void OnClearServerDataCalled(base::Closure* captured_callback,
+                             const base::Closure& callback) {
   *captured_callback = callback;
 }
 
 ACTION_P(ReturnNewMockHostCaptureClearServerData, captured_callback) {
   return new SyncEngineCaptureClearServerData(base::Bind(
       &OnClearServerDataCalled, base::Unretained(captured_callback)));
 }
 
 void DoNothing(DataTypeController::ConfigureResult ignored1,
                const SyncMergeResult& ignored2,
@@ skipping 127 matching lines @@
   void ExpectSyncEngineCreationCollectDeleteDir(
       int times,
       std::vector<bool>* delete_dir_param) {
     EXPECT_CALL(*component_factory_, CreateSyncEngine(_, _, _, _))
         .Times(times)
         .WillRepeatedly(
             ReturnNewMockHostCollectDeleteDirParam(delete_dir_param));
   }
 
   void ExpectSyncEngineCreationCaptureClearServerData(
-      syncer::SyncManager::ClearServerDataCallback* captured_callback) {
+      base::Closure* captured_callback) {
     EXPECT_CALL(*component_factory_, CreateSyncEngine(_, _, _, _))
         .Times(1)
         .WillOnce(ReturnNewMockHostCaptureClearServerData(captured_callback));
   }
 
   void PrepareDelayedInitSyncEngine() {
     EXPECT_CALL(*component_factory_, CreateSyncEngine(_, _, _, _))
         .WillOnce(ReturnNewSyncEngineNoReturn());
   }
 
@@ skipping 379 matching lines @@
 
 // Verify that OnLocalSetPassphraseEncryption triggers catch up configure sync
 // cycle, calls ClearServerData, shuts down and restarts sync.
 TEST_F(ProfileSyncServiceTest, OnLocalSetPassphraseEncryption) {
   base::test::ScopedFeatureList scoped_feature_list;
   scoped_feature_list.InitAndEnableFeature(
       switches::kSyncClearDataOnPassphraseEncryption);
   IssueTestTokens();
   CreateService(ProfileSyncService::AUTO_START);
 
-  syncer::SyncManager::ClearServerDataCallback captured_callback;
+  base::Closure captured_callback;
   syncer::ConfigureReason configure_reason = syncer::CONFIGURE_REASON_UNKNOWN;
 
   // Initialize sync, ensure that both DataTypeManager and SyncEngine are
   // initialized and DTM::Configure is called with
   // CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE.
   ExpectSyncEngineCreationCaptureClearServerData(&captured_callback);
   ExpectDataTypeManagerCreation(
       1, GetRecordingConfigureCalledCallback(&configure_reason));
   InitializeForNthSync();
   EXPECT_TRUE(service()->IsSyncActive());
@@ skipping 52 matching lines @@
 
   // Simulate user entering encryption passphrase. Ensure Configure was called
   // but don't let it continue.
   const syncer::SyncEncryptionHandler::NigoriState nigori_state;
   service()->GetEncryptionObserverForTest()->OnLocalSetPassphraseEncryption(
       nigori_state);
   EXPECT_EQ(syncer::CONFIGURE_REASON_CATCH_UP, configure_reason);
 
   // Simulate browser restart. First configuration is a regular one.
   service()->Shutdown();
-  syncer::SyncManager::ClearServerDataCallback captured_callback;
+  base::Closure captured_callback;
   ExpectSyncEngineCreationCaptureClearServerData(&captured_callback);
   ExpectDataTypeManagerCreation(
       1, GetRecordingConfigureCalledCallback(&configure_reason));
   service()->RequestStart();
   testing::Mock::VerifyAndClearExpectations(component_factory());
   EXPECT_EQ(syncer::CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE, configure_reason);
   EXPECT_TRUE(captured_callback.is_null());
 
   // Simulate configure successful. This time it should be catch up.
   service()->OnConfigureDone(result);
@@ skipping 12 matching lines @@
       1, GetRecordingConfigureCalledCallback(&configure_reason));
   captured_callback.Run();
   testing::Mock::VerifyAndClearExpectations(component_factory());
   EXPECT_EQ(syncer::CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE, configure_reason);
 }
 
 // Verify that if after OnLocalSetPassphraseEncryption ClearServerData gets
 // interrupted, transition again from catch up sync cycle after browser restart.
 TEST_F(ProfileSyncServiceTest,
        OnLocalSetPassphraseEncryption_RestartDuringClearServerData) {
-  syncer::SyncManager::ClearServerDataCallback captured_callback;
+  base::Closure captured_callback;
   syncer::ConfigureReason configure_reason = syncer::CONFIGURE_REASON_UNKNOWN;
   base::test::ScopedFeatureList scoped_feature_list;
   scoped_feature_list.InitAndEnableFeature(
       switches::kSyncClearDataOnPassphraseEncryption);
   IssueTestTokens();
   CreateService(ProfileSyncService::AUTO_START);
   ExpectSyncEngineCreationCaptureClearServerData(&captured_callback);
   ExpectDataTypeManagerCreation(1, GetDefaultConfigureCalledCallback());
   InitializeForNthSync();
   testing::Mock::VerifyAndClearExpectations(component_factory());
@@ skipping 136 matching lines @@
   // Progress the controller to RUNNING first, which is how the service
   // determines whether a type is enabled.
   controller->StartAssociating(base::Bind(&DoNothing));
   controller->FinishStart(DataTypeController::OK_FIRST_RUN);
   service()->RegisterDataTypeController(std::move(controller));
   EXPECT_NE(nullptr, service()->GetOpenTabsUIDelegate());
 }
 
 }  // namespace
 }  // namespace browser_sync