[Sync] Make BackendMigrator not wait for full sync cycles

chrome/browser/sync/engine/sync_scheduler_unittest.cc

 // Copyright (c) 2011 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/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
-#include "base/memory/scoped_callback_factory.h"
+#include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/task.h"
 #include "base/test/test_timeouts.h"
 #include "chrome/browser/sync/engine/mock_model_safe_workers.h"
 #include "chrome/browser/sync/engine/configure_reason.h"
 #include "chrome/browser/sync/engine/sync_scheduler.h"
 #include "chrome/browser/sync/engine/syncer.h"
 #include "chrome/browser/sync/sessions/test_util.h"
 #include "chrome/test/sync/engine/mock_connection_manager.h"
 #include "chrome/test/sync/engine/test_directory_setter_upper.h"
@@ skipping 48 matching lines @@
   // QuitLoopNow).
   MessageLoop::current()->PostTask(FROM_HERE, base::Bind(&QuitLoopNow));
   RunLoop();
 }
 
 // Convenient to use in tests wishing to analyze SyncShare calls over time.
 static const size_t kMinNumSamples = 5;
 class SyncSchedulerTest : public testing::Test {
  public:
   SyncSchedulerTest()
-      : callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+      : weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
         context_(NULL),
         syncer_(NULL),
         delay_(NULL) {}
 
   class MockDelayProvider : public SyncScheduler::DelayProvider {
    public:
     MOCK_METHOD1(GetDelay, TimeDelta(const TimeDelta&));
   };
 
   virtual void SetUp() {
@@ skipping 46 matching lines @@
     }
   }
 
   void DoQuitLoopNow() {
     QuitLoopNow();
   }
 
   void StartSyncScheduler(SyncScheduler::Mode mode) {
     scheduler()->Start(
         mode,
-        callback_factory_.NewCallback(&SyncSchedulerTest::DoQuitLoopNow));
+        base::Bind(&SyncSchedulerTest::DoQuitLoopNow,
+                   weak_ptr_factory_.GetWeakPtr()));
   }
 
   bool GetBackoffAndResetTest() {
     syncable::ModelTypeBitSet nudge_types;
     StartSyncScheduler(SyncScheduler::NORMAL_MODE);
     RunLoop();
 
     scheduler()->ScheduleNudge(
         zero(), NUDGE_SOURCE_LOCAL, nudge_types, FROM_HERE);
     RunLoop();
@@ skipping 29 matching lines @@
         return false;
     }
     if (lhs.count() != count)
       return false;
     return true;
   }
 
   SyncSessionContext* context() { return context_; }
 
  private:
-  base::ScopedCallbackFactory<SyncSchedulerTest> callback_factory_;
+  base::WeakPtrFactory<SyncSchedulerTest> weak_ptr_factory_;
   MessageLoop message_loop_;
   scoped_ptr<SyncScheduler> scheduler_;
   scoped_ptr<MockConnectionManager> connection_;
   SyncSessionContext* context_;
   MockSyncer* syncer_;
   MockDelayProvider* delay_;
   scoped_ptr<MockModelSafeWorkerRegistrar> registrar_;
   MockDirectorySetterUpper syncdb_;
 };
 
@@ skipping 747 matching lines @@
   EXPECT_LE(TimeDelta::FromSeconds(10),
             SyncScheduler::GetRecommendedDelay(TimeDelta::FromSeconds(10)));
   EXPECT_EQ(TimeDelta::FromSeconds(kMaxBackoffSeconds),
             SyncScheduler::GetRecommendedDelay(
                 TimeDelta::FromSeconds(kMaxBackoffSeconds)));
   EXPECT_EQ(TimeDelta::FromSeconds(kMaxBackoffSeconds),
             SyncScheduler::GetRecommendedDelay(
                 TimeDelta::FromSeconds(kMaxBackoffSeconds + 1)));
 }
 
+namespace {
+
+class MockCallback : public base::SupportsWeakPtr<MockCallback> {
+ public:
+  MOCK_METHOD0(Run, void());
+};
+
+}  // namespace
+
 // Test that appropriate syncer steps are requested for each job type.
 TEST_F(SyncSchedulerTest, SyncerSteps) {
   // Nudges.
   EXPECT_CALL(*syncer(), SyncShare(_, SYNCER_BEGIN, SYNCER_END))
       .Times(1);
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
   RunLoop();
 
   scheduler()->ScheduleNudge(
       zero(), NUDGE_SOURCE_LOCAL, ModelTypeBitSet(), FROM_HERE);
@@ skipping 29 matching lines @@
 
   scheduler()->Stop();
   Mock::VerifyAndClearExpectations(syncer());
 
   // Cleanup disabled types.
   EXPECT_CALL(*syncer(),
               SyncShare(_, CLEANUP_DISABLED_TYPES, CLEANUP_DISABLED_TYPES));
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
   RunLoop();
 
-  scheduler()->ScheduleCleanupDisabledTypes();
+  MockCallback mock_callback;
+  EXPECT_CALL(mock_callback, Run());
+  scheduler()->ScheduleCleanupDisabledTypes(
+      base::Bind(&MockCallback::Run, mock_callback.AsWeakPtr()));
   PumpLoop();
   PumpLoop();
 
   scheduler()->Stop();
   Mock::VerifyAndClearExpectations(syncer());
 
   // Poll.
   EXPECT_CALL(*syncer(), SyncShare(_, SYNCER_BEGIN, SYNCER_END))
       .Times(AtLeast(1))
       .WillRepeatedly(QuitLoopNowAction());
@@ skipping 48 matching lines @@
   PumpLoop();
   // Pump again to run job.
   PumpLoop();
 
   scheduler()->Stop();
 
   EXPECT_TRUE(expected == context()->previous_session_routing_info());
 }
 
 }  // namespace browser_sync