Abort sync cycles when download step fails

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.
 //
 // Mock ServerConnectionManager class for use in client unit tests.
 
 #ifndef SYNC_TEST_ENGINE_MOCK_CONNECTION_MANAGER_H_
 #define SYNC_TEST_ENGINE_MOCK_CONNECTION_MANAGER_H_
 #pragma once
 
@@ skipping 99 matching lines @@
                                      const std::string& entry_id);
   void SetLastUpdatePosition(int64 position_in_parent);
   void SetNewTimestamp(int ts);
   void SetChangesRemaining(int64 count);
 
   // Add a new batch of updates after the current one.  Allows multiple
   // GetUpdates responses to be buffered up, since the syncer may
   // issue multiple requests during a sync cycle.
   void NextUpdateBatch();
 
-  void FailNextPostBufferToPathCall() { fail_next_postbuffer_ = true; }
+  void FailNextPostBufferToPathCall() { countdown_to_postbuffer_fail_ = 1; }
+  void FailNthPostBufferToPathCall(int n) { countdown_to_postbuffer_fail_ = n; }
 
   void SetClearUserDataResponseStatus(sync_pb::SyncEnums::ErrorType errortype);
 
-  // A visitor class to allow a test to change some monitoring state atomically
-  // with the action of overriding the response codes sent back to the Syncer
-  // (for example, so you can say "ThrottleNextRequest, and assert no more
-  // requests are made once throttling is in effect" in one step.
-  class ResponseCodeOverrideRequestor {
-   public:
-    // Called with response_code_override_lock_ acquired.
-    virtual void OnOverrideComplete() = 0;
-
-   protected:
-    virtual ~ResponseCodeOverrideRequestor() {}
-  };
-  void ThrottleNextRequest(ResponseCodeOverrideRequestor* visitor);
-  void FailWithAuthInvalid(ResponseCodeOverrideRequestor* visitor);
-  void StopFailingWithAuthInvalid(ResponseCodeOverrideRequestor* visitor);
   void FailNonPeriodicGetUpdates() { fail_non_periodic_get_updates_ = true; }
 
   // Simple inspectors.
   bool client_stuck() const { return client_stuck_; }
 
   sync_pb::ClientCommand* GetNextClientCommand();
 
   const std::vector<syncable::Id>& committed_ids() const {
     return committed_ids_;
   }
@@ skipping 66 matching lines @@
   // cases where we're mocking out most of the code that performs network
   // requests.
   void UpdateConnectionStatus();
 
   // Return by copy to be thread-safe.
   const std::string store_birthday() {
     base::AutoLock lock(store_birthday_lock_);
     return store_birthday_;
   }
 
+  // Explicitly indicate that we will not be fetching some updates.
+  void ClearUpdatesQueue() {
+    update_queue_.clear();
+  }
+
   // Locate the most recent update message for purpose of alteration.
   sync_pb::SyncEntity* GetMutableLastUpdate();
 
  private:
   sync_pb::SyncEntity* AddUpdateFull(syncable::Id id, syncable::Id parentid,
                                      std::string name, int64 version,
                                      int64 sync_ts,
                                      bool is_dir);
   sync_pb::SyncEntity* AddUpdateFull(std::string id,
                                      std::string parentid, std::string name,
@@ skipping 57 matching lines @@
   // The next id the mock will return to a commit.
   int next_new_id_;
 
   // The store birthday we send to the client.
   std::string store_birthday_;
   base::Lock store_birthday_lock_;
   bool store_birthday_sent_;
   bool client_stuck_;
   std::string commit_time_rename_prepended_string_;
 
-  // Fail on the next call to PostBufferToPath().
-  bool fail_next_postbuffer_;
+  // On each PostBufferToPath() call, we decrement this counter.  The call fails
+  // iff we hit zero at that call.
+  int countdown_to_postbuffer_fail_;
 
   // Our directory.  Used only to ensure that we are not holding the transaction
   // lock when performing network I/O.  Can be NULL if the test author is
   // confident this can't happen.
   syncable::Directory* directory_;
 
   // The updates we'll return to the next request.
   std::list<sync_pb::GetUpdatesResponse> update_queue_;
   base::Closure mid_commit_callback_;
   MidCommitObserver* mid_commit_observer_;
@@ skipping 37 matching lines @@
   int num_get_updates_requests_;
 
   std::string next_token_;
 
   sync_pb::ClientToServerMessage last_request_;
 
   DISALLOW_COPY_AND_ASSIGN(MockConnectionManager);
 };
 
 #endif  // SYNC_TEST_ENGINE_MOCK_CONNECTION_MANAGER_H_