Make the throttle delay configurable by the server.

chrome/browser/sync/engine/syncer_proto_util.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/syncer_proto_util.h"
 
 #include "base/format_macros.h"
 #include "base/stringprintf.h"
 #include "chrome/browser/sync/engine/net/server_connection_manager.h"
 #include "chrome/browser/sync/engine/syncer.h"
 #include "chrome/browser/sync/engine/syncer_types.h"
 #include "chrome/browser/sync/engine/syncer_util.h"
 #include "chrome/browser/sync/protocol/service_constants.h"
+#include "chrome/browser/sync/protocol/sync.pb.h"
 #include "chrome/browser/sync/sessions/sync_session.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/browser/sync/syncable/model_type.h"
 #include "chrome/browser/sync/syncable/syncable-inl.h"
 #include "chrome/browser/sync/syncable/syncable.h"
 
 using std::string;
 using std::stringstream;
 using syncable::BASE_VERSION;
 using syncable::CTIME;
@@ skipping 151 matching lines @@
         http_response.server_status = HttpResponse::SYNC_AUTH_ERROR;
         return false;
       default:
         return true;
     }
   }
 
   return false;
 }
 
+base::TimeDelta SyncerProtoUtil::GetThrottleDelay(
+    const sync_pb::ClientToServerResponse& response) {
+  if (!response.has_client_command())
+    return base::TimeDelta::FromSeconds(kSyncDelayAfterThrottled);
+  const sync_pb::ClientCommand& command = response.client_command();
+  if (command.has_throttle_delay_seconds())
+    return base::TimeDelta::FromSeconds(command.throttle_delay_seconds());
+  else
+    return base::TimeDelta::FromSeconds(kSyncDelayAfterThrottled);

[akalin, 2011/08/10 19:48:14]

i don't like repeating the constant twice.  How about using:

base::TimeDelta throttle_delay =
    base::TimeDelta::FromSeconds(kSyncDelayAfterThrottled);
if (response.has_client_command()) {
  const ...;
  if (command.has_throttle_delay_seconds()) {
    throttle_delay = base...;
  }
}
return throttle_delay;

or

base::TimeDelta default_throttle_delay =
    base::TimeDelta::FromSeconds(kSyncDelayAfterThrottled);
if (!response.has_client_command()) {
  return default_throttle_delay;
}
const ...;
if (!command.has_throttle_delay_seconds()) {
  return default_throttle_delay;
}
return FromSeconds(command.throttle_delay_seconds());

[lipalani1, 2011/08/10 20:38:58]

Done.

+}
+
 namespace {
 
 // Helper function for an assertion in PostClientToServerMessage.
 bool IsVeryFirstGetUpdates(const ClientToServerMessage& message) {
   if (!message.has_get_updates())
     return false;
   DCHECK_LT(0, message.get_updates().from_progress_marker_size());
   for (int i = 0; i < message.get_updates().from_progress_marker_size(); ++i) {
     if (!message.get_updates().from_progress_marker(i).token().empty())
       return false;
@@ skipping 34 matching lines @@
     case ClientToServerResponse::UNKNOWN:
       LOG(WARNING) << "Sync protocol out-of-date. The server is using a more "
                    << "recent version.";
       return false;
     case ClientToServerResponse::SUCCESS:
       LogResponseProfilingData(*response);
       return true;
     case ClientToServerResponse::THROTTLED:
       LOG(WARNING) << "Client silenced by server.";
       session->delegate()->OnSilencedUntil(base::TimeTicks::Now() +
-          base::TimeDelta::FromSeconds(kSyncDelayAfterThrottled));
+          GetThrottleDelay(*response));
       return false;
     case ClientToServerResponse::TRANSIENT_ERROR:
       return false;
     case ClientToServerResponse::MIGRATION_DONE:
       HandleMigrationDoneResponse(response, session);
       return false;
     case ClientToServerResponse::USER_NOT_ACTIVATED:
     case ClientToServerResponse::AUTH_INVALID:
     case ClientToServerResponse::ACCESS_DENIED:
       // WARNING: PostAndProcessHeaders contains a hack for this case.
@@ skipping 125 matching lines @@
 std::string SyncerProtoUtil::ClientToServerResponseDebugString(
     const sync_pb::ClientToServerResponse& response) {
   // Add more handlers as needed.
   std::string output;
   if (response.has_get_updates())
     output.append(GetUpdatesResponseString(response.get_updates()));
   return output;
 }
 
 }  // namespace browser_sync