[Sync] Add client-side plumbing for server control of sessions commit delay

chrome/browser/sync/engine/sync_scheduler.cc

 // Copyright (c) 2011 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 "chrome/browser/sync/engine/sync_scheduler.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/compiler_specific.h"
@@ skipping 117 matching lines @@
 // Helper macros to log with the syncer thread name; useful when there
 // are multiple syncer threads involved.
 
 #define SLOG(severity) LOG(severity) << name_ << ": "
 
 #define SVLOG(verbose_level) VLOG(verbose_level) << name_ << ": "
 
 #define SVLOG_LOC(from_here, verbose_level)             \
   VLOG_LOC(from_here, verbose_level) << name_ << ": "
 
+namespace {
+
+const int kDefaultSessionsCommitDelaySeconds = 10;

[tim (not reviewing), 2011/08/10 18:42:11]

I was hoping to keep consts like this in one place, but I stupidly named the
file "polling_constants.h".  

[akalin, 2011/08/10 20:10:36]

I think it's okay for now since it's temp code.  If we do a more general
solution we can do the constants properly.

+
+}  // namespace
+
 SyncScheduler::SyncScheduler(const std::string& name,
                              sessions::SyncSessionContext* context,
                              Syncer* syncer)
     : method_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       name_(name),
       sync_loop_(MessageLoop::current()),
       started_(false),
       syncer_short_poll_interval_seconds_(
           TimeDelta::FromSeconds(kDefaultShortPollIntervalSeconds)),
       syncer_long_poll_interval_seconds_(
           TimeDelta::FromSeconds(kDefaultLongPollIntervalSeconds)),
+      sessions_commit_delay_(
+          TimeDelta::FromSeconds(kDefaultSessionsCommitDelaySeconds)),
       mode_(NORMAL_MODE),
       server_connection_ok_(false),
       delay_provider_(new DelayProvider()),
       syncer_(syncer),
       session_context_(context) {
   DCHECK(sync_loop_);
 }
 
 SyncScheduler::~SyncScheduler() {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
@@ skipping 897 matching lines @@
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   syncer_short_poll_interval_seconds_ = new_interval;
 }
 
 void SyncScheduler::OnReceivedLongPollIntervalUpdate(
     const base::TimeDelta& new_interval) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   syncer_long_poll_interval_seconds_ = new_interval;
 }
 
+void SyncScheduler::OnReceivedSessionsCommitDelay(
+    const base::TimeDelta& new_delay) {
+  DCHECK_EQ(MessageLoop::current(), sync_loop_);
+  sessions_commit_delay_ = new_delay;
+}
+
 void SyncScheduler::OnShouldStopSyncingPermanently() {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   SVLOG(2) << "OnShouldStopSyncingPermanently";
   syncer_->RequestEarlyExit();  // Thread-safe.
   Notify(SyncEngineEvent::STOP_SYNCING_PERMANENTLY);
 }
 
 void SyncScheduler::OnServerConnectionEvent(
     const ServerConnectionEvent& event) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   PostTask(FROM_HERE, "CheckServerConnectionManagerStatus",
            method_factory_.NewRunnableMethod(
                &SyncScheduler::CheckServerConnectionManagerStatus,
                event.connection_code));
 }
 
 void SyncScheduler::set_notifications_enabled(bool notifications_enabled) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   session_context_->set_notifications_enabled(notifications_enabled);
 }
 
+base::TimeDelta SyncScheduler::GetSessionsCommitDelay() const {
+  return sessions_commit_delay_;

[tim (not reviewing), 2011/08/10 18:42:11]

The style guide would recommend calling this method sessions_commit_delay()

[akalin, 2011/08/10 20:10:36]

Done.

+}
+
 #undef SVLOG_LOC
 
 #undef SVLOG
 
 #undef SLOG
 
-#undef VLOG_LOC
-
-#undef VLOG_LOC_STREAM
-
 #undef ENUM_CASE
 
 }  // browser_sync