[Sync] Add support for server controlled nudge delays

sync/internal_api/sync_manager_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/internal_api/sync_manager_impl.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 43 matching lines @@
 
 namespace syncer {
 
 using sessions::SyncSessionContext;
 using syncable::ImmutableWriteTransactionInfo;
 using syncable::SPECIFICS;
 using syncable::UNIQUE_POSITION;
 
 namespace {
 
-// Delays for syncer nudges.
-static const int kDefaultNudgeDelayMilliseconds = 200;
-static const int kSlowNudgeDelayMilliseconds = 2000;
-static const int kSyncRefreshDelayMsec = 500;
-static const int kSyncSchedulerDelayMsec = 250;
-
 GetUpdatesCallerInfo::GetUpdatesSource GetSourceFromReason(
     ConfigureReason reason) {
   switch (reason) {
     case CONFIGURE_REASON_RECONFIGURATION:
       return GetUpdatesCallerInfo::RECONFIGURATION;
     case CONFIGURE_REASON_MIGRATION:
       return GetUpdatesCallerInfo::MIGRATION;
     case CONFIGURE_REASON_NEW_CLIENT:
       return GetUpdatesCallerInfo::NEW_CLIENT;
     case CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE:
     case CONFIGURE_REASON_CRYPTO:
       return GetUpdatesCallerInfo::NEWLY_SUPPORTED_DATATYPE;
     default:
       NOTREACHED();
   }
   return GetUpdatesCallerInfo::UNKNOWN;
 }
 
 }  // namespace
 
-// A class to calculate nudge delays for types.
-class NudgeStrategy {

[rlarocque, 2014/08/20 00:13:32]

Woo-hoo!  I'm glad to see this being deleted.

[Nicolas Zea, 2014/08/20 22:49:43]

Acknowledged.

- public:
-  static TimeDelta GetNudgeDelayTimeDelta(const ModelType& model_type,
-                                          SyncManagerImpl* core) {
-    NudgeDelayStrategy delay_type = GetNudgeDelayStrategy(model_type);
-    return GetNudgeDelayTimeDeltaFromType(delay_type,
-                                          model_type,
-                                          core);
-  }
-
- private:
-  // Possible types of nudge delay for datatypes.
-  // Note: These are just hints. If a sync happens then all dirty entries
-  // would be committed as part of the sync.
-  enum NudgeDelayStrategy {
-    // Sync right away.
-    IMMEDIATE,
-
-    // Sync this change while syncing another change.
-    ACCOMPANY_ONLY,
-
-    // The datatype does not use one of the predefined wait times but defines
-    // its own wait time logic for nudge.
-    CUSTOM,
-  };
-
-  static NudgeDelayStrategy GetNudgeDelayStrategy(const ModelType& type) {
-    switch (type) {
-     case AUTOFILL:
-       return ACCOMPANY_ONLY;
-     case BOOKMARKS:
-     case PREFERENCES:
-     case SESSIONS:
-     case FAVICON_IMAGES:
-     case FAVICON_TRACKING:
-       return CUSTOM;
-     default:
-       return IMMEDIATE;
-    }
-  }
-
-  static TimeDelta GetNudgeDelayTimeDeltaFromType(
-      const NudgeDelayStrategy& delay_type, const ModelType& model_type,
-      const SyncManagerImpl* core) {
-    CHECK(core);
-    TimeDelta delay = TimeDelta::FromMilliseconds(
-       kDefaultNudgeDelayMilliseconds);
-    switch (delay_type) {
-     case IMMEDIATE:
-       delay = TimeDelta::FromMilliseconds(
-           kDefaultNudgeDelayMilliseconds);
-       break;
-     case ACCOMPANY_ONLY:
-       delay = TimeDelta::FromSeconds(kDefaultShortPollIntervalSeconds);
-       break;
-     case CUSTOM:
-       switch (model_type) {
-         case BOOKMARKS:
-         case PREFERENCES:
-           delay = TimeDelta::FromMilliseconds(kSlowNudgeDelayMilliseconds);
-           break;
-         case SESSIONS:
-         case FAVICON_IMAGES:
-         case FAVICON_TRACKING:
-           delay = core->scheduler()->GetSessionsCommitDelay();
-           break;
-         default:
-           NOTREACHED();
-       }
-       break;
-     default:
-       NOTREACHED();
-    }
-    return delay;
-  }
-};
-
 SyncManagerImpl::SyncManagerImpl(const std::string& name)
     : name_(name),
       change_delegate_(NULL),
       initialized_(false),
       observing_network_connectivity_changes_(false),
       report_unrecoverable_error_function_(NULL),
       weak_ptr_factory_(this) {
   // Pre-fill |notification_info_map_|.
   for (int i = FIRST_REAL_MODEL_TYPE; i < MODEL_TYPE_COUNT; ++i) {
     notification_info_map_.insert(
@@ skipping 690 matching lines @@
                                                      &(change_records_[i]))) {
         for (size_t j = 0; j < change_records_[i].Get().size(); ++j)
           entries_changed->push_back((change_records_[i].Get())[j].id);
       }
       if (change_records_[i].Get().empty())
         change_records_.erase(i);
     }
   }
 }
 
