[Sync] Remove unnecessary posting of methods in sync scheduler.

sync/engine/sync_scheduler.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.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/bind.h"
@@ skipping 237 matching lines @@
 
 void SyncScheduler::Start(Mode mode, const base::Closure& callback) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   std::string thread_name = MessageLoop::current()->thread_name();
   if (thread_name.empty())
     thread_name = "<Main thread>";
   SDVLOG(2) << "Start called from thread "
             << thread_name << " with mode " << GetModeString(mode);
   if (!started_) {
     started_ = true;
-    PostTask(FROM_HERE, "SendInitialSnapshot",
-             base::Bind(&SyncScheduler::SendInitialSnapshot,
-                        weak_ptr_factory_.GetWeakPtr()));
+    SendInitialSnapshot();
   }
-  PostTask(FROM_HERE, "StartImpl",
-           base::Bind(&SyncScheduler::StartImpl,
-                      weak_ptr_factory_.GetWeakPtr(), mode, callback));
-}
 
-void SyncScheduler::SendInitialSnapshot() {
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
-  scoped_ptr<SyncSession> dummy(new SyncSession(session_context_, this,
-      SyncSourceInfo(), ModelSafeRoutingInfo(),
-      std::vector<ModelSafeWorker*>()));
-  SyncEngineEvent event(SyncEngineEvent::STATUS_CHANGED);
-  event.snapshot = dummy->TakeSnapshot();
-  session_context_->NotifyListeners(event);
-}
-
-void SyncScheduler::StartImpl(Mode mode, const base::Closure& callback) {
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
-  SDVLOG(2) << "In StartImpl with mode " << GetModeString(mode);
-
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
   DCHECK(!session_context_->account_name().empty());
   DCHECK(syncer_.get());
   Mode old_mode = mode_;
   mode_ = mode;
   AdjustPolling(NULL);  // Will kick start poll timer if needed.
   if (!callback.is_null())
     callback.Run();
 
   if (old_mode != mode_) {
     // We just changed our mode. See if there are any pending jobs that we could
     // execute in the new mode.
     DoPendingJobIfPossible(false);
   }
 }
 
+void SyncScheduler::SendInitialSnapshot() {
+  DCHECK_EQ(MessageLoop::current(), sync_loop_);
+  scoped_ptr<SyncSession> dummy(new SyncSession(session_context_, this,
+      SyncSourceInfo(), ModelSafeRoutingInfo(),
+      std::vector<ModelSafeWorker*>()));
+  SyncEngineEvent event(SyncEngineEvent::STATUS_CHANGED);
+  event.snapshot = dummy->TakeSnapshot();
+  session_context_->NotifyListeners(event);
+}
+
 SyncScheduler::JobProcessDecision SyncScheduler::DecideWhileInWaitInterval(
     const SyncSessionJob& job) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   DCHECK(wait_interval_.get());
   DCHECK_NE(job.purpose, SyncSessionJob::CLEAR_USER_DATA);
   DCHECK_NE(job.purpose, SyncSessionJob::CLEANUP_DISABLED_TYPES);
 
   SDVLOG(2) << "DecideWhileInWaitInterval with WaitInterval mode "
             << WaitInterval::GetModeString(wait_interval_->mode)
             << (wait_interval_->had_nudge ? " (had nudge)" : "")
@@ skipping 145 matching lines @@
 
 // Functor for std::find_if to search by ModelSafeGroup.
 struct ModelSafeWorkerGroupIs {
   explicit ModelSafeWorkerGroupIs(ModelSafeGroup group) : group(group) {}
   bool operator()(ModelSafeWorker* w) {
     return group == w->GetModelSafeGroup();
   }
   ModelSafeGroup group;
 };
 
