Massively simplify the NetworkChangeNotifier infrastructure:...

chrome/browser/sync/engine/syncapi.cc

-// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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/syncapi.h"
 
 #include "build/build_config.h"
 
 #include <iomanip>
 #include <list>
 #include <string>
@@ skipping 35 matching lines @@
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/browser/sync/syncable/syncable.h"
 #include "chrome/browser/sync/util/character_set_converters.h"
 #include "chrome/browser/sync/util/closure.h"
 #include "chrome/browser/sync/util/crypto_helpers.h"
 #include "chrome/browser/sync/util/path_helpers.h"
 #include "chrome/browser/sync/util/user_settings.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/deprecated/event_sys.h"
 #include "chrome/common/net/gaia/gaia_authenticator.h"
-#include "chrome/common/net/network_change_notifier_proxy.h"
 #include "chrome/common/net/notifier/listener/mediator_thread_impl.h"
 #include "chrome/common/net/notifier/listener/notification_constants.h"
 #include "chrome/common/net/notifier/listener/talk_mediator.h"
 #include "chrome/common/net/notifier/listener/talk_mediator_impl.h"
 #include "net/base/network_change_notifier.h"
 
 using browser_sync::AllStatus;
 using browser_sync::AllStatusEvent;
 using browser_sync::AuthWatcher;
 using browser_sync::AuthWatcherEvent;
@@ skipping 808 matching lines @@
     DCHECK(!core_message_loop_);
     DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   }
 
   bool Init(const FilePath& database_location,
             const std::string& sync_server_and_path,
             int port,
             const char* gaia_service_id,
             const char* gaia_source,
             bool use_ssl,
-            chrome_common_net::NetworkChangeNotifierThread*
-                network_change_notifier_thread,
             HttpPostProviderFactory* post_factory,
             HttpPostProviderFactory* auth_post_factory,
             ModelSafeWorkerRegistrar* model_safe_worker_registrar,
             bool attempt_last_user_authentication,
             bool invalidate_last_user_auth_token,
             bool invalidate_xmpp_auth_token,
             const char* user_agent,
             const std::string& lsid,
             browser_sync::NotificationMethod notification_method);
 
@@ skipping 261 matching lines @@
   scoped_ptr<EventListenerHookup> authwatcher_hookup_;
 
   // Our cache of a recent authentication problem. If no authentication problem
   // occurred, or if the last problem encountered has been cleared (by a
   // subsequent AuthWatcherEvent), this is set to NONE.
   AuthError::State auth_problem_;
 
   // The sync dir_manager to which we belong.
   SyncManager* const sync_manager_;
 
-  // An object that notifies us whenever there is a network-related
-  // change (e.g., disconnections).
-  scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_;
-
   // The entity that provides us with information about which types to sync.
   // The instance is shared between the SyncManager and the Syncer.
   ModelSafeWorkerRegistrar* registrar_;
 
   // True if the next SyncCycle should notify peers of an update.
   bool notification_pending_;
 
   // Set to true once Init has been called, and we know of an authenticated
   // valid) username either from a fresh authentication attempt (as in
   // first-use case) or from a previous attempt stored in our UserSettings
@@ skipping 11 matching lines @@
 SyncManager::SyncManager() {
   data_ = new SyncInternal(this);
 }
 
 bool SyncManager::Init(const FilePath& database_location,
                        const char* sync_server_and_path,
                        int sync_server_port,
                        const char* gaia_service_id,
                        const char* gaia_source,
                        bool use_ssl,
-                       chrome_common_net::NetworkChangeNotifierThread*
-                           network_change_notifier_thread,
                        HttpPostProviderFactory* post_factory,
                        HttpPostProviderFactory* auth_post_factory,
                        ModelSafeWorkerRegistrar* registrar,
                        bool attempt_last_user_authentication,
                        bool invalidate_last_user_auth_token,
                        bool invalidate_xmpp_auth_token,
                        const char* user_agent,
                        const char* lsid,
                        browser_sync::NotificationMethod notification_method) {
   DCHECK(post_factory);
   LOG(INFO) << "SyncManager starting Init...";
   string server_string(sync_server_and_path);
   return data_->Init(database_location,
                      server_string,
                      sync_server_port,
                      gaia_service_id,
                      gaia_source,
                      use_ssl,
-                     network_change_notifier_thread,
                      post_factory,
                      auth_post_factory,
                      registrar,
                      attempt_last_user_authentication,
                      invalidate_last_user_auth_token,
                      invalidate_xmpp_auth_token,
                      user_agent,
                      lsid,
                      notification_method);
 }
