[Sync] Parse and save per-data type throttle data

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"
@@ skipping 169 matching lines @@
   if (response.has_client_command()) {
     const sync_pb::ClientCommand& command = response.client_command();
     if (command.has_throttle_delay_seconds()) {
       throttle_delay =
           base::TimeDelta::FromSeconds(command.throttle_delay_seconds());
     }
   }
   return throttle_delay;
 }
 
+void SyncerProtoUtil::HandleThrottleError(
+    const SyncProtocolError& error,
+    const base::TimeTicks& throttled_until,
+    sessions::SyncSessionContext* context,
+    sessions::SyncSession::Delegate* delegate) {
+  DCHECK_EQ(error.error_type, browser_sync::THROTTLED);
+  if (error.error_data_types.size() > 0) {
+     context->SetUnthrottleTime(error.error_data_types, throttled_until);
+  } else {
+    // No datatypes indicates the client should be completely throttled.
+    delegate->OnSilencedUntil(throttled_until);
+  }
+}
+
 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 51 matching lines @@
 
 browser_sync::SyncProtocolError ConvertErrorPBToLocalType(
     const sync_pb::ClientToServerResponse::Error& error) {
   browser_sync::SyncProtocolError sync_protocol_error;
   sync_protocol_error.error_type = ConvertSyncProtocolErrorTypePBToLocalType(
       error.error_type());
   sync_protocol_error.error_description = error.error_description();
   sync_protocol_error.url = error.url();
   sync_protocol_error.action = ConvertClientActionPBToLocalClientAction(
       error.action());
+
+  if (error.error_data_type_ids_size() > 0) {
+    // THROTTLED is currently the only error code that uses |error_data_types|.
+    DCHECK_EQ(error.error_type(), ClientToServerResponse::THROTTLED);
+    for (int i = 0; i < error.error_data_type_ids_size(); ++i) {
+      sync_protocol_error.error_data_types.insert(
+          syncable::GetModelTypeFromExtensionFieldNumber(
+              error.error_data_type_ids(i)));
+    }
+  }
+
   return sync_protocol_error;
 }
 
 // TODO(lipalani) : Rename these function names as per the CR for issue 7740067.
 browser_sync::SyncProtocolError ConvertLegacyErrorCodeToNewError(
     const sync_pb::ClientToServerResponse::ErrorType& error_type) {
   browser_sync::SyncProtocolError error;
   error.error_type = ConvertSyncProtocolErrorTypePBToLocalType(error_type);
   if (error_type == ClientToServerResponse::CLEAR_PENDING ||
       error_type == ClientToServerResponse::NOT_MY_BIRTHDAY) {
@@ skipping 53 matching lines @@
   switch (sync_protocol_error.error_type) {
     case browser_sync::UNKNOWN_ERROR:
       LOG(WARNING) << "Sync protocol out-of-date. The server is using a more "
                    << "recent version.";
       return false;
     case browser_sync::SYNC_SUCCESS:
       LogResponseProfilingData(*response);
       return true;
     case browser_sync::THROTTLED:
       LOG(WARNING) << "Client silenced by server.";
-      session->delegate()->OnSilencedUntil(base::TimeTicks::Now() +
-          GetThrottleDelay(*response));
+      HandleThrottleError(sync_protocol_error,
+                          base::TimeTicks::Now() + GetThrottleDelay(*response),
+                          session->context(),
+                          session->delegate());
       return false;
     case browser_sync::TRANSIENT_ERROR:
       return false;
     case browser_sync::MIGRATION_DONE:
       HandleMigrationDoneResponse(response, session);
       return false;
     case browser_sync::CLEAR_PENDING:
     case browser_sync::NOT_MY_BIRTHDAY:
       return false;
     default:
@@ 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