Rename SyncNotifier->Invalidator and SyncNotifierObserver->InvalidationHandler.

sync/internal_api/sync_manager_impl.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 "sync/internal_api/sync_manager_impl.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 22 matching lines @@
 #include "sync/internal_api/public/util/experiments.h"
 #include "sync/internal_api/public/write_node.h"
 #include "sync/internal_api/public/write_transaction.h"
 #include "sync/internal_api/syncapi_internal.h"
 #include "sync/internal_api/syncapi_server_connection_manager.h"
 #include "sync/js/js_arg_list.h"
 #include "sync/js/js_event_details.h"
 #include "sync/js/js_event_handler.h"
 #include "sync/js/js_reply_handler.h"
 #include "sync/notifier/invalidation_util.h"
-#include "sync/notifier/sync_notifier.h"
+#include "sync/notifier/invalidator.h"
 #include "sync/protocol/proto_value_conversions.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/entry.h"
 #include "sync/syncable/in_memory_directory_backing_store.h"
 #include "sync/syncable/on_disk_directory_backing_store.h"
 #include "sync/util/get_session_name.h"
 
 using base::TimeDelta;
 using sync_pb::GetUpdatesCallerInfo;
@@ skipping 288 matching lines @@
     const WeakHandle<JsEventHandler>& event_handler,
     const std::string& sync_server_and_path,
     int port,
     bool use_ssl,
     const scoped_refptr<base::TaskRunner>& blocking_task_runner,
     scoped_ptr<HttpPostProviderFactory> post_factory,
     const std::vector<ModelSafeWorker*>& workers,
     ExtensionsActivityMonitor* extensions_activity_monitor,
     SyncManager::ChangeDelegate* change_delegate,
     const SyncCredentials& credentials,
-    scoped_ptr<SyncNotifier> sync_notifier,
+    scoped_ptr<Invalidator> invalidator,
     const std::string& restored_key_for_bootstrapping,
     const std::string& restored_keystore_key_for_bootstrapping,
     scoped_ptr<InternalComponentsFactory> internal_components_factory,
     Encryptor* encryptor,
     UnrecoverableErrorHandler* unrecoverable_error_handler,
     ReportUnrecoverableErrorFunction report_unrecoverable_error_function) {
   CHECK(!initialized_);
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(post_factory.get());
   DCHECK(!credentials.email.empty());
   DCHECK(!credentials.sync_token.empty());
   DVLOG(1) << "SyncManager starting Init...";
 
   weak_handle_this_ = MakeWeakHandle(weak_ptr_factory_.GetWeakPtr());
 
   blocking_task_runner_ = blocking_task_runner;
 
   change_delegate_ = change_delegate;
 
-  sync_notifier_ = sync_notifier.Pass();
-  sync_notifier_->RegisterHandler(this);
+  invalidator_ = invalidator.Pass();
+  invalidator_->RegisterHandler(this);
 
   AddObserver(&js_sync_manager_observer_);
   SetJsEventHandler(event_handler);
 
   AddObserver(&debug_info_event_listener_);
 
   database_path_ = database_location.Append(
       syncable::Directory::kSyncDatabaseFilename);
   encryptor_ = encryptor;
   unrecoverable_error_handler_ = unrecoverable_error_handler;
@@ skipping 34 matching lines @@
 
   connection_manager_.reset(new SyncAPIServerConnectionManager(
       sync_server_and_path, port, use_ssl, post_factory.release()));
   connection_manager_->set_client_id(directory()->cache_guid());
   connection_manager_->AddListener(this);
 
   // Retrieve and set the sync notifier state.
   std::string unique_id = directory()->cache_guid();
   DVLOG(1) << "Read notification unique ID: " << unique_id;
   allstatus_.SetUniqueId(unique_id);
-  sync_notifier_->SetUniqueId(unique_id);
+  invalidator_->SetUniqueId(unique_id);
 
   std::string state = directory()->GetNotificationState();
   if (VLOG_IS_ON(1)) {
     std::string encoded_state;
     base::Base64Encode(state, &encoded_state);
     DVLOG(1) << "Read notification state: " << encoded_state;
   }
 
   // TODO(tim): Remove once invalidation state has been migrated to new
   // InvalidationStateTracker store. Bug 124140.
-  sync_notifier_->SetStateDeprecated(state);
+  invalidator_->SetStateDeprecated(state);
 
   // Build a SyncSessionContext and store the worker in it.
   DVLOG(1) << "Sync is bringing up SyncSessionContext.";
   std::vector<SyncEngineEventListener*> listeners;
   listeners.push_back(&allstatus_);
   listeners.push_back(this);
   session_context_ = internal_components_factory->BuildContext(
       connection_manager_.get(),
       directory(),
       workers,
@@ skipping 196 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(initialized_);
   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))
     return;  // Auth token is known to be invalid, so exit early.
 
