[Sync] Rename csync namespace to syncer

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 "sync/internal_api/public/sync_manager.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 44 matching lines @@
 #include "sync/syncable/directory.h"
 #include "sync/syncable/directory_change_delegate.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/cryptographer.h"
 #include "sync/util/get_session_name.h"
 #include "sync/util/time.h"
 
 using base::TimeDelta;
-using csync::AllStatus;
-using csync::Cryptographer;
-using csync::Encryptor;
-using csync::JsArgList;
-using csync::JsBackend;
-using csync::JsEventDetails;
-using csync::JsEventHandler;
-using csync::JsEventHandler;
-using csync::JsReplyHandler;
-using csync::JsMutationEventObserver;
-using csync::JsSyncManagerObserver;
-using csync::kNigoriTag;
-using csync::KeyParams;
-using csync::ModelSafeRoutingInfo;
-using csync::ReportUnrecoverableErrorFunction;
-using csync::ServerConnectionEvent;
-using csync::ServerConnectionEventListener;
-using csync::SyncEngineEvent;
-using csync::SyncEngineEventListener;
-using csync::SyncScheduler;
-using csync::Syncer;
-using csync::UnrecoverableErrorHandler;
-using csync::WeakHandle;
-using csync::sessions::SyncSessionContext;
+using syncer::AllStatus;
+using syncer::Cryptographer;
+using syncer::Encryptor;
+using syncer::JsArgList;
+using syncer::JsBackend;
+using syncer::JsEventDetails;
+using syncer::JsEventHandler;
+using syncer::JsEventHandler;
+using syncer::JsReplyHandler;
+using syncer::JsMutationEventObserver;
+using syncer::JsSyncManagerObserver;
+using syncer::kNigoriTag;
+using syncer::KeyParams;
+using syncer::ModelSafeRoutingInfo;
+using syncer::ReportUnrecoverableErrorFunction;
+using syncer::ServerConnectionEvent;
+using syncer::ServerConnectionEventListener;
+using syncer::SyncEngineEvent;
+using syncer::SyncEngineEventListener;
+using syncer::SyncScheduler;
+using syncer::Syncer;
+using syncer::UnrecoverableErrorHandler;
+using syncer::WeakHandle;
+using syncer::sessions::SyncSessionContext;
 using syncable::ImmutableWriteTransactionInfo;
 using syncable::ModelType;
 using syncable::ModelTypeSet;
 using syncable::SPECIFICS;
 using sync_pb::GetUpdatesCallerInfo;
 
 namespace {
 
 // Delays for syncer nudges.
 static const int kSyncRefreshDelayMsec = 500;
 static const int kSyncSchedulerDelayMsec = 250;
 
 GetUpdatesCallerInfo::GetUpdatesSource GetSourceFromReason(
-    csync::ConfigureReason reason) {
+    syncer::ConfigureReason reason) {
   switch (reason) {
-    case csync::CONFIGURE_REASON_RECONFIGURATION:
+    case syncer::CONFIGURE_REASON_RECONFIGURATION:
       return GetUpdatesCallerInfo::RECONFIGURATION;
-    case csync::CONFIGURE_REASON_MIGRATION:
+    case syncer::CONFIGURE_REASON_MIGRATION:
       return GetUpdatesCallerInfo::MIGRATION;
-    case csync::CONFIGURE_REASON_NEW_CLIENT:
+    case syncer::CONFIGURE_REASON_NEW_CLIENT:
       return GetUpdatesCallerInfo::NEW_CLIENT;
-    case csync::CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE:
+    case syncer::CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE:
       return GetUpdatesCallerInfo::NEWLY_SUPPORTED_DATATYPE;
     default:
       NOTREACHED();
   }
 
   return GetUpdatesCallerInfo::UNKNOWN;
 }
 
 // The maximum number of times we will automatically overwrite the nigori node
 // because the encryption keys don't match (per chrome instantiation).
 static const int kNigoriOverwriteLimit = 10;
 
 } // namespace
 
