Delete lots of sync ServerConnectionManager code

chrome/browser/sync/internal_api/sync_manager.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/internal_api/sync_manager.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 179 matching lines @@
             HttpPostProviderFactory* post_factory,
             ModelSafeWorkerRegistrar* model_safe_worker_registrar,
             ChangeDelegate* change_delegate,
             const std::string& user_agent,
             const SyncCredentials& credentials,
             sync_notifier::SyncNotifier* sync_notifier,
             const std::string& restored_key_for_bootstrapping,
             bool setup_for_test_mode,
             UnrecoverableErrorHandler* unrecoverable_error_handler);
 
-  void CheckServerReachable() {
-    if (connection_manager()) {
-      connection_manager()->CheckServerReachable();
-    } else {
-      NOTREACHED() << "Should be valid connection manager!";
-    }
-  }
-
   // Sign into sync with given credentials.
   // We do not verify the tokens given. After this call, the tokens are set
   // and the sync DB is open. True if successful, false if something
   // went wrong.
   bool SignIn(const SyncCredentials& credentials);
 
   // Update tokens that we're using in Sync. Email must stay the same.
   void UpdateCredentials(const SyncCredentials& credentials);
 
+  void KickScheduler();
+
   // Called when the user disables or enables a sync type.
   void UpdateEnabledTypes();
 
   // Conditionally sets the flag in the Nigori node which instructs other
   // clients to start syncing tabs.
   void MaybeSetSyncTabsInNigoriNode(ModelTypeSet enabled_types);
 
   // Tell the sync engine to start the syncing process.
   void StartSyncingNormally();
 
@@ skipping 153 matching lines @@
       return value;
     }
   };
 
   typedef std::map<syncable::ModelType, NotificationInfo> NotificationInfoMap;
   typedef JsArgList
       (SyncManager::SyncInternal::*UnboundJsMessageHandler)(const JsArgList&);
   typedef base::Callback<JsArgList(const JsArgList&)> JsMessageHandler;
   typedef std::map<std::string, JsMessageHandler> JsMessageHandlerMap;
 
-  // Helper to call OnAuthError when no authentication credentials are
-  // available.
-  void RaiseAuthNeededEvent();
-
   // Internal callback of UpdateCryptographerAndNigoriCallback.
   void UpdateCryptographerAndNigoriCallback(
       const base::Callback<void(bool)>& done_callback,
       const std::string& session_name);
 
   // Determine if the parents or predecessors differ between the old and new
   // versions of an entry stored in |a| and |b|.  Note that a node's index may
   // change without its NEXT_ID changing if the node at NEXT_ID also moved (but
   // the relative order is unchanged).  To handle such cases, we rely on the
   // caller to treat a position update on any sibling as updating the positions
@@ skipping 248 matching lines @@
 
 SyncManager::ChangeObserver::~ChangeObserver() {}
 
 SyncManager::Observer::~Observer() {}
 
 SyncManager::SyncManager(const std::string& name)
     : data_(new SyncInternal(name)) {}
 
 SyncManager::Status::Status()
     : summary(INVALID),
-      authenticated(false),
-      server_up(false),
-      server_reachable(false),
       server_broken(false),
       notifications_enabled(false),
       notifications_received(0),
       notifiable_commits(0),
       max_consecutive_errors(0),
       unsynced_count(0),
       conflicting_count(0),
       syncing(false),
       initial_sync_ended(false),
       syncer_stuck(false),
@@ skipping 42 matching lines @@
                      registrar,
                      change_delegate,
                      user_agent,
                      credentials,
                      sync_notifier,
                      restored_key_for_bootstrapping,
                      setup_for_test_mode,
                      unrecoverable_error_handler);
 }
 
-void SyncManager::CheckServerReachable() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  data_->CheckServerReachable();
-}
-
 void SyncManager::UpdateCredentials(const SyncCredentials& credentials) {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->UpdateCredentials(credentials);
 }
 
 void SyncManager::UpdateEnabledTypes() {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->UpdateEnabledTypes();
 }
 
