Move some files from sync/engine to internal_api

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/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"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
@@ skipping 258 matching lines @@
   model_types[syncable::BOOKMARKS] = true;
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records))));
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
   RunLoop();
 
   scheduler()->ScheduleConfig(
-      model_types, sync_api::CONFIGURE_REASON_RECONFIGURATION);
+      model_types, GetUpdatesCallerInfo::RECONFIGURATION);
   RunLoop();
 
   ASSERT_EQ(1U, records.snapshots.size());
   EXPECT_TRUE(CompareModelTypeBitSetToModelTypePayloadMap(model_types,
       records.snapshots[0]->source.types));
   EXPECT_EQ(GetUpdatesCallerInfo::RECONFIGURATION,
             records.snapshots[0]->source.updates_source);
 }
 
 // Simulate a failure and make sure the config request is retried.
 TEST_F(SyncSchedulerTest, ConfigWithBackingOff) {
   UseMockDelayProvider();
   EXPECT_CALL(*delay(), GetDelay(_))
       .WillRepeatedly(Return(TimeDelta::FromMilliseconds(1)));
   SyncShareRecords records;
   syncable::ModelTypeBitSet model_types;
   model_types[syncable::BOOKMARKS] = true;
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
                       WithArg<0>(RecordSyncShare(&records))))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records))));
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
   RunLoop();
 
   ASSERT_EQ(0U, records.snapshots.size());
   scheduler()->ScheduleConfig(
-      model_types, sync_api::CONFIGURE_REASON_RECONFIGURATION);
+      model_types, GetUpdatesCallerInfo::RECONFIGURATION);
   RunLoop();
 
   ASSERT_EQ(1U, records.snapshots.size());
   RunLoop();
 
   ASSERT_EQ(2U, records.snapshots.size());
   EXPECT_TRUE(CompareModelTypeBitSetToModelTypePayloadMap(model_types,
       records.snapshots[1]->source.types));
   EXPECT_EQ(GetUpdatesCallerInfo::SYNC_CYCLE_CONTINUATION,
             records.snapshots[1]->source.updates_source);
@@ skipping 16 matching lines @@
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
                       WithArg<0>(RecordSyncShare(&records))))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records))));
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
   RunLoop();
 
   ASSERT_EQ(0U, records.snapshots.size());
   scheduler()->ScheduleConfig(
-      model_types1, sync_api::CONFIGURE_REASON_RECONFIGURATION);
+      model_types1, GetUpdatesCallerInfo::RECONFIGURATION);
   RunLoop();
 
   ASSERT_EQ(1U, records.snapshots.size());
   scheduler()->ScheduleConfig(
-      model_types2, sync_api::CONFIGURE_REASON_RECONFIGURATION);
+      model_types2, GetUpdatesCallerInfo::RECONFIGURATION);
   RunLoop();
 
   ASSERT_EQ(2U, records.snapshots.size());
   RunLoop();
 
   ASSERT_EQ(3U, records.snapshots.size());
   EXPECT_TRUE(CompareModelTypeBitSetToModelTypePayloadMap(model_types2,
       records.snapshots[2]->source.types));
   EXPECT_EQ(GetUpdatesCallerInfo::RECONFIGURATION,
             records.snapshots[2]->source.updates_source);
@@ skipping 17 matching lines @@
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records))))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records))));
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
   RunLoop();
 
   ASSERT_EQ(0U, records.snapshots.size());
   scheduler()->ScheduleConfig(
-      model_types, sync_api::CONFIGURE_REASON_RECONFIGURATION);
+      model_types, GetUpdatesCallerInfo::RECONFIGURATION);
   RunLoop();
 
   ASSERT_EQ(1U, records.snapshots.size());
   scheduler()->ScheduleNudge(
       zero(), NUDGE_SOURCE_LOCAL, model_types, FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(2U, records.snapshots.size());
   RunLoop();
 
@@ skipping 278 matching lines @@
   RunLoop();
 
   scheduler()->ScheduleNudge(
       zero(), NUDGE_SOURCE_LOCAL, types, FROM_HERE);
   PumpLoop();
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
   RunLoop();
 
   scheduler()->ScheduleConfig(
-      types, sync_api::CONFIGURE_REASON_RECONFIGURATION);
+      types, GetUpdatesCallerInfo::RECONFIGURATION);
   PumpLoop();
 }
 
 TEST_F(SyncSchedulerTest, ThrottlingExpires) {
   SyncShareRecords records;
   TimeDelta poll(TimeDelta::FromMilliseconds(15));
   TimeDelta throttle1(TimeDelta::FromMilliseconds(150));
   TimeDelta throttle2(TimeDelta::FromMinutes(10));
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
 
@@ skipping 32 matching lines @@
   nudge_types[syncable::AUTOFILL] = true;
   scheduler()->ScheduleNudge(
       zero(), NUDGE_SOURCE_LOCAL, nudge_types, FROM_HERE);
   scheduler()->ScheduleNudge(
       zero(), NUDGE_SOURCE_LOCAL, nudge_types, FROM_HERE);
 
   syncable::ModelTypeBitSet config_types;
   config_types[syncable::BOOKMARKS] = true;
 
   scheduler()->ScheduleConfig(
-      config_types, sync_api::CONFIGURE_REASON_RECONFIGURATION);
+      config_types, GetUpdatesCallerInfo::RECONFIGURATION);
   RunLoop();
 
   ASSERT_EQ(1U, records.snapshots.size());
   EXPECT_TRUE(CompareModelTypeBitSetToModelTypePayloadMap(config_types,
       records.snapshots[0]->source.types));
 }
 
 // Test that exponential backoff is properly triggered.
 TEST_F(SyncSchedulerTest, BackoffTriggers) {
   UseMockDelayProvider();
@@ skipping 81 matching lines @@
   EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
             r.snapshots[2]->source.updates_source);
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_)).Times(0);
   EXPECT_CALL(*delay(), GetDelay(_)).Times(0);
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
   RunLoop();
 
   scheduler()->ScheduleConfig(
-      types, sync_api::CONFIGURE_REASON_RECONFIGURATION);
+      types, GetUpdatesCallerInfo::RECONFIGURATION);
   PumpLoop();
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
   RunLoop();
 
   scheduler()->ScheduleNudge(
       zero(), NUDGE_SOURCE_LOCAL, types, FROM_HERE);
   scheduler()->ScheduleNudge(
       zero(), NUDGE_SOURCE_LOCAL, types, FROM_HERE);
   PumpLoop();
@@ skipping 121 matching lines @@
 
   scheduler()->Stop();
   Mock::VerifyAndClearExpectations(syncer());
 
   // Configuration.
   EXPECT_CALL(*syncer(), SyncShare(_, DOWNLOAD_UPDATES, APPLY_UPDATES));
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
   RunLoop();
 
   scheduler()->ScheduleConfig(
-      ModelTypeBitSet(), sync_api::CONFIGURE_REASON_RECONFIGURATION);
+      ModelTypeBitSet(), GetUpdatesCallerInfo::RECONFIGURATION);
   PumpLoop();
   PumpLoop();
 
   scheduler()->Stop();
   Mock::VerifyAndClearExpectations(syncer());
 
   // Cleanup disabled types.
   EXPECT_CALL(*syncer(),
               SyncShare(_, CLEANUP_DISABLED_TYPES, CLEANUP_DISABLED_TYPES));
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
@@ skipping 61 matching lines @@
   PumpLoop();
   // Pump again to run job.
   PumpLoop();
 
   scheduler()->Stop();
 
   EXPECT_TRUE(expected == context()->previous_session_routing_info());
 }
 
 }  // namespace browser_sync