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

sync/internal_api/sync_manager.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/internal_api/sync_manager.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 829 matching lines @@
 
 bool SyncManager::IsUsingExplicitPassphrase() {
   return data_ && data_->IsUsingExplicitPassphrase();
 }
 
 void SyncManager::RequestCleanupDisabledTypes(
     const browser_sync::ModelSafeRoutingInfo& routing_info) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (data_->scheduler()) {
     data_->session_context()->set_routing_info(routing_info);
-    data_->scheduler()->ScheduleCleanupDisabledTypes();
+    data_->scheduler()->CleanupDisabledTypes();
   }
 }
 
 void SyncManager::RequestClearServerData() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (data_->scheduler())
-    data_->scheduler()->ScheduleClearUserData();
+    data_->scheduler()->ClearUserData();
 }
 
 void SyncManager::RequestConfig(
     const browser_sync::ModelSafeRoutingInfo& routing_info,
     const ModelTypeSet& types, ConfigureReason reason) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!data_->scheduler()) {
     LOG(INFO)
         << "SyncManager::RequestConfig: bailing out because scheduler is "
         << "null";
     return;
   }
   StartConfigurationMode(base::Closure());
   data_->session_context()->set_routing_info(routing_info);
-  data_->scheduler()->ScheduleConfig(types, GetSourceFromReason(reason));
+  data_->scheduler()->ScheduleConfiguration(types, GetSourceFromReason(reason));
 }
 
 void SyncManager::StartConfigurationMode(const base::Closure& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!data_->scheduler()) {
     LOG(INFO)
         << "SyncManager::StartConfigurationMode: could not start "
         << "configuration mode because because scheduler is null";
     return;
   }
@@ skipping 1076 matching lines @@
   }
 }
 
 SyncManager::Status SyncManager::SyncInternal::GetStatus() {
   return allstatus_.status();
 }
 
 void SyncManager::SyncInternal::RequestNudge(
     const tracked_objects::Location& location) {
   if (scheduler()) {
-     scheduler()->ScheduleNudge(
+     scheduler()->ScheduleNudgeAsync(
         TimeDelta::FromMilliseconds(0), browser_sync::NUDGE_SOURCE_LOCAL,
         ModelTypeSet(), location);
   }
 }
 
 TimeDelta SyncManager::SyncInternal::GetNudgeDelayTimeDelta(
     const ModelType& model_type) {
   return NudgeStrategy::GetNudgeDelayTimeDelta(model_type, this);
 }
 
 void SyncManager::SyncInternal::RequestNudgeForDataTypes(
     const tracked_objects::Location& nudge_location,
     ModelTypeSet types) {
   if (!scheduler()) {
     NOTREACHED();
     return;
   }
 
   debug_info_event_listener_.OnNudgeFromDatatype(types.First().Get());
 
   // TODO(lipalani) : Calculate the nudge delay based on all types.
   base::TimeDelta nudge_delay = NudgeStrategy::GetNudgeDelayTimeDelta(
       types.First().Get(),
       this);
-  scheduler()->ScheduleNudge(nudge_delay,
-                             browser_sync::NUDGE_SOURCE_LOCAL,
-                             types,
-                             nudge_location);
+  scheduler()->ScheduleNudgeAsync(nudge_delay,
+                                  browser_sync::NUDGE_SOURCE_LOCAL,
+                                  types,
+                                  nudge_location);
 }
 
 void SyncManager::SyncInternal::OnSyncEngineEvent(
     const SyncEngineEvent& event) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Only send an event if this is due to a cycle ending and this cycle
   // concludes a canonical "sync" process; that is, based on what is known
   // locally we are "all happy" and up-to-date.  There may be new changes on
   // the server, but we'll get them on a subsequent sync.
   //
@@ skipping 314 matching lines @@
     info->payload = it->second;
   }
 }
 
 void SyncManager::SyncInternal::OnIncomingNotification(
     const syncable::ModelTypePayloadMap& type_payloads,
     sync_notifier::IncomingNotificationSource source) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (source == sync_notifier::LOCAL_NOTIFICATION) {
     if (scheduler()) {
-      scheduler()->ScheduleNudgeWithPayloads(
+      scheduler()->ScheduleNudgeWithPayloadsAsync(
           TimeDelta::FromMilliseconds(kSyncRefreshDelayMsec),
           browser_sync::NUDGE_SOURCE_LOCAL_REFRESH,
           type_payloads, FROM_HERE);
     }
   } else if (!type_payloads.empty()) {
     if (scheduler()) {
-      scheduler()->ScheduleNudgeWithPayloads(
+      scheduler()->ScheduleNudgeWithPayloadsAsync(
           TimeDelta::FromMilliseconds(kSyncSchedulerDelayMsec),
           browser_sync::NUDGE_SOURCE_NOTIFICATION,
           type_payloads, FROM_HERE);
     }
     allstatus_.IncrementNotificationsReceived();
     UpdateNotificationInfo(type_payloads);
     debug_info_event_listener_.OnIncomingNotification(type_payloads);
   } else {
     LOG(WARNING) << "Sync received notification without any type information.";
   }
@@ skipping 152 matching lines @@
     share->directory->GetDownloadProgress(i.Get(), &marker);
 
     if (marker.token().empty())
       result.Put(i.Get());
 
   }
   return result;
 }
 
 }  // namespace sync_api