Trim code from sync's ServerConnectionManager

sync/engine/sync_scheduler_whitebox_unittest.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 "base/message_loop.h"
 #include "base/time.h"
 #include "sync/engine/sync_scheduler.h"
 #include "sync/sessions/sync_session_context.h"
 #include "sync/sessions/test_util.h"
 #include "sync/test/engine/fake_model_safe_worker_registrar.h"
@@ skipping 16 matching lines @@
 class SyncSchedulerWhiteboxTest : public testing::Test {
  public:
   virtual void SetUp() {
     dir_maker_.SetUp();
     Syncer* syncer = new Syncer();
     ModelSafeRoutingInfo routes;
     routes[syncable::BOOKMARKS] = GROUP_UI;
     routes[syncable::NIGORI] = GROUP_PASSIVE;
     registrar_.reset(new FakeModelSafeWorkerRegistrar(routes));
     connection_.reset(new MockConnectionManager(NULL));
-    connection_->SetServerReachable();
     context_ =
         new SyncSessionContext(
             connection_.get(), dir_maker_.directory(),
             registrar_.get(), &extensions_activity_monitor_,
             std::vector<SyncEngineEventListener*>(), NULL);
     context_->set_notifications_enabled(true);
     context_->set_account_name("Test");
     scheduler_.reset(
         new SyncScheduler("TestSyncSchedulerWhitebox", context_, syncer));
   }
 
   virtual void TearDown() {
     scheduler_.reset();
   }
 
   void SetMode(SyncScheduler::Mode mode) {
     scheduler_->mode_ = mode;
   }
 
   void SetLastSyncedTime(base::TimeTicks ticks) {
     scheduler_->last_sync_session_end_time_ = ticks;
   }
 
-  void SetServerConnection(bool connected) {
-    scheduler_->server_connection_ok_ = connected;
-  }
-
   void ResetWaitInterval() {
     scheduler_->wait_interval_.reset();
   }
 
   void SetWaitIntervalToThrottled() {
     scheduler_->wait_interval_.reset(new SyncScheduler::WaitInterval(
         SyncScheduler::WaitInterval::THROTTLED, TimeDelta::FromSeconds(1)));
   }
 
   void SetWaitIntervalToExponentialBackoff() {
     scheduler_->wait_interval_.reset(
        new SyncScheduler::WaitInterval(
        SyncScheduler::WaitInterval::EXPONENTIAL_BACKOFF,
        TimeDelta::FromSeconds(1)));
   }
 
   void SetWaitIntervalHadNudge(bool had_nudge) {
     scheduler_->wait_interval_->had_nudge = had_nudge;
   }
 
   SyncScheduler::JobProcessDecision DecideOnJob(
       const SyncScheduler::SyncSessionJob& job) {
     return scheduler_->DecideOnJob(job);
   }
 
   void InitializeSyncerOnNormalMode() {
     SetMode(SyncScheduler::NORMAL_MODE);
     ResetWaitInterval();
-    SetServerConnection(true);
     SetLastSyncedTime(base::TimeTicks::Now());
   }
 
   SyncScheduler::JobProcessDecision CreateAndDecideJob(
       SyncScheduler::SyncSessionJob::SyncSessionJobPurpose purpose) {
     SyncSession* s = scheduler_->CreateSyncSession(SyncSourceInfo());
     SyncScheduler::SyncSessionJob job(purpose, TimeTicks::Now(),
          make_linked_ptr(s),
          false,
          FROM_HERE);
@@ skipping 163 matching lines @@
   struct SyncScheduler::SyncSessionJob job;
   job.purpose = SyncScheduler::SyncSessionJob::CONFIGURATION;
   job.scheduled_start = TimeTicks::Now();
   job.is_canary_job = true;
   SyncScheduler::JobProcessDecision decision = DecideOnJob(job);
 
   EXPECT_EQ(decision, SyncScheduler::CONTINUE);
 }
 
 }  // namespace browser_sync