sync: Process client commands on commit response

sync/sessions/sync_session.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/sessions/sync_session.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/logging.h"
@@ skipping 134 matching lines @@
   enabled_groups_ = ComputeEnabledGroups(routing_info_, workers_);
 }
 
 void SyncSession::PrepareForAnotherSyncCycle() {
   finished_ = false;
   source_.updates_source =
       sync_pb::GetUpdatesCallerInfo::SYNC_CYCLE_CONTINUATION;
   status_controller_.reset(new StatusController(routing_info_));
 }
 
+void SyncSession::ProcessClientCommand(const sync_pb::ClientCommand& command) {

[tim (not reviewing), 2012/09/11 20:08:55]

We have a few "do on every request/response" actions now, and we're handling
most (all?) of them in PostClientToServerMessage. For example,
PersistBagOfChips, delegate()->OnSyncProtocolError(), SetProtocolVersion... etc.
 Could you move this handling to that method?  Whether or not it is the final
resting place for these things, it'd be nice to keep them together at a single
choke point versus maintaining them scattered in each command. 

[rlarocque, 2012/09/11 20:28:55]

Done, sort of.

I moved the call to this function into PostClientToServerMessage.  I left the
definition here.  That was how I interpreted your comment on first reading.  

Did you also want to inline this code into that method?

+  if (command.has_max_commit_batch_size()) {
+    context()->set_max_commit_batch_size(command.max_commit_batch_size());
+  }
+  if (command.has_set_sync_long_poll_interval()) {
+    delegate()->OnReceivedLongPollIntervalUpdate(
+        base::TimeDelta::FromSeconds(command.set_sync_long_poll_interval()));
+  }
+  if (command.has_set_sync_poll_interval()) {
+    delegate()->OnReceivedShortPollIntervalUpdate(
+        base::TimeDelta::FromSeconds(command.set_sync_poll_interval()));
+  }
+  if (command.has_sessions_commit_delay_seconds()) {
+    delegate()->OnReceivedSessionsCommitDelay(
+        base::TimeDelta::FromSeconds(command.sessions_commit_delay_seconds()));
+  }
+}
+
 SyncSessionSnapshot SyncSession::TakeSnapshot() const {
   syncable::Directory* dir = context_->directory();
 
   bool is_share_useable = true;
   ModelTypeSet initial_sync_ended;
   ModelTypeStateMap download_progress_markers;
   for (int i = FIRST_REAL_MODEL_TYPE; i < MODEL_TYPE_COUNT; ++i) {
     ModelType type(ModelTypeFromInt(i));
     if (routing_info_.count(type) != 0) {
       if (dir->initial_sync_ended_for_type(type))
@@ skipping 102 matching lines @@
   // with the server. Therefore, we verify no errors and at least one SYNCER_OK.
   return reached_server && !HadErrors(state);
 }
 
 void SyncSession::SetFinished() {
   finished_ = true;
 }
 
 }  // namespace sessions
 }  // namespace syncer