[Sync] Fix namespace for sync_driver component

chrome/browser/sync/glue/sync_backend_registrar.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 "chrome/browser/sync/glue/sync_backend_registrar.h"
 
 #include <cstddef>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 184 matching lines @@
   base::AutoLock lock(lock_);
   for (WorkerMap::const_iterator it = workers_.begin();
        it != workers_.end(); ++it) {
     it->second->RequestStop();
   }
 }
 
 void SyncBackendRegistrar::ActivateDataType(
     syncer::ModelType type,
     syncer::ModelSafeGroup group,
-    ChangeProcessor* change_processor,
+    sync_driver::ChangeProcessor* change_processor,
     syncer::UserShare* user_share) {
   DVLOG(1) << "Activate: " << syncer::ModelTypeToString(type);
 
   base::AutoLock lock(lock_);
   // Ensure that the given data type is in the PASSIVE group.
   syncer::ModelSafeRoutingInfo::iterator i = routing_info_.find(type);
   DCHECK(i != routing_info_.end());
   DCHECK_EQ(i->second, syncer::GROUP_PASSIVE);
   routing_info_[type] = group;
 
@@ skipping 21 matching lines @@
 bool SyncBackendRegistrar::IsTypeActivatedForTest(
     syncer::ModelType type) const {
   return GetProcessor(type) != NULL;
 }
 
 void SyncBackendRegistrar::OnChangesApplied(
     syncer::ModelType model_type,
     int64 model_version,
     const syncer::BaseTransaction* trans,
     const syncer::ImmutableChangeRecordList& changes) {
-  ChangeProcessor* processor = GetProcessor(model_type);
+  sync_driver::ChangeProcessor* processor = GetProcessor(model_type);
   if (!processor)
     return;
 
   processor->ApplyChangesFromSyncModel(trans, model_version, changes);
 }
 
 void SyncBackendRegistrar::OnChangesComplete(syncer::ModelType model_type) {
-  ChangeProcessor* processor = GetProcessor(model_type);
+  sync_driver::ChangeProcessor* processor = GetProcessor(model_type);
   if (!processor)
     return;
 
   // This call just notifies the processor that it can commit; it
   // already buffered any changes it plans to makes so needs no
   // further information.
   processor->CommitChangesFromSyncModel();
 }
 
 void SyncBackendRegistrar::GetWorkers(
     std::vector<scoped_refptr<syncer::ModelSafeWorker> >* out) {
   base::AutoLock lock(lock_);
   out->clear();
   for (WorkerMap::const_iterator it = workers_.begin();
        it != workers_.end(); ++it) {
     out->push_back(it->second.get());
   }
 }
 
 void SyncBackendRegistrar::GetModelSafeRoutingInfo(
     syncer::ModelSafeRoutingInfo* out) {
   base::AutoLock lock(lock_);
   syncer::ModelSafeRoutingInfo copy(routing_info_);
   out->swap(copy);
 }
 
-ChangeProcessor* SyncBackendRegistrar::GetProcessor(
+sync_driver::ChangeProcessor* SyncBackendRegistrar::GetProcessor(
     syncer::ModelType type) const {
   base::AutoLock lock(lock_);
-  ChangeProcessor* processor = GetProcessorUnsafe(type);
+  sync_driver::ChangeProcessor* processor = GetProcessorUnsafe(type);
   if (!processor)
     return NULL;
 
   // We can only check if |processor| exists, as otherwise the type is
   // mapped to syncer::GROUP_PASSIVE.
   CHECK(IsCurrentThreadSafeForModel(type));
   return processor;
 }
 
-ChangeProcessor* SyncBackendRegistrar::GetProcessorUnsafe(
+sync_driver::ChangeProcessor* SyncBackendRegistrar::GetProcessorUnsafe(
     syncer::ModelType type) const {
   lock_.AssertAcquired();
-  std::map<syncer::ModelType, ChangeProcessor*>::const_iterator
+  std::map<syncer::ModelType, sync_driver::ChangeProcessor*>::const_iterator
       it = processors_.find(type);
 
   // Until model association happens for a datatype, it will not
   // appear in the processors list.  During this time, it is OK to
   // drop changes on the floor (since model association has not
   // happened yet).  When the data type is activated, model
   // association takes place then the change processor is added to the
   // |processors_| list.
   if (it == processors_.end())
     return NULL;
@@ skipping 58 matching lines @@
         base::Bind(&SyncBackendRegistrar::OnWorkerUnregistrationDone,
                    base::Unretained(this)));
   }
 }
 
 base::Thread* SyncBackendRegistrar::sync_thread() {
   return sync_thread_.get();
 }
 
 }  // namespace browser_sync