-namespace csync {
+namespace syncer {
 
 const int SyncManager::kDefaultNudgeDelayMilliseconds = 200;
 const int SyncManager::kPreferencesNudgeDelayMilliseconds = 2000;
 
 // Maximum count and size for traffic recorder.
 const unsigned int kMaxMessagesToRecord = 10;
 const unsigned int kMaxMessageSizeToRecord = 5 * 1024;
 
 //////////////////////////////////////////////////////////////////////////
 // SyncManager's implementation: SyncManager::SyncInternal
 class SyncManager::SyncInternal
     : public net::NetworkChangeNotifier::IPAddressObserver,
-      public csync::Cryptographer::Observer,
-      public csync::SyncNotifierObserver,
+      public syncer::Cryptographer::Observer,
+      public syncer::SyncNotifierObserver,
       public JsBackend,
       public SyncEngineEventListener,
       public ServerConnectionEventListener,
       public syncable::DirectoryChangeDelegate {
  public:
   explicit SyncInternal(const std::string& name)
       : name_(name),
         weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
         change_delegate_(NULL),
         initialized_(false),
@@ skipping 44 matching lines @@
     CHECK(!initialized_);
   }
 
   bool Init(const FilePath& database_location,
             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,
             HttpPostProviderFactory* post_factory,
-            const csync::ModelSafeRoutingInfo& model_safe_routing_info,
-            const std::vector<csync::ModelSafeWorker*>& workers,
-            csync::ExtensionsActivityMonitor*
+            const syncer::ModelSafeRoutingInfo& model_safe_routing_info,
+            const std::vector<syncer::ModelSafeWorker*>& workers,
+            syncer::ExtensionsActivityMonitor*
                 extensions_activity_monitor,
             ChangeDelegate* change_delegate,
             const SyncCredentials& credentials,
-            csync::SyncNotifier* sync_notifier,
+            syncer::SyncNotifier* sync_notifier,
             const std::string& restored_key_for_bootstrapping,
             TestingMode testing_mode,
             Encryptor* encryptor,
             UnrecoverableErrorHandler* unrecoverable_error_handler,
             ReportUnrecoverableErrorFunction
                 report_unrecoverable_error_function);
 
   // 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);
 
   // Called when the user disables or enables a sync type.
   void UpdateEnabledTypes(const ModelTypeSet& enabled_types);
 
   // Tell the sync engine to start the syncing process.
   void StartSyncingNormally(
-      const csync::ModelSafeRoutingInfo& routing_info);
+      const syncer::ModelSafeRoutingInfo& routing_info);
 
   // Whether or not the Nigori node is encrypted using an explicit passphrase.
   bool IsUsingExplicitPassphrase();
 
   // Update the Cryptographer from the current nigori node and write back any
   // necessary changes to the nigori node. We also detect missing encryption
   // keys and write them into the nigori node.
   // Also updates or adds the device information into the nigori node.
   // Note: opens a transaction and can trigger an ON_PASSPHRASE_REQUIRED, so
   // should only be called after syncapi is fully initialized.
@@ skipping 75 matching lines @@
   bool OpenDirectory();
 
   // Cryptographer::Observer implementation.
   virtual void OnEncryptedTypesChanged(
       syncable::ModelTypeSet encrypted_types,
       bool encrypt_everything) OVERRIDE;
 
   // SyncNotifierObserver implementation.
   virtual void OnNotificationsEnabled() OVERRIDE;
   virtual void OnNotificationsDisabled(
-      csync::NotificationsDisabledReason reason) OVERRIDE;
+      syncer::NotificationsDisabledReason reason) OVERRIDE;
   virtual void OnIncomingNotification(
       const syncable::ModelTypePayloadMap& type_payloads,
-      csync::IncomingNotificationSource source) OVERRIDE;
+      syncer::IncomingNotificationSource source) OVERRIDE;
 
   void AddObserver(SyncManager::Observer* observer);
   void RemoveObserver(SyncManager::Observer* observer);
 
   // Accessors for the private members.
   syncable::Directory* directory() { return share_.directory.get(); }
   SyncAPIServerConnectionManager* connection_manager() {
     return connection_manager_.get();
   }
   SyncSessionContext* session_context() { return session_context_.get(); }
@@ skipping 204 matching lines @@
   // |blocking_task_runner| is a TaskRunner to be used for tasks that
   // may block on disk I/O.
   scoped_refptr<base::TaskRunner> blocking_task_runner_;
 
   // We give a handle to share_ to clients of the API for use when constructing
   // any transaction type.
   UserShare share_;
 
   // This can be called from any thread, but only between calls to
   // OpenDirectory() and ShutdownOnSyncThread().
-  csync::WeakHandle<SyncManager::ChangeObserver> change_observer_;
+  syncer::WeakHandle<SyncManager::ChangeObserver> change_observer_;
 
   ObserverList<SyncManager::Observer> observers_;
 
   // The ServerConnectionManager used to abstract communication between the
   // client (the Syncer) and the sync server.
   scoped_ptr<SyncAPIServerConnectionManager> connection_manager_;
 
   // A container of various bits of information used by the SyncScheduler to
   // create SyncSessions.  Must outlive the SyncScheduler.
   scoped_ptr<SyncSessionContext> session_context_;
 
   // The scheduler that runs the Syncer. Needs to be explicitly
   // Start()ed.
   scoped_ptr<SyncScheduler> scheduler_;
 
   // The SyncNotifier which notifies us when updates need to be downloaded.
-  scoped_ptr<csync::SyncNotifier> sync_notifier_;
+  scoped_ptr<syncer::SyncNotifier> sync_notifier_;
 
   // A multi-purpose status watch object that aggregates stats from various
   // sync components.
   AllStatus allstatus_;
 
   // Each element of this array is a store of change records produced by
   // HandleChangeEvent during the CALCULATE_CHANGES step.  The changes are
   // segregated by model type, and are stored here to be processed and
   // forwarded to the observer slightly later, at the TRANSACTION_ENDING
   // step by HandleTransactionEndingChangeEvent. The list is cleared in the
@@ skipping 16 matching lines @@
   // Map used to store the notification info to be displayed in
   // about:sync page.
   NotificationInfoMap notification_info_map_;
 
   // These are for interacting with chrome://sync-internals.
   JsMessageHandlerMap js_message_handlers_;
   WeakHandle<JsEventHandler> js_event_handler_;
   JsSyncManagerObserver js_sync_manager_observer_;
   JsMutationEventObserver js_mutation_event_observer_;
 
-  csync::ThrottledDataTypeTracker throttled_data_type_tracker_;
+  syncer::ThrottledDataTypeTracker throttled_data_type_tracker_;
 
   // This is for keeping track of client events to send to the server.
   DebugInfoEventListener debug_info_event_listener_;
 
-  csync::TrafficRecorder traffic_recorder_;
+  syncer::TrafficRecorder traffic_recorder_;
 
   Encryptor* encryptor_;
   UnrecoverableErrorHandler* unrecoverable_error_handler_;
   ReportUnrecoverableErrorFunction report_unrecoverable_error_function_;
 
   MessageLoop* const created_on_loop_;
 
   // The number of times we've automatically (i.e. not via SetPassphrase or
   // conflict resolver) updated the nigori's encryption keys in this chrome
   // instantiation.
