sync: Refactor per-datatype throttling

sync/engine/syncer_proto_util.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_proto_util.h"
 
 #include "base/format_macros.h"
 #include "base/stringprintf.h"
 #include "sync/engine/net/server_connection_manager.h"
 #include "sync/engine/syncer.h"
 #include "sync/engine/syncer_types.h"
+#include "sync/engine/throttled_data_type_tracker.h"
 #include "sync/engine/traffic_logger.h"
 #include "sync/internal_api/public/syncable/model_type.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/protocol/sync_enums.pb.h"
 #include "sync/protocol/sync_protocol_error.h"
 #include "sync/sessions/sync_session.h"
 #include "sync/syncable/syncable-inl.h"
 #include "sync/syncable/syncable.h"
 #include "sync/util/time.h"
 
@@ skipping 184 matching lines @@
       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,
+    ThrottledDataTypeTracker* tracker,
     sessions::SyncSession::Delegate* delegate) {
   DCHECK_EQ(error.error_type, browser_sync::THROTTLED);
   if (error.error_data_types.Empty()) {
     // No datatypes indicates the client should be completely throttled.
     delegate->OnSilencedUntil(throttled_until);
   } else {
-     context->SetUnthrottleTime(error.error_data_types, throttled_until);
+    tracker->SetUnthrottleTime(error.error_data_types, 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());
@@ skipping 152 matching lines @@
       LOG(WARNING) << "Sync protocol out-of-date. The server is using a more "
                    << "recent version.";
       return SERVER_RETURN_UNKNOWN_ERROR;
     case browser_sync::SYNC_SUCCESS:
       LogResponseProfilingData(*response);
       return SYNCER_OK;
     case browser_sync::THROTTLED:
       LOG(WARNING) << "Client silenced by server.";
       HandleThrottleError(sync_protocol_error,
                           base::TimeTicks::Now() + GetThrottleDelay(*response),
-                          session->context(),
+                          session->context()->throttled_data_type_tracker(),
                           session->delegate());
       return SERVER_RETURN_THROTTLED;
     case browser_sync::TRANSIENT_ERROR:
       return SERVER_RETURN_TRANSIENT_ERROR;
     case browser_sync::MIGRATION_DONE:
       HandleMigrationDoneResponse(response, session);
       return SERVER_RETURN_MIGRATION_DONE;
     case browser_sync::CLEAR_PENDING:
       return SERVER_RETURN_CLEAR_PENDING;
     case browser_sync::NOT_MY_BIRTHDAY:
@@ skipping 127 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