Delete lots of sync ServerConnectionManager code

chrome/browser/sync/engine/sync_scheduler.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/engine/sync_scheduler.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/bind.h"
@@ skipping 172 matching lines @@
       name_(name),
       sync_loop_(MessageLoop::current()),
       started_(false),
       syncer_short_poll_interval_seconds_(
           TimeDelta::FromSeconds(kDefaultShortPollIntervalSeconds)),
       syncer_long_poll_interval_seconds_(
           TimeDelta::FromSeconds(kDefaultLongPollIntervalSeconds)),
       sessions_commit_delay_(
           TimeDelta::FromSeconds(kDefaultSessionsCommitDelaySeconds)),
       mode_(NORMAL_MODE),
-      server_connection_ok_(false),
       delay_provider_(new DelayProvider()),
       syncer_(syncer),
       session_context_(context) {
   DCHECK(sync_loop_);
 }
 
 SyncScheduler::~SyncScheduler() {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   StopImpl(base::Closure());
 }
 
-void SyncScheduler::CheckServerConnectionManagerStatus(
-    HttpResponse::ServerConnectionCode code) {
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
-  SDVLOG(2) << "New server connection code: "
-            << HttpResponse::GetServerConnectionCodeString(code);
-  bool old_server_connection_ok = server_connection_ok_;
-
-  // Note, be careful when adding cases here because if the SyncScheduler
-  // thinks there is no valid connection as determined by this method, it
-  // will drop out of *all* forward progress sync loops (it won't poll and it
-  // will queue up Talk notifications but not actually call SyncShare) until
-  // some external action causes a ServerConnectionManager to broadcast that
-  // a valid connection has been re-established.
-  if (HttpResponse::CONNECTION_UNAVAILABLE == code ||
-      HttpResponse::SYNC_AUTH_ERROR == code) {
-    server_connection_ok_ = false;
-    SDVLOG(2) << "Sync auth error or unavailable connection: "
-              << "server connection is down";
-  } else if (HttpResponse::SERVER_CONNECTION_OK == code) {
-    server_connection_ok_ = true;
-    SDVLOG(2) << "Sync server connection is ok: "
-              << "server connection is up, doing canary job";
-    DoCanaryJob();
-  }
-
-  if (old_server_connection_ok != server_connection_ok_) {
-    const char* transition =
-        server_connection_ok_ ? "down -> up" : "up -> down";
-    SDVLOG(2) << "Server connection changed: " << transition;
-  }
-}
-
 void SyncScheduler::Start(Mode mode, const base::Closure& callback) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   std::string thread_name = MessageLoop::current()->thread_name();
   if (thread_name.empty())
     thread_name = "<Main thread>";
   SDVLOG(2) << "Start called from thread "
             << thread_name << " with mode " << GetModeString(mode);
   if (!started_) {
     started_ = true;
-    WatchConnectionManager();
     PostTask(FROM_HERE, "SendInitialSnapshot",
              base::Bind(&SyncScheduler::SendInitialSnapshot,
                         weak_ptr_factory_.GetWeakPtr()));
   }
   PostTask(FROM_HERE, "StartImpl",
            base::Bind(&SyncScheduler::StartImpl,
                       weak_ptr_factory_.GetWeakPtr(), mode, callback));
 }
 
 void SyncScheduler::SendInitialSnapshot() {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   scoped_ptr<SyncSession> dummy(new SyncSession(session_context_.get(), this,
       SyncSourceInfo(), ModelSafeRoutingInfo(),
       std::vector<ModelSafeWorker*>()));
   SyncEngineEvent event(SyncEngineEvent::STATUS_CHANGED);
   sessions::SyncSessionSnapshot snapshot(dummy->TakeSnapshot());
   event.snapshot = &snapshot;
   session_context_->NotifyListeners(event);
 }
 
