[Sync] Move ModelType and related classes to 'syncer' namespace

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 80 matching lines @@
 // 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 syncer {
 
 using sessions::SyncSessionContext;
 using syncable::ImmutableWriteTransactionInfo;
-using syncable::ModelType;
-using syncable::ModelTypeSet;
 using syncable::SPECIFICS;
 
 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;
 
 //////////////////////////////////////////////////////////////////////////
@@ skipping 15 matching lines @@
         testing_mode_(NON_TEST),
         observing_ip_address_changes_(false),
         throttled_data_type_tracker_(&allstatus_),
         traffic_recorder_(kMaxMessagesToRecord, kMaxMessageSizeToRecord),
         encryptor_(NULL),
         unrecoverable_error_handler_(NULL),
         report_unrecoverable_error_function_(NULL),
         created_on_loop_(MessageLoop::current()),
         nigori_overwrite_count_(0) {
     // Pre-fill |notification_info_map_|.
-    for (int i = syncable::FIRST_REAL_MODEL_TYPE;
-         i < syncable::MODEL_TYPE_COUNT; ++i) {
+    for (int i = syncer::FIRST_REAL_MODEL_TYPE;
+         i < syncer::MODEL_TYPE_COUNT; ++i) {
       notification_info_map_.insert(
-          std::make_pair(syncable::ModelTypeFromInt(i), NotificationInfo()));
+          std::make_pair(syncer::ModelTypeFromInt(i), NotificationInfo()));
     }
 
     // Bind message handlers.
     BindJsMessageHandler(
         "getNotificationState",
         &SyncManager::SyncInternal::GetNotificationState);
     BindJsMessageHandler(
         "getNotificationInfo",
         &SyncManager::SyncInternal::GetNotificationInfo);
     BindJsMessageHandler(
@@ skipping 138 matching lines @@
       syncable::BaseTransaction* trans) OVERRIDE;
   virtual void HandleCalculateChangesChangeEventFromSyncer(
       const ImmutableWriteTransactionInfo& write_transaction_info,
       syncable::BaseTransaction* trans) OVERRIDE;
 
   // Open the directory named with username_for_share
   bool OpenDirectory();
 
   // Cryptographer::Observer implementation.
   virtual void OnEncryptedTypesChanged(
-      syncable::ModelTypeSet encrypted_types,
+      syncer::ModelTypeSet encrypted_types,
       bool encrypt_everything) OVERRIDE;
 
   // SyncNotifierObserver implementation.
   virtual void OnNotificationsEnabled() OVERRIDE;
   virtual void OnNotificationsDisabled(
       syncer::NotificationsDisabledReason reason) OVERRIDE;
   virtual void OnIncomingNotification(
-      const syncable::ModelTypePayloadMap& type_payloads,
+      const syncer::ModelTypePayloadMap& type_payloads,
       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();
   }
@@ skipping 23 matching lines @@
   void NotifyCryptographerState(Cryptographer* cryptographer);
 
   // See SyncManager::Shutdown* for information.
   void StopSyncingForShutdown(const base::Closure& callback);
   void ShutdownOnSyncThread();
 
   // If this is a deletion for a password, sets the legacy
   // ExtraPasswordChangeRecordData field of |buffer|. Otherwise sets
   // |buffer|'s specifics field to contain the unencrypted data.
   void SetExtraChangeRecordData(int64 id,
-                                syncable::ModelType type,
+                                syncer::ModelType type,
                                 ChangeReorderBuffer* buffer,
                                 Cryptographer* cryptographer,
                                 const syncable::EntryKernel& original,
                                 bool existed_before,
                                 bool exists_now);
 
   // Called only by our NetworkChangeNotifier.
   virtual void OnIPAddressChanged() OVERRIDE;
 
-  syncable::ModelTypeSet InitialSyncEndedTypes() {
+  syncer::ModelTypeSet InitialSyncEndedTypes() {
     DCHECK(initialized_);
     return directory()->initial_sync_ended_types();
   }
 
   // SyncEngineEventListener implementation.
   virtual void OnSyncEngineEvent(const SyncEngineEvent& event) OVERRIDE;
 
   // ServerConnectionEventListener implementation.
   virtual void OnServerConnectionEvent(
       const ServerConnectionEvent& event) OVERRIDE;
@@ skipping 16 matching lines @@
 
     // Returned pointer owned by the caller.
     DictionaryValue* ToValue() const {
       DictionaryValue* value = new DictionaryValue();
       value->SetInteger("totalCount", total_count);
       value->SetString("payload", payload);
       return value;
     }
   };
 
-  typedef std::map<syncable::ModelType, NotificationInfo> NotificationInfoMap;
+  typedef std::map<syncer::ModelType, NotificationInfo> NotificationInfoMap;
   typedef JsArgList
       (SyncManager::SyncInternal::*UnboundJsMessageHandler)(const JsArgList&);
   typedef base::Callback<JsArgList(const JsArgList&)> JsMessageHandler;
   typedef std::map<std::string, JsMessageHandler> JsMessageHandlerMap;
 
   // Internal callback of UpdateCryptographerAndNigoriCallback.
   void UpdateCryptographerAndNigoriCallback(
       const std::string& chrome_version,
       const base::Closure& 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
   // of all siblings.
   static bool VisiblePositionsDiffer(
       const syncable::EntryKernelMutation& mutation) {
     const syncable::EntryKernel& a = mutation.original;
     const syncable::EntryKernel& b = mutation.mutated;
     // If the datatype isn't one where the browser model cares about position,
     // don't bother notifying that data model of position-only changes.
     if (!ShouldMaintainPosition(
-            syncable::GetModelTypeFromSpecifics(b.ref(SPECIFICS))))
+            syncer::GetModelTypeFromSpecifics(b.ref(SPECIFICS))))
       return false;
     if (a.ref(syncable::NEXT_ID) != b.ref(syncable::NEXT_ID))
       return true;
     if (a.ref(syncable::PARENT_ID) != b.ref(syncable::PARENT_ID))
       return true;
     return false;
   }
 
   // Determine if any of the fields made visible to clients of the Sync API
   // differ between the versions of an entry stored in |a| and |b|. A return
   // value of false means that it should be OK to ignore this change.
   static bool VisiblePropertiesDiffer(
       const syncable::EntryKernelMutation& mutation,
       Cryptographer* cryptographer) {
     const syncable::EntryKernel& a = mutation.original;
     const syncable::EntryKernel& b = mutation.mutated;
     const sync_pb::EntitySpecifics& a_specifics = a.ref(SPECIFICS);
     const sync_pb::EntitySpecifics& b_specifics = b.ref(SPECIFICS);
-    DCHECK_EQ(syncable::GetModelTypeFromSpecifics(a_specifics),
-              syncable::GetModelTypeFromSpecifics(b_specifics));
-    syncable::ModelType model_type =
-        syncable::GetModelTypeFromSpecifics(b_specifics);
+    DCHECK_EQ(syncer::GetModelTypeFromSpecifics(a_specifics),
+              syncer::GetModelTypeFromSpecifics(b_specifics));
+    syncer::ModelType model_type =
+        syncer::GetModelTypeFromSpecifics(b_specifics);
     // Suppress updates to items that aren't tracked by any browser model.
-    if (model_type < syncable::FIRST_REAL_MODEL_TYPE ||
+    if (model_type < syncer::FIRST_REAL_MODEL_TYPE ||
         !a.ref(syncable::UNIQUE_SERVER_TAG).empty()) {
       return false;
     }
     if (a.ref(syncable::IS_DIR) != b.ref(syncable::IS_DIR))
       return true;
     if (!AreSpecificsEqual(cryptographer,
                            a.ref(syncable::SPECIFICS),
                            b.ref(syncable::SPECIFICS))) {
       return true;
     }
     // We only care if the name has changed if neither specifics is encrypted
     // (encrypted nodes blow away the NON_UNIQUE_NAME).
     if (!a_specifics.has_encrypted() && !b_specifics.has_encrypted() &&
         a.ref(syncable::NON_UNIQUE_NAME) != b.ref(syncable::NON_UNIQUE_NAME))
       return true;
     if (VisiblePositionsDiffer(mutation))
       return true;
     return false;
   }
 
   bool ChangeBuffersAreEmpty() {
-    for (int i = 0; i < syncable::MODEL_TYPE_COUNT; ++i) {
+    for (int i = 0; i < syncer::MODEL_TYPE_COUNT; ++i) {
       if (!change_buffers_[i].IsEmpty())
         return false;
     }
     return true;
   }
 
   void ReEncryptEverything(WriteTransaction* trans);
 
   // Called for every notification. This updates the notification statistics
   // to be displayed in about:sync.
   void UpdateNotificationInfo(
-      const syncable::ModelTypePayloadMap& type_payloads);
+      const syncer::ModelTypePayloadMap& type_payloads);
 
   // Checks for server reachabilty and requests a nudge.
   void OnIPAddressChangedImpl();
 
   // Helper function used only by the constructor.
   void BindJsMessageHandler(
     const std::string& name, UnboundJsMessageHandler unbound_message_handler);
 
   // Returned pointer is owned by the caller.
   static DictionaryValue* NotificationInfoToValue(
@@ skipping 60 matching lines @@
   // 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
   // TRANSACTION_COMPLETE step by HandleTransactionCompleteChangeEvent.
-  ChangeReorderBuffer change_buffers_[syncable::MODEL_TYPE_COUNT];
+  ChangeReorderBuffer change_buffers_[syncer::MODEL_TYPE_COUNT];
 
   SyncManager::ChangeDelegate* change_delegate_;
 
   // Set to true once Init has been called.
   bool initialized_;
 
   // Controls the disabling of certain SyncManager features.
   // Can be used to disable communication with the server and the use of an
   // on-disk file for maintaining syncer state.
   // TODO(117836): Clean up implementation of SyncManager unit tests.
@@ skipping 52 matching lines @@
     // Sync this change while syncing another change.
     ACCOMPANY_ONLY,
 
     // The datatype does not use one of the predefined wait times but defines
     // its own wait time logic for nudge.
     CUSTOM,
   };
 
   static NudgeDelayStrategy GetNudgeDelayStrategy(const ModelType& type) {
     switch (type) {
-     case syncable::AUTOFILL:
+     case syncer::AUTOFILL:
        return ACCOMPANY_ONLY;
-     case syncable::PREFERENCES:
-     case syncable::SESSIONS:
+     case syncer::PREFERENCES:
+     case syncer::SESSIONS:
        return CUSTOM;
      default:
        return IMMEDIATE;
     }
   }
 
   static TimeDelta GetNudgeDelayTimeDeltaFromType(
       const NudgeDelayStrategy& delay_type, const ModelType& model_type,
       const SyncManager::SyncInternal* core) {
     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(
            syncer::kDefaultShortPollIntervalSeconds);
        break;
      case CUSTOM:
        switch (model_type) {
-         case syncable::PREFERENCES:
+         case syncer::PREFERENCES:
            delay = TimeDelta::FromMilliseconds(
                SyncManager::kPreferencesNudgeDelayMilliseconds);
            break;
-         case syncable::SESSIONS:
+         case syncer::SESSIONS:
            delay = core->scheduler()->sessions_commit_delay();
            break;
          default:
            NOTREACHED();
        }
        break;
      default:
        NOTREACHED();
     }
     return delay;
@@ skipping 62 matching lines @@
   data_->UpdateEnabledTypes(enabled_types);
 }
 
 void SyncManager::ThrowUnrecoverableError() {
   DCHECK(thread_checker_.CalledOnValidThread());
   ReadTransaction trans(FROM_HERE, GetUserShare());
   trans.GetWrappedTrans()->OnUnrecoverableError(
       FROM_HERE, "Simulating unrecoverable error for testing purposes.");
 }
 
