[Sync] Minor refactor around SyncCycle and ModelTypeSet usage.

components/sync/engine_impl/sync_scheduler_impl.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/sync/engine_impl/sync_scheduler_impl.h"
 
 #include <algorithm>
 #include <cstring>
 #include <utility>
 
@@ skipping 221 matching lines @@
 ModelTypeSet SyncSchedulerImpl::GetEnabledAndUnblockedTypes() {
   ModelTypeSet enabled_types = cycle_context_->GetEnabledTypes();
   ModelTypeSet enabled_protocol_types =
       Intersection(ProtocolTypes(), enabled_types);
   ModelTypeSet blocked_types = nudge_tracker_.GetBlockedTypes();
   return Difference(enabled_protocol_types, blocked_types);
 }
 
 void SyncSchedulerImpl::SendInitialSnapshot() {
   DCHECK(CalledOnValidThread());
-  std::unique_ptr<SyncCycle> dummy(SyncCycle::Build(cycle_context_, this));
   SyncCycleEvent event(SyncCycleEvent::STATUS_CHANGED);
-  event.snapshot = dummy->TakeSnapshot();
+  event.snapshot = SyncCycle(cycle_context_, this).TakeSnapshot();
   for (auto& observer : *cycle_context_->listeners())
     observer.OnSyncCycleEvent(event);
 }
 
 void SyncSchedulerImpl::ScheduleConfiguration(
     const ConfigurationParams& params) {
   DCHECK(CalledOnValidThread());
   DCHECK(IsConfigRelatedUpdateSourceValue(params.source));
   DCHECK_EQ(CONFIGURATION_MODE, mode_);
   DCHECK(!params.ready_task.is_null());
@@ skipping 167 matching lines @@
   DCHECK(CalledOnValidThread());
   nudge_tracker_.SetDefaultNudgeDelay(delay_ms);
 }
 
 void SyncSchedulerImpl::DoNudgeSyncCycleJob(JobPriority priority) {
   DCHECK(CalledOnValidThread());
   DCHECK(CanRunNudgeJobNow(priority));
 
   DVLOG(2) << "Will run normal mode sync cycle with types "
            << ModelTypeSetToString(GetEnabledAndUnblockedTypes());
-  std::unique_ptr<SyncCycle> cycle(SyncCycle::Build(cycle_context_, this));
+  SyncCycle cycle(cycle_context_, this);
   bool success = syncer_->NormalSyncShare(GetEnabledAndUnblockedTypes(),
-                                          &nudge_tracker_, cycle.get());
+                                          &nudge_tracker_, &cycle);
 
   if (success) {
     // That cycle took care of any outstanding work we had.
     SDVLOG(2) << "Nudge succeeded.";
     nudge_tracker_.RecordSuccessfulSyncCycle();
     HandleSuccess();
 
     // If this was a canary, we may need to restart the poll timer (the poll
     // timer may have fired while the scheduler was in an error state, ignoring
     // the poll).
     if (!poll_timer_.IsRunning()) {
       SDVLOG(1) << "Canary succeeded, restarting polling.";
       AdjustPolling(UPDATE_INTERVAL);
     }
   } else {
-    HandleFailure(cycle->status_controller().model_neutral_state());
+    HandleFailure(cycle.status_controller().model_neutral_state());
   }
 }
 
 void SyncSchedulerImpl::DoConfigurationSyncCycleJob(JobPriority priority) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(mode_, CONFIGURATION_MODE);
   DCHECK(pending_configure_params_ != nullptr);
 
   if (!CanRunJobNow(priority)) {
     SDVLOG(2) << "Unable to run configure job right now.";
     RunAndReset(&pending_configure_params_->retry_task);
     return;
   }
 
   SDVLOG(2) << "Will run configure SyncShare with types "
             << ModelTypeSetToString(
                    pending_configure_params_->types_to_download);
