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; }

[rlarocque, 2012/04/06 20:35:09]

At this point, it probably makes sense to start thinking about using gmock here.
 However, I'd rather just get my current CL done for now and we can revisit the
entire class in a later CL.

+  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.
@@ skipping 84 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_