[Sync] Put everything in sync/api into csync namespace

chrome/browser/sync/glue/non_frontend_data_type_controller.h

 // 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.
 
 #ifndef CHROME_BROWSER_SYNC_GLUE_NON_FRONTEND_DATA_TYPE_CONTROLLER_H__
 #define CHROME_BROWSER_SYNC_GLUE_NON_FRONTEND_DATA_TYPE_CONTROLLER_H__
 #pragma once
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/callback_forward.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "chrome/browser/sync/glue/data_type_controller.h"
 #include "chrome/browser/sync/glue/data_type_error_handler.h"
 
 class Profile;
 class ProfileSyncService;
 class ProfileSyncComponentsFactory;
+
+namespace base {
+class TimeDelta;
+}
+
+namespace csync {
 class SyncError;
+}
 
-namespace base { class TimeDelta; }
 namespace browser_sync {
 
 class AssociatorInterface;
 class ChangeProcessor;
 
 // TODO(zea): Rename frontend to UI (http://crbug.com/78833).
 // Implementation for datatypes that do not reside on the frontend thread
 // (UI thread). This is the same thread we perform initialization
 // on, so we don't have to worry about thread safety. The main start/stop
 // funtionality is implemented by default. Derived classes must implement:
@@ skipping 52 matching lines @@
       const tracked_objects::Location& from_here,
       const base::Closure& task) = 0;
 
   // Datatype specific creation of sync components.
   // Note: this is performed on the datatype's thread.
   virtual void CreateSyncComponents() = 0;
 
   // Start failed, make sure we record it, clean up state, and invoke the
   // callback on the frontend thread.
   // Note: this is performed on the datatype's thread.
-  virtual void StartFailed(StartResult result, const SyncError& error);
+  virtual void StartFailed(StartResult result, const csync::SyncError& error);
 
   // Start up complete, update the state and invoke the callback.
   // Note: this is performed on the datatype's thread.
   virtual void StartDone(DataTypeController::StartResult result,
                          DataTypeController::State new_state,
-                         const SyncError& error);
+                         const csync::SyncError& error);
 
   // UI thread implementation of StartDone.
   virtual void StartDoneImpl(DataTypeController::StartResult result,
                              DataTypeController::State new_state,
-                             const SyncError& error);
+                             const csync::SyncError& error);
 
   // Perform any DataType controller specific state cleanup before stopping
   // the datatype controller. The default implementation is a no-op.
   // Note: this is performed on the frontend (UI) thread.
   virtual void StopModels();
 
   // The actual implementation of Disabling the datatype. This happens
   // on the UI thread.
   virtual void DisableImpl(const tracked_objects::Location& from_here,
                            const std::string& message);
@@ skipping 65 matching lines @@
   // This is added for debugging purpose.
   // TODO(lipalani): Remove after debugging.
   bool start_models_failed_;
 
   DISALLOW_COPY_AND_ASSIGN(NonFrontendDataTypeController);
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_GLUE_NON_FRONTEND_DATA_TYPE_CONTROLLER_H__