Delete lots of sync ServerConnectionManager code

chrome/browser/sync/profile_sync_service_harness.cc

 // 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.
 
 #include "chrome/browser/sync/profile_sync_service_harness.h"
 
 #include <cstddef>
 #include <iterator>
 #include <ostream>
 #include <set>
@@ skipping 261 matching lines @@
         SignalStateCompleteWithNextState(FULLY_SYNCED);
         break;
       }
       if (service()->passphrase_required_reason() ==
               sync_api::REASON_SET_PASSPHRASE_FAILED) {
         // A passphrase is required for decryption and we don't have it. Do not
         // wait any more.
         SignalStateCompleteWithNextState(SET_PASSPHRASE_FAILED);
         break;
       }
-      if (!GetStatus().server_reachable) {
-        // The client cannot reach the sync server because the network is
-        // disabled. There is no need to wait anymore.
-        SignalStateCompleteWithNextState(SERVER_UNREACHABLE);
-        break;
-      }
       break;
     }
     case WAITING_FOR_DATA_SYNC: {
       if (IsDataSynced()) {
         SignalStateCompleteWithNextState(FULLY_SYNCED);
         break;
       }
       break;
     }
     case WAITING_FOR_UPDATES: {
@@ skipping 32 matching lines @@
       // The correctness of this if condition may depend on the ordering of its
       // sub-expressions.  See crbug.com/98607, crbug.com/95619.
       // TODO(rlarocque): Figure out a less brittle way of detecting this.
       if (IsTypeEncrypted(waiting_for_encryption_type_) &&
           IsFullySynced() &&
           GetLastSessionSnapshot()->num_conflicting_updates == 0) {
         // Encryption is now complete for the the type in which we were waiting.
         SignalStateCompleteWithNextState(FULLY_SYNCED);
         break;
       }
-      if (!GetStatus().server_reachable) {
-        // The client cannot reach the sync server because the network is
-        // disabled. There is no need to wait anymore.
-        SignalStateCompleteWithNextState(SERVER_UNREACHABLE);
-        break;
-      }
       break;
     }
     case WAITING_FOR_SYNC_CONFIGURATION: {
       DVLOG(1) << GetClientInfoString("WAITING_FOR_SYNC_CONFIGURATION");
       if (service()->ShouldPushChanges()) {
         // The Datatype manager is configured and sync is fully initialized.
         SignalStateCompleteWithNextState(FULLY_SYNCED);
       }
       break;
     }
@@ skipping 37 matching lines @@
     case WAITING_FOR_ACTIONABLE_ERROR: {
       DVLOG(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: {
-      DVLOG(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_FULL_SYNC);
-      }
-      break;
-    }
     case SET_PASSPHRASE_FAILED: {
       // A passphrase is required for decryption. There is nothing the sync
       // client can do until SetPassphrase() is called.
       DVLOG(1) << GetClientInfoString("SET_PASSPHRASE_FAILED");
       break;
     }
     case FULLY_SYNCED: {
       // The client is online and fully synced. There is nothing to do.
       DVLOG(1) << GetClientInfoString("FULLY_SYNCED");
       break;
@@ skipping 110 matching lines @@
   return AwaitStatusChangeWithTimeout(kLiveSyncOperationTimeoutMs,
                                       "Waiting for sync configuration.");
 }
 
 bool ProfileSyncServiceHarness::AwaitDataSyncCompletion(
     const std::string& reason) {
   DVLOG(1) << GetClientInfoString("AwaitDataSyncCompletion");
 
   CHECK(service()->sync_initialized());
   CHECK_NE(wait_state_, SYNC_DISABLED);
-  CHECK_NE(wait_state_, SERVER_UNREACHABLE);
 
   if (IsDataSynced()) {
     // Client is already synced; don't wait.
     return true;
   }
 
   wait_state_ = WAITING_FOR_DATA_SYNC;
   AwaitStatusChangeWithTimeout(kLiveSyncOperationTimeoutMs, reason);
   if (wait_state_ == FULLY_SYNCED) {
     return true;
@@ skipping 10 matching lines @@
   if (wait_state_ == SYNC_DISABLED) {
     LOG(ERROR) << "Sync disabled for " << profile_debug_name_ << ".";
     return false;
   }
 
   if (IsFullySynced()) {
     // Client is already synced; don't wait.
     return true;
   }
 
-  if (wait_state_ == SERVER_UNREACHABLE) {
-    // Client was offline; wait for it to go online, and then wait for sync.
-    AwaitStatusChangeWithTimeout(kLiveSyncOperationTimeoutMs, reason);
-    DCHECK_EQ(wait_state_, WAITING_FOR_FULL_SYNC);
-    return AwaitStatusChangeWithTimeout(kLiveSyncOperationTimeoutMs, reason);
-  }
-
   DCHECK(service()->sync_initialized());
   wait_state_ = WAITING_FOR_FULL_SYNC;
   AwaitStatusChangeWithTimeout(kLiveSyncOperationTimeoutMs, reason);
   if (wait_state_ == FULLY_SYNCED) {
     // Client is online; sync was successful.
     return true;
-  } else if (wait_state_ == SERVER_UNREACHABLE) {
-    // Client is offline; sync was unsuccessful.
-    LOG(ERROR) << "Client went offline after waiting for sync to finish";
-    return false;
   } else {
     LOG(ERROR) << "Invalid wait state: " << wait_state_;
     return false;
   }
 }
 
 bool ProfileSyncServiceHarness::AwaitSyncDisabled(const std::string& reason) {
   DCHECK(service()->HasSyncSetupCompleted());
   DCHECK_NE(wait_state_, SYNC_DISABLED);
   wait_state_ = WAITING_FOR_SYNC_DISABLED;
@@ skipping 495 matching lines @@
   return service_->GetPreferredDataTypes().Has(type);
 }
 
 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;
 }