@@ skipping 29 matching lines @@
   return data_->username_for_share();
 }
 
 bool SyncManager::SyncInternal::Init(
     const FilePath& database_location,
     const std::string& sync_server_and_path,
     int port,
     const char* gaia_service_id,
     const char* gaia_source,
     bool use_ssl,
-    chrome_common_net::NetworkChangeNotifierThread*
-        network_change_notifier_thread,
     HttpPostProviderFactory* post_factory,
     HttpPostProviderFactory* auth_post_factory,
     ModelSafeWorkerRegistrar* model_safe_worker_registrar,
     bool attempt_last_user_authentication,
     bool invalidate_last_user_auth_token,
     bool invalidate_xmpp_auth_token,
     const char* user_agent,
     const std::string& lsid,
     browser_sync::NotificationMethod notification_method) {
 
@@ skipping 17 matching lines @@
   share_.dir_manager.reset(new DirectoryManager(database_location));
 
   string client_id = user_settings_->GetClientId();
   connection_manager_.reset(new SyncAPIServerConnectionManager(
       sync_server_and_path, port, use_ssl, user_agent, client_id,
       post_factory));
 
   // Watch various objects for aggregated status.
   allstatus_.WatchConnectionManager(connection_manager());
 
-  network_change_notifier_.reset(
-      new chrome_common_net::NetworkChangeNotifierProxy(
-          network_change_notifier_thread));
-  network_change_notifier_->AddObserver(this);
-  // TODO(akalin): CheckServerReachable() can block, which may cause
-  // jank if we try to shut down sync.  Fix this.
+  net::NetworkChangeNotifier::AddObserver(this);
+  // TODO(akalin): CheckServerReachable() can block, which may cause jank if we
+  // try to shut down sync.  Fix this.
   connection_manager()->CheckServerReachable();
 
-  // NOTIFICATION_SERVER uses a substantially different notification
-  // method, so it has its own MediatorThread implementation.
-  // Everything else just uses MediatorThreadImpl.
+  // NOTIFICATION_SERVER uses a substantially different notification method, so
+  // it has its own MediatorThread implementation.  Everything else just uses
+  // MediatorThreadImpl.
   notifier::MediatorThread* mediator_thread =
       (notification_method == browser_sync::NOTIFICATION_SERVER) ?
-      static_cast<notifier::MediatorThread*>(
-          new sync_notifier::ServerNotifierThread(
-              network_change_notifier_thread)) :
-      static_cast<notifier::MediatorThread*>(
-          new notifier::MediatorThreadImpl(network_change_notifier_thread));
+      new sync_notifier::ServerNotifierThread() :
+      new notifier::MediatorThreadImpl();
   const bool kInitializeSsl = true;
   const bool kConnectImmediately = false;
-  talk_mediator_.reset(new TalkMediatorImpl(
-      mediator_thread,
-      kInitializeSsl, kConnectImmediately, invalidate_xmpp_auth_token));
+  talk_mediator_.reset(new TalkMediatorImpl(mediator_thread, kInitializeSsl,
+      kConnectImmediately, invalidate_xmpp_auth_token));
   if (notification_method != browser_sync::NOTIFICATION_LEGACY &&
       notification_method != browser_sync::NOTIFICATION_SERVER) {
     if (notification_method == browser_sync::NOTIFICATION_TRANSITIONAL) {
       talk_mediator_->AddSubscribedServiceUrl(
           browser_sync::kSyncLegacyServiceUrl);
     }
     talk_mediator_->AddSubscribedServiceUrl(browser_sync::kSyncServiceUrl);
   }
 
   // Listen to TalkMediator events ourselves
@@ skipping 242 matching lines @@
   // HandleAuthWatcherEvent(), and HandleTalkMediatorEvent() for the
   // events that may be posted.)
   {
     CHECK(core_message_loop_);
     bool old_state = core_message_loop_->NestableTasksAllowed();
     core_message_loop_->SetNestableTasksAllowed(true);
     core_message_loop_->RunAllPending();
     core_message_loop_->SetNestableTasksAllowed(old_state);
   }
 
-  if (network_change_notifier_.get()) {
-    network_change_notifier_->RemoveObserver(this);
-    network_change_notifier_.reset();
-  }
+  net::NetworkChangeNotifier::RemoveObserver(this);
 
   if (dir_manager()) {
     dir_manager()->FinalSaveChangesForAll();
     dir_manager()->Close(username_for_share());
   }
 
   // Reset the DirectoryManager and UserSettings so they relinquish sqlite
   // handles to backing files.
   share_.dir_manager.reset();
   user_settings_.reset();
@@ skipping 508 matching lines @@
 UserShare* SyncManager::GetUserShare() const {
   DCHECK(data_->initialized()) << "GetUserShare requires initialization!";
   return data_->GetUserShare();
 }
 
 SyncManager::ExtraAutofillChangeRecordData::~ExtraAutofillChangeRecordData() {
   delete pre_deletion_data;
 }
 
 }  // namespace sync_api