@@ skipping 45 matching lines @@
     CHECK(core);
     TimeDelta delay = TimeDelta::FromMilliseconds(
        SyncManager::kDefaultNudgeDelayMilliseconds);
     switch (delay_type) {
      case IMMEDIATE:
        delay = TimeDelta::FromMilliseconds(
            SyncManager::kDefaultNudgeDelayMilliseconds);
        break;
      case ACCOMPANY_ONLY:
        delay = TimeDelta::FromSeconds(
-           csync::kDefaultShortPollIntervalSeconds);
+           syncer::kDefaultShortPollIntervalSeconds);
        break;
      case CUSTOM:
        switch (model_type) {
          case syncable::PREFERENCES:
            delay = TimeDelta::FromMilliseconds(
                SyncManager::kPreferencesNudgeDelayMilliseconds);
            break;
          case syncable::SESSIONS:
            delay = core->scheduler()->sessions_commit_delay();
            break;
@@ skipping 18 matching lines @@
     : data_(new SyncInternal(name)) {}
 
 bool SyncManager::Init(
     const FilePath& database_location,
     const WeakHandle<JsEventHandler>& event_handler,
     const std::string& sync_server_and_path,
     int sync_server_port,
     bool use_ssl,
     const scoped_refptr<base::TaskRunner>& blocking_task_runner,
     HttpPostProviderFactory* post_factory,
-    const csync::ModelSafeRoutingInfo& model_safe_routing_info,
-    const std::vector<csync::ModelSafeWorker*>& workers,
-    csync::ExtensionsActivityMonitor* extensions_activity_monitor,
+    const syncer::ModelSafeRoutingInfo& model_safe_routing_info,
+    const std::vector<syncer::ModelSafeWorker*>& workers,
+    syncer::ExtensionsActivityMonitor* extensions_activity_monitor,
     ChangeDelegate* change_delegate,
     const SyncCredentials& credentials,
-    csync::SyncNotifier* sync_notifier,
+    syncer::SyncNotifier* sync_notifier,
     const std::string& restored_key_for_bootstrapping,
     TestingMode testing_mode,
     Encryptor* encryptor,
     UnrecoverableErrorHandler* unrecoverable_error_handler,
     ReportUnrecoverableErrorFunction report_unrecoverable_error_function) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(post_factory);
   DVLOG(1) << "SyncManager starting Init...";
   std::string server_string(sync_server_and_path);
   return data_->Init(database_location,
@@ skipping 31 matching lines @@
   ReadTransaction trans(FROM_HERE, GetUserShare());
   trans.GetWrappedTrans()->OnUnrecoverableError(
       FROM_HERE, "Simulating unrecoverable error for testing purposes.");
 }
 
 syncable::ModelTypeSet SyncManager::InitialSyncEndedTypes() {
   return data_->InitialSyncEndedTypes();
 }
 
 void SyncManager::StartSyncingNormally(
-    const csync::ModelSafeRoutingInfo& routing_info) {
+    const syncer::ModelSafeRoutingInfo& routing_info) {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->StartSyncingNormally(routing_info);
 }
 
 void SyncManager::SetEncryptionPassphrase(const std::string& passphrase,
                                           bool is_explicit) {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->SetEncryptionPassphrase(passphrase, is_explicit);
 }
 
@@ skipping 23 matching lines @@
 bool SyncManager::EncryptEverythingEnabledForTest() const {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   return trans.GetCryptographer()->encrypt_everything();
 }
 
 bool SyncManager::IsUsingExplicitPassphrase() {
   return data_ && data_->IsUsingExplicitPassphrase();
 }
 
 void SyncManager::RequestCleanupDisabledTypes(
-    const csync::ModelSafeRoutingInfo& routing_info) {
+    const syncer::ModelSafeRoutingInfo& routing_info) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (data_->scheduler()) {
     data_->session_context()->set_routing_info(routing_info);
     data_->scheduler()->CleanupDisabledTypes();
   }
 }
 
 void SyncManager::RequestConfig(
-    const csync::ModelSafeRoutingInfo& routing_info,
+    const syncer::ModelSafeRoutingInfo& routing_info,
     const ModelTypeSet& types, ConfigureReason reason) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!data_->scheduler()) {
     LOG(INFO)
         << "SyncManager::RequestConfig: bailing out because scheduler is "
         << "null";
     return;
   }
   StartConfigurationMode(base::Closure());
   data_->session_context()->set_routing_info(routing_info);
   data_->scheduler()->ScheduleConfiguration(types, GetSourceFromReason(reason));
 }
 
 void SyncManager::StartConfigurationMode(const base::Closure& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!data_->scheduler()) {
     LOG(INFO)
         << "SyncManager::StartConfigurationMode: could not start "
         << "configuration mode because because scheduler is null";
     return;
   }
   data_->scheduler()->Start(
-      csync::SyncScheduler::CONFIGURATION_MODE, callback);
+      syncer::SyncScheduler::CONFIGURATION_MODE, callback);
 }
 
 bool SyncManager::SyncInternal::Init(
     const FilePath& database_location,
     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,
     HttpPostProviderFactory* post_factory,
-    const csync::ModelSafeRoutingInfo& model_safe_routing_info,
-    const std::vector<csync::ModelSafeWorker*>& workers,
-    csync::ExtensionsActivityMonitor* extensions_activity_monitor,
+    const syncer::ModelSafeRoutingInfo& model_safe_routing_info,
+    const std::vector<syncer::ModelSafeWorker*>& workers,
+    syncer::ExtensionsActivityMonitor* extensions_activity_monitor,
     ChangeDelegate* change_delegate,
     const SyncCredentials& credentials,
-    csync::SyncNotifier* sync_notifier,
+    syncer::SyncNotifier* sync_notifier,
     const std::string& restored_key_for_bootstrapping,
     TestingMode testing_mode,
     Encryptor* encryptor,
     UnrecoverableErrorHandler* unrecoverable_error_handler,
     ReportUnrecoverableErrorFunction report_unrecoverable_error_function) {
   CHECK(!initialized_);
 
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DVLOG(1) << "Starting SyncInternal initialization.";
@@ skipping 65 matching lines @@
         &traffic_recorder_));
     session_context()->set_account_name(credentials.email);
     scheduler_.reset(new SyncScheduler(name_, session_context(), new Syncer()));
   }
 
   bool signed_in = SignIn(credentials);
 
   if (signed_in) {
     if (scheduler()) {
       scheduler()->Start(
-          csync::SyncScheduler::CONFIGURATION_MODE, base::Closure());
+          syncer::SyncScheduler::CONFIGURATION_MODE, base::Closure());
     }
 
     initialized_ = true;
 
     // Cryptographer should only be accessed while holding a
     // transaction.  Grabbing the user share for the transaction
     // checks the initialization state, so this must come after
     // |initialized_| is set to true.
     ReadTransaction trans(FROM_HERE, GetUserShare());
     trans.GetCryptographer()->Bootstrap(restored_key_for_bootstrapping);
