[Sync] Add ClearServerData support to Sync Scheduler

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 "base/bind.h"
@@ skipping 61 matching lines @@
       NOTREACHED();
       return false;
   }
 }
 
 bool IsActionableError(
     const SyncProtocolError& error) {
   return (error.action != UNKNOWN_ACTION);
 }
 
+void RunAndReset(base::Closure* task) {
+  DCHECK(task);
+  if (task->is_null())
+    return;
+  task->Run();
+  task->Reset();
+}
+
 }  // namespace
 
 ConfigurationParams::ConfigurationParams()
     : source(GetUpdatesCallerInfo::UNKNOWN) {}
 ConfigurationParams::ConfigurationParams(
     const sync_pb::GetUpdatesCallerInfo::GetUpdatesSource& source,
     ModelTypeSet types_to_download,
     const ModelSafeRoutingInfo& routing_info,
     const base::Closure& ready_task,
     const base::Closure& retry_task)
     : source(source),
       types_to_download(types_to_download),
       routing_info(routing_info),
       ready_task(ready_task),
       retry_task(retry_task) {
   DCHECK(!ready_task.is_null());
 }
 ConfigurationParams::~ConfigurationParams() {}
 
+ClearParams::ClearParams(const base::Closure& report_success_task)
+    : report_success_task(report_success_task) {
+  DCHECK(!report_success_task.is_null());
+}
+ClearParams::~ClearParams() {}
+
 SyncSchedulerImpl::WaitInterval::WaitInterval()
     : mode(UNKNOWN) {}
 
 SyncSchedulerImpl::WaitInterval::WaitInterval(Mode mode, TimeDelta length)
     : mode(mode), length(length) {}
 
 SyncSchedulerImpl::WaitInterval::~WaitInterval() {}
 
 #define ENUM_CASE(x) case x: return #x; break;
 
@@ skipping 100 matching lines @@
     thread_name = "<Main thread>";
   SDVLOG(2) << "Start called from thread "
             << thread_name << " with mode " << GetModeString(mode);
   if (!started_) {
     started_ = true;
     SendInitialSnapshot();
   }
 
   DCHECK(!session_context_->account_name().empty());
   DCHECK(syncer_.get());
+
+  if (mode == CLEAR_SERVER_DATA_MODE) {
+    DCHECK_EQ(mode_, CONFIGURATION_MODE);
+  }
   Mode old_mode = mode_;
   mode_ = mode;
   // Only adjust the poll reset time if it was valid and in the past.
   if (!last_poll_time.is_null() && last_poll_time < base::Time::Now()) {
     // Convert from base::Time to base::TimeTicks. The reason we use Time
     // for persisting is that TimeTicks can stop making forward progress when
     // the machine is suspended. This implies that on resume the client might
     // actually have miss the real poll, unless the client is restarted. Fixing
     // that would require using an AlarmTimer though, which is only supported
     // on certain platforms.
@@ skipping 75 matching lines @@
   // Only reconfigure if we have types to download.
   if (!params.types_to_download.Empty()) {
     pending_configure_params_.reset(new ConfigurationParams(params));
     TrySyncSessionJob();
   } else {
     SDVLOG(2) << "No change in routing info, calling ready task directly.";
     params.ready_task.Run();
   }
 }
 