-TimeDelta SyncManagerImpl::GetNudgeDelayTimeDelta(
-    const ModelType& model_type) {
-  return NudgeStrategy::GetNudgeDelayTimeDelta(model_type, this);
-}
-
 void SyncManagerImpl::RequestNudgeForDataTypes(
     const tracked_objects::Location& nudge_location,
     ModelTypeSet types) {
   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_->ScheduleLocalNudge(nudge_delay,
-                                 types,
-                                 nudge_location);
+  scheduler_->ScheduleLocalNudge(types, nudge_location);
 }
 
 void SyncManagerImpl::NudgeForInitialDownload(syncer::ModelType type) {
   DCHECK(thread_checker_.CalledOnValidThread());
   scheduler_->ScheduleInitialSyncNudge(type);
 }
 
 void SyncManagerImpl::NudgeForCommit(syncer::ModelType type) {
   DCHECK(thread_checker_.CalledOnValidThread());
   RequestNudgeForDataTypes(FROM_HERE, ModelTypeSet(type));
@@ skipping 79 matching lines @@
   allstatus_.SetNotificationsEnabled(invalidator_enabled);
   scheduler_->SetNotificationsEnabled(invalidator_enabled);
 }
 
 void SyncManagerImpl::OnIncomingInvalidation(
     syncer::ModelType type,
     scoped_ptr<InvalidationInterface> invalidation) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   scheduler_->ScheduleInvalidationNudge(
-      TimeDelta::FromMilliseconds(kSyncSchedulerDelayMsec),
       type,
       invalidation.Pass(),
       FROM_HERE);
 }
 
 void SyncManagerImpl::RefreshTypes(ModelTypeSet types) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (types.Empty()) {
     LOG(WARNING) << "Sync received refresh request with no types specified.";
   } else {
     scheduler_->ScheduleLocalRefreshRequest(
-        TimeDelta::FromMilliseconds(kSyncRefreshDelayMsec),
         types, FROM_HERE);
   }
 }
 
 SyncStatus SyncManagerImpl::GetDetailedStatus() const {
   return allstatus_.status();
 }
 
 void SyncManagerImpl::SaveChanges() {
   directory()->SaveChanges();
@@ skipping 113 matching lines @@
 
 bool SyncManagerImpl::HasDirectoryTypeDebugInfoObserver(
     syncer::TypeDebugInfoObserver* observer) {
   return model_type_registry_->HasDirectoryTypeDebugInfoObserver(observer);
 }
 
 void SyncManagerImpl::RequestEmitDebugInfo() {
   model_type_registry_->RequestEmitDebugInfo();
 }
 
-// static.
-int SyncManagerImpl::GetDefaultNudgeDelay() {
-  return kDefaultNudgeDelayMilliseconds;
-}
-
-// static.
-int SyncManagerImpl::GetSlowNudgeDelay() {
-  return kSlowNudgeDelayMilliseconds;
-}
-
 }  // namespace syncer