-void SyncScheduler::ScheduleClearUserData() {
+void SyncScheduler::ClearUserData() {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
-  PostTask(FROM_HERE, "ScheduleClearUserDataImpl",
-           base::Bind(&SyncScheduler::ScheduleClearUserDataImpl,
-                      weak_ptr_factory_.GetWeakPtr()));
+  SyncSessionJob job(SyncSessionJob::CLEAR_USER_DATA, TimeTicks::Now(),
+                     make_linked_ptr(CreateSyncSession(SyncSourceInfo())),
+                     false,
+                     FROM_HERE);
+
+  DoSyncSessionJob(job);
 }
 
-// TODO(sync): Remove the *Impl methods for the other Schedule*
-// functions, too.
-void SyncScheduler::ScheduleCleanupDisabledTypes() {
+void SyncScheduler::CleanupDisabledTypes() {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   SyncSessionJob job(SyncSessionJob::CLEANUP_DISABLED_TYPES, TimeTicks::Now(),
                      make_linked_ptr(CreateSyncSession(SyncSourceInfo())),
                      false,
                      FROM_HERE);
-  ScheduleSyncSessionJob(job);
+  DoSyncSessionJob(job);
 }
 
 void SyncScheduler::ScheduleNudge(
     const TimeDelta& delay,
     NudgeSource source, ModelTypeSet types,
     const tracked_objects::Location& nudge_location) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   SDVLOG_LOC(nudge_location, 2)
       << "Nudge scheduled with delay " << delay.InMilliseconds() << " ms, "
       << "source " << GetNudgeSourceString(source) << ", "
       << "types " << ModelTypeSetToString(types);
 
   ModelTypePayloadMap types_with_payloads =
       syncable::ModelTypePayloadMapFromEnumSet(types, std::string());
-  PostTask(nudge_location, "ScheduleNudgeImpl",
-           base::Bind(&SyncScheduler::ScheduleNudgeImpl,
-                      weak_ptr_factory_.GetWeakPtr(),
-                      delay,
-                      GetUpdatesFromNudgeSource(source),
-                      types_with_payloads,
-                      false,
-                      nudge_location));
+  SyncScheduler::ScheduleNudgeImpl(delay,
+                                   GetUpdatesFromNudgeSource(source),
+                                   types_with_payloads,
+                                   false,
+                                   nudge_location);
 }
 
 void SyncScheduler::ScheduleNudgeWithPayloads(
     const TimeDelta& delay,
     NudgeSource source, const ModelTypePayloadMap& types_with_payloads,
     const tracked_objects::Location& nudge_location) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   SDVLOG_LOC(nudge_location, 2)
       << "Nudge scheduled with delay " << delay.InMilliseconds() << " ms, "
       << "source " << GetNudgeSourceString(source) << ", "
       << "payloads "
       << syncable::ModelTypePayloadMapToString(types_with_payloads);
 
-  PostTask(nudge_location, "ScheduleNudgeImpl",
-           base::Bind(&SyncScheduler::ScheduleNudgeImpl,
-                      weak_ptr_factory_.GetWeakPtr(),
-                      delay,
-                      GetUpdatesFromNudgeSource(source),
-                      types_with_payloads,
-                      false,
-                      nudge_location));
-}
-
-void SyncScheduler::ScheduleClearUserDataImpl() {
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
-  SyncSessionJob job(SyncSessionJob::CLEAR_USER_DATA, TimeTicks::Now(),
-                     make_linked_ptr(CreateSyncSession(SyncSourceInfo())),
-                     false,
-                     FROM_HERE);
-
-  ScheduleSyncSessionJob(job);
+  SyncScheduler::ScheduleNudgeImpl(delay,
+                                   GetUpdatesFromNudgeSource(source),
+                                   types_with_payloads,
+                                   false,
+                                   nudge_location);
 }
 
 void SyncScheduler::ScheduleNudgeImpl(
     const TimeDelta& delay,
     GetUpdatesCallerInfo::GetUpdatesSource source,
     const ModelTypePayloadMap& types_with_payloads,
     bool is_canary_job, const tracked_objects::Location& nudge_location) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
 
   SDVLOG_LOC(nudge_location, 2)
@@ skipping 78 matching lines @@
   if (passive_group_added == false) {
     iter it = std::find_if(current_workers.begin(), current_workers.end(),
                            ModelSafeWorkerGroupIs(GROUP_PASSIVE));
     if (it != current_workers.end())
       result_workers->push_back(*it);
     else
       NOTREACHED();
   }
 }
 