@@ skipping 388 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(credentials.email, share_.name);
   DCHECK(!credentials.email.empty());
   DCHECK(!credentials.sync_token.empty());
 
   observing_ip_address_changes_ = true;
   if (connection_manager()->set_auth_token(credentials.sync_token)) {
     sync_notifier_->UpdateCredentials(
         credentials.email, credentials.sync_token);
     if (!setup_for_test_mode_ && initialized_) {
-      // Post a task so we don't block UpdateCredentials.
+      // Kick the sync scheduler.  It may have been waiting for that auth token.
       MessageLoop::current()->PostTask(
-          FROM_HERE, base::Bind(&SyncInternal::CheckServerReachable,
-                                weak_ptr_factory_.GetWeakPtr()));
+           FROM_HERE, base::Bind(&SyncInternal::KickScheduler,
+                                 weak_ptr_factory_.GetWeakPtr()));
     }
   }
 }
 
+void SyncManager::SyncInternal::KickScheduler() {
+  scheduler()->TryToConnect();
+}
+
 void SyncManager::SyncInternal::UpdateEnabledTypes() {
   DCHECK(thread_checker_.CalledOnValidThread());
   ModelSafeRoutingInfo routes;
   registrar_->GetModelSafeRoutingInfo(&routes);
   const ModelTypeSet enabled_types = GetRoutingInfoTypes(routes);
   sync_notifier_->UpdateEnabledTypes(enabled_types);
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableSyncTabsForOtherClients)) {
     MaybeSetSyncTabsInNigoriNode(enabled_types);
   }
@@ skipping 12 matching lines @@
                    << "found.";
       return;
     }
 
     sync_pb::NigoriSpecifics specifics(node.GetNigoriSpecifics());
     specifics.set_sync_tabs(true);
     node.SetNigoriSpecifics(specifics);
   }
 }
 
-void SyncManager::SyncInternal::RaiseAuthNeededEvent() {
-  FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
-      OnAuthError(AuthError(AuthError::INVALID_GAIA_CREDENTIALS)));
-}
-
 void SyncManager::SyncInternal::SetPassphrase(
     const std::string& passphrase, bool is_explicit) {
   // We do not accept empty passphrases.
   if (passphrase.empty()) {
     DVLOG(1) << "Rejecting empty passphrase.";
     WriteTransaction trans(FROM_HERE, GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     sync_pb::EncryptedData pending_keys;
     if (cryptographer->has_pending_keys())
       pending_keys = cryptographer->GetPendingKeys();
@@ skipping 320 matching lines @@
       base::Bind(&SyncInternal::OnIPAddressChangedImpl,
                  weak_ptr_factory_.GetWeakPtr()),
       kChromeOSNetworkChangeReactionDelayHackMsec);
 #else
   OnIPAddressChangedImpl();
 #endif  // defined(OS_CHROMEOS)
 }
 
 void SyncManager::SyncInternal::OnIPAddressChangedImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  CheckServerReachable();
+  scheduler()->TryToConnect();
 }
 
 void SyncManager::SyncInternal::OnServerConnectionEvent(
     const ServerConnectionEvent& event) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  allstatus_.HandleServerConnectionEvent(event);
   if (event.connection_code ==
       browser_sync::HttpResponse::SERVER_CONNECTION_OK) {
     FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                       OnAuthError(AuthError::None()));
   }
 
   if (event.connection_code == browser_sync::HttpResponse::SYNC_AUTH_ERROR) {
     observing_ip_address_changes_ = false;
     FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
         OnAuthError(AuthError(AuthError::INVALID_GAIA_CREDENTIALS)));
@@ skipping 746 matching lines @@
     lookup->GetDownloadProgress(i.Get(), &marker);
 
     if (marker.token().empty())
       result.Put(i.Get());
 
   }
   return result;
 }
 
 }  // namespace sync_api