[Sync] Remove unneeded 'using syncer::' lines and 'syncer::' scopings

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 36 matching lines @@
 #include "sync/syncable/directory.h"
 #include "sync/syncable/entry.h"
 #include "sync/syncable/in_memory_directory_backing_store.h"
 #include "sync/syncable/nigori_util.h"
 #include "sync/syncable/on_disk_directory_backing_store.h"
 #include "sync/util/get_session_name.h"
 
 using base::TimeDelta;
 using sync_pb::GetUpdatesCallerInfo;
 
+namespace syncer {
+
+using sessions::SyncSessionContext;
+using syncable::ImmutableWriteTransactionInfo;
+using syncable::SPECIFICS;
+
 namespace {
 
 // Delays for syncer nudges.
 static const int kDefaultNudgeDelayMilliseconds = 200;
 static const int kPreferencesNudgeDelayMilliseconds = 2000;
 static const int kSyncRefreshDelayMsec = 500;
 static const int kSyncSchedulerDelayMsec = 250;
 
+// 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;
+
+// Maximum count and size for traffic recorder.
+static const unsigned int kMaxMessagesToRecord = 10;
+static const unsigned int kMaxMessageSizeToRecord = 5 * 1024;
+
 GetUpdatesCallerInfo::GetUpdatesSource GetSourceFromReason(
-    syncer::ConfigureReason reason) {
+    ConfigureReason reason) {
   switch (reason) {
-    case syncer::CONFIGURE_REASON_RECONFIGURATION:
+    case CONFIGURE_REASON_RECONFIGURATION:
       return GetUpdatesCallerInfo::RECONFIGURATION;
-    case syncer::CONFIGURE_REASON_MIGRATION:
+    case CONFIGURE_REASON_MIGRATION:
       return GetUpdatesCallerInfo::MIGRATION;
-    case syncer::CONFIGURE_REASON_NEW_CLIENT:
+    case CONFIGURE_REASON_NEW_CLIENT:
       return GetUpdatesCallerInfo::NEW_CLIENT;
-    case syncer::CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE:
+    case 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 syncer {
-
-using sessions::SyncSessionContext;
-using syncable::ImmutableWriteTransactionInfo;
-using syncable::SPECIFICS;
-
-// Maximum count and size for traffic recorder.
-const unsigned int kMaxMessagesToRecord = 10;
-const unsigned int kMaxMessageSizeToRecord = 5 * 1024;
+}  // namespace
 
 // A class to calculate nudge delays for types.
 class NudgeStrategy {
  public:
   static TimeDelta GetNudgeDelayTimeDelta(const ModelType& model_type,
                                           SyncManagerImpl* core) {
     NudgeDelayStrategy delay_type = GetNudgeDelayStrategy(model_type);
     return GetNudgeDelayTimeDeltaFromType(delay_type,
                                           model_type,
                                           core);
@@ skipping 10 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 syncer::AUTOFILL:
+     case AUTOFILL:
        return ACCOMPANY_ONLY;
-     case syncer::PREFERENCES:
-     case syncer::SESSIONS:
+     case PREFERENCES:
+     case SESSIONS:
        return CUSTOM;
      default:
        return IMMEDIATE;
     }
   }
 
   static TimeDelta GetNudgeDelayTimeDeltaFromType(
       const NudgeDelayStrategy& delay_type, const ModelType& model_type,
       const SyncManagerImpl* core) {
     CHECK(core);
     TimeDelta delay = TimeDelta::FromMilliseconds(
        kDefaultNudgeDelayMilliseconds);
     switch (delay_type) {
      case IMMEDIATE:
        delay = TimeDelta::FromMilliseconds(
            kDefaultNudgeDelayMilliseconds);
        break;
      case ACCOMPANY_ONLY:
-       delay = TimeDelta::FromSeconds(
-           syncer::kDefaultShortPollIntervalSeconds);
+       delay = TimeDelta::FromSeconds(kDefaultShortPollIntervalSeconds);
        break;
      case CUSTOM:
        switch (model_type) {
-         case syncer::PREFERENCES:
+         case PREFERENCES:
            delay = TimeDelta::FromMilliseconds(
                kPreferencesNudgeDelayMilliseconds);
            break;
-         case syncer::SESSIONS:
+         case SESSIONS:
            delay = core->scheduler()->GetSessionsCommitDelay();
            break;
          default:
            NOTREACHED();
        }
        break;
      default:
        NOTREACHED();
     }
     return delay;
   }
 };
 
 SyncManagerImpl::SyncManagerImpl(const std::string& name)
     : name_(name),
       weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       change_delegate_(NULL),
       initialized_(false),
       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),
       nigori_overwrite_count_(0) {
   // Pre-fill |notification_info_map_|.
-  for (int i = syncer::FIRST_REAL_MODEL_TYPE;
-       i < syncer::MODEL_TYPE_COUNT; ++i) {
+  for (int i = FIRST_REAL_MODEL_TYPE; i < MODEL_TYPE_COUNT; ++i) {
     notification_info_map_.insert(
-        std::make_pair(syncer::ModelTypeFromInt(i), NotificationInfo()));
+        std::make_pair(ModelTypeFromInt(i), NotificationInfo()));
   }
 
   // Bind message handlers.
   BindJsMessageHandler(
       "getNotificationState",
       &SyncManagerImpl::GetNotificationState);
   BindJsMessageHandler(
       "getNotificationInfo",
       &SyncManagerImpl::GetNotificationInfo);
   BindJsMessageHandler(
@@ skipping 30 matching lines @@
   value->SetString("payload", payload);
   return value;
 }
 
 bool SyncManagerImpl::VisiblePositionsDiffer(
     const syncable::EntryKernelMutation& mutation) const {
   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(
-          syncer::GetModelTypeFromSpecifics(b.ref(SPECIFICS)))) {
+  if (!ShouldMaintainPosition(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;
 }
 
 bool SyncManagerImpl::VisiblePropertiesDiffer(
     const syncable::EntryKernelMutation& mutation,
     Cryptographer* cryptographer) const {
   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(syncer::GetModelTypeFromSpecifics(a_specifics),
-            syncer::GetModelTypeFromSpecifics(b_specifics));
-  syncer::ModelType model_type =
-      syncer::GetModelTypeFromSpecifics(b_specifics);
+  DCHECK_EQ(GetModelTypeFromSpecifics(a_specifics),
+            GetModelTypeFromSpecifics(b_specifics));
+  ModelType model_type = GetModelTypeFromSpecifics(b_specifics);
   // Suppress updates to items that aren't tracked by any browser model.
-  if (model_type < syncer::FIRST_REAL_MODEL_TYPE ||
+  if (model_type < 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 SyncManagerImpl::ChangeBuffersAreEmpty() {
-  for (int i = 0; i < syncer::MODEL_TYPE_COUNT; ++i) {
+  for (int i = 0; i < MODEL_TYPE_COUNT; ++i) {
     if (!change_buffers_[i].IsEmpty())
       return false;
   }
   return true;
 }
 
 void SyncManagerImpl::ThrowUnrecoverableError() {
   DCHECK(thread_checker_.CalledOnValidThread());
   ReadTransaction trans(FROM_HERE, GetUserShare());
   trans.GetWrappedTrans()->OnUnrecoverableError(
       FROM_HERE, "Simulating unrecoverable error for testing purposes.");
 }
 
-syncer::ModelTypeSet SyncManagerImpl::InitialSyncEndedTypes() {
+ModelTypeSet SyncManagerImpl::InitialSyncEndedTypes() {
   DCHECK(initialized_);
   return directory()->initial_sync_ended_types();
 }
 
-syncer::ModelTypeSet SyncManagerImpl::GetTypesWithEmptyProgressMarkerToken(
-    syncer::ModelTypeSet types) {
+ModelTypeSet SyncManagerImpl::GetTypesWithEmptyProgressMarkerToken(
+    ModelTypeSet types) {
   DCHECK(initialized_);
-  syncer::ModelTypeSet result;
-  for (syncer::ModelTypeSet::Iterator i = types.First();
-       i.Good(); i.Inc()) {
+  ModelTypeSet result;
+  for (ModelTypeSet::Iterator i = types.First(); i.Good(); i.Inc()) {
     sync_pb::DataTypeProgressMarker marker;
     directory()->GetDownloadProgress(i.Get(), &marker);
 
     if (marker.token().empty())
       result.Put(i.Get());
 
   }
   return result;
 }
 
@@ skipping 15 matching lines @@
   RefreshEncryption();
 }
 
 bool SyncManagerImpl::EncryptEverythingEnabledForTest() {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   return trans.GetCryptographer()->encrypt_everything();
 }
 
 void SyncManagerImpl::ConfigureSyncer(
     ConfigureReason reason,
-    const syncer::ModelTypeSet& types_to_config,
-    const syncer::ModelSafeRoutingInfo& new_routing_info,
+    const ModelTypeSet& types_to_config,
+    const ModelSafeRoutingInfo& new_routing_info,
     const base::Closure& ready_task,
     const base::Closure& retry_task) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!ready_task.is_null());
   DCHECK(!retry_task.is_null());
 
   // TODO(zea): set this based on whether cryptographer has keystore
   // encryption key or not (requires opening a transaction). crbug.com/129665.
   ConfigurationParams::KeystoreKeyStatus keystore_key_status =
       ConfigurationParams::KEYSTORE_KEY_UNNECESSARY;
 
   ConfigurationParams params(GetSourceFromReason(reason),
                              types_to_config,
                              new_routing_info,
                              keystore_key_status,
                              ready_task);
 
-  scheduler_->Start(syncer::SyncScheduler::CONFIGURATION_MODE);
+  scheduler_->Start(SyncScheduler::CONFIGURATION_MODE);
   if (!scheduler_->ScheduleConfiguration(params))
     retry_task.Run();
 
 }
 
 bool SyncManagerImpl::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,
     scoped_ptr<HttpPostProviderFactory> post_factory,
-    const syncer::ModelSafeRoutingInfo& model_safe_routing_info,
-    const std::vector<syncer::ModelSafeWorker*>& workers,
-    syncer::ExtensionsActivityMonitor* extensions_activity_monitor,
+    const ModelSafeRoutingInfo& model_safe_routing_info,
+    const std::vector<ModelSafeWorker*>& workers,
+    ExtensionsActivityMonitor* extensions_activity_monitor,
     SyncManager::ChangeDelegate* change_delegate,
     const SyncCredentials& credentials,
-    scoped_ptr<syncer::SyncNotifier> sync_notifier,
+    scoped_ptr<SyncNotifier> sync_notifier,
     const std::string& restored_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());
   DVLOG(1) << "SyncManager starting Init...";
 
@@ skipping 52 matching lines @@
       listeners,
       &debug_info_event_listener_,
       &traffic_recorder_).Pass();
   session_context_->set_account_name(credentials.email);
   scheduler_ = internal_components_factory->BuildScheduler(
       name_, session_context_.get()).Pass();
 
   bool success = SignIn(credentials);
 
   if (success) {
-    scheduler_->Start(syncer::SyncScheduler::CONFIGURATION_MODE);
+    scheduler_->Start(SyncScheduler::CONFIGURATION_MODE);
 
     initialized_ = true;
 
     // Unapplied datatypes (those that do not have initial sync ended set) get
     // re-downloaded during any configuration. But, it's possible for a datatype
     // to have a progress marker but not have initial sync ended yet, making
     // it a candidate for migration. This is a problem, as the DataTypeManager
     // does not support a migration while it's already in the middle of a
     // configuration. As a result, any partially synced datatype can stall the
     // DTM, waiting for the configuration to complete, which it never will due
@@ skipping 27 matching lines @@
 
   sync_notifier_->AddObserver(this);
 
   return success;
 }
 
 void SyncManagerImpl::RefreshNigori(const std::string& chrome_version,
                                     const base::Closure& done_callback) {
   DCHECK(initialized_);
   DCHECK(thread_checker_.CalledOnValidThread());
-  syncer::GetSessionName(
+  GetSessionName(
       blocking_task_runner_,
       base::Bind(
           &SyncManagerImpl::UpdateCryptographerAndNigoriCallback,
           weak_ptr_factory_.GetWeakPtr(),
           chrome_version,
           done_callback));
 }
 
 void SyncManagerImpl::UpdateNigoriEncryptionState(
     Cryptographer* cryptographer,
@@ skipping 26 matching lines @@
   cryptographer->UpdateNigoriFromEncryptedTypes(&nigori);
 
   // If nothing has changed, this is a no-op.
   nigori_node->SetNigoriSpecifics(nigori);
 }
 
 void SyncManagerImpl::UpdateCryptographerAndNigoriCallback(
     const std::string& chrome_version,
     const base::Closure& done_callback,
     const std::string& session_name) {
-  if (!directory()->initial_sync_ended_for_type(syncer::NIGORI)) {
+  if (!directory()->initial_sync_ended_for_type(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);
 
-    if (node.InitByTagLookup(kNigoriTag) == syncer::BaseNode::INIT_OK) {
+    if (node.InitByTagLookup(kNigoriTag) == 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(syncer::REASON_DECRYPTION,
+                          OnPassphraseRequired(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()) {
           // Update the version number in case it changed due to an update.
@@ skipping 47 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 SyncManagerImpl::StartSyncingNormally(
-    const syncer::ModelSafeRoutingInfo& routing_info) {
+    const ModelSafeRoutingInfo& routing_info) {
   // Start the sync scheduler.
   // TODO(sync): We always want the newest set of routes when we switch back
   // to normal mode. Figure out how to enforce set_routing_info is always
   // appropriately set and that it's only modified when switching to normal
   // mode.
   DCHECK(thread_checker_.CalledOnValidThread());
   session_context_->set_routing_info(routing_info);
   scheduler_->Start(SyncScheduler::NORMAL_MODE);
 }
 
 syncable::Directory* SyncManagerImpl::directory() {
   return share_.directory.get();
 }
 
 const SyncScheduler* SyncManagerImpl::scheduler() const {
   return scheduler_.get();
 }
 
 bool SyncManagerImpl::OpenDirectory() {
   DCHECK(!initialized_) << "Should only happen once";
 
   // Set before Open().
-  change_observer_ =
-      syncer::MakeWeakHandle(js_mutation_event_observer_.AsWeakPtr());
+  change_observer_ = MakeWeakHandle(js_mutation_event_observer_.AsWeakPtr());
   WeakHandle<syncable::TransactionObserver> transaction_observer(
-      syncer::MakeWeakHandle(js_mutation_event_observer_.AsWeakPtr()));
+      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 23 matching lines @@
   sync_notifier_->SetUniqueId(unique_id);
   // TODO(tim): Remove once invalidation state has been migrated to new
   // InvalidationStateTracker store. Bug 124140.
   sync_notifier_->SetStateDeprecated(state);
 
   UpdateCredentials(credentials);
   return true;
 }
 
 bool SyncManagerImpl::PurgePartiallySyncedTypes() {
-  syncer::ModelTypeSet partially_synced_types =
-      syncer::ModelTypeSet::All();
+  ModelTypeSet partially_synced_types = ModelTypeSet::All();
   partially_synced_types.RemoveAll(InitialSyncEndedTypes());
   partially_synced_types.RemoveAll(GetTypesWithEmptyProgressMarkerToken(
-      syncer::ModelTypeSet::All()));
+      ModelTypeSet::All()));
 
   UMA_HISTOGRAM_COUNTS("Sync.PartiallySyncedTypes",
                        partially_synced_types.Size());
   if (partially_synced_types.Empty())
     return true;
   return directory()->PurgeEntriesWithTypeIn(partially_synced_types);
 }
 
 void SyncManagerImpl::UpdateCredentials(
     const SyncCredentials& credentials) {
@@ skipping 26 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) != syncer::BaseNode::INIT_OK) {
+  if (node.InitByTagLookup(kNigoriTag) != 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 94 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) != syncer::BaseNode::INIT_OK) {
+  if (node.InitByTagLookup(kNigoriTag) != 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(syncer::REASON_DECRYPTION,
+                        OnPassphraseRequired(REASON_DECRYPTION,
                                              cryptographer->GetPendingKeys()));
     } else {
       FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
-                        OnPassphraseRequired(syncer::REASON_ENCRYPTION,
+                        OnPassphraseRequired(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 SyncManagerImpl::IsUsingExplicitPassphrase() {
   ReadTransaction trans(FROM_HERE, &share_);
   ReadNode node(&trans);
-  if (node.InitByTagLookup(kNigoriTag) != syncer::BaseNode::INIT_OK) {
+  if (node.InitByTagLookup(kNigoriTag) != 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 SyncManagerImpl::RefreshEncryption() {
   DCHECK(initialized_);
 
   WriteTransaction trans(FROM_HERE, GetUserShare());
   WriteNode node(&trans);
-  if (node.InitByTagLookup(kNigoriTag) != syncer::BaseNode::INIT_OK) {
+  if (node.InitByTagLookup(kNigoriTag) != 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(syncer::REASON_DECRYPTION,
+                      OnPassphraseRequired(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.
   ReEncryptEverything(&trans);
 }
 
 // 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 SyncManagerImpl::ReEncryptEverything(
       WriteTransaction* trans) {
   Cryptographer* cryptographer = trans->GetCryptographer();
   if (!cryptographer || !cryptographer->is_ready())
     return;
-  syncer::ModelTypeSet encrypted_types = GetEncryptedTypes(trans);
-  for (syncer::ModelTypeSet::Iterator iter = encrypted_types.First();
+  ModelTypeSet encrypted_types = GetEncryptedTypes(trans);
+  for (ModelTypeSet::Iterator iter = encrypted_types.First();
        iter.Good(); iter.Inc()) {
-    if (iter.Get() == syncer::PASSWORDS || iter.Get() == syncer::NIGORI)
+    if (iter.Get() == PASSWORDS || iter.Get() == NIGORI)
       continue; // These types handle encryption differently.
 
     ReadNode type_root(trans);
-    std::string tag = syncer::ModelTypeToRootTag(iter.Get());
-    if (type_root.InitByTagLookup(tag) != syncer::BaseNode::INIT_OK)
+    std::string tag = ModelTypeToRootTag(iter.Get());
+    if (type_root.InitByTagLookup(tag) != 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) != syncer::BaseNode::INIT_OK) {
+      if (child.InitByIdLookup(child_id) != 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 = syncer::ModelTypeToRootTag(syncer::PASSWORDS);
-  if (passwords_root.InitByTagLookup(passwords_tag) ==
-          syncer::BaseNode::INIT_OK) {
+  std::string passwords_tag = ModelTypeToRootTag(PASSWORDS);
+  if (passwords_root.InitByTagLookup(passwords_tag) == 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) {
+      if (child.InitByIdLookup(child_id) != 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_,
@@ skipping 80 matching lines @@
 
 void SyncManagerImpl::OnIPAddressChangedImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
   scheduler_->OnConnectionStatusChange();
 }
 
 void SyncManagerImpl::OnServerConnectionEvent(
     const ServerConnectionEvent& event) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (event.connection_code ==
-      syncer::HttpResponse::SERVER_CONNECTION_OK) {
+      HttpResponse::SERVER_CONNECTION_OK) {
     FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                       OnConnectionStatusChange(CONNECTION_OK));
   }
 
-  if (event.connection_code == syncer::HttpResponse::SYNC_AUTH_ERROR) {
+  if (event.connection_code == HttpResponse::SYNC_AUTH_ERROR) {
     observing_ip_address_changes_ = false;
     FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                       OnConnectionStatusChange(CONNECTION_AUTH_ERROR));
   }
 
-  if (event.connection_code ==
-      syncer::HttpResponse::SYNC_SERVER_ERROR) {
+  if (event.connection_code == HttpResponse::SYNC_SERVER_ERROR) {
     FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                       OnConnectionStatusChange(CONNECTION_SERVER_ERROR));
   }
 }
 
 void SyncManagerImpl::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 21 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 = syncer::FIRST_REAL_MODEL_TYPE;
-       i < syncer::MODEL_TYPE_COUNT; ++i) {
-    const syncer::ModelType type = syncer::ModelTypeFromInt(i);
+  for (int i = FIRST_REAL_MODEL_TYPE; i < MODEL_TYPE_COUNT; ++i) {
+    const ModelType type = 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_->
           OnChangesApplied(type, &read_trans, ordered_changes);
       change_observer_.Call(FROM_HERE,
           &SyncManager::ChangeObserver::OnChangesApplied,
           type, write_transaction_info.Get().id, ordered_changes);
       models_with_changes.Put(type);
     }
     change_buffers_[i].Clear();
   }
   return models_with_changes;
 }
 
 void SyncManagerImpl::HandleCalculateChangesChangeEventFromSyncApi(
     const ImmutableWriteTransactionInfo& write_transaction_info,
     syncable::BaseTransaction* trans) {
   // 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.
-  syncer::ModelTypeSet mutated_model_types;
+  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;
     }
 
-    syncer::ModelType model_type =
-        syncer::GetModelTypeFromSpecifics(
-            it->second.mutated.ref(SPECIFICS));
-    if (model_type < syncer::FIRST_REAL_MODEL_TYPE) {
+    ModelType model_type =
+        GetModelTypeFromSpecifics(it->second.mutated.ref(SPECIFICS));
+    if (model_type < FIRST_REAL_MODEL_TYPE) {
       NOTREACHED() << "Permanent or underspecified item changed via syncapi.";
       continue;
     }
 
     // Found real mutation.
-    if (model_type != syncer::UNSPECIFIED) {
+    if (model_type != 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,
                              &SyncManagerImpl::RequestNudgeForDataTypes,
                              FROM_HERE,
                              mutated_model_types);
     } else {
       NOTREACHED();
     }
   }
 }
 
 void SyncManagerImpl::SetExtraChangeRecordData(int64 id,
-    syncer::ModelType type, ChangeReorderBuffer* buffer,
+    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 == syncer::PASSWORDS) {
+    if (type == 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.
-    syncer::ModelType type =
-        syncer::GetModelTypeFromSpecifics(
-            it->second.mutated.ref(SPECIFICS));
-    if (type < syncer::FIRST_REAL_MODEL_TYPE)
+    ModelType type =
+        GetModelTypeFromSpecifics(it->second.mutated.ref(SPECIFICS));
+    if (type < 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 13 matching lines @@
 void SyncManagerImpl::RequestNudgeForDataTypes(
     const tracked_objects::Location& nudge_location,
     ModelTypeSet types) {
   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,
-                                 syncer::NUDGE_SOURCE_LOCAL,
+                                 NUDGE_SOURCE_LOCAL,
                                  types,
                                  nudge_location);
 }
 
 void SyncManagerImpl::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(syncer::REASON_DECRYPTION,
+                          OnPassphraseRequired(REASON_DECRYPTION,
                                                pending_keys));
       } else if (!cryptographer->is_ready() &&
-                 event.snapshot.initial_sync_ended().Has(syncer::NIGORI)) {
+                 event.snapshot.initial_sync_ended().Has(NIGORI)) {
         DVLOG(1) << "OnPassphraseRequired sent because cryptographer is not "
                  << "ready";
         FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
-                          OnPassphraseRequired(syncer::REASON_ENCRYPTION,
+                          OnPassphraseRequired(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) ==
-              syncer::BaseNode::INIT_OK) {
+      if (nigori_node.InitByTagLookup(kNigoriTag) == 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.
     //
     // 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 =
-            syncer::ModelTypePayloadMapToEnumSet(
-                event.snapshot.source().types);
+            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_,
                       OnStopSyncingPermanently());
@@ skipping 55 matching lines @@
   js_message_handlers_[name] =
       base::Bind(unbound_message_handler, base::Unretained(this));
 }
 
 DictionaryValue* SyncManagerImpl::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 =
-        syncer::ModelTypeToString(it->first);
+    const std::string& model_type_str = ModelTypeToString(it->first);
     value->Set(model_type_str, it->second.ToValue());
   }
 
   return value;
 }
 
 JsArgList SyncManagerImpl::GetNotificationState(
     const JsArgList& args) {
   bool notifications_enabled = allstatus_.status().notifications_enabled;
   ListValue return_args;
@@ skipping 51 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) != syncer::BaseNode::INIT_OK) {
+      if (node.InitByIdLookup(id) != BaseNode::INIT_OK) {
         continue;
       }
       node_summaries->Append((node.*info_getter)());
     }
   }
   return JsArgList(&return_args);
 }
 
 }  // namespace
 
@@ skipping 36 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 SyncManagerImpl::OnEncryptedTypesChanged(
-    syncer::ModelTypeSet encrypted_types,
+    ModelTypeSet encrypted_types,
     bool encrypt_everything) {
   // NOTE: We're in a transaction.
   FOR_EACH_OBSERVER(
       SyncManager::Observer, observers_,
       OnEncryptedTypesChanged(encrypted_types, encrypt_everything));
 }
 
 void SyncManagerImpl::UpdateNotificationInfo(
-    const syncer::ModelTypePayloadMap& type_payloads) {
-  for (syncer::ModelTypePayloadMap::const_iterator it = type_payloads.begin();
+    const ModelTypePayloadMap& type_payloads) {
+  for (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 SyncManagerImpl::OnNotificationsEnabled() {
   DVLOG(1) << "Notifications enabled";
   allstatus_.SetNotificationsEnabled(true);
   scheduler_->SetNotificationsEnabled(true);
 
   // TODO(akalin): Separate onNotificationStateChange into
   // enabled/disabled events.
   if (js_event_handler_.IsInitialized()) {
     DictionaryValue details;
     details.Set("enabled", Value::CreateBooleanValue(true));
     js_event_handler_.Call(FROM_HERE,
                            &JsEventHandler::HandleJsEvent,
                            "onNotificationStateChange",
                            JsEventDetails(&details));
   }
 }
 
 void SyncManagerImpl::OnNotificationsDisabled(
-    syncer::NotificationsDisabledReason reason) {
+    NotificationsDisabledReason reason) {
   DVLOG(1) << "Notifications disabled with reason "
-           << syncer::NotificationsDisabledReasonToString(reason);
+           << NotificationsDisabledReasonToString(reason);
   allstatus_.SetNotificationsEnabled(false);
   scheduler_->SetNotificationsEnabled(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 SyncManagerImpl::OnIncomingNotification(
-    const syncer::ModelTypePayloadMap& type_payloads,
-    syncer::IncomingNotificationSource source) {
+    const ModelTypePayloadMap& type_payloads,
+    IncomingNotificationSource source) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (source == syncer::LOCAL_NOTIFICATION) {
+  if (source == LOCAL_NOTIFICATION) {
     scheduler_->ScheduleNudgeWithPayloadsAsync(
         TimeDelta::FromMilliseconds(kSyncRefreshDelayMsec),
-        syncer::NUDGE_SOURCE_LOCAL_REFRESH,
+        NUDGE_SOURCE_LOCAL_REFRESH,
         type_payloads, FROM_HERE);
   } else if (!type_payloads.empty()) {
     scheduler_->ScheduleNudgeWithPayloadsAsync(
         TimeDelta::FromMilliseconds(kSyncSchedulerDelayMsec),
-        syncer::NUDGE_SOURCE_NOTIFICATION,
+        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 (syncer::ModelTypePayloadMap::const_iterator
-             it = type_payloads.begin();
+    for (ModelTypePayloadMap::const_iterator it = type_payloads.begin();
          it != type_payloads.end(); ++it) {
       const std::string& model_type_str =
-          syncer::ModelTypeToString(it->first);
+          ModelTypeToString(it->first);
       changed_types->Append(Value::CreateStringValue(model_type_str));
     }
-    details.SetString("source", (source == syncer::LOCAL_NOTIFICATION) ?
+    details.SetString("source", (source == LOCAL_NOTIFICATION) ?
         "LOCAL_NOTIFICATION" : "REMOTE_NOTIFICATION");
     js_event_handler_.Call(FROM_HERE,
                            &JsEventHandler::HandleJsEvent,
                            "onIncomingNotification",
                            JsEventDetails(&details));
   }
 }
 
 SyncStatus SyncManagerImpl::GetDetailedStatus() const {
   return allstatus_.status();
 }
 
 void SyncManagerImpl::SaveChanges() {
   directory()->SaveChanges();
 }
 
 const std::string& SyncManagerImpl::username_for_share() const {
   return share_.name;
 }
 
 UserShare* SyncManagerImpl::GetUserShare() {
   DCHECK(initialized_);
   return &share_;
 }
 
-syncer::ModelTypeSet SyncManagerImpl::GetEncryptedDataTypesForTest() {
+ModelTypeSet SyncManagerImpl::GetEncryptedDataTypesForTest() {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   return GetEncryptedTypes(&trans);
 }
 
-bool SyncManagerImpl::ReceivedExperiment(syncer::Experiments* experiments) {
+bool SyncManagerImpl::ReceivedExperiment(Experiments* experiments) {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   ReadNode node(&trans);
-  if (node.InitByTagLookup(kNigoriTag) != syncer::BaseNode::INIT_OK) {
+  if (node.InitByTagLookup(kNigoriTag) != 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 SyncManagerImpl::HasUnsyncedItems() {
-  syncer::ReadTransaction trans(FROM_HERE, GetUserShare());
+  ReadTransaction trans(FROM_HERE, GetUserShare());
   return (trans.GetWrappedTrans()->directory()->unsynced_entity_count() != 0);
 }
 
 void SyncManagerImpl::SimulateEnableNotificationsForTest() {
   DCHECK(thread_checker_.CalledOnValidThread());
   OnNotificationsEnabled();
 }
 
 void SyncManagerImpl::SimulateDisableNotificationsForTest(int reason) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  OnNotificationsDisabled(
-      static_cast<syncer::NotificationsDisabledReason>(reason));
+  OnNotificationsDisabled(static_cast<NotificationsDisabledReason>(reason));
 }
 
 void SyncManagerImpl::TriggerOnIncomingNotificationForTest(
     ModelTypeSet model_types) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  syncer::ModelTypePayloadMap model_types_with_payloads =
-      syncer::ModelTypePayloadMapFromEnumSet(model_types,
+  ModelTypePayloadMap model_types_with_payloads =
+      ModelTypePayloadMapFromEnumSet(model_types,
           std::string());
 
-  OnIncomingNotification(model_types_with_payloads,
-                         syncer::REMOTE_NOTIFICATION);
+  OnIncomingNotification(model_types_with_payloads, REMOTE_NOTIFICATION);
 }
 
 // static.
 int SyncManagerImpl::GetDefaultNudgeDelay() {
   return kDefaultNudgeDelayMilliseconds;
 }
 
 // static.
 int SyncManagerImpl::GetPreferencesNudgeDelay() {
   return kPreferencesNudgeDelayMilliseconds;
 }
 
 }  // namespace syncer