-void SyncScheduler::WatchConnectionManager() {
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
-  ServerConnectionManager* scm = session_context_->connection_manager();
-  PostTask(FROM_HERE, "CheckServerConnectionManagerStatus",
-           base::Bind(&SyncScheduler::CheckServerConnectionManagerStatus,
-                      weak_ptr_factory_.GetWeakPtr(),
-                      scm->server_status()));
-  scm->AddListener(this);
-}
-
 void SyncScheduler::StartImpl(Mode mode, const base::Closure& callback) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   SDVLOG(2) << "In StartImpl with mode " << GetModeString(mode);
 
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   DCHECK(!session_context_->account_name().empty());
   DCHECK(syncer_.get());
   Mode old_mode = mode_;
   mode_ = mode;
   AdjustPolling(NULL);  // Will kick start poll timer if needed.
@@ skipping 64 matching lines @@
   // We are in normal mode.
   DCHECK_EQ(mode_, NORMAL_MODE);
   DCHECK_NE(job.purpose, SyncSessionJob::CONFIGURATION);
 
   // Freshness condition
   if (job.scheduled_start < last_sync_session_end_time_) {
     SDVLOG(2) << "Dropping job because of freshness";
     return DROP;
   }
 
-  if (server_connection_ok_)
+  if (!session_context_->connection_manager()->HasInvalidAuthToken())
     return CONTINUE;
 
-  SDVLOG(2) << "Bad server connection. Using that to decide on job.";
+  SDVLOG(2) << "We have no valid auth token. Using that to decide on job.";
   return job.purpose == SyncSessionJob::NUDGE ? SAVE : DROP;
 }
 
 void SyncScheduler::InitOrCoalescePendingJob(const SyncSessionJob& job) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   DCHECK(job.purpose != SyncSessionJob::CONFIGURATION);
   if (pending_nudge_.get() == NULL) {
     SDVLOG(2) << "Creating a pending nudge job";
     SyncSession* s = job.session.get();
     scoped_ptr<SyncSession> session(new SyncSession(s->context(),
@@ skipping 634 matching lines @@
 
 void SyncScheduler::StopImpl(const base::Closure& callback) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   SDVLOG(2) << "StopImpl called";
 
   // Kill any in-flight method calls.
   weak_ptr_factory_.InvalidateWeakPtrs();
   wait_interval_.reset();
   poll_timer_.Stop();
   if (started_) {
-    session_context_->connection_manager()->RemoveListener(this);
     started_ = false;
   }
   if (!callback.is_null())
     callback.Run();
 }
 
 void SyncScheduler::DoCanaryJob() {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   SDVLOG(2) << "Do canary job";
   DoPendingJobIfPossible(true);
@@ skipping 135 matching lines @@
     const sessions::SyncSessionSnapshot& snapshot) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   if (ShouldRequestEarlyExit(snapshot.errors.sync_protocol_error)) {
     SDVLOG(2) << "Sync Scheduler requesting early exit.";
     syncer_->RequestEarlyExit();  // Thread-safe.
   }
   if (IsActionableError(snapshot.errors.sync_protocol_error))
     OnActionableError(snapshot);
 }
 
+void SyncScheduler::TryToConnect() {
+  if (wait_interval_.get() && wait_interval_->mode == WaitInterval::THROTTLED)
+    return;
 
-void SyncScheduler::OnServerConnectionEvent(
-    const ServerConnectionEvent& event) {
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
-  PostTask(FROM_HERE, "CheckServerConnectionManagerStatus",
-           base::Bind(&SyncScheduler::CheckServerConnectionManagerStatus,
-                      weak_ptr_factory_.GetWeakPtr(),
-                      event.connection_code));
+  DoCanaryJob();
 }
 
 void SyncScheduler::set_notifications_enabled(bool notifications_enabled) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   session_context_->set_notifications_enabled(notifications_enabled);
 }
 
 base::TimeDelta SyncScheduler::sessions_commit_delay() const {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   return sessions_commit_delay_;
 }
 
 #undef SDVLOG_LOC
 
 #undef SDVLOG
 
 #undef SLOG
 
 #undef ENUM_CASE
 
 }  // browser_sync