Convert //sync from scoped_ptr to std::unique_ptr

sync/engine/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 "sync/engine/sync_scheduler_impl.h"
 
 #include <algorithm>
 #include <cstring>
 #include <utility>
 
@@ skipping 261 matching lines @@
 ModelTypeSet SyncSchedulerImpl::GetEnabledAndUnthrottledTypes() {
   ModelTypeSet enabled_types = session_context_->GetEnabledTypes();
   ModelTypeSet enabled_protocol_types =
       Intersection(ProtocolTypes(), enabled_types);
   ModelTypeSet throttled_types = nudge_tracker_.GetThrottledTypes();
   return Difference(enabled_protocol_types, throttled_types);
 }
 
 void SyncSchedulerImpl::SendInitialSnapshot() {
   DCHECK(CalledOnValidThread());
-  scoped_ptr<SyncSession> dummy(SyncSession::Build(session_context_, this));
+  std::unique_ptr<SyncSession> dummy(
+      SyncSession::Build(session_context_, this));
   SyncCycleEvent event(SyncCycleEvent::STATUS_CHANGED);
   event.snapshot = dummy->TakeSnapshot();
   FOR_EACH_OBSERVER(SyncEngineEventListener,
                     *session_context_->listeners(),
                     OnSyncCycleEvent(event));
 }
 
 namespace {
 
 // Helper to extract the routing info corresponding to types in
@@ skipping 117 matching lines @@
 
   SDVLOG_LOC(nudge_location, 2)
       << "Scheduling sync because of local refresh request for "
       << ModelTypeSetToString(types);
   base::TimeDelta nudge_delay = nudge_tracker_.RecordLocalRefreshRequest(types);
   ScheduleNudgeImpl(nudge_delay, nudge_location);
 }
 
 void SyncSchedulerImpl::ScheduleInvalidationNudge(
     syncer::ModelType model_type,
-    scoped_ptr<InvalidationInterface> invalidation,
+    std::unique_ptr<InvalidationInterface> invalidation,
     const tracked_objects::Location& nudge_location) {
   DCHECK(CalledOnValidThread());
 
   SDVLOG_LOC(nudge_location, 2)
       << "Scheduling sync because we received invalidation for "
       << ModelTypeToString(model_type);
   base::TimeDelta nudge_delay = nudge_tracker_.RecordRemoteInvalidation(
       model_type, std::move(invalidation));
   ScheduleNudgeImpl(nudge_delay, nudge_location);
 }
@@ skipping 62 matching lines @@
   DCHECK(CalledOnValidThread());
   nudge_tracker_.SetDefaultNudgeDelay(delay_ms);
 }
 
 void SyncSchedulerImpl::DoNudgeSyncSessionJob(JobPriority priority) {
   DCHECK(CalledOnValidThread());
   DCHECK(CanRunNudgeJobNow(priority));
 
   DVLOG(2) << "Will run normal mode sync cycle with types "
            << ModelTypeSetToString(session_context_->GetEnabledTypes());
-  scoped_ptr<SyncSession> session(SyncSession::Build(session_context_, this));
+  std::unique_ptr<SyncSession> session(
+      SyncSession::Build(session_context_, this));
   bool success = syncer_->NormalSyncShare(
       GetEnabledAndUnthrottledTypes(), &nudge_tracker_, session.get());
 
   if (success) {
     // That cycle took care of any outstanding work we had.
     SDVLOG(2) << "Nudge succeeded.";
     nudge_tracker_.RecordSuccessfulSyncCycle();
     scheduled_nudge_time_ = base::TimeTicks();
     HandleSuccess();
 
@@ skipping 15 matching lines @@
   DCHECK(pending_configure_params_ != NULL);
 
   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(session_context_->GetEnabledTypes());
-  scoped_ptr<SyncSession> session(SyncSession::Build(session_context_, this));
+  std::unique_ptr<SyncSession> session(
+      SyncSession::Build(session_context_, this));
   bool success = syncer_->ConfigureSyncShare(
       pending_configure_params_->types_to_download,
       pending_configure_params_->source,
       session.get());
 
   if (success) {
     SDVLOG(2) << "Configure succeeded.";
     pending_configure_params_->ready_task.Run();
     pending_configure_params_.reset();
     HandleSuccess();
   } else {
     HandleFailure(session->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::DoClearServerDataSyncSessionJob(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.";
     RunAndReset(&pending_configure_params_->retry_task);
     return;
   }
 
-  scoped_ptr<SyncSession> session(SyncSession::Build(session_context_, this));
+  std::unique_ptr<SyncSession> session(
+      SyncSession::Build(session_context_, this));
   const bool success = syncer_->PostClearServerData(session.get());
   if (!success) {
     HandleFailure(session->status_controller().model_neutral_state());
     return;
   }
 
   SDVLOG(2) << "Clear succeeded.";
   pending_clear_params_->report_success_task.Run();
   pending_clear_params_.reset();
   HandleSuccess();
@@ skipping 24 matching lines @@
         new WaitInterval(WaitInterval::EXPONENTIAL_BACKOFF, length));
     SDVLOG(2) << "Sync cycle failed.  Will back off for "
         << wait_interval_->length.InMilliseconds() << "ms.";
   }
   RestartWaiting();
 }
 
 void SyncSchedulerImpl::DoPollSyncSessionJob() {
   SDVLOG(2) << "Polling with types "
             << ModelTypeSetToString(GetEnabledAndUnthrottledTypes());
-  scoped_ptr<SyncSession> session(SyncSession::Build(session_context_, this));
+  std::unique_ptr<SyncSession> session(
+      SyncSession::Build(session_context_, this));
   bool success = syncer_->PollSyncShare(
       GetEnabledAndUnthrottledTypes(),
       session.get());
 
   // 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 {
@@ skipping 358 matching lines @@
 
 #undef SDVLOG_LOC
 
 #undef SDVLOG
 
 #undef SLOG
 
 #undef ENUM_CASE
 
 }  // namespace syncer