Simulate transient error and verify exponential backoff.

chrome/browser/sync/profile_sync_service_harness.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/profile_sync_service_harness.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <iterator>
 #include <ostream>
@@ skipping 10 matching lines @@
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/sessions/session_state.h"
 #include "chrome/browser/sync/signin_manager.h"
 #include "chrome/browser/sync/sync_ui_util.h"
 
 using browser_sync::sessions::SyncSessionSnapshot;
 
 // The amount of time for which we wait for a live sync operation to complete.
 static const int kLiveSyncOperationTimeoutMs = 45000;
 
+// The amount of time we wait for testcases that verify exponential backoff.
+static const int kExponentialBackoffVerificationTimeoutMs = 60000;
+
 // Simple class to implement a timeout using PostDelayedTask.  If it is not
 // aborted before picked up by a message queue, then it asserts with the message
 // provided.  This class is not thread safe.
 class StateChangeTimeoutEvent
     : public base::RefCountedThreadSafe<StateChangeTimeoutEvent> {
  public:
   StateChangeTimeoutEvent(ProfileSyncServiceHarness* caller,
                           const std::string& message);
 
   // The entry point to the class from PostDelayedTask.
@@ skipping 270 matching lines @@
       }
       break;
     }
     case WAITING_FOR_SYNC_DISABLED: {
       VLOG(1) << GetClientInfoString("WAITING_FOR_SYNC_DISABLED");
       if (service()->HasSyncSetupCompleted() == false) {
         // Sync has been disabled.
         SignalStateCompleteWithNextState(SYNC_DISABLED);
       }
     }
+    case WAITING_FOR_EXPONENTIAL_BACKOFF_VERIFICATION: {
+      if (retry_verifier_.VerifyRetryInterval(*GetLastSessionSnapshot())
+          == false) {
+        SignalStateCompleteWithNextState(
+            EXPONENTIAL_BACKOFF_VERIFICATION_FAILED);
+      } else {
+        // We only verify the first 5 retries.
+        if (retry_verifier_.RetryCount() >= 5) {
+          SignalStateCompleteWithNextState(
+              EXPONENTIAL_BACKOFF_VERIFICATION_SUCEEDED);
+        }
+      }
+    }
+    break;
     case SERVER_UNREACHABLE: {
       VLOG(1) << GetClientInfoString("SERVER_UNREACHABLE");
       if (GetStatus().server_reachable) {
         // The client was offline due to the network being disabled, but is now
         // back online. Wait for the pending sync cycle to complete.
         SignalStateCompleteWithNextState(WAITING_FOR_SYNC_TO_FINISH);
       }
       break;
     }
     case SET_PASSPHRASE_FAILED: {
@@ skipping 134 matching lines @@
   DCHECK(wait_state_ != SYNC_DISABLED);
   wait_state_ = WAITING_FOR_SYNC_DISABLED;
   AwaitStatusChangeWithTimeout(kLiveSyncOperationTimeoutMs, reason);
   if (wait_state_ == SYNC_DISABLED) {
     return true;
   } else {
     return false;
   }
 }
 
+bool ProfileSyncServiceHarness::AwaitExponentialBackoffVerification() {
+  retry_verifier_.Initialize(*GetLastSessionSnapshot());
+  wait_state_ = WAITING_FOR_EXPONENTIAL_BACKOFF_VERIFICATION;
+  AwaitStatusChangeWithTimeout(kExponentialBackoffVerificationTimeoutMs,
+      "Verify Exponential backoff");
+  return (wait_state_ == EXPONENTIAL_BACKOFF_VERIFICATION_SUCEEDED);
+}
+
 bool ProfileSyncServiceHarness::AwaitMutualSyncCycleCompletion(
     ProfileSyncServiceHarness* partner) {
   VLOG(1) << GetClientInfoString("AwaitMutualSyncCycleCompletion");
   if (!AwaitSyncCycleCompletion("Sync cycle completion on active client."))
     return false;
   return partner->WaitUntilTimestampMatches(this,
       "Sync cycle completion on passive client.");
 }
 
 bool ProfileSyncServiceHarness::AwaitGroupSyncCycleCompletion(
@@ skipping 342 matching lines @@
   return true;
 }
 
 std::string ProfileSyncServiceHarness::GetServiceStatus() {
   DictionaryValue value;
   sync_ui_util::ConstructAboutInformation(service_, &value);
   std::string service_status;
   base::JSONWriter::Write(&value, true, &service_status);
   return service_status;
 }