@@ skipping 15 matching lines @@
 
   sync_notifier_->AddObserver(this);
 
   return signed_in;
 }
 
 void SyncManager::SyncInternal::UpdateCryptographerAndNigori(
     const std::string& chrome_version,
     const base::Closure& done_callback) {
   DCHECK(initialized_);
-  csync::GetSessionName(
+  syncer::GetSessionName(
       blocking_task_runner_,
       base::Bind(
           &SyncManager::SyncInternal::UpdateCryptographerAndNigoriCallback,
           weak_ptr_factory_.GetWeakPtr(),
           chrome_version,
           done_callback));
 }
 
 void SyncManager::SyncInternal::UpdateNigoriEncryptionState(
     Cryptographer* cryptographer,
@@ skipping 37 matching lines @@
     done_callback.Run();  // Should only happen during first time sync.
     return;
   }
 
   bool success = false;
   {
     WriteTransaction trans(FROM_HERE, GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     WriteNode node(&trans);
 
-    if (node.InitByTagLookup(kNigoriTag) == csync::BaseNode::INIT_OK) {
+    if (node.InitByTagLookup(kNigoriTag) == syncer::BaseNode::INIT_OK) {
       sync_pb::NigoriSpecifics nigori(node.GetNigoriSpecifics());
       Cryptographer::UpdateResult result = cryptographer->Update(nigori);
       if (result == Cryptographer::NEEDS_PASSPHRASE) {
         sync_pb::EncryptedData pending_keys;
         if (cryptographer->has_pending_keys())
           pending_keys = cryptographer->GetPendingKeys();
         FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
-                          OnPassphraseRequired(csync::REASON_DECRYPTION,
+                          OnPassphraseRequired(syncer::REASON_DECRYPTION,
                                                pending_keys));
       }
 
 
       // Add or update device information.
       bool contains_this_device = false;
       for (int i = 0; i < nigori.device_information_size(); ++i) {
         const sync_pb::DeviceInformation& device_information =
             nigori.device_information(i);
         if (device_information.cache_guid() == directory()->cache_guid()) {
@@ skipping 49 matching lines @@
   // TODO(lipalani): Explore the possibility of hooking this up to
   // SyncManager::Observer and making |AllStatus| a listener for that.
   allstatus_.SetCryptographerReady(cryptographer->is_ready());
   allstatus_.SetCryptoHasPendingKeys(cryptographer->has_pending_keys());
   debug_info_event_listener_.SetCryptographerReady(cryptographer->is_ready());
   debug_info_event_listener_.SetCrytographerHasPendingKeys(
       cryptographer->has_pending_keys());
 }
 
 void SyncManager::SyncInternal::StartSyncingNormally(
-    const csync::ModelSafeRoutingInfo& routing_info) {
+    const syncer::ModelSafeRoutingInfo& routing_info) {
   // Start the sync scheduler.
   if (scheduler()) { // NULL during certain unittests.
     session_context()->set_routing_info(routing_info);
     scheduler()->Start(SyncScheduler::NORMAL_MODE, base::Closure());
   }
 }
 
 bool SyncManager::SyncInternal::OpenDirectory() {
   DCHECK(!initialized_) << "Should only happen once";
 
   // Set before Open().
   change_observer_ =
-      csync::MakeWeakHandle(js_mutation_event_observer_.AsWeakPtr());
+      syncer::MakeWeakHandle(js_mutation_event_observer_.AsWeakPtr());
   WeakHandle<syncable::TransactionObserver> transaction_observer(
-      csync::MakeWeakHandle(js_mutation_event_observer_.AsWeakPtr()));
+      syncer::MakeWeakHandle(js_mutation_event_observer_.AsWeakPtr()));
 
   syncable::DirOpenResult open_result = syncable::NOT_INITIALIZED;
   open_result = directory()->Open(username_for_share(), this,
                                   transaction_observer);
   if (open_result != syncable::OPENED) {
     LOG(ERROR) << "Could not open share for:" << username_for_share();
     return false;
   }
 
   connection_manager()->set_client_id(directory()->cache_guid());
@@ skipping 59 matching lines @@
   if (passphrase.empty()) {
     NOTREACHED() << "Cannot encrypt with an empty passphrase.";
     return;
   }
 
   // All accesses to the cryptographer are protected by a transaction.
   WriteTransaction trans(FROM_HERE, GetUserShare());
   Cryptographer* cryptographer = trans.GetCryptographer();
   KeyParams key_params = {"localhost", "dummy", passphrase};
   WriteNode node(&trans);
-  if (node.InitByTagLookup(kNigoriTag) != csync::BaseNode::INIT_OK) {
+  if (node.InitByTagLookup(kNigoriTag) != syncer::BaseNode::INIT_OK) {
     // TODO(albertb): Plumb an UnrecoverableError all the way back to the PSS.
     NOTREACHED();
     return;
   }
 
   bool nigori_has_explicit_passphrase =
       node.GetNigoriSpecifics().using_explicit_passphrase();
   std::string bootstrap_token;
   sync_pb::EncryptedData pending_keys;
   if (cryptographer->has_pending_keys())
@@ skipping 93 matching lines @@
   if (passphrase.empty()) {
     NOTREACHED() << "Cannot decrypt with an empty passphrase.";
     return;
   }
 
   // All accesses to the cryptographer are protected by a transaction.
   WriteTransaction trans(FROM_HERE, GetUserShare());
   Cryptographer* cryptographer = trans.GetCryptographer();
   KeyParams key_params = {"localhost", "dummy", passphrase};
   WriteNode node(&trans);
-  if (node.InitByTagLookup(kNigoriTag) != csync::BaseNode::INIT_OK) {
+  if (node.InitByTagLookup(kNigoriTag) != syncer::BaseNode::INIT_OK) {
     // TODO(albertb): Plumb an UnrecoverableError all the way back to the PSS.
     NOTREACHED();
     return;
   }
 
   if (!cryptographer->has_pending_keys()) {
     // Note that this *can* happen in a rare situation where data is
     // re-encrypted on another client while a SetDecryptionPassphrase() call is
     // in-flight on this client. It is rare enough that we choose to do nothing.
     NOTREACHED() << "Attempt to set decryption passphrase failed because there "
@@ skipping 132 matching lines @@
     FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                       OnBootstrapTokenUpdated(bootstrap_token));
   }
 
   if (!success) {
     if (cryptographer->is_ready()) {
       LOG(ERROR) << "Attempt to change passphrase failed while cryptographer "
                  << "was ready.";
     } else if (cryptographer->has_pending_keys()) {
       FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
-                        OnPassphraseRequired(csync::REASON_DECRYPTION,
+                        OnPassphraseRequired(syncer::REASON_DECRYPTION,
                                              cryptographer->GetPendingKeys()));
     } else {
       FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
-                        OnPassphraseRequired(csync::REASON_ENCRYPTION,
+                        OnPassphraseRequired(syncer::REASON_ENCRYPTION,
                                              sync_pb::EncryptedData()));
     }
     return;
   }
 
   FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                     OnPassphraseAccepted());
   DCHECK(cryptographer->is_ready());
 
   // TODO(tim): Bug 58231. It would be nice if setting a passphrase didn't
@@ skipping 11 matching lines @@
   nigori_node->SetNigoriSpecifics(specifics);
 
   // Does nothing if everything is already encrypted or the cryptographer has
   // pending keys.
   ReEncryptEverything(trans);
 }
 
 bool SyncManager::SyncInternal::IsUsingExplicitPassphrase() {
   ReadTransaction trans(FROM_HERE, &share_);
   ReadNode node(&trans);
-  if (node.InitByTagLookup(kNigoriTag) != csync::BaseNode::INIT_OK) {
+  if (node.InitByTagLookup(kNigoriTag) != syncer::BaseNode::INIT_OK) {
     // TODO(albertb): Plumb an UnrecoverableError all the way back to the PSS.
     NOTREACHED();
     return false;
   }
 
   return node.GetNigoriSpecifics().using_explicit_passphrase();
 }
 
 void SyncManager::SyncInternal::RefreshEncryption() {
   DCHECK(initialized_);
 
   WriteTransaction trans(FROM_HERE, GetUserShare());
   WriteNode node(&trans);
-  if (node.InitByTagLookup(kNigoriTag) != csync::BaseNode::INIT_OK) {
+  if (node.InitByTagLookup(kNigoriTag) != syncer::BaseNode::INIT_OK) {
     NOTREACHED() << "Unable to set encrypted datatypes because Nigori node not "
                  << "found.";
     return;
   }
 
   Cryptographer* cryptographer = trans.GetCryptographer();
 
   if (!cryptographer->is_ready()) {
     DVLOG(1) << "Attempting to encrypt datatypes when cryptographer not "
              << "initialized, prompting for passphrase.";
     // TODO(zea): this isn't really decryption, but that's the only way we have
     // to prompt the user for a passsphrase. See http://crbug.com/91379.
     sync_pb::EncryptedData pending_keys;
     if (cryptographer->has_pending_keys())
       pending_keys = cryptographer->GetPendingKeys();
     FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
-                      OnPassphraseRequired(csync::REASON_DECRYPTION,
+                      OnPassphraseRequired(syncer::REASON_DECRYPTION,
                                            pending_keys));
     return;
   }
 
   UpdateNigoriEncryptionState(cryptographer, &node);
 
   allstatus_.SetEncryptedTypes(cryptographer->GetEncryptedTypes());
 
   // We reencrypt everything regardless of whether the set of encrypted
   // types changed to ensure that any stray unencrypted entries are overwritten.
@@ skipping 10 matching lines @@
     return;
   syncable::ModelTypeSet encrypted_types = GetEncryptedTypes(trans);
   for (syncable::ModelTypeSet::Iterator iter = encrypted_types.First();
        iter.Good(); iter.Inc()) {
     if (iter.Get() == syncable::PASSWORDS ||
         iter.Get() == syncable::NIGORI)
       continue; // These types handle encryption differently.
 
     ReadNode type_root(trans);
     std::string tag = syncable::ModelTypeToRootTag(iter.Get());
-    if (type_root.InitByTagLookup(tag) != csync::BaseNode::INIT_OK)
+    if (type_root.InitByTagLookup(tag) != syncer::BaseNode::INIT_OK)
       continue; // Don't try to reencrypt if the type's data is unavailable.
 
     // Iterate through all children of this datatype.
     std::queue<int64> to_visit;
     int64 child_id = type_root.GetFirstChildId();
     to_visit.push(child_id);
     while (!to_visit.empty()) {
       child_id = to_visit.front();
       to_visit.pop();
       if (child_id == kInvalidId)
         continue;
 
       WriteNode child(trans);
-      if (child.InitByIdLookup(child_id) != csync::BaseNode::INIT_OK) {
+      if (child.InitByIdLookup(child_id) != syncer::BaseNode::INIT_OK) {
         NOTREACHED();
         continue;
       }
       if (child.GetIsFolder()) {
         to_visit.push(child.GetFirstChildId());
       }
       if (child.GetEntry()->Get(syncable::UNIQUE_SERVER_TAG).empty()) {
       // Rewrite the specifics of the node with encrypted data if necessary
       // (only rewrite the non-unique folders).
         child.ResetFromSpecifics();
       }
       to_visit.push(child.GetSuccessorId());
     }
   }
 
   // Passwords are encrypted with their own legacy scheme.  Passwords are always
   // encrypted so we don't need to check GetEncryptedTypes() here.
   ReadNode passwords_root(trans);
   std::string passwords_tag =
       syncable::ModelTypeToRootTag(syncable::PASSWORDS);
   if (passwords_root.InitByTagLookup(passwords_tag) ==
-          csync::BaseNode::INIT_OK) {
+          syncer::BaseNode::INIT_OK) {
     int64 child_id = passwords_root.GetFirstChildId();
     while (child_id != kInvalidId) {
       WriteNode child(trans);
-      if (child.InitByIdLookup(child_id) != csync::BaseNode::INIT_OK) {
+      if (child.InitByIdLookup(child_id) != syncer::BaseNode::INIT_OK) {
         NOTREACHED();
         return;
       }
       child.SetPasswordSpecifics(child.GetPasswordSpecifics());
       child_id = child.GetSuccessorId();
     }
   }
 
   // NOTE: We notify from within a transaction.
   FOR_EACH_OBSERVER(SyncManager::Observer, observers_, OnEncryptionComplete());
@@ skipping 99 matching lines @@
 void SyncManager::SyncInternal::OnIPAddressChangedImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (scheduler())
     scheduler()->OnConnectionStatusChange();
 }
 
 void SyncManager::SyncInternal::OnServerConnectionEvent(
     const ServerConnectionEvent& event) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (event.connection_code ==
-      csync::HttpResponse::SERVER_CONNECTION_OK) {
+      syncer::HttpResponse::SERVER_CONNECTION_OK) {
     FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                       OnConnectionStatusChange(CONNECTION_OK));
   }
 
-  if (event.connection_code == csync::HttpResponse::SYNC_AUTH_ERROR) {
+  if (event.connection_code == syncer::HttpResponse::SYNC_AUTH_ERROR) {
     observing_ip_address_changes_ = false;
     FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                       OnConnectionStatusChange(CONNECTION_AUTH_ERROR));
   }
 
   if (event.connection_code ==
-      csync::HttpResponse::SYNC_SERVER_ERROR) {
+      syncer::HttpResponse::SYNC_SERVER_ERROR) {
     FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                       OnConnectionStatusChange(CONNECTION_SERVER_ERROR));
   }
 }
 
 void SyncManager::SyncInternal::HandleTransactionCompleteChangeEvent(
     ModelTypeSet models_with_changes) {
   // This notification happens immediately after the transaction mutex is
   // released. This allows work to be performed without blocking other threads
   // from acquiring a transaction.
@@ skipping 169 matching lines @@
 }
 
 SyncStatus SyncManager::SyncInternal::GetStatus() {
   return allstatus_.status();
 }
 
 void SyncManager::SyncInternal::RequestNudge(
     const tracked_objects::Location& location) {
   if (scheduler()) {
      scheduler()->ScheduleNudgeAsync(
-        TimeDelta::FromMilliseconds(0), csync::NUDGE_SOURCE_LOCAL,
+        TimeDelta::FromMilliseconds(0), syncer::NUDGE_SOURCE_LOCAL,
         ModelTypeSet(), location);
   }
 }
 
 TimeDelta SyncManager::SyncInternal::GetNudgeDelayTimeDelta(
     const ModelType& model_type) {
   return NudgeStrategy::GetNudgeDelayTimeDelta(model_type, this);
 }
 
 void SyncManager::SyncInternal::RequestNudgeForDataTypes(
     const tracked_objects::Location& nudge_location,
     ModelTypeSet types) {
   if (!scheduler()) {
     NOTREACHED();
     return;
   }
 
   debug_info_event_listener_.OnNudgeFromDatatype(types.First().Get());
 
   // TODO(lipalani) : Calculate the nudge delay based on all types.
   base::TimeDelta nudge_delay = NudgeStrategy::GetNudgeDelayTimeDelta(
       types.First().Get(),
       this);
   scheduler()->ScheduleNudgeAsync(nudge_delay,
-                                  csync::NUDGE_SOURCE_LOCAL,
+                                  syncer::NUDGE_SOURCE_LOCAL,
                                   types,
                                   nudge_location);
 }
 
 void SyncManager::SyncInternal::OnSyncEngineEvent(
     const SyncEngineEvent& event) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Only send an event if this is due to a cycle ending and this cycle
   // concludes a canonical "sync" process; that is, based on what is known
   // locally we are "all happy" and up-to-date.  There may be new changes on
   // the server, but we'll get them on a subsequent sync.
   //
   // Notifications are sent at the end of every sync cycle, regardless of
   // whether we should sync again.
   if (event.what_happened == SyncEngineEvent::SYNC_CYCLE_ENDED) {
     {
       // Check to see if we need to notify the frontend that we have newly
       // encrypted types or that we require a passphrase.
       ReadTransaction trans(FROM_HERE, GetUserShare());
       Cryptographer* cryptographer = trans.GetCryptographer();
       // If we've completed a sync cycle and the cryptographer isn't ready
       // yet, prompt the user for a passphrase.
       if (cryptographer->has_pending_keys()) {
         DVLOG(1) << "OnPassPhraseRequired Sent";
         sync_pb::EncryptedData pending_keys = cryptographer->GetPendingKeys();
         FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
-                          OnPassphraseRequired(csync::REASON_DECRYPTION,
+                          OnPassphraseRequired(syncer::REASON_DECRYPTION,
                                                pending_keys));
       } else if (!cryptographer->is_ready() &&
                  event.snapshot.initial_sync_ended().Has(syncable::NIGORI)) {
         DVLOG(1) << "OnPassphraseRequired sent because cryptographer is not "
                  << "ready";
         FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
-                          OnPassphraseRequired(csync::REASON_ENCRYPTION,
+                          OnPassphraseRequired(syncer::REASON_ENCRYPTION,
                                                sync_pb::EncryptedData()));
       }
 
       NotifyCryptographerState(cryptographer);
       allstatus_.SetEncryptedTypes(cryptographer->GetEncryptedTypes());
     }
 
     if (!initialized_) {
       LOG(INFO) << "OnSyncCycleCompleted not sent because sync api is not "
                 << "initialized";
       return;
     }
 
     if (!event.snapshot.has_more_to_sync()) {
       // To account for a nigori node arriving with stale/bad data, we ensure
       // that the nigori node is up to date at the end of each cycle.
       WriteTransaction trans(FROM_HERE, GetUserShare());
       WriteNode nigori_node(&trans);
       if (nigori_node.InitByTagLookup(kNigoriTag) ==
-              csync::BaseNode::INIT_OK) {
+              syncer::BaseNode::INIT_OK) {
         Cryptographer* cryptographer = trans.GetCryptographer();
         UpdateNigoriEncryptionState(cryptographer, &nigori_node);
       }
 
       DVLOG(1) << "Sending OnSyncCycleCompleted";
       FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                         OnSyncCycleCompleted(event.snapshot));
     }
 
     // This is here for tests, which are still using p2p notifications.
@@ skipping 148 matching lines @@
   ListValue* id_list = NULL;
   ReadTransaction trans(FROM_HERE, user_share);
   if (args.Get().GetList(0, &id_list)) {
     CHECK(id_list);
     for (size_t i = 0; i < id_list->GetSize(); ++i) {
       int64 id = GetId(*id_list, i);
       if (id == kInvalidId) {
         continue;
       }
       ReadNode node(&trans);
-      if (node.InitByIdLookup(id) != csync::BaseNode::INIT_OK) {
+      if (node.InitByIdLookup(id) != syncer::BaseNode::INIT_OK) {
         continue;
       }
       node_summaries->Append((node.*info_getter)());
     }
   }
   return JsArgList(&return_args);
 }
 
 }  // namespace
 
@@ skipping 77 matching lines @@
     DictionaryValue details;
     details.Set("enabled", Value::CreateBooleanValue(true));
     js_event_handler_.Call(FROM_HERE,
                            &JsEventHandler::HandleJsEvent,
                            "onNotificationStateChange",
                            JsEventDetails(&details));
   }
 }
 
 void SyncManager::SyncInternal::OnNotificationsDisabled(
-    csync::NotificationsDisabledReason reason) {
+    syncer::NotificationsDisabledReason reason) {
   DVLOG(1) << "Notifications disabled with reason "
-           << csync::NotificationsDisabledReasonToString(reason);
+           << syncer::NotificationsDisabledReasonToString(reason);
   allstatus_.SetNotificationsEnabled(false);
   if (scheduler()) {
     scheduler()->set_notifications_enabled(false);
   }
   if (js_event_handler_.IsInitialized()) {
     DictionaryValue details;
     details.Set("enabled", Value::CreateBooleanValue(false));
     js_event_handler_.Call(FROM_HERE,
                            &JsEventHandler::HandleJsEvent,
                            "onNotificationStateChange",
                            JsEventDetails(&details));
   }
   // TODO(akalin): Treat a CREDENTIALS_REJECTED state as an auth
   // error.
 }
 
 void SyncManager::SyncInternal::OnIncomingNotification(
     const syncable::ModelTypePayloadMap& type_payloads,
-    csync::IncomingNotificationSource source) {
+    syncer::IncomingNotificationSource source) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (source == csync::LOCAL_NOTIFICATION) {
+  if (source == syncer::LOCAL_NOTIFICATION) {
     if (scheduler()) {
       scheduler()->ScheduleNudgeWithPayloadsAsync(
           TimeDelta::FromMilliseconds(kSyncRefreshDelayMsec),
-          csync::NUDGE_SOURCE_LOCAL_REFRESH,
+          syncer::NUDGE_SOURCE_LOCAL_REFRESH,
           type_payloads, FROM_HERE);
     }
   } else if (!type_payloads.empty()) {
     if (scheduler()) {
       scheduler()->ScheduleNudgeWithPayloadsAsync(
           TimeDelta::FromMilliseconds(kSyncSchedulerDelayMsec),
-          csync::NUDGE_SOURCE_NOTIFICATION,
+          syncer::NUDGE_SOURCE_NOTIFICATION,
           type_payloads, FROM_HERE);
     }
     allstatus_.IncrementNotificationsReceived();
     UpdateNotificationInfo(type_payloads);
     debug_info_event_listener_.OnIncomingNotification(type_payloads);
   } else {
     LOG(WARNING) << "Sync received notification without any type information.";
   }
 
   if (js_event_handler_.IsInitialized()) {
     DictionaryValue details;
     ListValue* changed_types = new ListValue();
     details.Set("changedTypes", changed_types);
     for (syncable::ModelTypePayloadMap::const_iterator
              it = type_payloads.begin();
          it != type_payloads.end(); ++it) {
       const std::string& model_type_str =
           syncable::ModelTypeToString(it->first);
       changed_types->Append(Value::CreateStringValue(model_type_str));
     }
-    details.SetString("source", (source == csync::LOCAL_NOTIFICATION) ?
+    details.SetString("source", (source == syncer::LOCAL_NOTIFICATION) ?
         "LOCAL_NOTIFICATION" : "REMOTE_NOTIFICATION");
     js_event_handler_.Call(FROM_HERE,
                            &JsEventHandler::HandleJsEvent,
                            "onIncomingNotification",
                            JsEventDetails(&details));
   }
 }
 
 void SyncManager::SyncInternal::AddObserver(
     SyncManager::Observer* observer) {
@@ skipping 33 matching lines @@
 TimeDelta SyncManager::GetNudgeDelayTimeDelta(
     const ModelType& model_type) {
   return data_->GetNudgeDelayTimeDelta(model_type);
 }
 
 syncable::ModelTypeSet SyncManager::GetEncryptedDataTypesForTest() const {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   return GetEncryptedTypes(&trans);
 }
 
-bool SyncManager::ReceivedExperiment(csync::Experiments* experiments)
+bool SyncManager::ReceivedExperiment(syncer::Experiments* experiments)
     const {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   ReadNode node(&trans);
-  if (node.InitByTagLookup(kNigoriTag) != csync::BaseNode::INIT_OK) {
+  if (node.InitByTagLookup(kNigoriTag) != syncer::BaseNode::INIT_OK) {
     DVLOG(1) << "Couldn't find Nigori node.";
     return false;
   }
   bool found_experiment = false;
   if (node.GetNigoriSpecifics().sync_tab_favicons()) {
     experiments->sync_tab_favicons = true;
     found_experiment = true;
   }
   return found_experiment;
 }
 
 bool SyncManager::HasUnsyncedItems() const {
-  csync::ReadTransaction trans(FROM_HERE, GetUserShare());
+  syncer::ReadTransaction trans(FROM_HERE, GetUserShare());
   return (trans.GetWrappedTrans()->directory()->unsynced_entity_count() != 0);
 }
 
 void SyncManager::SimulateEnableNotificationsForTest() {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->OnNotificationsEnabled();
 }
 
 void SyncManager::SimulateDisableNotificationsForTest(int reason) {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->OnNotificationsDisabled(
-      static_cast<csync::NotificationsDisabledReason>(reason));
+      static_cast<syncer::NotificationsDisabledReason>(reason));
 }
 
 void SyncManager::TriggerOnIncomingNotificationForTest(
     ModelTypeSet model_types) {
   DCHECK(thread_checker_.CalledOnValidThread());
   syncable::ModelTypePayloadMap model_types_with_payloads =
       syncable::ModelTypePayloadMapFromEnumSet(model_types,
           std::string());
 
   data_->OnIncomingNotification(model_types_with_payloads,
-                                csync::REMOTE_NOTIFICATION);
+                                syncer::REMOTE_NOTIFICATION);
 }
 
 const char* ConnectionStatusToString(ConnectionStatus status) {
   switch (status) {
     case CONNECTION_OK:
       return "CONNECTION_OK";
     case CONNECTION_AUTH_ERROR:
       return "CONNECTION_AUTH_ERROR";
     case CONNECTION_SERVER_ERROR:
       return "CONNECTION_SERVER_ERROR";
@@ skipping 14 matching lines @@
     case REASON_DECRYPTION:
       return "REASON_DECRYPTION";
     default:
       NOTREACHED();
       return "INVALID_REASON";
   }
 }
 
 // Helper function to determine if initial sync had ended for types.
 bool InitialSyncEndedForTypes(syncable::ModelTypeSet types,
-                              csync::UserShare* share) {
+                              syncer::UserShare* share) {
   for (syncable::ModelTypeSet::Iterator i = types.First();
        i.Good(); i.Inc()) {
     if (!share->directory->initial_sync_ended_for_type(i.Get()))
       return false;
   }
   return true;
 }
 
 syncable::ModelTypeSet GetTypesWithEmptyProgressMarkerToken(
     syncable::ModelTypeSet types,
-    csync::UserShare* share) {
+    syncer::UserShare* share) {
   syncable::ModelTypeSet result;
   for (syncable::ModelTypeSet::Iterator i = types.First();
        i.Good(); i.Inc()) {
     sync_pb::DataTypeProgressMarker marker;
     share->directory->GetDownloadProgress(i.Get(), &marker);
 
     if (marker.token().empty())
       result.Put(i.Get());
 
   }
   return result;
 }
 
-}  // namespace csync
+}  // namespace syncer