+void SyncSchedulerImpl::ScheduleClearServerData(const ClearParams& params) {
+  DCHECK(CalledOnValidThread());
+  DCHECK_EQ(CLEAR_SERVER_DATA_MODE, mode_);
+  DCHECK(!pending_configure_params_);
+  DCHECK(!params.report_success_task.is_null());
+  CHECK(started_) << "Scheduler must be running to clear.";
+  pending_clear_params_.reset(new ClearParams(params));
+  TrySyncSessionJob();
+}
+
 bool SyncSchedulerImpl::CanRunJobNow(JobPriority priority) {
   DCHECK(CalledOnValidThread());
   if (IsCurrentlyThrottled()) {
     SDVLOG(1) << "Unable to run a job because we're throttled.";
     return false;
   }
 
   if (IsBackingOff() && priority != CANARY_PRIORITY) {
     SDVLOG(1) << "Unable to run a job because we're backing off.";
     return false;
@@ skipping 14 matching lines @@
     SDVLOG(1) << "Unable to run a nudge job right now";
     return false;
   }
 
   const ModelTypeSet enabled_types = session_context_->GetEnabledTypes();
   if (nudge_tracker_.GetThrottledTypes().HasAll(enabled_types)) {
     SDVLOG(1) << "Not running a nudge because we're fully type throttled.";
     return false;
   }
 
-  if (mode_ == CONFIGURATION_MODE) {
-    SDVLOG(1) << "Not running nudge because we're in configuration mode.";
+  if (mode_ != NORMAL_MODE) {
+    SDVLOG(1) << "Not running nudge because we're not in normal mode.";
     return false;
   }
 
   return true;
 }
 
 void SyncSchedulerImpl::ScheduleLocalNudge(
     ModelTypeSet types,
     const tracked_objects::Location& nudge_location) {
   DCHECK(CalledOnValidThread());
@@ skipping 81 matching lines @@
   pending_wakeup_timer_.Start(
       nudge_location,
       delay,
       base::Bind(&SyncSchedulerImpl::PerformDelayedNudge,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 const char* SyncSchedulerImpl::GetModeString(SyncScheduler::Mode mode) {
   switch (mode) {
     ENUM_CASE(CONFIGURATION_MODE);
+    ENUM_CASE(CLEAR_SERVER_DATA_MODE);
     ENUM_CASE(NORMAL_MODE);
   }
   return "";
 }
 
 void SyncSchedulerImpl::SetDefaultNudgeDelay(base::TimeDelta delay_ms) {
   DCHECK(CalledOnValidThread());
   nudge_tracker_.SetDefaultNudgeDelay(delay_ms);
 }
 
@@ skipping 26 matching lines @@
   }
 }
 
 void SyncSchedulerImpl::DoConfigurationSyncSessionJob(JobPriority priority) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(mode_, CONFIGURATION_MODE);
   DCHECK(pending_configure_params_ != NULL);
 
   if (!CanRunJobNow(priority)) {
     SDVLOG(2) << "Unable to run configure job right now.";
-    if (!pending_configure_params_->retry_task.is_null()) {
-      pending_configure_params_->retry_task.Run();
-      pending_configure_params_->retry_task.Reset();
-    }
+    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));
   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_ && !pending_configure_params_->retry_task.is_null()) {
-      pending_configure_params_->retry_task.Run();
-      pending_configure_params_->retry_task.Reset();
-    }
+    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));
+  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();
+}
+
 void SyncSchedulerImpl::HandleSuccess() {
   // If we're here, then we successfully reached the server.  End all backoff.
   wait_interval_.reset();
   NotifyRetryTime(base::Time());
 }
 
 void SyncSchedulerImpl::HandleFailure(
     const sessions::ModelNeutralState& model_neutral_state) {
   if (IsCurrentlyThrottled()) {
     SDVLOG(2) << "Was throttled during previous sync cycle.";
@@ skipping 126 matching lines @@
   DCHECK(CalledOnValidThread());
   SDVLOG(2) << "Stop called";
 
   // Kill any in-flight method calls.
   weak_ptr_factory_.InvalidateWeakPtrs();
   wait_interval_.reset();
   NotifyRetryTime(base::Time());
   poll_timer_.Stop();
   pending_wakeup_timer_.Stop();
   pending_configure_params_.reset();
+  pending_clear_params_.reset();
   if (started_)
     started_ = false;
 }
 
 // This is the only place where we invoke DoSyncSessionJob with canary
 // privileges.  Everyone else should use NORMAL_PRIORITY.
 void SyncSchedulerImpl::TryCanaryJob() {
   next_sync_session_job_priority_ = CANARY_PRIORITY;
   SDVLOG(2) << "Attempting canary job";
   TrySyncSessionJob();
@@ skipping 12 matching lines @@
   next_sync_session_job_priority_ = NORMAL_PRIORITY;
 
   nudge_tracker_.SetSyncCycleStartTime(base::TimeTicks::Now());
 
   DCHECK(CalledOnValidThread());
   if (mode_ == CONFIGURATION_MODE) {
     if (pending_configure_params_) {
       SDVLOG(2) << "Found pending configure job";
       DoConfigurationSyncSessionJob(priority);
     }
+  } else if (mode_ == CLEAR_SERVER_DATA_MODE) {
+    if (pending_clear_params_) {
+      DoClearServerDataSyncSessionJob(priority);
+    }
   } else if (CanRunNudgeJobNow(priority)) {
     if (nudge_tracker_.IsSyncRequired()) {
       SDVLOG(2) << "Found pending nudge job";
       DoNudgeSyncSessionJob(priority);
     } else if (((base::TimeTicks::Now() - last_poll_reset_) >=
                 GetPollInterval())) {
       SDVLOG(2) << "Found pending poll";
       DoPollSyncSessionJob();
     }
   } else {
@@ skipping 208 matching lines @@
 
 #undef SDVLOG_LOC
 
 #undef SDVLOG
 
 #undef SLOG
 
 #undef ENUM_CASE
 
 }  // namespace syncer