-syncable::ModelTypeSet SyncManager::InitialSyncEndedTypes() {
+syncer::ModelTypeSet SyncManager::InitialSyncEndedTypes() {
   return data_->InitialSyncEndedTypes();
 }
 
 void SyncManager::StartSyncingNormally(
     const syncer::ModelSafeRoutingInfo& routing_info) {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->StartSyncingNormally(routing_info);
 }
 
 void SyncManager::SetEncryptionPassphrase(const std::string& passphrase,
@@ skipping 245 matching lines @@
   cryptographer->UpdateNigoriFromEncryptedTypes(&nigori);
 
   // If nothing has changed, this is a no-op.
   nigori_node->SetNigoriSpecifics(nigori);
 }
 
 void SyncManager::SyncInternal::UpdateCryptographerAndNigoriCallback(
     const std::string& chrome_version,
     const base::Closure& done_callback,
     const std::string& session_name) {
-  if (!directory()->initial_sync_ended_for_type(syncable::NIGORI)) {
+  if (!directory()->initial_sync_ended_for_type(syncer::NIGORI)) {
     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);
 
@@ skipping 519 matching lines @@
 }
 
 // This function iterates over all encrypted types.  There are many scenarios in
 // which data for some or all types is not currently available.  In that case,
 // the lookup of the root node will fail and we will skip encryption for that
 // type.
 void SyncManager::SyncInternal::ReEncryptEverything(WriteTransaction* trans) {
   Cryptographer* cryptographer = trans->GetCryptographer();
   if (!cryptographer || !cryptographer->is_ready())
     return;
-  syncable::ModelTypeSet encrypted_types = GetEncryptedTypes(trans);
-  for (syncable::ModelTypeSet::Iterator iter = encrypted_types.First();
+  syncer::ModelTypeSet encrypted_types = GetEncryptedTypes(trans);
+  for (syncer::ModelTypeSet::Iterator iter = encrypted_types.First();
        iter.Good(); iter.Inc()) {
-    if (iter.Get() == syncable::PASSWORDS ||
-        iter.Get() == syncable::NIGORI)
+    if (iter.Get() == syncer::PASSWORDS || iter.Get() == syncer::NIGORI)
       continue; // These types handle encryption differently.
 
     ReadNode type_root(trans);
-    std::string tag = syncable::ModelTypeToRootTag(iter.Get());
+    std::string tag = syncer::ModelTypeToRootTag(iter.Get());
     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();
@@ skipping 13 matching lines @@
       // (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);
+  std::string passwords_tag = syncer::ModelTypeToRootTag(syncer::PASSWORDS);
   if (passwords_root.InitByTagLookup(passwords_tag) ==
           syncer::BaseNode::INIT_OK) {
     int64 child_id = passwords_root.GetFirstChildId();
     while (child_id != kInvalidId) {
       WriteNode child(trans);
       if (child.InitByIdLookup(child_id) != syncer::BaseNode::INIT_OK) {
         NOTREACHED();
         return;
       }
       child.SetPasswordSpecifics(child.GetPasswordSpecifics());
@@ skipping 157 matching lines @@
   if (!change_delegate_ || ChangeBuffersAreEmpty())
     return ModelTypeSet();
 
   // This will continue the WriteTransaction using a read only wrapper.
   // This is the last chance for read to occur in the WriteTransaction
   // that's closing. This special ReadTransaction will not close the
   // underlying transaction.
   ReadTransaction read_trans(GetUserShare(), trans);
 
   ModelTypeSet models_with_changes;
-  for (int i = syncable::FIRST_REAL_MODEL_TYPE;
-       i < syncable::MODEL_TYPE_COUNT; ++i) {
-    const syncable::ModelType type = syncable::ModelTypeFromInt(i);
+  for (int i = syncer::FIRST_REAL_MODEL_TYPE;
+       i < syncer::MODEL_TYPE_COUNT; ++i) {
+    const syncer::ModelType type = syncer::ModelTypeFromInt(i);
     if (change_buffers_[type].IsEmpty())
       continue;
 
     ImmutableChangeRecordList ordered_changes;
     // TODO(akalin): Propagate up the error further (see
     // http://crbug.com/100907).
     CHECK(change_buffers_[type].GetAllChangesInTreeOrder(&read_trans,
                                                          &ordered_changes));
     if (!ordered_changes.Get().empty()) {
       change_delegate_->
@@ skipping 13 matching lines @@
     syncable::BaseTransaction* trans) {
   if (!scheduler()) {
     return;
   }
 
   // We have been notified about a user action changing a sync model.
   LOG_IF(WARNING, !ChangeBuffersAreEmpty()) <<
       "CALCULATE_CHANGES called with unapplied old changes.";
 
   // The mutated model type, or UNSPECIFIED if nothing was mutated.
-  syncable::ModelTypeSet mutated_model_types;
+  syncer::ModelTypeSet mutated_model_types;
 
   const syncable::ImmutableEntryKernelMutationMap& mutations =
       write_transaction_info.Get().mutations;
   for (syncable::EntryKernelMutationMap::const_iterator it =
            mutations.Get().begin(); it != mutations.Get().end(); ++it) {
     if (!it->second.mutated.ref(syncable::IS_UNSYNCED)) {
       continue;
     }
 
-    syncable::ModelType model_type =
-        syncable::GetModelTypeFromSpecifics(
+    syncer::ModelType model_type =
+        syncer::GetModelTypeFromSpecifics(
             it->second.mutated.ref(SPECIFICS));
-    if (model_type < syncable::FIRST_REAL_MODEL_TYPE) {
+    if (model_type < syncer::FIRST_REAL_MODEL_TYPE) {
       NOTREACHED() << "Permanent or underspecified item changed via syncapi.";
       continue;
     }
 
     // Found real mutation.
-    if (model_type != syncable::UNSPECIFIED) {
+    if (model_type != syncer::UNSPECIFIED) {
       mutated_model_types.Put(model_type);
     }
   }
 
   // Nudge if necessary.
   if (!mutated_model_types.Empty()) {
     if (weak_handle_this_.IsInitialized()) {
       weak_handle_this_.Call(FROM_HERE,
                              &SyncInternal::RequestNudgeForDataTypes,
                              FROM_HERE,
                              mutated_model_types);
     } else {
       NOTREACHED();
     }
   }
 }
 
 void SyncManager::SyncInternal::SetExtraChangeRecordData(int64 id,
-    syncable::ModelType type, ChangeReorderBuffer* buffer,
+    syncer::ModelType type, ChangeReorderBuffer* buffer,
     Cryptographer* cryptographer, const syncable::EntryKernel& original,
     bool existed_before, bool exists_now) {
   // If this is a deletion and the datatype was encrypted, we need to decrypt it
   // and attach it to the buffer.
   if (!exists_now && existed_before) {
     sync_pb::EntitySpecifics original_specifics(original.ref(SPECIFICS));
-    if (type == syncable::PASSWORDS) {
+    if (type == syncer::PASSWORDS) {
       // Passwords must use their own legacy ExtraPasswordChangeRecordData.
       scoped_ptr<sync_pb::PasswordSpecificsData> data(
           DecryptPasswordSpecifics(original_specifics, cryptographer));
       if (!data.get()) {
         NOTREACHED();
         return;
       }
       buffer->SetExtraDataForId(id, new ExtraPasswordChangeRecordData(*data));
     } else if (original_specifics.has_encrypted()) {
       // All other datatypes can just create a new unencrypted specifics and
@@ skipping 18 matching lines @@
 
   Cryptographer* crypto = directory()->GetCryptographer(trans);
   const syncable::ImmutableEntryKernelMutationMap& mutations =
       write_transaction_info.Get().mutations;
   for (syncable::EntryKernelMutationMap::const_iterator it =
            mutations.Get().begin(); it != mutations.Get().end(); ++it) {
     bool existed_before = !it->second.original.ref(syncable::IS_DEL);
     bool exists_now = !it->second.mutated.ref(syncable::IS_DEL);
 
     // Omit items that aren't associated with a model.
-    syncable::ModelType type =
-        syncable::GetModelTypeFromSpecifics(
+    syncer::ModelType type =
+        syncer::GetModelTypeFromSpecifics(
             it->second.mutated.ref(SPECIFICS));
-    if (type < syncable::FIRST_REAL_MODEL_TYPE)
+    if (type < syncer::FIRST_REAL_MODEL_TYPE)
       continue;
 
     int64 handle = it->first;
     if (exists_now && !existed_before)
       change_buffers_[type].PushAddedItem(handle);
     else if (!exists_now && existed_before)
       change_buffers_[type].PushDeletedItem(handle);
     else if (exists_now && existed_before &&
              VisiblePropertiesDiffer(it->second, crypto)) {
       change_buffers_[type].PushUpdatedItem(
@@ skipping 61 matching lines @@
       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(syncer::REASON_DECRYPTION,
                                                pending_keys));
       } else if (!cryptographer->is_ready() &&
-                 event.snapshot.initial_sync_ended().Has(syncable::NIGORI)) {
+                 event.snapshot.initial_sync_ended().Has(syncer::NIGORI)) {
         DVLOG(1) << "OnPassphraseRequired sent because cryptographer is not "
                  << "ready";
         FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                           OnPassphraseRequired(syncer::REASON_ENCRYPTION,
                                                sync_pb::EncryptedData()));
       }
 
       NotifyCryptographerState(cryptographer);
       allstatus_.SetEncryptedTypes(cryptographer->GetEncryptedTypes());
     }
@@ skipping 22 matching lines @@
 
     // 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()) {
         const ModelTypeSet changed_types =
-            syncable::ModelTypePayloadMapToEnumSet(
+            syncer::ModelTypePayloadMapToEnumSet(
                 event.snapshot.source().types);
         sync_notifier_->SendNotification(changed_types);
       } else {
         DVLOG(1) << "Not sending notification: sync_notifier_ is NULL";
       }
     }
   }
 
   if (event.what_happened == SyncEngineEvent::STOP_SYNCING_PERMANENTLY) {
     FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
@@ skipping 57 matching lines @@
       base::Bind(unbound_message_handler, base::Unretained(this));
 }
 
 DictionaryValue* SyncManager::SyncInternal::NotificationInfoToValue(
     const NotificationInfoMap& notification_info) {
   DictionaryValue* value = new DictionaryValue();
 
   for (NotificationInfoMap::const_iterator it = notification_info.begin();
       it != notification_info.end(); ++it) {
     const std::string& model_type_str =
-        syncable::ModelTypeToString(it->first);
+        syncer::ModelTypeToString(it->first);
     value->Set(model_type_str, it->second.ToValue());
   }
 
   return value;
 }
 
 JsArgList SyncManager::SyncInternal::GetNotificationState(
     const JsArgList& args) {
   bool notifications_enabled = allstatus_.status().notifications_enabled;
   ListValue return_args;
@@ skipping 112 matching lines @@
     for (syncable::Directory::ChildHandles::const_iterator it =
              child_handles.begin(); it != child_handles.end(); ++it) {
       child_ids->Append(Value::CreateStringValue(
           base::Int64ToString(*it)));
     }
   }
   return JsArgList(&return_args);
 }
 
 void SyncManager::SyncInternal::OnEncryptedTypesChanged(
-    syncable::ModelTypeSet encrypted_types,
+    syncer::ModelTypeSet encrypted_types,
     bool encrypt_everything) {
   // NOTE: We're in a transaction.
   FOR_EACH_OBSERVER(
       SyncManager::Observer, observers_,
       OnEncryptedTypesChanged(encrypted_types, encrypt_everything));
 }
 
 void SyncManager::SyncInternal::UpdateNotificationInfo(
-    const syncable::ModelTypePayloadMap& type_payloads) {
-  for (syncable::ModelTypePayloadMap::const_iterator it = type_payloads.begin();
+    const syncer::ModelTypePayloadMap& type_payloads) {
+  for (syncer::ModelTypePayloadMap::const_iterator it = type_payloads.begin();
        it != type_payloads.end(); ++it) {
     NotificationInfo* info = &notification_info_map_[it->first];
     info->total_count++;
     info->payload = it->second;
   }
 }
 
 void SyncManager::SyncInternal::OnNotificationsEnabled() {
   DVLOG(1) << "Notifications enabled";
   allstatus_.SetNotificationsEnabled(true);
@@ skipping 26 matching lines @@
     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,
+    const syncer::ModelTypePayloadMap& type_payloads,
     syncer::IncomingNotificationSource source) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (source == syncer::LOCAL_NOTIFICATION) {
     if (scheduler()) {
       scheduler()->ScheduleNudgeWithPayloadsAsync(
           TimeDelta::FromMilliseconds(kSyncRefreshDelayMsec),
           syncer::NUDGE_SOURCE_LOCAL_REFRESH,
           type_payloads, FROM_HERE);
     }
   } else if (!type_payloads.empty()) {
     if (scheduler()) {
       scheduler()->ScheduleNudgeWithPayloadsAsync(
           TimeDelta::FromMilliseconds(kSyncSchedulerDelayMsec),
           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
+    for (syncer::ModelTypePayloadMap::const_iterator
              it = type_payloads.begin();
          it != type_payloads.end(); ++it) {
       const std::string& model_type_str =
-          syncable::ModelTypeToString(it->first);
+          syncer::ModelTypeToString(it->first);
       changed_types->Append(Value::CreateStringValue(model_type_str));
     }
     details.SetString("source", (source == syncer::LOCAL_NOTIFICATION) ?
         "LOCAL_NOTIFICATION" : "REMOTE_NOTIFICATION");
     js_event_handler_.Call(FROM_HERE,
                            &JsEventHandler::HandleJsEvent,
                            "onIncomingNotification",
                            JsEventDetails(&details));
   }
 }
@@ skipping 31 matching lines @@
   data_->UpdateCryptographerAndNigori(
       chrome_version,
       done_callback);
 }
 
 TimeDelta SyncManager::GetNudgeDelayTimeDelta(
     const ModelType& model_type) {
   return data_->GetNudgeDelayTimeDelta(model_type);
 }
 
-syncable::ModelTypeSet SyncManager::GetEncryptedDataTypesForTest() const {
+syncer::ModelTypeSet SyncManager::GetEncryptedDataTypesForTest() const {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   return GetEncryptedTypes(&trans);
 }
 
 bool SyncManager::ReceivedExperiment(syncer::Experiments* experiments)
     const {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   ReadNode node(&trans);
   if (node.InitByTagLookup(kNigoriTag) != syncer::BaseNode::INIT_OK) {
     DVLOG(1) << "Couldn't find Nigori node.";
@@ skipping 19 matching lines @@
 
 void SyncManager::SimulateDisableNotificationsForTest(int reason) {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->OnNotificationsDisabled(
       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,
+  syncer::ModelTypePayloadMap model_types_with_payloads =
+      syncer::ModelTypePayloadMapFromEnumSet(model_types,
           std::string());
 
   data_->OnIncomingNotification(model_types_with_payloads,
                                 syncer::REMOTE_NOTIFICATION);
 }
 
 const char* ConnectionStatusToString(ConnectionStatus status) {
   switch (status) {
     case CONNECTION_OK:
       return "CONNECTION_OK";
@@ skipping 17 matching lines @@
       return "REASON_ENCRYPTION";
     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,
+bool InitialSyncEndedForTypes(syncer::ModelTypeSet types,
                               syncer::UserShare* share) {
-  for (syncable::ModelTypeSet::Iterator i = types.First();
+  for (syncer::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,
+syncer::ModelTypeSet GetTypesWithEmptyProgressMarkerToken(
+    syncer::ModelTypeSet types,
     syncer::UserShare* share) {
-  syncable::ModelTypeSet result;
-  for (syncable::ModelTypeSet::Iterator i = types.First();
+  syncer::ModelTypeSet result;
+  for (syncer::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 syncer