[Sync] Fix namespace for sync_driver component

components/sync_driver/non_blocking_data_type_controller_unittest.cc

 // Copyright 2014 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 <list>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/sequenced_task_runner.h"
 #include "base/test/test_simple_task_runner.h"
 #include "components/sync_driver/non_blocking_data_type_controller.h"
 #include "sync/engine/model_type_sync_proxy_impl.h"
 #include "sync/engine/model_type_sync_worker.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/sync_context_proxy.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-namespace syncer {
+namespace sync_driver {
 
 class ModelTypeSyncWorker;
 
 namespace {
 
 // A useless instance of ModelTypeSyncWorker.
-class NullModelTypeSyncWorker : public ModelTypeSyncWorker {
+class NullModelTypeSyncWorker : public syncer::ModelTypeSyncWorker {
  public:
   NullModelTypeSyncWorker();
   virtual ~NullModelTypeSyncWorker();
 
-  virtual void EnqueueForCommit(const CommitRequestDataList& list) OVERRIDE;
+  virtual void EnqueueForCommit(
+      const syncer::CommitRequestDataList& list) OVERRIDE;
 };
 
 NullModelTypeSyncWorker::NullModelTypeSyncWorker() {
 }
 
 NullModelTypeSyncWorker::~NullModelTypeSyncWorker() {
 }
 
 void NullModelTypeSyncWorker::EnqueueForCommit(
-    const CommitRequestDataList& list) {
+    const syncer::CommitRequestDataList& list) {
   NOTREACHED() << "Not implemented.";
 }
 
 // A class that pretends to be the sync backend.
 class MockSyncContext {
  public:
   void Connect(
       syncer::ModelType type,
       const scoped_refptr<base::SingleThreadTaskRunner>& model_task_runner,
       const base::WeakPtr<syncer::ModelTypeSyncProxyImpl>& type_proxy) {
     enabled_types_.Put(type);
     model_task_runner->PostTask(
         FROM_HERE,
         base::Bind(&syncer::ModelTypeSyncProxyImpl::OnConnect,
                    type_proxy,
-                   base::Passed(scoped_ptr<ModelTypeSyncWorker>(
+                   base::Passed(scoped_ptr<syncer::ModelTypeSyncWorker>(
                                     new NullModelTypeSyncWorker()).Pass())));
   }
 
   void Disconnect(syncer::ModelType type) {
     DCHECK(enabled_types_.Has(type));
     enabled_types_.Remove(type);
   }
 
  private:
   std::list<base::Closure> tasks_;
   syncer::ModelTypeSet enabled_types_;
 };
 
 // A proxy to the MockSyncContext that implements SyncContextProxy.
 class MockSyncContextProxy : public syncer::SyncContextProxy {
  public:
   MockSyncContextProxy(
       MockSyncContext* sync_context,
       const scoped_refptr<base::TestSimpleTaskRunner>& model_task_runner,
       const scoped_refptr<base::TestSimpleTaskRunner>& sync_task_runner)
       : mock_sync_context_(sync_context),
         model_task_runner_(model_task_runner),
         sync_task_runner_(sync_task_runner) {}
   virtual ~MockSyncContextProxy() {}
 
   virtual void ConnectTypeToSync(
       syncer::ModelType type,
-      const DataTypeState& data_type_state,
+      const syncer::DataTypeState& data_type_state,
       const base::WeakPtr<syncer::ModelTypeSyncProxyImpl>& type_proxy)
       OVERRIDE {
     // Normally we'd use MessageLoopProxy::current() as the TaskRunner argument
     // to Connect().  That won't work here in this test, so we use the
     // model_task_runner_ that was injected for this purpose instead.
     sync_task_runner_->PostTask(FROM_HERE,
                                 base::Bind(&MockSyncContext::Connect,
                                            base::Unretained(mock_sync_context_),
                                            type,
                                            model_task_runner_,
@@ skipping 82 matching lines @@
 
   void SetAutoRunTasks(bool auto_run_tasks) {
     auto_run_tasks_ = auto_run_tasks;
   }
 
  protected:
   syncer::ModelTypeSyncProxyImpl type_sync_proxy_;
   scoped_refptr<base::TestSimpleTaskRunner> model_thread_;
   scoped_refptr<base::TestSimpleTaskRunner> sync_thread_;
 
-  browser_sync::NonBlockingDataTypeController controller_;
+  NonBlockingDataTypeController controller_;
 
   MockSyncContext mock_sync_context_;
   MockSyncContextProxy mock_context_proxy_;
 
   bool auto_run_tasks_;
 };
 
 // Initialization when the user has disabled syncing for this type.
 TEST_F(NonBlockingDataTypeControllerTest, UserDisabled) {
   SetIsPreferred(false);
@@ skipping 229 matching lines @@
   // The sync thread has three messages related to those enables and
   // disables sittin in its queue.  Let's allow it to process them.
   RunQueuedSyncThreadTasks();
 
   // Let the model thread process any messages from the sync thread.
   RunQueuedModelThreadTasks();
   EXPECT_TRUE(type_sync_proxy_.IsPreferred());
   EXPECT_TRUE(type_sync_proxy_.IsConnected());
 }
 
-}  // namespace syncer
+}  // namespace sync_driver