[Sync] Sync client should to exponential backoff when receive partial failure

components/sync/test/engine/mock_connection_manager.h

 // 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.
 
 #ifndef COMPONENTS_SYNC_TEST_ENGINE_MOCK_CONNECTION_MANAGER_H_
 #define COMPONENTS_SYNC_TEST_ENGINE_MOCK_CONNECTION_MANAGER_H_
 
 #include <stdint.h>
 
 #include <bitset>
@@ skipping 198 matching lines @@
     use_legacy_bookmarks_protocol_ = value;
   }
 
   void set_store_birthday(const std::string& new_birthday) {
     // Multiple threads can set store_birthday_ in our tests, need to lock it to
     // ensure atomic read/writes and avoid race conditions.
     base::AutoLock lock(store_birthday_lock_);
     store_birthday_ = new_birthday;
   }
 
-  void set_partial_throttling(bool value) { partialThrottling_ = value; }
+  void set_throttling(bool value) { throttling_ = value; }
+
+  void set_partial_failure(bool value) { partial_failure_ = value; }
 
   // Retrieve the number of GetUpdates requests that the mock server has
   // seen since the last time this function was called.  Can be used to
   // verify that a GetUpdates actually did or did not happen after running
   // the syncer.
   int GetAndClearNumGetUpdatesRequests() {
     int result = num_get_updates_requests_;
     num_get_updates_requests_ = 0;
     return result;
   }
 
   // Expect that GetUpdates will request exactly the types indicated in
   // the bitset.
   void ExpectGetUpdatesRequestTypes(ModelTypeSet expected_filter) {
     expected_filter_ = expected_filter;
   }
 
-  // Set throttled date types.
-  void SetThrottledTypes(ModelTypeSet types) { throttled_type_ = types; }
+  // Set partial failure date types.
+  void SetPartialFailureTypes(ModelTypeSet types) {
+    partial_failure_type_ = types;
+  }
 
   void SetServerReachable();
 
   void SetServerNotReachable();
 
   // Updates our internal state as if we had attempted a connection.  Does not
   // send notifications as a real connection attempt would.  This is useful in
   // cases where we're mocking out most of the code that performs network
   // requests.
   void UpdateConnectionStatus();
@@ skipping 119 matching lines @@
 
   // The AUTHENTICATE response we'll return for auth requests.
   sync_pb::AuthenticateResponse auth_response_;
   // What we use to determine if we should return SUCCESS or BAD_AUTH_TOKEN.
   std::string valid_auth_token_;
 
   // Whether we are faking a server mandating clients to throttle requests.
   // Protected by |response_code_override_lock_|.
   bool throttling_;
 
-  // Whether we are faking a server mandating clients to partial throttle
+  // Whether we are faking a server mandating clients to partial failure
   // requests.
   // Protected by |response_code_override_lock_|.
-  bool partialThrottling_;
+  bool partial_failure_;
 
   base::Lock response_code_override_lock_;
 
   // True if we are only accepting GetUpdatesCallerInfo::PERIODIC requests.
   bool fail_non_periodic_get_updates_;
 
   std::unique_ptr<sync_pb::ClientCommand> gu_client_command_;
   std::unique_ptr<sync_pb::ClientCommand> commit_client_command_;
 
   // The next value to use for the position_in_parent property.
   int64_t next_position_in_parent_;
 
   // The default is to use the newer sync_pb::BookmarkSpecifics-style protocol.
   // If this option is set to true, then the MockConnectionManager will
   // use the older sync_pb::SyncEntity_BookmarkData-style protocol.
   bool use_legacy_bookmarks_protocol_;
 
   ModelTypeSet expected_filter_;
 
-  ModelTypeSet throttled_type_;
+  ModelTypeSet partial_failure_type_;
 
   int num_get_updates_requests_;
 
   std::string next_token_;
 
   std::vector<sync_pb::ClientToServerMessage> requests_;
 
   DISALLOW_COPY_AND_ASSIGN(MockConnectionManager);
 };
 
 }  // namespace syncer
 
 #endif  // COMPONENTS_SYNC_TEST_ENGINE_MOCK_CONNECTION_MANAGER_H_