-  std::unique_ptr<SyncCycle> cycle(SyncCycle::Build(cycle_context_, this));
-  bool success = syncer_->ConfigureSyncShare(
-      pending_configure_params_->types_to_download,
-      pending_configure_params_->source, cycle.get());
+  SyncCycle cycle(cycle_context_, this);
+  bool success =
+      syncer_->ConfigureSyncShare(pending_configure_params_->types_to_download,
+                                  pending_configure_params_->source, &cycle);
 
   if (success) {
     SDVLOG(2) << "Configure succeeded.";
     pending_configure_params_->ready_task.Run();
     pending_configure_params_.reset();
     HandleSuccess();
   } else {
-    HandleFailure(cycle->status_controller().model_neutral_state());
+    HandleFailure(cycle.status_controller().model_neutral_state());
     // Sync cycle might receive response from server that causes scheduler to
     // stop and draws pending_configure_params_ invalid.
     if (started_)
       RunAndReset(&pending_configure_params_->retry_task);
   }
 }
 
 void SyncSchedulerImpl::DoClearServerDataSyncCycleJob(JobPriority priority) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(mode_, CLEAR_SERVER_DATA_MODE);
 
   if (!CanRunJobNow(priority)) {
     SDVLOG(2) << "Unable to run clear server data job right now.";
     return;
   }
 
-  std::unique_ptr<SyncCycle> cycle(SyncCycle::Build(cycle_context_, this));
-  const bool success = syncer_->PostClearServerData(cycle.get());
+  SyncCycle cycle(cycle_context_, this);
+  const bool success = syncer_->PostClearServerData(&cycle);
   if (!success) {
-    HandleFailure(cycle->status_controller().model_neutral_state());
+    HandleFailure(cycle.status_controller().model_neutral_state());
     return;
   }
 
   SDVLOG(2) << "Clear succeeded.";
   pending_clear_params_->report_success_task.Run();
   pending_clear_params_.reset();
   HandleSuccess();
 }
 
 void SyncSchedulerImpl::HandleSuccess() {
@@ skipping 21 matching lines @@
         WaitInterval::EXPONENTIAL_BACKOFF, length);
     SDVLOG(2) << "Sync cycle failed.  Will back off for "
               << wait_interval_->length.InMilliseconds() << "ms.";
   }
   RestartWaiting();
 }
 
 void SyncSchedulerImpl::DoPollSyncCycleJob() {
   SDVLOG(2) << "Polling with types "
             << ModelTypeSetToString(GetEnabledAndUnblockedTypes());
-  std::unique_ptr<SyncCycle> cycle(SyncCycle::Build(cycle_context_, this));
-  bool success =
-      syncer_->PollSyncShare(GetEnabledAndUnblockedTypes(), cycle.get());
+  SyncCycle cycle(cycle_context_, this);
+  bool success = syncer_->PollSyncShare(GetEnabledAndUnblockedTypes(), &cycle);
 
   // Only restart the timer if the poll succeeded. Otherwise rely on normal
   // failure handling to retry with backoff.
   if (success) {
     AdjustPolling(FORCE_RESET);
     HandleSuccess();
   } else {
-    HandleFailure(cycle->status_controller().model_neutral_state());
+    HandleFailure(cycle.status_controller().model_neutral_state());
   }
 }
 
 void SyncSchedulerImpl::UpdateNudgeTimeRecords(ModelTypeSet types) {
   DCHECK(CalledOnValidThread());
   TimeTicks now = TimeTicks::Now();
   // Update timing information for how often datatypes are triggering nudges.
   for (ModelTypeSet::Iterator iter = types.First(); iter.Good(); iter.Inc()) {
     TimeTicks previous = last_local_nudges_by_model_type_[iter.Get()];
     last_local_nudges_by_model_type_[iter.Get()] = now;
@@ skipping 367 matching lines @@
 
 #undef SDVLOG_LOC
 
 #undef SDVLOG
 
 #undef SLOG
 
 #undef ENUM_CASE
 
 }  // namespace syncer