[Sync] Move //components/sync to the syncer namespace, take 2.

components/sync/core_impl/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 "components/sync/core_impl/sync_manager_impl.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 767 matching lines @@
 }
 
 void SyncManagerImpl::RequestNudgeForDataTypes(
     const tracked_objects::Location& nudge_location,
     ModelTypeSet types) {
   debug_info_event_listener_.OnNudgeFromDatatype(types.First().Get());
 
   scheduler_->ScheduleLocalNudge(types, nudge_location);
 }
 
-void SyncManagerImpl::NudgeForInitialDownload(syncer::ModelType type) {
+void SyncManagerImpl::NudgeForInitialDownload(ModelType type) {
   DCHECK(thread_checker_.CalledOnValidThread());
   scheduler_->ScheduleInitialSyncNudge(type);
 }
 
-void SyncManagerImpl::NudgeForCommit(syncer::ModelType type) {
+void SyncManagerImpl::NudgeForCommit(ModelType type) {
   DCHECK(thread_checker_.CalledOnValidThread());
   RequestNudgeForDataTypes(FROM_HERE, ModelTypeSet(type));
 }
 
-void SyncManagerImpl::NudgeForRefresh(syncer::ModelType type) {
+void SyncManagerImpl::NudgeForRefresh(ModelType type) {
   DCHECK(thread_checker_.CalledOnValidThread());
   RefreshTypes(ModelTypeSet(type));
 }
 
 void SyncManagerImpl::OnSyncCycleEvent(const SyncCycleEvent& 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.
@@ skipping 41 matching lines @@
 
 void SyncManagerImpl::SetInvalidatorEnabled(bool invalidator_enabled) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DVLOG(1) << "Invalidator enabled state is now: " << invalidator_enabled;
   allstatus_.SetNotificationsEnabled(invalidator_enabled);
   scheduler_->SetNotificationsEnabled(invalidator_enabled);
 }
 
 void SyncManagerImpl::OnIncomingInvalidation(
-    syncer::ModelType type,
+    ModelType type,
     std::unique_ptr<InvalidationInterface> invalidation) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   allstatus_.IncrementNotificationsReceived();
   scheduler_->ScheduleInvalidationNudge(type, std::move(invalidation),
                                         FROM_HERE);
 }
 
 void SyncManagerImpl::RefreshTypes(ModelTypeSet types) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 10 matching lines @@
 
 void SyncManagerImpl::SaveChanges() {
   directory()->SaveChanges();
 }
 
 UserShare* SyncManagerImpl::GetUserShare() {
   DCHECK(initialized_);
   return &share_;
 }
 
-std::unique_ptr<syncer_v2::ModelTypeConnector>
+std::unique_ptr<ModelTypeConnector>
 SyncManagerImpl::GetModelTypeConnectorProxy() {
   DCHECK(initialized_);
-  return base::MakeUnique<syncer_v2::ModelTypeConnectorProxy>(
+  return base::MakeUnique<ModelTypeConnectorProxy>(
       base::ThreadTaskRunnerHandle::Get(), model_type_registry_->AsWeakPtr());
 }
 
 const std::string SyncManagerImpl::cache_guid() {
   DCHECK(initialized_);
   return directory()->cache_guid();
 }
 
 bool SyncManagerImpl::ReceivedExperiment(Experiments* experiments) {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   ReadNode nigori_node(&trans);
   if (nigori_node.InitTypeRoot(NIGORI) != BaseNode::INIT_OK) {
     DVLOG(1) << "Couldn't find Nigori node.";
     return false;
   }
   bool found_experiment = false;
 
   ReadNode favicon_sync_node(&trans);
-  if (favicon_sync_node.InitByClientTagLookup(
-          syncer::EXPERIMENTS, syncer::kFaviconSyncTag) == BaseNode::INIT_OK) {
+  if (favicon_sync_node.InitByClientTagLookup(EXPERIMENTS, kFaviconSyncTag) ==
+      BaseNode::INIT_OK) {
     experiments->favicon_sync_limit =
         favicon_sync_node.GetExperimentsSpecifics()
             .favicon_sync()
             .favicon_sync_limit();
     found_experiment = true;
   }
 
   ReadNode pre_commit_update_avoidance_node(&trans);
   if (pre_commit_update_avoidance_node.InitByClientTagLookup(
-          syncer::EXPERIMENTS, syncer::kPreCommitUpdateAvoidanceTag) ==
-      BaseNode::INIT_OK) {
+          EXPERIMENTS, kPreCommitUpdateAvoidanceTag) == BaseNode::INIT_OK) {
     cycle_context_->set_server_enabled_pre_commit_update_avoidance(
         pre_commit_update_avoidance_node.GetExperimentsSpecifics()
             .pre_commit_update_avoidance()
             .enabled());
     // We don't bother setting found_experiment.  The frontend doesn't need to
     // know about this.
   }
 
   ReadNode gcm_invalidations_node(&trans);
   if (gcm_invalidations_node.InitByClientTagLookup(
-          syncer::EXPERIMENTS, syncer::kGCMInvalidationsTag) ==
-      BaseNode::INIT_OK) {
+          EXPERIMENTS, kGCMInvalidationsTag) == BaseNode::INIT_OK) {
     const sync_pb::GcmInvalidationsFlags& gcm_invalidations =
         gcm_invalidations_node.GetExperimentsSpecifics().gcm_invalidations();
     if (gcm_invalidations.has_enabled()) {
       experiments->gcm_invalidations_enabled = gcm_invalidations.enabled();
       found_experiment = true;
     }
   }
 
   return found_experiment;
 }
 
 bool SyncManagerImpl::HasUnsyncedItems() {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   return (trans.GetWrappedTrans()->directory()->unsynced_entity_count() != 0);
 }
 
 SyncEncryptionHandler* SyncManagerImpl::GetEncryptionHandler() {
   return sync_encryption_handler_.get();
 }
 
 std::vector<std::unique_ptr<ProtocolEvent>>
 SyncManagerImpl::GetBufferedProtocolEvents() {
   return protocol_event_buffer_.GetBufferedProtocolEvents();
 }
 
 void SyncManagerImpl::RegisterDirectoryTypeDebugInfoObserver(
-    syncer::TypeDebugInfoObserver* observer) {
+    TypeDebugInfoObserver* observer) {
   model_type_registry_->RegisterDirectoryTypeDebugInfoObserver(observer);
 }
 
 void SyncManagerImpl::UnregisterDirectoryTypeDebugInfoObserver(
-    syncer::TypeDebugInfoObserver* observer) {
+    TypeDebugInfoObserver* observer) {
   model_type_registry_->UnregisterDirectoryTypeDebugInfoObserver(observer);
 }
 
 bool SyncManagerImpl::HasDirectoryTypeDebugInfoObserver(
-    syncer::TypeDebugInfoObserver* observer) {
+    TypeDebugInfoObserver* observer) {
   return model_type_registry_->HasDirectoryTypeDebugInfoObserver(observer);
 }
 
 void SyncManagerImpl::RequestEmitDebugInfo() {
   model_type_registry_->RequestEmitDebugInfo();
 }
 
 void SyncManagerImpl::ClearServerData(const ClearServerDataCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   scheduler_->Start(SyncScheduler::CLEAR_SERVER_DATA_MODE, base::Time());
   ClearParams params(callback);
   scheduler_->ScheduleClearServerData(params);
 }
 
 void SyncManagerImpl::OnCookieJarChanged(bool account_mismatch,
                                          bool empty_jar) {
   DCHECK(thread_checker_.CalledOnValidThread());
   cycle_context_->set_cookie_jar_mismatch(account_mismatch);
   cycle_context_->set_cookie_jar_empty(empty_jar);
 }
 
 }  // namespace syncer