-  sync_notifier_->UpdateCredentials(credentials.email, credentials.sync_token);
+  invalidator_->UpdateCredentials(credentials.email, credentials.sync_token);
   scheduler_->OnCredentialsUpdated();
 }
 
 void SyncManagerImpl::UpdateEnabledTypes(
     const ModelTypeSet& enabled_types) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(initialized_);
-  sync_notifier_->UpdateRegisteredIds(
+  invalidator_->UpdateRegisteredIds(
       this,
       ModelTypeSetToObjectIdSet(enabled_types));
 }
 
 void SyncManagerImpl::RegisterInvalidationHandler(
-    SyncNotifierObserver* handler) {
+    InvalidationHandler* handler) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(initialized_);
-  sync_notifier_->RegisterHandler(handler);
+  invalidator_->RegisterHandler(handler);
 }
 
 void SyncManagerImpl::UpdateRegisteredInvalidationIds(
-    SyncNotifierObserver* handler,
+    InvalidationHandler* handler,
     const ObjectIdSet& ids) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(initialized_);
-  sync_notifier_->UpdateRegisteredIds(handler, ids);
+  invalidator_->UpdateRegisteredIds(handler, ids);
 }
 
 void SyncManagerImpl::UnregisterInvalidationHandler(
-    SyncNotifierObserver* handler) {
+    InvalidationHandler* handler) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(initialized_);
-  sync_notifier_->UnregisterHandler(handler);
+  invalidator_->UnregisterHandler(handler);
 }
 
 bool SyncManagerImpl::GetKeystoreKeyBootstrapToken(std::string* token) {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   return trans.GetCryptographer()->GetKeystoreKeyBootstrapToken(token);
 }
 
 void SyncManagerImpl::AddObserver(SyncManager::Observer* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   observers_.AddObserver(observer);
@@ skipping 25 matching lines @@
   if (sync_encryption_handler_.get()) {
     sync_encryption_handler_->RemoveObserver(&debug_info_event_listener_);
     sync_encryption_handler_->RemoveObserver(this);
   }
 
   SetJsEventHandler(WeakHandle<JsEventHandler>());
   RemoveObserver(&js_sync_manager_observer_);
 
   RemoveObserver(&debug_info_event_listener_);
 
-  // |sync_notifier_| and |connection_manager_| may end up being NULL here in
+  // |invalidator_| and |connection_manager_| may end up being NULL here in
   // tests (in synchronous initialization mode).
   //
   // TODO(akalin): Fix this behavior.
 
-  if (sync_notifier_.get())
-    sync_notifier_->UnregisterHandler(this);
-  sync_notifier_.reset();
+  if (invalidator_.get())
+    invalidator_->UnregisterHandler(this);
+  invalidator_.reset();
 
   if (connection_manager_.get())
     connection_manager_->RemoveListener(this);
   connection_manager_.reset();
 
   net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
   observing_ip_address_changes_ = false;
 
   if (initialized_ && directory()) {
     directory()->SaveChanges();
@@ skipping 260 matching lines @@
                         OnSyncCycleCompleted(event.snapshot));
     }
 
     // This is here for tests, which are still using p2p notifications.
     //
     // TODO(chron): Consider changing this back to track has_more_to_sync
     // only notify peers if a successful commit has occurred.
     bool is_notifiable_commit =
         (event.snapshot.model_neutral_state().num_successful_commits > 0);
     if (is_notifiable_commit) {
-      if (sync_notifier_.get()) {
+      if (invalidator_.get()) {
         const ModelTypeSet changed_types =
             ModelTypeStateMapToSet(event.snapshot.source().types);
-        sync_notifier_->SendNotification(changed_types);
+        invalidator_->SendNotification(changed_types);
       } else {
-        DVLOG(1) << "Not sending notification: sync_notifier_ is NULL";
+        DVLOG(1) << "Not sending notification: invalidator_ is NULL";
       }
     }
   }
 
   if (event.what_happened == SyncEngineEvent::STOP_SYNCING_PERMANENTLY) {
     FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                       OnStopSyncingPermanently());
     return;
   }
 
@@ skipping 330 matching lines @@
 int SyncManagerImpl::GetDefaultNudgeDelay() {
   return kDefaultNudgeDelayMilliseconds;
 }
 
 // static.
 int SyncManagerImpl::GetPreferencesNudgeDelay() {
   return kPreferencesNudgeDelayMilliseconds;
 }
 
 }  // namespace syncer