sync: Process client commands on commit response

sync/engine/syncer.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/engine/syncer.h"
 
 #include "base/debug/trace_event.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 36 matching lines @@
 using syncable::SERVER_POSITION_IN_PARENT;
 using syncable::SERVER_SPECIFICS;
 using syncable::SERVER_VERSION;
 
 #define ENUM_CASE(x) case x: return #x
 const char* SyncerStepToString(const SyncerStep step)
 {
   switch (step) {
     ENUM_CASE(SYNCER_BEGIN);
     ENUM_CASE(DOWNLOAD_UPDATES);
-    ENUM_CASE(PROCESS_CLIENT_COMMAND);
     ENUM_CASE(VERIFY_UPDATES);
     ENUM_CASE(PROCESS_UPDATES);
     ENUM_CASE(STORE_TIMESTAMPS);
     ENUM_CASE(APPLY_UPDATES);
     ENUM_CASE(COMMIT);
     ENUM_CASE(RESOLVE_CONFLICTS);
     ENUM_CASE(APPLY_UPDATES_TO_RESOLVE_CONFLICTS);
     ENUM_CASE(SYNCER_END);
   }
   NOTREACHED();
@@ skipping 43 matching lines @@
         // TODO(akalin): We may want to propagate this switch up
         // eventually.
 #if defined(OS_ANDROID)
         const bool kCreateMobileBookmarksFolder = true;
 #else
         const bool kCreateMobileBookmarksFolder = false;
 #endif
         DownloadUpdatesCommand download_updates(kCreateMobileBookmarksFolder);
         session->mutable_status_controller()->set_last_download_updates_result(
             download_updates.Execute(session));
-        next_step = PROCESS_CLIENT_COMMAND;
-        break;
-      }
-      case PROCESS_CLIENT_COMMAND: {
-        ProcessClientCommand(session);
         next_step = VERIFY_UPDATES;
         break;
       }
       case VERIFY_UPDATES: {
         VerifyUpdatesCommand verify_updates;
         verify_updates.Execute(session);
         next_step = PROCESS_UPDATES;
         break;
       }
       case PROCESS_UPDATES: {
@@ skipping 95 matching lines @@
              << "next step: " << SyncerStepToString(next_step) << ", "
              << "snapshot: " << session->TakeSnapshot().ToString();
     if (last_step == current_step) {
       session->SetFinished();
       break;
     }
     current_step = next_step;
   }
 }
 
-void Syncer::ProcessClientCommand(sessions::SyncSession* session) {
-  const sync_pb::ClientToServerResponse& response =
-      session->status_controller().updates_response();
-  if (!response.has_client_command())
-    return;
-  const ClientCommand& command = response.client_command();
-
-  // The server limits the number of items a client can commit in one batch.
-  if (command.has_max_commit_batch_size()) {
-    session->context()->set_max_commit_batch_size(
-        command.max_commit_batch_size());
-  }
-  if (command.has_set_sync_long_poll_interval()) {
-    session->delegate()->OnReceivedLongPollIntervalUpdate(
-        TimeDelta::FromSeconds(command.set_sync_long_poll_interval()));
-  }
-  if (command.has_set_sync_poll_interval()) {
-    session->delegate()->OnReceivedShortPollIntervalUpdate(
-        TimeDelta::FromSeconds(command.set_sync_poll_interval()));
-  }
-
-  if (command.has_sessions_commit_delay_seconds()) {
-    session->delegate()->OnReceivedSessionsCommitDelay(
-        TimeDelta::FromSeconds(command.sessions_commit_delay_seconds()));
-  }
-}
-
 void CopyServerFields(syncable::Entry* src, syncable::MutableEntry* dest) {
   dest->Put(SERVER_NON_UNIQUE_NAME, src->Get(SERVER_NON_UNIQUE_NAME));
   dest->Put(SERVER_PARENT_ID, src->Get(SERVER_PARENT_ID));
   dest->Put(SERVER_MTIME, src->Get(SERVER_MTIME));
   dest->Put(SERVER_CTIME, src->Get(SERVER_CTIME));
   dest->Put(SERVER_VERSION, src->Get(SERVER_VERSION));
   dest->Put(SERVER_IS_DIR, src->Get(SERVER_IS_DIR));
   dest->Put(SERVER_IS_DEL, src->Get(SERVER_IS_DEL));
   dest->Put(IS_UNAPPLIED_UPDATE, src->Get(IS_UNAPPLIED_UPDATE));
   dest->Put(SERVER_SPECIFICS, src->Get(SERVER_SPECIFICS));
   dest->Put(SERVER_POSITION_IN_PARENT, src->Get(SERVER_POSITION_IN_PARENT));
 }
 
 void ClearServerData(syncable::MutableEntry* entry) {
   entry->Put(SERVER_NON_UNIQUE_NAME, "");
   entry->Put(SERVER_PARENT_ID, syncable::GetNullId());
   entry->Put(SERVER_MTIME, Time());
   entry->Put(SERVER_CTIME, Time());
   entry->Put(SERVER_VERSION, 0);
   entry->Put(SERVER_IS_DIR, false);
   entry->Put(SERVER_IS_DEL, false);
   entry->Put(IS_UNAPPLIED_UPDATE, false);
   entry->Put(SERVER_SPECIFICS, sync_pb::EntitySpecifics::default_instance());
   entry->Put(SERVER_POSITION_IN_PARENT, 0);
 }
 
 }  // namespace syncer