test cases for server directed error handling code.

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 345 matching lines @@
       }
       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())
+      if (retry_verifier_.done()) {
+        // Retry verifier is done verifying exponential backoff.
         SignalStateCompleteWithNextState(WAITING_FOR_NOTHING);
+      }
       break;
     }
     case WAITING_FOR_MIGRATION_TO_START: {
       VLOG(1) << GetClientInfoString("WAITING_FOR_MIGRATION_TO_START");
       if (HasPendingBackendMigration()) {
+        // There are pending migrations. Wait for them.
         SignalStateCompleteWithNextState(WAITING_FOR_MIGRATION_TO_FINISH);
       }
       break;
     }
     case WAITING_FOR_MIGRATION_TO_FINISH: {
       VLOG(1) << GetClientInfoString("WAITING_FOR_MIGRATION_TO_FINISH");
       if (!HasPendingBackendMigration()) {
+        // Done migrating.
         SignalStateCompleteWithNextState(WAITING_FOR_NOTHING);
       }
       break;
+    }
+    case WAITING_FOR_ACTIONABLE_ERROR: {
+      VLOG(1) << GetClientInfoString("WAITING_FOR_ACTIONABLE_ERROR");
+      ProfileSyncService::Status status = GetStatus();
+      if (status.sync_protocol_error.action != browser_sync::UNKNOWN_ACTION &&
+          service_->unrecoverable_error_detected() == true) {
+        // An actionable error has been detected.
+        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;
     }
@@ skipping 182 matching lines @@
   const browser_sync::sessions::SyncSessionSnapshot *snap =
       GetLastSessionSnapshot();
   CHECK(snap);
   retry_verifier_.Initialize(*snap);
   wait_state_ = WAITING_FOR_EXPONENTIAL_BACKOFF_VERIFICATION;
   AwaitStatusChangeWithTimeout(kExponentialBackoffVerificationTimeoutMs,
       "Verify Exponential backoff");
   return (retry_verifier_.Succeeded());
 }
 
+bool ProfileSyncServiceHarness::AwaitActionableError() {
+  ProfileSyncService::Status status = GetStatus();
+  CHECK(status.sync_protocol_error.action == browser_sync::UNKNOWN_ACTION);
+  wait_state_ = WAITING_FOR_ACTIONABLE_ERROR;
+  AwaitStatusChangeWithTimeout(kLiveSyncOperationTimeoutMs,
+      "Waiting for actionable error");
+  status = GetStatus();
+  return (status.sync_protocol_error.action != browser_sync::UNKNOWN_ACTION &&
+          service_->unrecoverable_error_detected());
+}
+
 bool ProfileSyncServiceHarness::AwaitMigration(
     const syncable::ModelTypeSet& expected_migrated_types) {
   VLOG(1) << GetClientInfoString("AwaitMigration");
   VLOG(1) << profile_debug_name_ << ": waiting until migration is done for "
           << syncable::ModelTypeSetToString(expected_migrated_types);
   while (true) {
     bool migration_finished =
         std::includes(migrated_types_.begin(), migrated_types_.end(),
                       expected_migrated_types.begin(),
                       expected_migrated_types.end());
@@ skipping 447 matching lines @@
   return (synced_types.count(type) != 0);
 }
 
 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;
 }