-void SyncScheduler::ScheduleConfig(
+void SyncScheduler::Configure(
     ModelTypeSet types,
     GetUpdatesCallerInfo::GetUpdatesSource source) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   DCHECK(IsConfigRelatedUpdateSourceValue(source));
-  SDVLOG(2) << "Scheduling a config";
+  SDVLOG(2) << "Performing a config";
 
   ModelSafeRoutingInfo routes;
   std::vector<ModelSafeWorker*> workers;
   GetModelSafeParamsForTypes(types,
                              session_context_->routing_info(),
                              session_context_->workers(),
                              &routes, &workers);
 
-  PostTask(FROM_HERE, "ScheduleConfigImpl",
-           base::Bind(&SyncScheduler::ScheduleConfigImpl,
-                      weak_ptr_factory_.GetWeakPtr(),
-                      routes,
-                      workers,
-                      source));
-}
-
-void SyncScheduler::ScheduleConfigImpl(
-    const ModelSafeRoutingInfo& routing_info,
-    const std::vector<ModelSafeWorker*>& workers,
-    const sync_pb::GetUpdatesCallerInfo::GetUpdatesSource source) {
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
-
-  SDVLOG(2) << "In ScheduleConfigImpl";
   // TODO(tim): config-specific GetUpdatesCallerInfo value?

[tim (not reviewing), 2012/06/11 20:06:13]

I think this can be removed.

[Nicolas Zea, 2012/06/11 20:55:09]

Done.

   SyncSession* session = new SyncSession(session_context_, this,
       SyncSourceInfo(source,
-          syncable::ModelTypePayloadMapFromRoutingInfo(
-              routing_info, std::string())),
-      routing_info, workers);
+                     syncable::ModelTypePayloadMapFromRoutingInfo(
+                         routes, std::string())),
+      routes, workers);
   SyncSessionJob job(SyncSessionJob::CONFIGURATION, TimeTicks::Now(),
                      make_linked_ptr(session),
                      false,
                      FROM_HERE);
-  ScheduleSyncSessionJob(job);
+  DoSyncSessionJob(job);
 }
 
 const char* SyncScheduler::GetModeString(SyncScheduler::Mode mode) {
   switch (mode) {
     ENUM_CASE(CONFIGURATION_MODE);
     ENUM_CASE(NORMAL_MODE);
   }
   return "";
 }
 
@@ skipping 66 matching lines @@
 void SyncScheduler::ScheduleSyncSessionJob(const SyncSessionJob& job) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   TimeDelta delay = job.scheduled_start - TimeTicks::Now();
   if (delay < TimeDelta::FromMilliseconds(0))
     delay = TimeDelta::FromMilliseconds(0);
   SDVLOG_LOC(job.from_here, 2)
       << "In ScheduleSyncSessionJob with "
       << SyncSessionJob::GetPurposeString(job.purpose)
       << " job and " << delay.InMilliseconds() << " ms delay";
 
+  DCHECK(job.purpose == SyncSessionJob::NUDGE ||
+         job.purpose == SyncSessionJob::POLL);
   if (job.purpose == SyncSessionJob::NUDGE) {
     SDVLOG_LOC(job.from_here, 2) << "Resetting pending_nudge";
     DCHECK(!pending_nudge_.get() || pending_nudge_->session.get() ==
            job.session);
     pending_nudge_.reset(new SyncSessionJob(job));
   }
+
   PostDelayedTask(job.from_here, "DoSyncSessionJob",
                   base::Bind(&SyncScheduler::DoSyncSessionJob,
                              weak_ptr_factory_.GetWeakPtr(),
                              job),
                   delay);
 }
 
 void SyncScheduler::DoSyncSessionJob(const SyncSessionJob& job) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   if (!ShouldRunJob(job)) {
@@ skipping 420 matching lines @@
 
 #undef SDVLOG_LOC
 
 #undef SDVLOG
 
 #undef SLOG
 
 #undef ENUM_CASE
 
 }  // browser_sync