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>
 #include <set>
 #include <sstream>
 #include <vector>
 
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/task.h"
 #include "base/tracked.h"
 #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;
 
+// TODO(rsimha): Remove the following lines once crbug.com/91863 is fixed.
 // 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 test cases 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 279 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);
       }
       break;
     }
+    case WAITING_FOR_EXPONENTIAL_BACKOFF_VERIFICATION: {
+      VLOG(1) << GetClientInfoString(
+                     "WAITING_FOR_EXPONENTIAL_BACKOFF_VERIFICATION");
+      const browser_sync::sessions::SyncSessionSnapshot *snap =
+          GetLastSessionSnapshot();
+      CHECK(snap);
+      retry_verifier_.VerifyRetryInterval(*snap);
+      if (retry_verifier_.Done())
+         SignalStateCompleteWithNextState(WAITING_FOR_NOTHING);
+      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: {
       // A passphrase is required for decryption. There is nothing the sync
       // client can do until SetPassphrase() is called.
       VLOG(1) << GetClientInfoString("SET_PASSPHRASE_FAILED");
       break;
     }
     case FULLY_SYNCED: {
       // The client is online and fully synced. There is nothing to do.
       VLOG(1) << GetClientInfoString("FULLY_SYNCED");
       break;
     }
     case SYNC_DISABLED: {
       // Syncing is disabled for the client. There is nothing to do.
       VLOG(1) << GetClientInfoString("SYNC_DISABLED");
       break;
     }
+    case WAITING_FOR_NOTHING: {
+      // We don't care about the state of the syncer for the rest of the test
+      // case.
+      VLOG(1) << GetClientInfoString("WAIT_FOR_NOTHING");

[Raghu Simha, 2011/08/05 23:23:58]

s/WAIT_FOR_NOTHING/WAITING_FOR_NOTHING/

[lipalani1, 2011/08/09 01:39:02]

Done.

+      break;
+    }
     default:
       // Invalid state during observer callback which may be triggered by other
       // classes using the the UI message loop.  Defer to their handling.
       break;
   }
   return original_wait_state != wait_state_;
 }
 
 void ProfileSyncServiceHarness::OnStateChanged() {
   RunStateChangeMachine();
@@ skipping 105 matching lines @@
 }
 
 bool ProfileSyncServiceHarness::AwaitSyncDisabled(const std::string& reason) {
   DCHECK(service()->HasSyncSetupCompleted());
   DCHECK_NE(wait_state_, SYNC_DISABLED);
   wait_state_ = WAITING_FOR_SYNC_DISABLED;
   AwaitStatusChangeWithTimeout(kLiveSyncOperationTimeoutMs, reason);
   return wait_state_ == SYNC_DISABLED;
 }
 
+bool ProfileSyncServiceHarness::AwaitExponentialBackoffVerification() {
+  retry_verifier_.Initialize(*GetLastSessionSnapshot());
+  wait_state_ = WAITING_FOR_EXPONENTIAL_BACKOFF_VERIFICATION;
+  AwaitStatusChangeWithTimeout(kExponentialBackoffVerificationTimeoutMs,
+      "Verify Exponential backoff");
+  return (retry_verifier_.Success());
+}
+
 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;
 }