[Sync] Add support for server controlled nudge delays

Server nudge delays override the local ones, but must be longer than the
default nudge delay. If set to 0, will reset the nudge to the default.

To accomplish this the delay logic was refactored and moved into the sync
scheduler, which is now aware of all delays for all types and sync cycles.

BUG=401600

Review URL: https://codereview.chromium.org/488843002

Cr-Commit-Position: refs/heads/master@{#291512}
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@291512 0039d316-1c4b-4281-b951-d872f2087c98

6 files changed, 161 insertions, 177 deletions

diff --git a/sync/engine/sync_scheduler.h b/sync/engine/sync_scheduler.h
index e490f94..e91ce61 100644
--- a/sync/engine/sync_scheduler.h
+++ b/sync/engine/sync_scheduler.h
@@ -96,7 +96,6 @@ class SYNC_EXPORT_PRIVATE SyncScheduler
   // The LocalNudge indicates that we've made a local change, and that the
   // syncer should plan to commit this to the server some time soon.
   virtual void ScheduleLocalNudge(
-      const base::TimeDelta& desired_delay,
       ModelTypeSet types,
       const tracked_objects::Location& nudge_location) = 0;
 
@@ -105,7 +104,6 @@ class SYNC_EXPORT_PRIVATE SyncScheduler
   // uses is to fetch the latest tab sync data when it's relevant to the UI on
   // platforms where tab sync is not registered for invalidations.
   virtual void ScheduleLocalRefreshRequest(
-      const base::TimeDelta& desired_delay,
       ModelTypeSet types,
       const tracked_objects::Location& nudge_location) = 0;
 
@@ -114,7 +112,6 @@ class SYNC_EXPORT_PRIVATE SyncScheduler
   // careful to pass along the "hints" delivered with those invalidations) in
   // order to fetch the update.
   virtual void ScheduleInvalidationNudge(
-      const base::TimeDelta& desired_delay,
       syncer::ModelType type,
       scoped_ptr<InvalidationInterface> invalidation,
       const tracked_objects::Location& nudge_location) = 0;
@@ -130,8 +127,6 @@ class SYNC_EXPORT_PRIVATE SyncScheduler
   // Change status of notifications in the SyncSessionContext.
   virtual void SetNotificationsEnabled(bool notifications_enabled) = 0;
 
-  virtual base::TimeDelta GetSessionsCommitDelay() const = 0;
-
   // Called when credentials are updated by the user.
   virtual void OnCredentialsUpdated() = 0;
 
diff --git a/sync/engine/sync_scheduler_impl.cc b/sync/engine/sync_scheduler_impl.cc
index 7b07815..22dc5e0 100644
--- a/sync/engine/sync_scheduler_impl.cc
+++ b/sync/engine/sync_scheduler_impl.cc
@@ -32,6 +32,20 @@ using sync_pb::GetUpdatesCallerInfo;
 
 namespace {
 
+bool IsConfigRelatedUpdateSourceValue(
+    GetUpdatesCallerInfo::GetUpdatesSource source) {
+  switch (source) {
+    case GetUpdatesCallerInfo::RECONFIGURATION:
+    case GetUpdatesCallerInfo::MIGRATION:
+    case GetUpdatesCallerInfo::NEW_CLIENT:
+    case GetUpdatesCallerInfo::NEWLY_SUPPORTED_DATATYPE:
+    case GetUpdatesCallerInfo::PROGRAMMATIC:
+      return true;
+    default:
+      return false;
+  }
+}
+
 bool ShouldRequestEarlyExit(const SyncProtocolError& error) {
   switch (error.error_type) {
     case SYNC_SUCCESS:
@@ -65,6 +79,7 @@ bool IsActionableError(
     const SyncProtocolError& error) {
   return (error.action != UNKNOWN_ACTION);
 }
+
 }  // namespace
 
 ConfigurationParams::ConfigurationParams()
@@ -132,26 +147,6 @@ GetUpdatesCallerInfo::GetUpdatesSource GetUpdatesFromNudgeSource(
 #define SDVLOG_LOC(from_here, verbose_level)             \
   DVLOG_LOC(from_here, verbose_level) << name_ << ": "
 
-namespace {
-
-const int kDefaultSessionsCommitDelaySeconds = 10;
-
-bool IsConfigRelatedUpdateSourceValue(
-    GetUpdatesCallerInfo::GetUpdatesSource source) {
-  switch (source) {
-    case GetUpdatesCallerInfo::RECONFIGURATION:
-    case GetUpdatesCallerInfo::MIGRATION:
-    case GetUpdatesCallerInfo::NEW_CLIENT:
-    case GetUpdatesCallerInfo::NEWLY_SUPPORTED_DATATYPE:
-    case GetUpdatesCallerInfo::PROGRAMMATIC:
-      return true;
-    default:
-      return false;
-  }
-}
-
-}  // namespace
-
 SyncSchedulerImpl::SyncSchedulerImpl(const std::string& name,
                                      BackoffDelayProvider* delay_provider,
                                      sessions::SyncSessionContext* context,
@@ -162,8 +157,6 @@ SyncSchedulerImpl::SyncSchedulerImpl(const std::string& name,
           TimeDelta::FromSeconds(kDefaultShortPollIntervalSeconds)),
       syncer_long_poll_interval_seconds_(
           TimeDelta::FromSeconds(kDefaultLongPollIntervalSeconds)),
-      sessions_commit_delay_(
-          TimeDelta::FromSeconds(kDefaultSessionsCommitDelaySeconds)),
       mode_(NORMAL_MODE),
       delay_provider_(delay_provider),
       syncer_(syncer),
@@ -357,7 +350,6 @@ bool SyncSchedulerImpl::CanRunNudgeJobNow(JobPriority priority) {
 }
 
 void SyncSchedulerImpl::ScheduleLocalNudge(
-    const TimeDelta& desired_delay,
     ModelTypeSet types,
     const tracked_objects::Location& nudge_location) {
   DCHECK(CalledOnValidThread());
@@ -367,12 +359,11 @@ void SyncSchedulerImpl::ScheduleLocalNudge(
       << "Scheduling sync because of local change to "
       << ModelTypeSetToString(types);
   UpdateNudgeTimeRecords(types);
-  nudge_tracker_.RecordLocalChange(types);
-  ScheduleNudgeImpl(desired_delay, nudge_location);
+  base::TimeDelta nudge_delay = nudge_tracker_.RecordLocalChange(types);
+  ScheduleNudgeImpl(nudge_delay, nudge_location);
 }
 
 void SyncSchedulerImpl::ScheduleLocalRefreshRequest(
-    const TimeDelta& desired_delay,
     ModelTypeSet types,
     const tracked_objects::Location& nudge_location) {
   DCHECK(CalledOnValidThread());
@@ -381,12 +372,11 @@ void SyncSchedulerImpl::ScheduleLocalRefreshRequest(
   SDVLOG_LOC(nudge_location, 2)
       << "Scheduling sync because of local refresh request for "
       << ModelTypeSetToString(types);
-  nudge_tracker_.RecordLocalRefreshRequest(types);
-  ScheduleNudgeImpl(desired_delay, nudge_location);
+  base::TimeDelta nudge_delay = nudge_tracker_.RecordLocalRefreshRequest(types);
+  ScheduleNudgeImpl(nudge_delay, nudge_location);
 }
 
 void SyncSchedulerImpl::ScheduleInvalidationNudge(
-    const TimeDelta& desired_delay,
     syncer::ModelType model_type,
     scoped_ptr<InvalidationInterface> invalidation,
     const tracked_objects::Location& nudge_location) {
@@ -395,8 +385,9 @@ void SyncSchedulerImpl::ScheduleInvalidationNudge(
   SDVLOG_LOC(nudge_location, 2)
       << "Scheduling sync because we received invalidation for "
       << ModelTypeToString(model_type);
-  nudge_tracker_.RecordRemoteInvalidation(model_type, invalidation.Pass());
-  ScheduleNudgeImpl(desired_delay, nudge_location);
+  base::TimeDelta nudge_delay =
+      nudge_tracker_.RecordRemoteInvalidation(model_type, invalidation.Pass());
+  ScheduleNudgeImpl(nudge_delay, nudge_location);
 }
 
 void SyncSchedulerImpl::ScheduleInitialSyncNudge(syncer::ModelType model_type) {
@@ -462,6 +453,11 @@ const char* SyncSchedulerImpl::GetModeString(SyncScheduler::Mode mode) {
   return "";
 }
 
+void SyncSchedulerImpl::SetDefaultNudgeDelay(base::TimeDelta delay_ms) {
+  DCHECK(CalledOnValidThread());
+  nudge_tracker_.SetDefaultNudgeDelay(delay_ms);
+}
+
 void SyncSchedulerImpl::DoNudgeSyncSessionJob(JobPriority priority) {
   DCHECK(CalledOnValidThread());
   DCHECK(CanRunNudgeJobNow(priority));
@@ -863,10 +859,10 @@ void SyncSchedulerImpl::OnReceivedLongPollIntervalUpdate(
   syncer_long_poll_interval_seconds_ = new_interval;
 }
 
-void SyncSchedulerImpl::OnReceivedSessionsCommitDelay(
-    const base::TimeDelta& new_delay) {
+void SyncSchedulerImpl::OnReceivedCustomNudgeDelays(
+    const std::map<ModelType, base::TimeDelta>& nudge_delays) {
   DCHECK(CalledOnValidThread());
-  sessions_commit_delay_ = new_delay;
+  nudge_tracker_.OnReceivedCustomNudgeDelays(nudge_delays);
 }
 
 void SyncSchedulerImpl::OnReceivedClientInvalidationHintBufferSize(int size) {
@@ -912,11 +908,6 @@ void SyncSchedulerImpl::SetNotificationsEnabled(bool notifications_enabled) {
     nudge_tracker_.OnInvalidationsDisabled();
 }
 
-base::TimeDelta SyncSchedulerImpl::GetSessionsCommitDelay() const {
-  DCHECK(CalledOnValidThread());
-  return sessions_commit_delay_;
-}
-
 #undef SDVLOG_LOC
 
 #undef SDVLOG
diff --git a/sync/engine/sync_scheduler_impl.h b/sync/engine/sync_scheduler_impl.h
index 7cb295b..0e5a27a 100644
--- a/sync/engine/sync_scheduler_impl.h
+++ b/sync/engine/sync_scheduler_impl.h
@@ -56,23 +56,18 @@ class SYNC_EXPORT_PRIVATE SyncSchedulerImpl
       const ConfigurationParams& params) OVERRIDE;
   virtual void Stop() OVERRIDE;
   virtual void ScheduleLocalNudge(
-      const base::TimeDelta& desired_delay,
       ModelTypeSet types,
       const tracked_objects::Location& nudge_location) OVERRIDE;
   virtual void ScheduleLocalRefreshRequest(
-      const base::TimeDelta& desired_delay,
       ModelTypeSet types,
       const tracked_objects::Location& nudge_location) OVERRIDE;
   virtual void ScheduleInvalidationNudge(
-      const base::TimeDelta& desired_delay,
       syncer::ModelType type,
       scoped_ptr<InvalidationInterface> invalidation,
       const tracked_objects::Location& nudge_location) OVERRIDE;
   virtual void ScheduleInitialSyncNudge(syncer::ModelType model_type) OVERRIDE;
   virtual void SetNotificationsEnabled(bool notifications_enabled) OVERRIDE;
 
-  virtual base::TimeDelta GetSessionsCommitDelay() const OVERRIDE;
-
   virtual void OnCredentialsUpdated() OVERRIDE;
   virtual void OnConnectionStatusChange() OVERRIDE;
 
@@ -86,8 +81,8 @@ class SYNC_EXPORT_PRIVATE SyncSchedulerImpl
       const base::TimeDelta& new_interval) OVERRIDE;
   virtual void OnReceivedLongPollIntervalUpdate(
       const base::TimeDelta& new_interval) OVERRIDE;
-  virtual void OnReceivedSessionsCommitDelay(
-      const base::TimeDelta& new_delay) OVERRIDE;
+  virtual void OnReceivedCustomNudgeDelays(
+      const std::map<ModelType, base::TimeDelta>& nudge_delays) OVERRIDE;
   virtual void OnReceivedClientInvalidationHintBufferSize(int size) OVERRIDE;
   virtual void OnSyncProtocolError(
       const SyncProtocolError& sync_protocol_error) OVERRIDE;
@@ -150,6 +145,8 @@ class SYNC_EXPORT_PRIVATE SyncSchedulerImpl
 
   static const char* GetModeString(Mode mode);
 
+  void SetDefaultNudgeDelay(base::TimeDelta delay_ms);
+
   // Invoke the syncer to perform a nudge job.
   void DoNudgeSyncSessionJob(JobPriority priority);
 
@@ -251,9 +248,6 @@ class SYNC_EXPORT_PRIVATE SyncSchedulerImpl
   base::TimeDelta syncer_short_poll_interval_seconds_;
   base::TimeDelta syncer_long_poll_interval_seconds_;
 
-  // Server-tweakable sessions commit delay.
-  base::TimeDelta sessions_commit_delay_;
-
   // Periodic timer for polling.  See AdjustPolling.
   base::RepeatingTimer<SyncSchedulerImpl> poll_timer_;
 
diff --git a/sync/engine/sync_scheduler_unittest.cc b/sync/engine/sync_scheduler_unittest.cc
index 268fae2..a436722 100644
--- a/sync/engine/sync_scheduler_unittest.cc
+++ b/sync/engine/sync_scheduler_unittest.cc
@@ -126,8 +126,8 @@ class SyncSchedulerTest : public testing::Test {
     delay_ = NULL;
     extensions_activity_ = new ExtensionsActivity();
 
-    routing_info_[BOOKMARKS] = GROUP_UI;
-    routing_info_[AUTOFILL] = GROUP_DB;
+    routing_info_[THEMES] = GROUP_UI;
+    routing_info_[TYPED_URLS] = GROUP_DB;
     routing_info_[THEMES] = GROUP_UI;
     routing_info_[NIGORI] = GROUP_PASSIVE;
 
@@ -159,6 +159,7 @@ class SyncSchedulerTest : public testing::Test {
             BackoffDelayProvider::FromDefaults(),
             context(),
             syncer_));
+    scheduler_->SetDefaultNudgeDelay(default_delay());
   }
 
   SyncSchedulerImpl* scheduler() { return scheduler_.get(); }
@@ -166,7 +167,7 @@ class SyncSchedulerTest : public testing::Test {
   MockSyncer* syncer() { return syncer_; }
   MockDelayProvider* delay() { return delay_; }
   MockConnectionManager* connection() { return connection_.get(); }
-  TimeDelta zero() { return TimeDelta::FromSeconds(0); }
+  TimeDelta default_delay() { return TimeDelta::FromSeconds(0); }
   TimeDelta timeout() {
     return TestTimeouts::action_timeout();
   }
@@ -206,10 +207,10 @@ class SyncSchedulerTest : public testing::Test {
   }
 
   bool RunAndGetBackoff() {
-    ModelTypeSet nudge_types(BOOKMARKS);
+    ModelTypeSet nudge_types(THEMES);
     StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
-    scheduler()->ScheduleLocalNudge(zero(), nudge_types, FROM_HERE);
+    scheduler()->ScheduleLocalNudge(nudge_types, FROM_HERE);
     RunLoop();
 
     return scheduler()->IsBackingOff();
@@ -298,7 +299,7 @@ ACTION(QuitLoopNowAction) {
 // Test nudge scheduling.
 TEST_F(SyncSchedulerTest, Nudge) {
   SyncShareTimes times;
-  ModelTypeSet model_types(BOOKMARKS);
+  ModelTypeSet model_types(THEMES);
 
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
@@ -307,19 +308,19 @@ TEST_F(SyncSchedulerTest, Nudge) {
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
-  scheduler()->ScheduleLocalNudge(zero(), model_types, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(model_types, FROM_HERE);
   RunLoop();
 
   Mock::VerifyAndClearExpectations(syncer());
 
   // Make sure a second, later, nudge is unaffected by first (no coalescing).
   SyncShareTimes times2;
-  model_types.Remove(BOOKMARKS);
-  model_types.Put(AUTOFILL);
+  model_types.Remove(THEMES);
+  model_types.Put(TYPED_URLS);
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
                       RecordSyncShare(&times2)));
-  scheduler()->ScheduleLocalNudge(zero(), model_types, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(model_types, FROM_HERE);
   RunLoop();
 }
 
@@ -327,7 +328,7 @@ TEST_F(SyncSchedulerTest, Nudge) {
 // errors.
 TEST_F(SyncSchedulerTest, Config) {
   SyncShareTimes times;
-  const ModelTypeSet model_types(BOOKMARKS);
+  const ModelTypeSet model_types(THEMES);
 
   EXPECT_CALL(*syncer(), ConfigureSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConfigureSuccess),
@@ -355,7 +356,7 @@ TEST_F(SyncSchedulerTest, ConfigWithBackingOff) {
   EXPECT_CALL(*delay(), GetDelay(_))
       .WillRepeatedly(Return(TimeDelta::FromMilliseconds(20)));
   SyncShareTimes times;
-  const ModelTypeSet model_types(BOOKMARKS);
+  const ModelTypeSet model_types(THEMES);
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
 
@@ -401,7 +402,7 @@ TEST_F(SyncSchedulerTest, ConfigWithStop) {
   EXPECT_CALL(*delay(), GetDelay(_))
       .WillRepeatedly(Return(TimeDelta::FromMilliseconds(20)));
   SyncShareTimes times;
-  const ModelTypeSet model_types(BOOKMARKS);
+  const ModelTypeSet model_types(THEMES);
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
 
@@ -429,7 +430,7 @@ TEST_F(SyncSchedulerTest, ConfigWithStop) {
 // Issue a nudge when the config has failed. Make sure both the config and
 // nudge are executed.
 TEST_F(SyncSchedulerTest, NudgeWithConfigWithBackingOff) {
-  const ModelTypeSet model_types(BOOKMARKS);
+  const ModelTypeSet model_types(THEMES);
   UseMockDelayProvider();
   EXPECT_CALL(*delay(), GetDelay(_))
       .WillRepeatedly(Return(TimeDelta::FromMilliseconds(50)));
@@ -459,7 +460,7 @@ TEST_F(SyncSchedulerTest, NudgeWithConfigWithBackingOff) {
   EXPECT_CALL(*syncer(), ConfigureSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConfigureFailed),
                       RecordSyncShare(&times)));
-  scheduler()->ScheduleLocalNudge(zero(), model_types, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(model_types, FROM_HERE);
   RunLoop();
   // Note that we're not RunLoop()ing for the NUDGE we just scheduled, but
   // for the first retry attempt from the config job (after
@@ -489,11 +490,10 @@ TEST_F(SyncSchedulerTest, NudgeCoalescing) {
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
                       RecordSyncShare(&times)));
-  const ModelTypeSet types1(BOOKMARKS), types2(AUTOFILL), types3(THEMES);
-  TimeDelta delay = zero();
-  TimeTicks optimal_time = TimeTicks::Now() + delay;
-  scheduler()->ScheduleLocalNudge(delay, types1, FROM_HERE);
-  scheduler()->ScheduleLocalNudge(zero(), types2, FROM_HERE);
+  const ModelTypeSet types1(THEMES), types2(TYPED_URLS), types3(THEMES);
+  TimeTicks optimal_time = TimeTicks::Now() + default_delay();
+  scheduler()->ScheduleLocalNudge(types1, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(types2, FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(1U, times.size());
@@ -505,7 +505,7 @@ TEST_F(SyncSchedulerTest, NudgeCoalescing) {
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
                       RecordSyncShare(&times2)));
-  scheduler()->ScheduleLocalNudge(zero(), types3, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(types3, FROM_HERE);
   RunLoop();
 }
 
@@ -517,13 +517,16 @@ TEST_F(SyncSchedulerTest, NudgeCoalescingWithDifferentTimings) {
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
                       RecordSyncShare(&times)));
-  ModelTypeSet types1(BOOKMARKS), types2(AUTOFILL), types3;
+  ModelTypeSet types1(THEMES), types2(TYPED_URLS), types3;
 
   // Create a huge time delay.
   TimeDelta delay = TimeDelta::FromDays(1);
 
-  scheduler()->ScheduleLocalNudge(delay, types1, FROM_HERE);
-  scheduler()->ScheduleLocalNudge(zero(), types2, FROM_HERE);
+  std::map<ModelType, TimeDelta> delay_map;
+  delay_map[types1.First().Get()] = delay;
+  scheduler()->OnReceivedCustomNudgeDelays(delay_map);
+  scheduler()->ScheduleLocalNudge(types1, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(types2, FROM_HERE);
 
   TimeTicks min_time = TimeTicks::Now();
   TimeTicks max_time = TimeTicks::Now() + delay;
@@ -547,7 +550,7 @@ TEST_F(SyncSchedulerTest, NudgeWithStates) {
                       RecordSyncShare(&times1)))
       .RetiresOnSaturation();
   scheduler()->ScheduleInvalidationNudge(
-      zero(), BOOKMARKS, BuildInvalidation(10, "test"), FROM_HERE);
+      THEMES, BuildInvalidation(10, "test"), FROM_HERE);
   RunLoop();
 
   Mock::VerifyAndClearExpectations(syncer());
@@ -558,7 +561,7 @@ TEST_F(SyncSchedulerTest, NudgeWithStates) {
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
                       RecordSyncShare(&times2)));
   scheduler()->ScheduleInvalidationNudge(
-      zero(), AUTOFILL, BuildInvalidation(10, "test2"), FROM_HERE);
+      TYPED_URLS, BuildInvalidation(10, "test2"), FROM_HERE);
   RunLoop();
 }
 
@@ -631,37 +634,9 @@ TEST_F(SyncSchedulerTest, PollIntervalUpdate) {
   AnalyzePollRun(times, kMinNumSamples, optimal_start, poll2);
 }
 
-// Test that the sessions commit delay is updated when needed.
-TEST_F(SyncSchedulerTest, SessionsCommitDelay) {
-  SyncShareTimes times;
-  TimeDelta delay1(TimeDelta::FromMilliseconds(120));
-  TimeDelta delay2(TimeDelta::FromMilliseconds(30));
-  scheduler()->OnReceivedSessionsCommitDelay(delay1);
-
-  EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
-      .WillOnce(
-          DoAll(
-              WithArgs<0,1,2>(
-                  sessions::test_util::SimulateSessionsCommitDelayUpdate(
-                      delay2)),
-              Invoke(sessions::test_util::SimulateNormalSuccess),
-              QuitLoopNowAction()));
-
-  EXPECT_EQ(delay1, scheduler()->GetSessionsCommitDelay());
-  StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-
-  EXPECT_EQ(delay1, scheduler()->GetSessionsCommitDelay());
-  const ModelTypeSet model_types(BOOKMARKS);
-  scheduler()->ScheduleLocalNudge(zero(), model_types, FROM_HERE);
-  RunLoop();
-
-  EXPECT_EQ(delay2, scheduler()->GetSessionsCommitDelay());
-  StopSyncScheduler();
-}
-
 // Test that no syncing occurs when throttled.
 TEST_F(SyncSchedulerTest, ThrottlingDoesThrottle) {
-  const ModelTypeSet types(BOOKMARKS);
+  const ModelTypeSet types(THEMES);
   TimeDelta poll(TimeDelta::FromMilliseconds(20));
   TimeDelta throttle(TimeDelta::FromMinutes(10));
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
@@ -674,8 +649,7 @@ TEST_F(SyncSchedulerTest, ThrottlingDoesThrottle) {
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
-  scheduler()->ScheduleLocalNudge(
-      TimeDelta::FromMicroseconds(1), types, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(types, FROM_HERE);
   PumpLoop();
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
@@ -738,9 +712,9 @@ TEST_F(SyncSchedulerTest, ThrottlingExpiresFromNudge) {
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
                       QuitLoopNowAction()));
 
-  const ModelTypeSet types(BOOKMARKS);
+  const ModelTypeSet types(THEMES);
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-  scheduler()->ScheduleLocalNudge(zero(), types, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(types, FROM_HERE);
 
   PumpLoop(); // To get PerformDelayedNudge called.
   PumpLoop(); // To get TrySyncSessionJob called
@@ -767,7 +741,7 @@ TEST_F(SyncSchedulerTest, ThrottlingExpiresFromConfigure) {
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConfigureSuccess),
                       QuitLoopNowAction()));
 
-  const ModelTypeSet types(BOOKMARKS);
+  const ModelTypeSet types(THEMES);
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
 
   CallbackCounter ready_counter;
@@ -793,13 +767,13 @@ TEST_F(SyncSchedulerTest, ThrottlingExpiresFromConfigure) {
 TEST_F(SyncSchedulerTest, TypeThrottlingBlocksNudge) {
   UseMockDelayProvider();
   EXPECT_CALL(*delay(), GetDelay(_))
-      .WillRepeatedly(Return(zero()));
+      .WillRepeatedly(Return(default_delay()));
 
   TimeDelta poll(TimeDelta::FromDays(1));
   TimeDelta throttle1(TimeDelta::FromSeconds(60));
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
 
-  const ModelTypeSet types(BOOKMARKS);
+  const ModelTypeSet types(THEMES);
 
   ::testing::InSequence seq;
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
@@ -810,13 +784,13 @@ TEST_F(SyncSchedulerTest, TypeThrottlingBlocksNudge) {
       .RetiresOnSaturation();
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-  scheduler()->ScheduleLocalNudge(zero(), types, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(types, FROM_HERE);
   PumpLoop(); // To get PerformDelayedNudge called.
   PumpLoop(); // To get TrySyncSessionJob called
   EXPECT_TRUE(GetThrottledTypes().HasAll(types));
 
   // This won't cause a sync cycle because the types are throttled.
-  scheduler()->ScheduleLocalNudge(zero(), types, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(types, FROM_HERE);
   PumpLoop();
 
   StopSyncScheduler();
@@ -825,14 +799,14 @@ TEST_F(SyncSchedulerTest, TypeThrottlingBlocksNudge) {
 TEST_F(SyncSchedulerTest, TypeThrottlingDoesBlockOtherSources) {
   UseMockDelayProvider();
   EXPECT_CALL(*delay(), GetDelay(_))
-      .WillRepeatedly(Return(zero()));
+      .WillRepeatedly(Return(default_delay()));
 
   SyncShareTimes times;
   TimeDelta poll(TimeDelta::FromDays(1));
   TimeDelta throttle1(TimeDelta::FromSeconds(60));
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
 
-  const ModelTypeSet throttled_types(BOOKMARKS);
+  const ModelTypeSet throttled_types(THEMES);
   const ModelTypeSet unthrottled_types(PREFERENCES);
 
   ::testing::InSequence seq;
@@ -845,18 +819,18 @@ TEST_F(SyncSchedulerTest, TypeThrottlingDoesBlockOtherSources) {
       .RetiresOnSaturation();
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-  scheduler()->ScheduleLocalNudge(zero(), throttled_types, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(throttled_types, FROM_HERE);
   PumpLoop(); // To get PerformDelayedNudge called.
   PumpLoop(); // To get TrySyncSessionJob called
   EXPECT_TRUE(GetThrottledTypes().HasAll(throttled_types));
 
   // Ignore invalidations for throttled types.
   scheduler()->ScheduleInvalidationNudge(
-      zero(), BOOKMARKS, BuildInvalidation(10, "test"), FROM_HERE);
+      THEMES, BuildInvalidation(10, "test"), FROM_HERE);
   PumpLoop();
 
   // Ignore refresh requests for throttled types.
-  scheduler()->ScheduleLocalRefreshRequest(zero(), throttled_types, FROM_HERE);
+  scheduler()->ScheduleLocalRefreshRequest(throttled_types, FROM_HERE);
   PumpLoop();
 
   Mock::VerifyAndClearExpectations(syncer());
@@ -865,7 +839,7 @@ TEST_F(SyncSchedulerTest, TypeThrottlingDoesBlockOtherSources) {
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillRepeatedly(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
                             RecordSyncShare(&times)));
-  scheduler()->ScheduleLocalNudge(zero(), unthrottled_types, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(unthrottled_types, FROM_HERE);
   RunLoop();
   Mock::VerifyAndClearExpectations(syncer());
 
@@ -880,11 +854,11 @@ TEST_F(SyncSchedulerTest, ConfigurationMode) {
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
 
-  const ModelTypeSet nudge_types(AUTOFILL);
-  scheduler()->ScheduleLocalNudge(zero(), nudge_types, FROM_HERE);
-  scheduler()->ScheduleLocalNudge(zero(), nudge_types, FROM_HERE);
+  const ModelTypeSet nudge_types(TYPED_URLS);
+  scheduler()->ScheduleLocalNudge(nudge_types, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(nudge_types, FROM_HERE);
 
-  const ModelTypeSet config_types(BOOKMARKS);
+  const ModelTypeSet config_types(THEMES);
 
   EXPECT_CALL(*syncer(), ConfigureSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConfigureSuccess),
@@ -993,7 +967,7 @@ TEST_F(BackoffTriggersSyncSchedulerTest, FailGetEncryptionKey) {
               QuitLoopNowAction()));
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
 
-  ModelTypeSet types(BOOKMARKS);
+  ModelTypeSet types(THEMES);
   CallbackCounter ready_counter;
   CallbackCounter retry_counter;
   ConfigurationParams params(
@@ -1012,7 +986,7 @@ TEST_F(BackoffTriggersSyncSchedulerTest, FailGetEncryptionKey) {
 TEST_F(SyncSchedulerTest, BackoffDropsJobs) {
   SyncShareTimes times;
   TimeDelta poll(TimeDelta::FromMilliseconds(10));
-  const ModelTypeSet types(BOOKMARKS);
+  const ModelTypeSet types(THEMES);
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
   UseMockDelayProvider();
 
@@ -1026,7 +1000,7 @@ TEST_F(SyncSchedulerTest, BackoffDropsJobs) {
 
   // This nudge should fail and put us into backoff.  Thanks to our mock
   // GetDelay() setup above, this will be a long backoff.
-  scheduler()->ScheduleLocalNudge(zero(), types, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(types, FROM_HERE);
   RunLoop();
 
   // From this point forward, no SyncShare functions should be invoked.
@@ -1036,10 +1010,7 @@ TEST_F(SyncSchedulerTest, BackoffDropsJobs) {
   PumpLoopFor(poll * 10);
 
   // Try (and fail) to schedule a nudge.
-  scheduler()->ScheduleLocalNudge(
-      base::TimeDelta::FromMilliseconds(10),
-      types,
-      FROM_HERE);
+  scheduler()->ScheduleLocalNudge(types, FROM_HERE);
 
   Mock::VerifyAndClearExpectations(syncer());
   Mock::VerifyAndClearExpectations(delay());
@@ -1092,7 +1063,7 @@ TEST_F(SyncSchedulerTest, BackoffElevation) {
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
   // Run again with a nudge.
-  scheduler()->ScheduleLocalNudge(zero(), ModelTypeSet(BOOKMARKS), FROM_HERE);
+  scheduler()->ScheduleLocalNudge(ModelTypeSet(THEMES), FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(kMinNumSamples, times.size());
@@ -1120,7 +1091,7 @@ TEST_F(SyncSchedulerTest, BackoffRelief) {
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
                       RecordSyncShare(&times)));
-  scheduler()->ScheduleLocalNudge(zero(), ModelTypeSet(BOOKMARKS), FROM_HERE);
+  scheduler()->ScheduleLocalNudge(ModelTypeSet(THEMES), FROM_HERE);
   RunLoop();
   Mock::VerifyAndClearExpectations(syncer());
   TimeTicks optimal_job_time = optimal_start;
@@ -1192,7 +1163,7 @@ TEST_F(SyncSchedulerTest, StartWhenNotConnected) {
                     Return(true)));
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
-  scheduler()->ScheduleLocalNudge(zero(), ModelTypeSet(BOOKMARKS), FROM_HERE);
+  scheduler()->ScheduleLocalNudge(ModelTypeSet(THEMES), FROM_HERE);
   // Should save the nudge for until after the server is reachable.
   base::MessageLoop::current()->RunUntilIdle();
 
@@ -1217,7 +1188,7 @@ TEST_F(SyncSchedulerTest, ServerConnectionChangeDuringBackoff) {
     .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
                     Return(true)));
 
-  scheduler()->ScheduleLocalNudge(zero(), ModelTypeSet(BOOKMARKS), FROM_HERE);
+  scheduler()->ScheduleLocalNudge(ModelTypeSet(THEMES), FROM_HERE);
   PumpLoop(); // To get PerformDelayedNudge called.
   PumpLoop(); // Run the nudge, that will fail and schedule a quick retry.
   ASSERT_TRUE(scheduler()->IsBackingOff());
@@ -1249,7 +1220,7 @@ TEST_F(SyncSchedulerTest, ConnectionChangeCanaryPreemptedByNudge) {
     .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
                     QuitLoopNowAction()));
 
-  scheduler()->ScheduleLocalNudge(zero(), ModelTypeSet(BOOKMARKS), FROM_HERE);
+  scheduler()->ScheduleLocalNudge(ModelTypeSet(THEMES), FROM_HERE);
 
   PumpLoop(); // To get PerformDelayedNudge called.
   PumpLoop(); // Run the nudge, that will fail and schedule a quick retry.
@@ -1260,7 +1231,7 @@ TEST_F(SyncSchedulerTest, ConnectionChangeCanaryPreemptedByNudge) {
   PumpLoop();
   connection()->SetServerReachable();
   connection()->UpdateConnectionStatus();
-  scheduler()->ScheduleLocalNudge(zero(), ModelTypeSet(BOOKMARKS), FROM_HERE);
+  scheduler()->ScheduleLocalNudge(ModelTypeSet(THEMES), FROM_HERE);
   base::MessageLoop::current()->RunUntilIdle();
 }
 
@@ -1275,7 +1246,7 @@ TEST_F(SyncSchedulerTest, DoubleCanaryInConfigure) {
   connection()->SetServerNotReachable();
   connection()->UpdateConnectionStatus();
 
-  ModelTypeSet model_types(BOOKMARKS);
+  ModelTypeSet model_types(THEMES);
   CallbackCounter ready_counter;
   CallbackCounter retry_counter;
   ConfigurationParams params(
@@ -1381,8 +1352,7 @@ TEST_F(SyncSchedulerTest, ReceiveNewRetryDelay) {
   base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(100);
   base::TimeDelta delay2 = base::TimeDelta::FromMilliseconds(200);
 
-  scheduler()->ScheduleLocalRefreshRequest(zero(), ModelTypeSet(BOOKMARKS),
-                                           FROM_HERE);
+  scheduler()->ScheduleLocalNudge(ModelTypeSet(THEMES), FROM_HERE);
   scheduler()->OnReceivedGuRetryDelay(delay1);
   EXPECT_EQ(delay1, GetRetryTimerDelay());
 
diff --git a/sync/engine/syncer_proto_util.cc b/sync/engine/syncer_proto_util.cc
index fe2a875..44ac321 100644
--- a/sync/engine/syncer_proto_util.cc
+++ b/sync/engine/syncer_proto_util.cc
@@ -420,9 +420,10 @@ SyncerError SyncerProtoUtil::PostClientToServerMessage(
     }
 
     if (command.has_sessions_commit_delay_seconds()) {
-      session->delegate()->OnReceivedSessionsCommitDelay(
-          base::TimeDelta::FromSeconds(
-              command.sessions_commit_delay_seconds()));
+      std::map<ModelType, base::TimeDelta> delay_map;
+      delay_map[SESSIONS] =
+          base::TimeDelta::FromSeconds(command.sessions_commit_delay_seconds());
+      session->delegate()->OnReceivedCustomNudgeDelays(delay_map);
     }
 
     if (command.has_client_invalidation_hint_buffer_size()) {
@@ -434,6 +435,22 @@ SyncerError SyncerProtoUtil::PostClientToServerMessage(
       session->delegate()->OnReceivedGuRetryDelay(
           base::TimeDelta::FromSeconds(command.gu_retry_delay_seconds()));
     }
+
+    if (command.custom_nudge_delays_size() > 0) {
+      // Note that because this happens after the sessions_commit_delay_seconds
+      // handling, any SESSIONS value in this map will override the one in
+      // sessions_commit_delay_seconds.
+      std::map<ModelType, base::TimeDelta> delay_map;
+      for (int i = 0; i < command.custom_nudge_delays_size(); ++i) {
+        ModelType type = GetModelTypeFromSpecificsFieldNumber(
+            command.custom_nudge_delays(i).datatype_id());
+        if (ProtocolTypes().Has(type)) {
+          delay_map[type] = base::TimeDelta::FromMilliseconds(
+              command.custom_nudge_delays(i).delay_ms());
+        }
+      }
+      session->delegate()->OnReceivedCustomNudgeDelays(delay_map);
+    }
   }
 
   // Now do any special handling for the error type and decide on the return
diff --git a/sync/engine/syncer_unittest.cc b/sync/engine/syncer_unittest.cc
index ccfc014..77bc288 100644
--- a/sync/engine/syncer_unittest.cc
+++ b/sync/engine/syncer_unittest.cc
@@ -212,9 +212,15 @@ class SyncerTest : public testing::Test,
       const base::TimeDelta& new_interval) OVERRIDE {
     last_short_poll_interval_received_ = new_interval;
   }
-  virtual void OnReceivedSessionsCommitDelay(
-      const base::TimeDelta& new_delay) OVERRIDE {
-    last_sessions_commit_delay_seconds_ = new_delay;
+  virtual void OnReceivedCustomNudgeDelays(
+      const std::map<ModelType, base::TimeDelta>& delay_map) OVERRIDE {
+    std::map<ModelType, base::TimeDelta>::const_iterator iter =
+        delay_map.find(SESSIONS);
+    if (iter != delay_map.end() && iter->second > base::TimeDelta())
+      last_sessions_commit_delay_ = iter->second;
+    iter = delay_map.find(BOOKMARKS);
+    if (iter != delay_map.end() && iter->second > base::TimeDelta())
+      last_bookmarks_commit_delay_ = iter->second;
   }
   virtual void OnReceivedClientInvalidationHintBufferSize(
       int size) OVERRIDE {
@@ -592,7 +598,8 @@ class SyncerTest : public testing::Test,
   bool saw_syncer_event_;
   base::TimeDelta last_short_poll_interval_received_;
   base::TimeDelta last_long_poll_interval_received_;
-  base::TimeDelta last_sessions_commit_delay_seconds_;
+  base::TimeDelta last_sessions_commit_delay_;
+  base::TimeDelta last_bookmarks_commit_delay_;
   int last_client_invalidation_hint_buffer_size_;
   std::vector<scoped_refptr<ModelSafeWorker> > workers_;
 
@@ -3606,36 +3613,41 @@ TEST_F(SyncerTest, TestClientCommandDuringUpdate) {
   command->set_set_sync_poll_interval(8);
   command->set_set_sync_long_poll_interval(800);
   command->set_sessions_commit_delay_seconds(3141);
+  sync_pb::CustomNudgeDelay* bookmark_delay =
+      command->add_custom_nudge_delays();
+  bookmark_delay->set_datatype_id(
+      GetSpecificsFieldNumberFromModelType(BOOKMARKS));
+  bookmark_delay->set_delay_ms(950);
   command->set_client_invalidation_hint_buffer_size(11);
   mock_server_->AddUpdateDirectory(1, 0, "in_root", 1, 1,
                                    foreign_cache_guid(), "-1");
   mock_server_->SetGUClientCommand(command);
   SyncShareNudge();
 
-  EXPECT_TRUE(TimeDelta::FromSeconds(8) ==
-              last_short_poll_interval_received_);
-  EXPECT_TRUE(TimeDelta::FromSeconds(800) ==
-              last_long_poll_interval_received_);
-  EXPECT_TRUE(TimeDelta::FromSeconds(3141) ==
-              last_sessions_commit_delay_seconds_);
+  EXPECT_EQ(TimeDelta::FromSeconds(8), last_short_poll_interval_received_);
+  EXPECT_EQ(TimeDelta::FromSeconds(800), last_long_poll_interval_received_);
+  EXPECT_EQ(TimeDelta::FromSeconds(3141), last_sessions_commit_delay_);
+  EXPECT_EQ(TimeDelta::FromMilliseconds(950), last_bookmarks_commit_delay_);
   EXPECT_EQ(11, last_client_invalidation_hint_buffer_size_);
 
   command = new ClientCommand();
   command->set_set_sync_poll_interval(180);
   command->set_set_sync_long_poll_interval(190);
   command->set_sessions_commit_delay_seconds(2718);
+  bookmark_delay = command->add_custom_nudge_delays();
+  bookmark_delay->set_datatype_id(
+      GetSpecificsFieldNumberFromModelType(BOOKMARKS));
+  bookmark_delay->set_delay_ms(1050);
   command->set_client_invalidation_hint_buffer_size(9);
-  mock_server_->AddUpdateDirectory(1, 0, "in_root", 1, 1,
-                                   foreign_cache_guid(), "-1");
+  mock_server_->AddUpdateDirectory(
+      1, 0, "in_root", 1, 1, foreign_cache_guid(), "-1");
   mock_server_->SetGUClientCommand(command);
   SyncShareNudge();
 
-  EXPECT_TRUE(TimeDelta::FromSeconds(180) ==
-              last_short_poll_interval_received_);
-  EXPECT_TRUE(TimeDelta::FromSeconds(190) ==
-              last_long_poll_interval_received_);
-  EXPECT_TRUE(TimeDelta::FromSeconds(2718) ==
-              last_sessions_commit_delay_seconds_);
+  EXPECT_EQ(TimeDelta::FromSeconds(180), last_short_poll_interval_received_);
+  EXPECT_EQ(TimeDelta::FromSeconds(190), last_long_poll_interval_received_);
+  EXPECT_EQ(TimeDelta::FromSeconds(2718), last_sessions_commit_delay_);
+  EXPECT_EQ(TimeDelta::FromMilliseconds(1050), last_bookmarks_commit_delay_);
   EXPECT_EQ(9, last_client_invalidation_hint_buffer_size_);
 }
 
@@ -3646,34 +3658,39 @@ TEST_F(SyncerTest, TestClientCommandDuringCommit) {
   command->set_set_sync_poll_interval(8);
   command->set_set_sync_long_poll_interval(800);
   command->set_sessions_commit_delay_seconds(3141);
+  sync_pb::CustomNudgeDelay* bookmark_delay =
+      command->add_custom_nudge_delays();
+  bookmark_delay->set_datatype_id(
+      GetSpecificsFieldNumberFromModelType(BOOKMARKS));
+  bookmark_delay->set_delay_ms(950);
   command->set_client_invalidation_hint_buffer_size(11);
   CreateUnsyncedDirectory("X", "id_X");
   mock_server_->SetCommitClientCommand(command);
   SyncShareNudge();
 
-  EXPECT_TRUE(TimeDelta::FromSeconds(8) ==
-              last_short_poll_interval_received_);
-  EXPECT_TRUE(TimeDelta::FromSeconds(800) ==
-              last_long_poll_interval_received_);
-  EXPECT_TRUE(TimeDelta::FromSeconds(3141) ==
-              last_sessions_commit_delay_seconds_);
+  EXPECT_EQ(TimeDelta::FromSeconds(8), last_short_poll_interval_received_);
+  EXPECT_EQ(TimeDelta::FromSeconds(800), last_long_poll_interval_received_);
+  EXPECT_EQ(TimeDelta::FromSeconds(3141), last_sessions_commit_delay_);
+  EXPECT_EQ(TimeDelta::FromMilliseconds(950), last_bookmarks_commit_delay_);
   EXPECT_EQ(11, last_client_invalidation_hint_buffer_size_);
 
   command = new ClientCommand();
   command->set_set_sync_poll_interval(180);
   command->set_set_sync_long_poll_interval(190);
   command->set_sessions_commit_delay_seconds(2718);
+  bookmark_delay = command->add_custom_nudge_delays();
+  bookmark_delay->set_datatype_id(
+      GetSpecificsFieldNumberFromModelType(BOOKMARKS));
+  bookmark_delay->set_delay_ms(1050);
   command->set_client_invalidation_hint_buffer_size(9);
   CreateUnsyncedDirectory("Y", "id_Y");
   mock_server_->SetCommitClientCommand(command);
   SyncShareNudge();
 
-  EXPECT_TRUE(TimeDelta::FromSeconds(180) ==
-              last_short_poll_interval_received_);
-  EXPECT_TRUE(TimeDelta::FromSeconds(190) ==
-              last_long_poll_interval_received_);
-  EXPECT_TRUE(TimeDelta::FromSeconds(2718) ==
-              last_sessions_commit_delay_seconds_);
+  EXPECT_EQ(TimeDelta::FromSeconds(180), last_short_poll_interval_received_);
+  EXPECT_EQ(TimeDelta::FromSeconds(190), last_long_poll_interval_received_);
+  EXPECT_EQ(TimeDelta::FromSeconds(2718), last_sessions_commit_delay_);
+  EXPECT_EQ(TimeDelta::FromMilliseconds(1050), last_bookmarks_commit_delay_);
   EXPECT_EQ(9, last_client_invalidation_hint_buffer_size_);
 }